Short variable declaration in Go - Step-by-Step Execution

Concept Flow - Short variable declaration

Start

↓

Use := to declare and assign

↓

Variable created with type inferred

↓

Variable ready to use

↓

End

The short variable declaration uses := to create and assign a variable in one step, with Go inferring the type automatically.

Execution Sample

Go

package main
import "fmt"
func main() {
  x := 10
  fmt.Println(x)
}

This code declares a variable x with value 10 using short declaration and prints it.

Execution Table

Step	Code Line	Action	Variable State	Output
1	x := 10	Declare x and assign 10	x = 10 (int)
2	fmt.Println(x)	Print value of x	x = 10 (int)	10
3	End	Program ends	x = 10 (int)

💡 Program ends after printing the value of x

Variable Tracker

Variable	Start	After 1	After 2	Final
x	undefined	10	10	10

Key Moments - 2 Insights

Why do we use := instead of = when declaring a variable?

The := operator both declares and assigns a variable in one step, as shown in execution_table step 1. Using = alone would require the variable to be declared first.

What type does the variable x have after declaration?

Go infers the type from the assigned value. In execution_table step 1, x is assigned 10, so its type is int.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of x after step 1?

A 10

B undefined

C 0

D nil

💡 Hint

Check the 'Variable State' column in row for step 1 in execution_table

At which step is the variable x printed?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Code Line' and 'Action' columns in execution_table

If we replace := with = in line 1, what will happen?

A Variable x will be declared and assigned

B Compilation error because x is not declared

C x will be assigned zero value

D Program will print 0

💡 Hint

Recall that := declares and assigns, = only assigns to existing variables

Concept Snapshot

Short variable declaration uses := to declare and assign a variable in one step.
Go infers the variable type automatically from the assigned value.
Example: x := 10 declares x as int with value 10.
Use := only inside functions, not for package-level variables.
Trying to use = without prior declaration causes an error.

Full Transcript

This example shows how to use short variable declaration in Go. The := operator declares a variable and assigns a value at the same time. In the code, x := 10 creates an integer variable x with value 10. Then fmt.Println(x) prints the value 10. The execution table traces these steps clearly. The variable tracker shows x changes from undefined to 10 after declaration. Key moments clarify why := is needed and how Go infers types. The quiz tests understanding of variable state and declaration rules. This helps beginners see how short variable declaration works step-by-step.

Practice

1. What does the short variable declaration := do in Go?

easy

A. It assigns a value to an already declared variable outside a function.

B. It declares and initializes a new variable inside a function.

C. It declares a variable without initializing it.

D. It declares a global variable accessible everywhere.

Solution

1. Step 1: Understand short variable declaration usage

   The := syntax declares and initializes a variable in one step inside functions.

2. Step 2: Differentiate from other declarations

   It cannot be used without initialization or outside functions for global variables.

3. Final Answer:

   It declares and initializes a new variable inside a function. -> Option B

4. Quick Check:

   Short declaration = declare + initialize [OK]

Hint: Remember := means declare and assign inside functions [OK]

Common Mistakes:

• Thinking := works outside functions
• Using := without initializing
• Confusing := with simple assignment =

2. Which of the following is the correct way to declare and initialize a variable using short variable declaration in Go?

easy

A. x =: 10

B. var x := 10

C. x := 10

D. x :== 10

Solution

1. Step 1: Identify correct short declaration syntax

   The correct syntax is variable := value without the var keyword.

2. Step 2: Check each option

   x := 10 matches the correct syntax. The other options have invalid syntax.

3. Final Answer:

   x := 10 -> Option C

4. Quick Check:

   Short declaration syntax = variable := value [OK]

Hint: Short declaration never uses 'var' keyword [OK]

Common Mistakes:

• Adding 'var' with :=
• Swapping := to =:
• Using double equals or colons

3. What will be the output of this Go code snippet?

func main() {
    a := 5
    a := 10
    fmt.Println(a)
}

medium

A. Compilation error

B. 10

C. 5

D. 0

Solution

1. Step 1: Analyze variable redeclaration

   Using a := 5 then a := 10 in the same scope causes redeclaration error.

2. Step 2: Understand Go's redeclaration rules

   Short declaration requires at least one new variable; here a is redeclared without new variables, causing error.

3. Final Answer:

   Compilation error -> Option A

4. Quick Check:

   Redeclaring same var with := in same scope = error [OK]

Hint: Short declaration needs at least one new variable [OK]

Common Mistakes:

• Assuming redeclaration overwrites variable
• Expecting last value to print
• Ignoring scope rules

4. Identify the error in this Go code snippet:

func main() {
    x := 10
    x := 20
    fmt.Println(x)
}

medium

A. x is redeclared in the same scope causing a compile error.

B. x is not initialized before use.

C. fmt.Println is used incorrectly.

D. No error, output will be 20.

Solution

1. Step 1: Check variable redeclaration

   The variable x is declared twice with := in the same function scope, which is not allowed.

2. Step 2: Understand Go's redeclaration rules

   Redeclaring a variable with := requires at least one new variable; here none is new, so compile error occurs.

3. Final Answer:

   x is redeclared in the same scope causing a compile error. -> Option A

4. Quick Check:

   Redeclaration without new vars = compile error [OK]

Hint: Redeclare only if at least one new variable appears [OK]

Common Mistakes:

• Thinking redeclaration updates variable silently
• Ignoring compile errors on redeclaration
• Assuming output prints last assigned value

5. Given the code below, which line correctly uses short variable declaration to add a new variable c while updating a?

func main() {
    a := 1
    b := 2
    // Insert line here
    fmt.Println(a, b, c)
}

hard

A. a, b := 3, 4

B. a := 3; c := 4

C. c := 4

D. a, c := 3, 4

Solution

1. Step 1: Understand short declaration with existing variables

   To update a and declare new c in one line, use a, c := 3, 4.

2. Step 2: Check other options

   a, b := 3, 4 redeclares two existing variables without a new one, causing a compile error. a := 3; c := 4 redeclares existing a without a new variable (compile error). c := 4 declares c without updating a.

3. Final Answer:

   a, c := 3, 4 -> Option D

4. Quick Check:

   Short declaration updates existing + new vars = correct [OK]

Hint: Use := with at least one new variable to update and declare [OK]

Common Mistakes:

• Trying to redeclare only existing vars with :=
• Declaring new vars separately without updating existing
• Forgetting to include new variable in declaration