Explain the difference between make and new in Go. When would you use each?

Explain the difference between make and new in Go. When would you use each?

In Go, make and new are both used for memory allocation, but they serve different purposes and are used with different types.

• new: The new function allocates memory for a given type and returns a pointer to that memory. The memory is initialized to zero values for that type. new is used with any type, including built-in types, structs, and custom types. It returns a pointer of type *T to newly allocated zeroed storage for a new item of type T. For example:

  p := new(int)   // p, of type *int, points to an unnamed int variable
  fmt.Println(*p) // prints 0

  You would use new when you need a pointer to a zeroed value of a type, particularly when you're working with structs or other composite types where you want to ensure all fields are initialized to their zero values.

• make: The make function is used only with the built-in types slice, map, and channel. Unlike new, make initializes these types to non-zero values. It returns an initialized (not zeroed) value of type T (not *T), which is ready to use. For example:

  s := make([]int, 5) // s is a slice of ints, length 5, capacity 5
  m := make(map[string]int) // m is a map of strings to ints
  c := make(chan int) // c is a channel of ints

  You would use make when you're initializing slices, maps, or channels. These types need special initialization and are not merely allocated with zero values.

What types of data structures are best initialized with 'make' in Go?

In Go, the make function is specifically designed for initializing the following three data structures:

• Slices: Slices are dynamic arrays that can grow or shrink in size. When you use make with a slice, you specify the length and optionally the capacity. This initializes the slice with zero values for its elements.

  mySlice := make([]int, 5, 10) // length 5, capacity 10

• Maps: Maps are key-value pairs where keys are unique. Using <code>make with a map initializes an empty map ready to store key-value pairs.

  myMap := make(map[string]int)

• Channels: Channels are the conduits through which you can send and receive values with the channel operator . Using <code>make with a channel initializes an empty channel that can be used for communication between goroutines.

  myChannel := make(chan int)

How does memory allocation differ between 'make' and 'new' in Go?

Memory allocation in Go differs between make and new in the following ways:

• new: When you use new, Go allocates memory for the type you specify and returns a pointer to that memory. The memory is initialized to the zero value for the specified type. new essentially performs a simple memory allocation without any additional initialization beyond setting zero values. It is generic and works with any type.

  p := new(int) // allocates memory and returns a pointer to zeroed int

• make: When you use make, Go not only allocates memory but also initializes the data structure. For slices, make allocates an underlying array of the specified length and capacity, and the slice is initialized with zero values. For maps and channels, make performs necessary internal initialization to make them ready to use. make only works with slices, maps, and channels.

  s := make([]int, 5) // allocates memory for a slice and initializes it

In summary, new allocates memory and returns a pointer to zeroed storage, whereas make allocates memory and initializes the specified data structure (slice, map, or channel) to a ready-to-use state.

In what scenarios might 'new' be more appropriate than 'make' in Go?

new might be more appropriate than make in the following scenarios:

• When working with custom types or structs: If you're defining a custom type or struct and need a pointer to a zeroed instance of that type, new is the appropriate choice. This is often useful for initializing objects before you fill in their fields.

  type Person struct {
    Name string
    Age  int
  }
  
  p := new(Person) // p is of type *Person, points to zeroed Person struct
  p.Name = "Alice"
  p.Age = 30

• When you need a pointer to any type: If you need a pointer to a basic type like int, float64, etc., or to a custom type where you want the zero value, new is suitable. This can be useful in scenarios where you're working with pointers directly.

  pi := new(int) // pi is of type *int, points to zeroed int
  *pi = 42

• For efficient zero-value initialization: When you want to efficiently allocate and zero-initialize memory for a type without the overhead of additional setup that make performs for slices, maps, and channels, new is more appropriate.

  zeroInt := new(int) // Efficient way to get a zeroed int pointer

• For compatibility with older code or libraries: In some cases, older Go code or libraries might expect pointers to types, and new can be used to satisfy these expectations.

In summary, new is more appropriate when you need a pointer to a zeroed value of any type, especially when working with custom types, structs, or basic types where you want to initialize to zero values before further manipulation.

The above is the detailed content of Explain the difference between make and new in Go. When would you use each?. For more information, please follow other related articles on the PHP Chinese website!