> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Go Short Variable
A short variable declaration uses the `:=` operator to declare and initialize one or more local variables simultaneously, relying on the compiler to infer their types from the assigned values. It serves as a syntactic shorthand for a standard `var` declaration with an initializer, omitting the explicit type signature.
## Syntax
```go theme={"dark"}
identifier := expression
identifier1, identifier2 := expression1, expression2
```
## Lexical Scope Restrictions
Short variable declarations are strictly confined to block scope. They can only be utilized within the body of a function. Package-level variables must be declared using the `var` keyword; attempting to use `:=` at the package level results in a compile-time syntax error (`non-declaration statement outside function body`).
## Type Inference Mechanics
The compiler resolves the type of the newly declared variable at compile time based on the right-hand side (RHS) expression.
* If the RHS is a typed expression, the variable inherits that exact type.
* If the RHS is an untyped constant, the variable assumes the default type for that constant class: `int` for integers, `float64` for floating-point numbers, `complex128` for complex numbers, `rune` for character literals, `string` for string literals, and `bool` for boolean constants.
```go theme={"dark"}
package main
import (
"fmt"
"os"
)
func main() {
// Type inferred as int (default for untyped integer constant)
count := 10
// Type inferred as float64 (default for untyped float constant)
pi := 3.14
// Type inferred as bool (default for untyped boolean constant)
isActive := true
// Type explicitly derived from the RHS function return types
file, err := os.Open("data.txt")
// Variables evaluated to satisfy the compiler's unused variable constraint
fmt.Println(count, pi, isActive, file, err)
}
```
## Redeclaration and Assignment Rules
Unlike standard `var` declarations, the `:=` operator permits the redeclaration of existing variables within the same lexical block, subject to a strict condition: **at least one non-blank variable on the left-hand side (LHS) must be newly declared.** The blank identifier (`_`) does not satisfy the requirement for a new variable.
When this condition is met, the `:=` operator acts as a standard assignment for the previously declared variables and a declaration for the new ones. The redeclared variables must retain their original type.
```go theme={"dark"}
package main
import "fmt"
func main() {
// 'a' and 'b' are newly declared
a, b := 1, 2
// Valid: 'c' is new. 'a' is merely reassigned.
a, c := 3, 4
// Invalid: The blank identifier (_) does not count as a new variable.
// a, _ := 5, 6 // Compile error: no new variables on left side of :=
// Variables evaluated to satisfy the compiler's unused variable constraint
fmt.Println(a, b, c)
}
```
## Variable Shadowing
Because `:=` always constitutes a declaration (for at least the new variables on the LHS), using it within a nested lexical block—such as an `if`, `for`, or `switch` statement—will instantiate a new variable. This new variable will shadow any variable with the identical identifier in an outer scope for the duration of the inner block.
```go theme={"dark"}
package main
import "fmt"
func main() {
x := 10 // Outer scope 'x'
if true {
x := 5 // Declares a NEW 'x' in the inner scope, shadowing the outer 'x'
x++ // Modifies the inner 'x' (becomes 6)
fmt.Println(x) // Prints 6
}
// Outer 'x' remains 10
fmt.Println(x) // Prints 10
}
```
Tired of Poor Go Skills? Fix That With Deep Grasping!
Learn More
