Arrays in Golang with example #6

Arrays in Golang with example #6

Mastering Arrays in Go: An In-Depth Guide to Working with Fixed-Length Sequences of Data

Play this article

Arrays in Go are fixed-length sequences of elements of the same type. This means that once an array is created, it cannot be resized or modified to hold more or fewer elements. The length of the array must be specified at the time of creation and cannot be changed later.

One important thing to note about arrays in Go is that they are value types, not reference types. This means that when an array is assigned to a new variable or passed to a function, the entire array is copied and the new variable or function receives a new copy of the array. This can be inefficient for large arrays or if the array needs to be modified in the new variable or function. In these cases, it is often more efficient to use a slice, which is a reference type.

Here is an example of creating and initializing an array of integers:

var myArray [5]int
myArray[0] = 1
myArray[1] = 2
myArray[2] = 3
myArray[3] = 4
myArray[4] = 5

We can also use a short declaration syntax to create and initialize an array in one line:

myArray := [5]int{1, 2, 3, 4, 5}

Elements in an array can be accessed using their index, which starts at 0 for the first element. For example, to access the third element of the array above, we would use myArray[2].

It is also possible to create an array using a composite literal, which is a list of values enclosed in curly braces. For example:

myArray := [5]int{1, 2, 3, 4, 5}

This creates an array of integers with a length of 5 and initializes the elements with the values 1, 2, 3, 4, and 5.

We can also specify only a portion of the values and Go will fill in the rest with the zero value for the type. For example:

myArray := [5]int{0, 1, 2}

This creates an array with a length of 5 and initializes the first three elements with the values 0, 1, and 2. The remaining two elements will be initialized with the zero value for integers, which is 0.

It is important to note that arrays in Go are immutable, meaning their length cannot be changed once they are created. However, we can create a slice from an array, which allows for the manipulation of the length and elements of the sequence.

I hope this helps clarify arrays in Go! Let me know if you have any further questions.