Short Variable Declaration in Go: What It Is and How to Use It

In Go, short variable declaration is a concise way to declare and initialize variables using := without explicitly stating the type. It lets you quickly create variables with their type inferred from the assigned value.

How It Works

Short variable declaration in Go uses the := operator to declare and initialize variables in one simple step. Instead of writing the full form with var and a type, Go figures out the type automatically from the value you assign. Think of it like quickly jotting down a note where the meaning is clear without extra explanation.

This is handy when you want to save time and keep your code clean. It works only inside functions, not at the package level, because Go needs to infer the type from the assigned value right away. If you try to use it outside a function, the compiler will give an error.

Example

This example shows how to declare a variable using short variable declaration and print its value.

go

package main

import "fmt"

func main() {
    message := "Hello, Go!"
    fmt.Println(message)
}

Output

Hello, Go!

When to Use

Use short variable declaration when you want to quickly create variables inside functions without writing their type. It is perfect for temporary variables, counters, or when the type is obvious from the value. For example, in loops, conditionals, or when calling functions that return values.

However, avoid it at the package level or when you want to declare a variable without initializing it immediately. Also, if you need to declare multiple variables with the same type but no initial value, use the full var syntax.

Key Points

• Short variable declaration uses := to declare and initialize variables in one step.
• It infers the variable type from the assigned value automatically.
• It can only be used inside functions, not at the package level.
• It helps write concise and readable code for local variables.

Key Takeaways

Short variable declaration uses := to declare and initialize variables with inferred types.

It works only inside functions, not at the package level.

Use it for quick, local variable creation when the type is clear from the value.

Avoid it when you need to declare variables without immediate initialization.

It keeps code concise and easy to read for common variable assignments.