Array declaration in Go - Step-by-Step Execution

Concept Flow - Array declaration

Start

↓

Declare array with size and type

↓

Memory allocated for fixed size

↓

Array elements initialized to zero values

↓

Array ready to use

↓

End

This flow shows how declaring an array in Go reserves fixed memory and initializes elements to zero values.

Execution Sample

Go

var arr [3]int
arr[0] = 10
arr[1] = 20
arr[2] = 30

Declare an integer array of size 3 and assign values to each element.

Execution Table

Step	Action	Array State	Explanation
1	Declare array var arr [3]int	[0 0 0]	Array of 3 ints created, all elements zero
2	Assign arr[0] = 10	[10 0 0]	First element set to 10
3	Assign arr[1] = 20	[10 20 0]	Second element set to 20
4	Assign arr[2] = 30	[10 20 30]	Third element set to 30
5	End	[10 20 30]	Array fully initialized with assigned values

💡 All array elements assigned, program ends

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
arr	undefined	[0 0 0]	[10 0 0]	[10 20 0]	[10 20 30]	[10 20 30]

Key Moments - 3 Insights

Why are all array elements zero after declaration?

In Go, arrays are initialized with zero values for their type automatically, as shown in execution_table step 1.

Can we assign values outside the declared size of the array?

No, arrays have fixed size. Trying to assign arr[3] would cause a runtime panic, as the array size is 3 (indices 0 to 2).

Is the array size changeable after declaration?

No, the size is fixed at declaration and cannot be changed later, as shown by the fixed array state in variable_tracker.

Visual Quiz - 3 Questions

Look at the execution_table, what is the array state after step 2?

A [0 10 0]

B [0 0 10]

C [10 0 0]

D [10 20 0]

💡 Hint

Check the 'Array State' column in execution_table row with Step 2.

At which step does the array become fully assigned with non-zero values?

A Step 2

B Step 4

C Step 3

D Step 1

💡 Hint

Look at the 'Array State' column in execution_table to see when all elements are non-zero.

If we declare var arr [5]int instead of [3]int, how would the initial array state change?

A [0 0 0 0 0]

B [0 0 0]

C [10 20 30 0 0]

D Array size would remain 3

💡 Hint

Refer to variable_tracker and concept_flow about array size and initialization.

Concept Snapshot

Array declaration in Go:
var arr [size]type
- Fixed size array
- Elements initialized to zero values
- Size cannot change after declaration
- Access elements by index arr[0], arr[1], ...

Full Transcript

In Go, declaring an array reserves fixed memory for a set number of elements of a specific type. The syntax is var arr [3]int which creates an array of 3 integers. All elements start with zero values automatically. You can assign values to each element by index, like arr[0] = 10. The array size is fixed and cannot be changed after declaration. Trying to access or assign outside the declared size causes an error. This example shows step-by-step how the array is created and updated.

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