Difference Between := and = in Go

By the end of this page, you will understand that = is used to assign a new value to an existing variable, while := is used for short variable declaration, which both declares and initializes variables. You will also see where each can be used, how scope affects them, and which beginner mistakes to avoid.

In Go, = and := are related, but they do different jobs.

• = means assign a value to a variable that already exists.
• := means declare a new variable and give it an initial value at the same time.

This distinction matters because Go is a statically typed language. Variables must be declared before they can be used. The := syntax is a convenient shortcut that lets Go infer the variable's type from the value on the right side.

= assignment

Use = when the variable has already been declared.

var age int
age = 30

You can also assign a new value later:

age = 31

:= short variable declaration

Use := when you want to create a variable and initialize it in one step.

age := 30

Go infers that age is an int.

Why this matters

This is important in real Go programs because:

• it affects scope
• it affects readability
• it prevents use of undeclared variables
• it helps Go infer types cleanly

A very common source of bugs is accidentally using := inside a smaller scope and creating a new variable instead of updating an existing one.

Think of variables like labeled storage boxes.

• := is like creating a new box, putting a label on it, and placing something inside.
• = is like opening an existing box and replacing what is inside.

If the box does not exist yet, you cannot use =. If the box already exists, using := may create a different box in a smaller area instead of reusing the original one.

Core syntax

Declare and initialize with :=

name := "Alice"
count := 10
isAdmin := true

Use this inside functions when you want a quick local variable declaration.

Declare first, assign later with =

var name string
name = "Alice"

Reassign an existing variable with =

score := 100
score = 120

Multiple variables with :=

x, y := 1, 2

Multiple assignment with =

x = 3
y = 4

Or:

Consider this example:

package main

import "fmt"

func main() {
    count := 5
    fmt.Println(count)

    count = 8
    fmt.Println(count)
}

Step-by-step

1. count := 5

   • Go creates a new variable named count
   • Go infers its type as int
   • The value 5 is stored in it

2. fmt.Println(count)

   • The current value of count is printed
   • Output: 5

3. count = 8

   • No new variable is created
   • The existing count variable is updated to 8

4. fmt.Println(count)

Where := is commonly used

Local variables inside functions

userID := 42
name := "Sam"

This is the most common style for short local setup code.

Receiving function results

result, err := doWork()

This is extremely common in Go, especially with error handling.

Loop and temporary values

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

Where = is commonly used

Updating state

total := 0
total = total + 5

Assigning after declaration

var configPath string
configPath = "/etc/app.conf"

Reusing existing variables

 err 
result, err = doWork()

In real Go codebases, developers usually follow a few common patterns.

1. Prefer := for short local declarations

Inside functions, := is often the default for variables that are first introduced close to where they are used.

file, err := os.Open("data.txt")

This keeps code short and readable.

2. Use = when updating existing variables

count := 0
count = count + 1

This makes it clear that the variable already exists and is being changed.

3. Use var plus = when zero value or wider scope is useful

var err error
var data []byte

data, err = os.ReadFile("config.json")

This is common when a variable must be used across several branches or later in the function.

4. Be careful with error shadowing

A common real-world bug happens when a developer writes := and accidentally creates a new variable in an inner scope.

1. Using = before declaring a variable

Broken code:

name = "Alice"

Why it fails:

• name does not exist yet
• Go requires variables to be declared before assignment

Fix:

name := "Alice"

Or:

var name string
name = "Alice"

2. Using := for an existing variable in the same scope

Broken code:

age := 20
age := 21

Why it fails:

• the second line does not introduce any new variable
• := requires at least one new variable on the left side

Fix:

age := 20
age = 21

3. Accidental shadowing inside a block

var vs :=

Quick reference

Use := when

• you are declaring a new variable
• you are inside a function
• you want Go to infer the type

name := "Go"
count := 10
result, err := doWork()

Use = when

• the variable already exists
• you want to change its value
• you declared it earlier with var or :=

count = 20
err = nil
x, y = 1, 2

Rules to remember

• := declares and initializes
• = only assigns
• := works only inside functions
• := needs at least one new variable on the left side
• = cannot be used with undeclared variables
• := can accidentally shadow outer variables

Can I use := everywhere in Go?

No. := can only be used inside functions. At package level, use var.

Is := just a shorter version of var?

It is a short declaration form for local variables. It both declares the variable and initializes it, with type inference.

Can I use = to create a variable?

No. = only assigns to a variable that already exists.

Why does Go say "no new variables on left side of :="?

Because := requires at least one variable on the left side to be newly declared in the current scope.

What is variable shadowing in Go?

Shadowing happens when := creates a new variable inside an inner scope with the same name as an outer variable.

Should I prefer := or var in Go?

Inside functions, := is often preferred for short local variables. Use var when you need explicit types, zero values, or package-level declarations.

• var declarations — related because var is the standard way to declare variables explicitly in Go.
• variable scope — related because := often creates variables in a specific block scope.
• variable shadowing — related because using := in inner blocks can hide outer variables.
• type inference — related because := lets Go determine the variable type automatically.
• zero values in Go — related because var declarations create variables even before assigning explicit values.
• multiple assignment — related because both = and := can work with multiple variables.
• error handling in Go — related because result, err := ... is one of the most common Go patterns.