Constants in Go - Step-by-Step Execution

Concept Flow - Constants

Declare constant with const keyword

↓

Assign fixed value

↓

Use constant in code

↓

Value cannot change

↓

Program runs

Constants are fixed values set once and used throughout the program without change.

Execution Sample

Go

package main
import "fmt"
const Pi = 3.14
func main() {
    fmt.Println(Pi)
}

This code declares a constant Pi and prints its value.

Execution Table

Step	Action	Evaluation	Result
1	Declare constant Pi	const Pi = 3.14	Pi is set to 3.14
2	Enter main function	func main()	Ready to execute main
3	Print Pi	fmt.Println(Pi)	Outputs 3.14
4	End program	No further code	Program terminates

💡 Program ends after printing the constant Pi value

Variable Tracker

Variable	Start	After 1	After 2	Final
Pi	undefined	3.14	3.14	3.14

Key Moments - 2 Insights

Why can't we change the value of Pi after declaring it?

Because Pi is declared as a constant (see execution_table step 1), its value is fixed and cannot be reassigned.

What happens if we try to assign a new value to Pi?

The Go compiler will give an error since constants cannot be changed after declaration, preventing reassignment.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of Pi at step 3?

A 3.14

B undefined

C 0

D Error

💡 Hint

Check the 'Evaluation' and 'Result' columns at step 3 in the execution_table.

At which step does the program print the constant value?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for the action 'Print Pi' in the execution_table.

If we tried to assign Pi = 3.1415 after declaration, what would happen?

A Pi changes to 3.1415

B Compiler error

C Program prints 3.1415

D Program ignores the assignment

💡 Hint

Constants cannot be reassigned as explained in key_moments and execution_table step 1.

Concept Snapshot

Constants in Go:
- Declared with 'const' keyword
- Assigned a fixed value at declaration
- Value cannot be changed later
- Used like variables but immutable
- Helps prevent accidental value changes

Full Transcript

This visual execution shows how constants work in Go. First, a constant Pi is declared with the value 3.14. This value is fixed and cannot be changed later. The main function prints the value of Pi. The program ends after printing. Trying to change Pi would cause a compiler error because constants are immutable.