Array declaration in Go

Introduction

Arrays help you store many values of the same type together, like a row of mailboxes holding letters.

When you know exactly how many items you want to store.

When you want to keep items in order and access them by position.

When you want to group related data, like daily temperatures for a week.

When you want to quickly access items using their index number.

Syntax

Go

package main

import "fmt"

func main() {
    var arrayName [size]Type
}

Replace arrayName with your variable name.

Replace size with a fixed number for how many items the array holds.

Replace Type with the type of items, like int, string, etc.

Examples

An array of 3 integers, all start as zero because Go sets default values.

Go

package main

import "fmt"

func main() {
    var emptyArray [3]int
    fmt.Println(emptyArray) // [0 0 0]
}

An array with one string element assigned.

Go

package main

import "fmt"

func main() {
    var singleElementArray [1]string
    singleElementArray[0] = "hello"
    fmt.Println(singleElementArray) // [hello]
}

An array of 4 strings initialized with values.

Go

package main

import "fmt"

func main() {
    var fruits [4]string = [4]string{"apple", "banana", "cherry", "date"}
    fmt.Println(fruits)
}

Assigning values to the first and last positions in the array.

Go

package main

import "fmt"

func main() {
    var numbers [5]int
    numbers[0] = 10
    numbers[4] = 50
    fmt.Println(numbers) // [10 0 0 0 50]
}

Sample Program

This program shows how to declare an array, see its default values, assign new values, and print the array before and after.

Go

package main

import "fmt"

func main() {
    // Declare an array of 5 integers
    var dailyTemperatures [5]int

    // Print the array before assigning values
    fmt.Println("Before assigning values:", dailyTemperatures)

    // Assign temperatures
    dailyTemperatures[0] = 70
    dailyTemperatures[1] = 72
    dailyTemperatures[2] = 68
    dailyTemperatures[3] = 65
    dailyTemperatures[4] = 74

    // Print the array after assigning values
    fmt.Println("After assigning values:", dailyTemperatures)
}

Important Notes

Time complexity to access any element by index is O(1), very fast.

Space complexity is fixed and depends on the array size you declare.

Common mistake: Trying to add more elements than the declared size causes errors.

Use arrays when size is fixed; use slices if you need flexible size.

Summary

Arrays store multiple values of the same type in a fixed size.

You declare arrays with a size and type, like [5]int for five integers.

Access array items by their position using indexes starting at 0.

Practice

1. What does the following Go code declare?
var arr [3]int

easy

A. A slice of integers with length 3

B. An array of 3 integers initialized with zero values

C. A pointer to an integer array

D. A map with integer keys and values

Solution

1. Step 1: Understand the syntax var arr [3]int

   This declares a fixed-size array named arr with 3 elements, each of type int.

2. Step 2: Recognize default initialization

   In Go, arrays are initialized with zero values for their type, so all 3 integers start as 0.

3. Final Answer:

   An array of 3 integers initialized with zero values -> Option B

4. Quick Check:

   Array declaration = fixed size + type + zero values [OK]

Hint: Remember: [n]type means fixed size array of n elements [OK]

Common Mistakes:

• Confusing array with slice declaration
• Thinking it creates a pointer or map
• Assuming uninitialized values are random

2. Which of the following is the correct way to declare an array of 4 strings in Go?

easy

A. var arr [4]string

B. var arr []string{4}

C. arr := [4]string{}

D. var arr string[4]

Solution

1. Step 1: Check Go array declaration syntax

   Arrays are declared with var name [size]type. So var arr [4]string is correct.

2. Step 2: Analyze other options

   var arr []string{4} uses slice syntax incorrectly. arr := [4]string{} is valid short declaration syntax in Go. var arr string[4] reverses size and type, which is invalid.

3. Final Answer:

   var arr [4]string -> Option A

4. Quick Check:

   Array syntax = var name [size]type [OK]

Hint: Array size goes inside brackets before type [OK]

Common Mistakes:

• Using slice syntax instead of array syntax
• Placing size after type
• Missing var keyword or wrong initialization

3. What is the output of this Go program?

package main
import "fmt"
func main() {
  var nums = [3]int{10, 20, 30}
  fmt.Println(nums[1])
}

medium

A. 10

B. 0

C. 30

D. 20

Solution

1. Step 1: Understand array initialization

   The array nums has 3 integers: 10 at index 0, 20 at index 1, and 30 at index 2.

2. Step 2: Access element at index 1

   Printing nums[1] outputs the second element, which is 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   Array index starts at 0, nums[1] = 20 [OK]

Hint: Array indexes start at 0; second element is index 1 [OK]

Common Mistakes:

• Confusing index 1 with index 0
• Expecting output 10 or 30 instead of 20
• Thinking array is zero-indexed but printing wrong element

4. Identify the error in this Go array declaration:

var arr [3]int = {1, 2, 3}

medium

A. Array initialization syntax is incorrect

B. Braces {} should be replaced with []

C. Missing keyword 'var'

D. Array size must be omitted

Solution

1. Step 1: Review array initialization syntax

   In Go, when initializing an array with values, the correct syntax is var arr = [3]int{1, 2, 3} or arr := [3]int{1, 2, 3}.

2. Step 2: Identify the error

   The code uses var arr [3]int = {1, 2, 3} which misses the array type on the right side before the braces. This causes a syntax error.

3. Final Answer:

   Array initialization syntax is incorrect -> Option A

4. Quick Check:

   Array init needs type before braces [OK]

Hint: Array init needs type before braces, like [3]int{...} [OK]

Common Mistakes:

• Omitting array type on right side during initialization
• Using wrong braces or brackets
• Trying to assign without proper syntax

5. How can you declare and initialize a 2D array of integers with 2 rows and 3 columns in Go?

hard

A. var matrix [2][3]int = [2][3]int{{1,2,3},{4,5,6}}

B. var matrix [][]int = {{1,2,3},{4,5,6}}

C. matrix := [2][3]int{{1,2,3},{4,5,6}}

D. var matrix [3][2]int = {{1,2},{3,4},{5,6}}

Solution

1. Step 1: Understand 2D array declaration

   A 2D array with 2 rows and 3 columns is declared as [2][3]int. Both dimensions must be specified.

2. Step 2: Check initialization syntax

   matrix := [2][3]int{{1,2,3},{4,5,6}} uses short declaration with := and correctly initializes the 2D array with two rows of three integers each.

3. Step 3: Analyze other options

   var matrix [2][3]int = [2][3]int{{1,2,3},{4,5,6}} is correct syntax but uses explicit var with type on both sides (valid but less common). var matrix [][]int = {{1,2,3},{4,5,6}} is a slice of slices, not an array. var matrix [3][2]int = {{1,2},{3,4},{5,6}} has dimensions reversed (3 rows, 2 columns).

4. Final Answer:

   matrix := [2][3]int{{1,2,3},{4,5,6}} -> Option C

5. Quick Check:

   2D array = [rows][cols]type with nested braces [OK]

Hint: Use [rows][cols]type with nested braces to initialize [OK]

Common Mistakes:

• Confusing slices with arrays
• Swapping row and column sizes
• Missing nested braces for 2D arrays