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:

x, y = 3, 4

Important rule about :=

:= can only be used when at least one variable on the left side is new.

x := 1
x, y := 2, 3 // valid because y is new

But this is invalid:

x := 1
x := 2 // invalid in the same scope: no new variables

Example

package main

import "fmt"

func main() {
    language := "Go"
    fmt.Println(language)

    language = "Golang"
    fmt.Println(language)
}

What happens here

• language := "Go" declares a new variable named language
• language = "Golang" updates the existing variable
• both lines store values, but only the first line creates the variable

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)

   • The updated value is printed
   • Output: 8

Scope example

package main

import "fmt"

func main() {
    value := 10

    if true {
        value := 20
        fmt.Println("inside:", value)
    }

    fmt.Println("outside:", value)
}

What prints

inside: 20
outside: 10

Inside the if block, value := 20 creates a new local variable instead of changing the outer value. This is called shadowing.

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

var err error
result, err = doWork()

This is useful when the variable already exists and you want to update it instead of declaring a new one.

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 err variable in an inner scope.

result, err := firstStep()
if err != nil {
    return err
}

if true {
    result, err := secondStep()
    _ = result
    if err != nil {
        return err
    }
}

The inner err is different from the outer one. This is sometimes fine, but sometimes confusing. Many teams prefer avoiding unnecessary shadowing for readability.

5. Guard clause pattern

data, err := loadData()
if err != nil {
    return err
}

This style appears throughout Go programs. := is used to declare data and err once, then if err != nil handles failure immediately.

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

Broken or confusing code:

total := 100
if true {
    total := 50
    fmt.Println(total)
}
fmt.Println(total)

This prints:

50
100

Why it happens:

• the inner total := 50 creates a new variable
• it does not update the outer total

Fix if you want to update the outer variable:

total := 100
if true {
    total = 50
}
fmt.Println(total)

4. Trying to use := at package level

Broken code:

package main

message := "hello"

Why it fails:

• short variable declaration is only allowed inside functions

Fix:

package main

var message = "hello"

5. Confusing declaration with reassignment in multiple assignment

x := 1
x, y := 2, 3

This is valid because y is new.

But this is not:

x := 1
y := 2
x, y := 3, 4

Fix:

x := 1
y := 2
x, y = 3, 4

var vs :=

Quick rule

• Use := when introducing a new local variable.
• Use = when changing an existing variable.

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

Common patterns

value := 10
value = 11

var name string
name = "Alice"

data, err := load()
if err != nil {
    return err
}

Common error signs

• no new variables on left side of :=
• undefined: variableName
• unexpected shadowing in inner blocks

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.

Can := and = both appear to assign values?

Yes, both place values into variables, but only := creates a new variable. = only updates an existing one.

• 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.