What is the difference between Go's make function and new function?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
In Go, make and new are two built-in functions used for memory allocation, but they serve different purposes and are used in different contexts. Understanding the distinction between make and new is crucial for effective memory management and data structure initialization in Go. This guide explains the differences between make and new, including their uses, syntax, and practical examples.
The new Function
Purpose
The new function in Go is used to allocate memory for a variable and returns a pointer to that memory. It initializes the allocated memory with the zero value of the type being allocated.
Syntax
pointer := new(Type)

Type is the type of the value to allocate.
pointer is a pointer to the allocated zero value of Type.

Example
package main

import "fmt"

func main() {
    // Allocate memory for an int
    p := new(int)

// Print the value and address
    fmt.Println("Value:", *p)  // Output: Value: 0
    fmt.Println("Address:", p)
}

Explanation:

new(int) allocates memory for an int and returns a pointer to it.
The pointer p points to an int with a zero value of 0.

Key Points

new only allocates memory and zeroes it out.
It returns a pointer to the allocated memory.
Used for basic types and structs when you need a pointer to a zeroed value.

The make Function
Purpose
The make function is used to initialize slices, maps, and channels. Unlike new, make not only allocates memory but also initializes the underlying data structure, making it ready for use.
Syntax
slice := make([]Type, length, capacity)
map := make(map[KeyType]ValueType)
channel := make(chan Type, bufferSize)

slice: Initializes a slice with a specified length and capacity.
map: Initializes a map with the specified key and value types.
channel: Initializes a channel with a specified buffer size.

Example: Using make with a Slice
package main

import "fmt"

func main() {
    // Initialize a slice with length 3 and capacity 5
    s := make([]int, 3, 5)

// Print the slice
    fmt.Println("Slice:", s)            // Output: Slice: [0 0 0]
    fmt.Println("Length:", len(s))      // Output: Length: 3
    fmt.Println("Capacity:", cap(s))    // Output: Capacity: 5
}

Explanation:

make([]int, 3, 5) creates a slice with 3 elements, each initialized to zero, and a capacity of 5.

Example: Using make with a Map
package main

import "fmt"

func main() {
    // Initialize a map with string keys and int values
    m := make(map[string]int)

// Set some key-value pairs
    m["a"] = 1
    m["b"] = 2

// Print the map
    fmt.Println("Map:", m)  // Output: Map: map[a:1 b:2]
}

Explanation:

make(map[string]int) creates a map ready for storing key-value pairs with string keys and int values.

Example: Using make with a Channel
package main

import "fmt"

func main() {
    // Initialize a channel with a buffer size of 2
    ch := make(chan int, 2)

// Send values into the channel
    ch &#x3C;- 1
    ch &#x3C;- 2

// Receive values from the channel
    fmt.Println(&#x3C;-ch)  // Output: 1
    fmt.Println(&#x3C;-ch)  // Output: 2
}

Explanation:

make(chan int, 2) creates a buffered channel that can hold up to 2 int values.

Key Points

make initializes and returns an initialized data structure.
It is used for slices, maps, and channels.
It prepares the data structure for use by setting initial values or setting buffer sizes.

Summary of Differences
| Feature | new Function | make Function |
| --- | --- | --- |
| Usage | Allocates memory and returns a pointer. | Initializes and returns an initialized data structure. |
| Types | Basic types (e.g., int, float64, struct). | Slices, maps, channels. |
| Initialization | Initializes memory to zero value. | Initializes underlying data structure, not zero. |
| Return Type | Returns a pointer to the allocated value. | Returns the data structure itself. |
| Example |   |   |
p := new(int)

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

Conclusion
In Go, the new function and make function are both essential for memory allocation, but they serve different purposes. The new function is used for allocating memory and returning a pointer to a zeroed value, while the make function is specifically for initializing slices, maps, and channels, setting them up for immediate use. Understanding when and how to use each function helps in writing more efficient and effective Go code.

What is the difference between Go's make function and new function?

Table of Contents

Introduction

The `new` Function

Purpose

The `make` Function

Purpose

Example: Using `make` with a Slice

Example: Using `make` with a Map

Example: Using `make` with a Channel

Summary of Differences

Conclusion

Similar Questions

Feature	`new` Function	`make` Function
Usage	Allocates memory and returns a pointer.	Initializes and returns an initialized data structure.
Types	Basic types (e.g., int, float64, struct).	Slices, maps, channels.
Initialization	Initializes memory to zero value.	Initializes underlying data structure, not zero.
Return Type	Returns a pointer to the allocated value.	Returns the data structure itself.
Example