This module is perfect for beginners to learn Go. Discover Go core constructs, advanced error handling, and networking techniques for aspiring Go programmers and Go developers.

Golang for Programmers

Go (also called Golang) is one of the most popular languages today and is a key part of many enterprise tech stacks. Many developers prefer Go to other languages like C++ and Scala because of its memory management model, which allows for easier concurrency.
In this module, you will learn Go and the core constructs and techniques of the language. After going through the basics, you will then learn more advanced Go concepts like error-handling, networking, and templating. You'll learn how to program efficiently in Go by gaining knowledge of common pitfalls and patterns, as well as by building your own applications. This module is perfect for aspiring Go developers and those who are Go beginners seeking to become proficient Go programmers.

Learn Go

## Array literals
When the values (or some of them) of the items are known beforehand, a simpler initialization exists using the __{ , ,}__ notation called __array literals__ (or constructors) instead of initializing every item in the __[ ]=__ way. Let's see some variants.

### 1st variant
Specify explicitly the size `n` of the array with `[n]`.
For example:
```go
var arrAge = [5]int{18, 20, 15, 22, 16}
```
Here is another example:
```go
var arr = [10]int{ 1, 2, 3 }
```
This is an array of __10__ elements with the 1st three _different_ from 0.

### 2nd variant
The [...] notation, for example:
```go
var arrLazy = [...]int{5, 6, 7, 8, 22}
```
`...` indicates the compiler has to count the number of items to obtain the length of the array. However, `[...]int` is not a type, so this is illegal: 
```go
var arrLazy [...]int = [...]int{5, 6, 7, 8, 22}
```
If the `...` is omitted then a [slice](https://www.educative.io/courses/the-way-to-go/slices) is created.
### 3rd variant
The `index: value` syntax can be followed.
For example:
```go
var arrKeyValue = [5]string{3: "Chris", 4: "Ron"}
```
## Passing an array to a function
Passing big arrays to a function quickly eats up a lot of memory because arrays are copied when passing.
There are 2 ways to prevent this:
+ Pass a pointer to the array.
+ Use a slice of the array (we’ll discuss slices in the [next section](https://www.educative.io/courses/the-way-to-go/slices)).

The following example illustrates the first solution:

# Array literals
When the values (or some of them) of the items are known beforehand, a simpler initialization exists using the __{ , ,}__ notation called __array literals__ (or constructors) instead of initializing every item in the __[ ]=__ way. Let's see some variants.

## 1st variant
Specify explicitly the size `n` of the array with `[n]`.
For example:
```go
var arrAge = [5]int{18, 20, 15, 22, 16}
```
Here is another example:
```go
var arr = [10]int{ 1, 2, 3 }
```
This is an array of __10__ elements with the 1st three _different_ from 0.

## 2nd variant
The [...] notation, for example:
```go
var arrLazy = [...]int{5, 6, 7, 8, 22}
```
`...` indicates the compiler has to count the number of items to obtain the length of the array. However, `[...]int` is not a type, so this is illegal: 
```go
var arrLazy [...]int = [...]int{5, 6, 7, 8, 22}
```
If the `...` is omitted then a [slice](https://www.educative.io/courses/the-way-to-go/slices) is created.
## 3rd variant
The `index: value` syntax can be followed.
For example:
```go
var arrKeyValue = [5]string{3: "Chris", 4: "Ron"}
```
# Passing an array to a function
Passing big arrays to a function quickly eats up a lot of memory because arrays are copied when passing.
There are 2 ways to prevent this:
+ Pass a pointer to the array.
+ Use a slice of the array (we’ll discuss slices in the [next section](https://www.educative.io/courses/the-way-to-go/slices)).

The following example illustrates the first solution:

This lesson explains array literals and handling arrays as parameters to functions in detail.

Introduction to Go

Go Data Types and Variables

Go if-else, switch-case,Construct, break and continue

Go Functions

Go Slices and Arrays

Wrap Up

Array literals

1^st variant