Go Variables

Variables are names that hold data which can change while the program is running. They let you store and use information in your program. For Example:

The number is: 10

Explanation:

• var number int = 10: creates a variable called number to store the value 10.
• fmt.Println: shows the value stored in the variable.

Rules for Naming Variables

1. Variable names must start with a letter or underscore (_).
2. Names can contain letters (a-z, A-Z), digits (0-9), and underscores _.
3. Variable names cannot start with a digit.
4. Variable names are case-sensitive: geeks and Geeks are different.
5. Keywords cannot be used as variable names.
6. No strict limit on length, but 4–15 characters is recommended.

Valid examples:

Geeks, geeks, _geeks23

Invalid examples:

123Geeks, 23geeks

Declaring Variables in Go

In Go language variables are created in two different ways:

• Using the var keyword
• Using short variable declaration (:=)

Using var keyword

Variables can be declared using the var keyword by specifying the variable name, type, and initial value.

Syntax

var variable_name type = expression

• In the above syntax, either type or = expression can be omitted, but not both.
• If the = expression is omitted, the variable is assigned the zero value of its type: 0 for numbers, false for Booleans, "" for strings, and nil for pointers or reference types.
• If the type is removed, then the type of the variable is determined by the value-initialize in the expression.

Example: Variable Declaration with Type Inference

The value of myvariable1 is : 20
The type of myvariable1 is : int
The value of myvariable2 is : GeeksforGeeks
The type of myvariable2 is : string
The value of myvariable3 is : 34.800000
The type of my...

Zero-Value Variables

If the expression is removed, the variable holds the zero-value of its type:

• 0 for numeric types
• false for boolean
• "" for strings
• nil for reference and interface types

Example:

myvariable1: 0
myvariable2: 
myvariable3: 0.000000

Declaring Multiple Variables of the Same Type

In Go, you can declare and initialize several variables of the same type in one line, which makes the code shorter and easier to read.

Output

a: 2, b: 45, c: 67

Declaring Multiple Variables of Different Types

Multiple variables of different types can be declared in a single line. If the type is not specified, Go automatically assigns a type based on the value.

Output

a: 2 (int), b: GFG (string), c: 67.560000 (float64)

Multiple Return Values from a Function

Variables can be initialized using a function that returns more than one value, allowing you to handle multiple results at once.

First number: 5
Second number: 10

Explanation:

• getNumbers() returns two numbers.
• a, b := getNumbers() stores both numbers in two variables at once.

Using Short Variable Declaration

The local variables which are declared and initialize in the functions are declared by using short variable declaration.

Syntax

variable_name := expression

Note: Please don't confuse in between := and = as := is a declaration and = is assignment.

Important Points: In the above expression, the type of the variable is determined by the type of the expression.

myvar1: 39 (int)
myvar2: GeeksforGeeks (string)
myvar3: 34.670000 (float64)

Declaring Multiple Variables Using := (Same Type)

Multiple local variables of the same type can be declared and initialized in a single line using the short variable declaration :=

Output

myvar1: 800 (int)
myvar2: 34 (int)
myvar3: 56 (int)

Declaring Multiple Variables Using := (Different Type)

Multiple local variables of different types can be declared and initialized in a single line using the short variable declaration :=, and Go automatically determines their types from the values.

Output

myvar1: 800 (int)
myvar2: Geeks (string)
myvar3: 47.560000 (float64)

Multiple Return Values with Short Declaration

Variables can be initialized using a function that returns multiple values, and the short declaration := can be used to store them in a single line.

Number: 7
Text: GoLang

Explanation:

• getValues() returns two values: an int and a string.
• x, y := getValues() uses short variable declaration := to assign both values at once.

Short Declaration as Assignment

A short variable declaration works like an assignment only if at least one variable is new in the same block.

The value of myvar1 and myvar2 is : 39 100
The value of myvar3 and myvar2 is : 45 100