Go make() vs new(): When and Why to Use Each

By the end of this page, you will understand why new() and make() exist in Go, what each one actually does, and why returning local values from a function is completely valid. You will also learn which types use make(), which types can use new(), and the practical situations where Go developers choose one approach over another.

In Go, new() and make() solve different problems.

• new(T) allocates zeroed storage for a value of type T and returns *T.
• make(T, ...) creates and initializes certain built-in reference-like types and returns a value of type T, not *T.

What new() does

new(T) gives you a pointer to a zero value of type T.

p := new(int)
fmt.Println(*p) // 0

This is roughly similar to:

var x int
p := &x

So new() is not magic memory management that makes values survive after a function returns. Go already allows that safely.

What make() does

Think of Go values as different kinds of containers.

• new() gives you the address of an empty box.
• make() gives you a box that is already assembled and ready for use for special container types.

Analogy

Imagine three situations:

• new(int) is like getting a numbered parking spot with a car-sized empty space in it. You now have a pointer to that spot.
• make([]int, 3) is like getting an actual shelf with 3 usable slots already set up.
• Returning a local variable from a function is like handing someone the shelf before leaving the room. Go makes sure it remains available.

The key idea is:

• new() allocates storage
• make() initializes special built-in data structures
• returning locals is safe because Go handles the memory details for you

Core syntax

new()

p := new(T)

• Allocates zeroed storage for type T
• Returns *T

Example:

package main

import "fmt"

func main() {
    count := new(int)
    fmt.Println(*count) // 0

    *count = 42
    fmt.Println(*count) // 42
}

Here, count is a pointer to an int.

make()

s := make([]int, len, cap)
m := make(map[string]int)
ch := make( )

Consider this example:

package main

import "fmt"

func build() (*int, map[string]int) {
    n := 7
    m := make(map[string]int)
    m["value"] = n
    return &n, m
}

func main() {
    p, m := build()
    fmt.Println(*p)
    fmt.Println(m["value"])
}

Step by step

Inside build()

1. n := 7

   • A local integer variable is created with value 7.

2. m := make(map[string]int)

   • A usable empty map is created.
   • This map is initialized and ready to store key-value pairs.

3. m["value"] = n

Common practical uses of make()

Building maps for lookups

userAges := make(map[string]int)
userAges["Sam"] = 31

Used in:

• caching data
• counting occurrences
• grouping records
• configuration lookups

Creating slices with known size

results := make([]string, 0, 100)

Used in:

• collecting database rows
• building API response lists
• processing files line by line

Creating channels for goroutines

jobs := make(chan string)

Used in:

• worker pools
• background processing
• passing data safely between goroutines

Common practical uses of new()

When you specifically need a pointer to a zero value

In real Go codebases, developers usually choose the clearest form rather than always reaching for new().

Common patterns

Composite literals for structs

type Server struct {
    Host string
    Port int
}

func NewServer() *Server {
    return &Server{Host: "localhost", Port: 8080}
}

This is more common than:

s := new(Server)
s.Host = "localhost"
s.Port = 8080
return s

make() before writing to a map

func countWords(words []string) map[string]int {
    counts := make(map[string]int)
    for _, w := range words {
        counts[w]++
    }
     counts
}

1. Using new(map[...]) and expecting a usable map

Broken code:

m := new(map[string]int)
(*m)["a"] = 1

Why it fails:

• new(map[string]int) returns *map[string]int
• the map value inside is still nil
• writing to a nil map causes a panic

Correct code:

m := make(map[string]int)
m["a"] = 1

2. Using new([]int) when you really want a slice

Broken idea:

s := new([]int)
fmt.Println(len(*s)) // 0, but not very useful

This gives you a pointer to a nil slice, not an initialized working slice with length or capacity.

Usually you want:

new() vs make()

new(User) vs &User{}

Quick reference

Use new() when

• You need a *T
• You want a pointer to a zero value

p := new(int)   // *int
u := new(User)  // *User

Use make() when

• You need a usable slice, map, or channel

s := make([]int, 5)
m := make(map[string]int)
ch := make(chan string)

Important rules

• new(T) returns *T
• make(T, ...) returns T
• make() only works for slices, maps, and channels
• Returning pointers to local variables is safe in Go
• Nil map: readable, not writable

Why does Go have both new() and make()?

Because they do different jobs. new() allocates zeroed storage and returns a pointer. make() creates usable slices, maps, and channels.

Can I return a pointer to a local variable in Go?

Yes. Go makes this safe automatically.

Why can't I write to a nil map?

A nil map has no initialized internal storage for entries. Use make(map[K]V) first.

Why can I append to a nil slice but not write to a nil map?

Slices and maps have different runtime behavior. append can allocate a new backing array for a nil slice, but map assignment requires an initialized map.

Should I use new() for structs?

Usually, &Struct{} or &Struct{Field: value} is clearer and more idiomatic.

Does make() allocate on the heap?

You usually do not need to care. Go decides stack or heap placement automatically based on usage.

Can make() be used with arrays or structs?

No. make() is only for slices, maps, and channels.

• Pointers in Go — new() returns pointers, so pointer basics are directly related.
• Zero values in Go — both new() and ordinary declarations produce zero-valued data.
• Slices in Go — slices are one of the main types created with make().
• Maps in Go — maps often require make() before inserting values.
• Channels in Go — channels are always created with make().
• Composite literals in Go — &Struct{} is a common alternative to new(Struct).
• Escape analysis in Go — helps explain why returning local pointers is safe.
• Nil values in Go — understanding nil is important for maps, slices, and pointers.