Explicación detallada de la diferencia entre golang make y new

Tabla de contenido

Muchos amigos no entendieron por qué hay dos funciones para asignar memoria cuando entraron en contacto por primera vez con Golang: nuevo y hacer. Como dice el refrán: La existencia es razonable. Expliquemos en detalle la diferencia entre las dos.

Uno nuevo

Mira primero la declaración de la función:

func new(Type) *Type

new es una función incorporada de Golang, que se utiliza para asignar memoria. El primer parámetro es el tipo y el valor de retorno es el puntero del tipo. Su valor se inicializa a "cero" (valor cero correspondiente al tipo, int se inicializa a 0, bool se inicializa a falso, etc.).

P.ej:

package main
import "fmt"

func main() {
	id := new(int)
	name := new(string)
	flag := new(bool)
	fmt.Printf("id type: %T  value: %v\n", id, *id)
	fmt.Printf("name type: %T  value: %v\n", name, *name)
	fmt.Printf("flag type: %T  value: %v\n", flag, *flag)
}

Salida:

id type: *int  value: 0
name type: *string  value: 
flag type: *bool  value: false

Como puede verse en el ejemplo anterior, el valor "cero" inicializado difiere según el tipo: el número entero se inicializa en 0, la cadena se inicializa en vacío y el tipo bool se inicializa en falso.

Dos, haz

Mira primero la declaración de la función:

func make(t Type, size ...IntegerType) Type

make es una función incorporada de Golang. Solo se utiliza para asignar e inicializar tipos de objetos de corte, mapa y canal. Los tres tipos son estructuras. El valor de retorno es un tipo, no un puntero.

Estructura del código fuente de Slice:

type slice struct {
    array unsafe.Pointer  //指针
    len   int             //长度
    cap   int             //容量
}

Estructura del código fuente del mapa:

// A header for a Go map.
type hmap struct {
	// Note: the format of the hmap is also encoded in cmd/compile/internal/gc/reflect.go.
	// Make sure this stays in sync with the compiler's definition.
	count     int // # live cells == size of map.  Must be first (used by len() builtin)
	flags     uint8
	B         uint8  // log_2 of # of buckets (can hold up to loadFactor * 2^B items)
	noverflow uint16 // approximate number of overflow buckets; see incrnoverflow for details
	hash0     uint32 // hash seed

	buckets    unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.
	oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing
	nevacuate  uintptr        // progress counter for evacuation (buckets less than this have been evacuated)

	extra *mapextra // optional fields
}

Estructura de fuente de canal:

type hchan struct {
	qcount   uint           // total data in the queue
	dataqsiz uint           // size of the circular queue
	buf      unsafe.Pointer // points to an array of dataqsiz elements
	elemsize uint16
	closed   uint32
	elemtype *_type // element type
	sendx    uint   // send index
	recvx    uint   // receive index
	recvq    waitq  // list of recv waiters
	sendq    waitq  // list of send waiters

	// lock protects all fields in hchan, as well as several
	// fields in sudogs blocked on this channel.
	//
	// Do not change another G's status while holding this lock
	// (in particular, do not ready a G), as this can deadlock
	// with stack shrinking.
	lock mutex
}

P.ej:

package main

import "fmt"

func main() {
	//map
	fmt.Println("map:")
	var nameId = make(map[string]int, 0)
	fmt.Printf("nameId \ntype: %#v\n", nameId)
	nameId["Golang"] = 1
	nameId["C++"] = 2
	nameId["PHP"] = 3

	for name, id := range nameId {
		fmt.Printf("name = %v, id = %v\n", name, id)
	}
	// slice
	var hobby = make([]string, 2, 100) // 其中 2是长度，100是容量
	hobby[0] = "打篮球"
	hobby[1] = "乒乓球"
	fmt.Println("\nslice:")
	fmt.Printf("length = %v  caps = %v\n", len(hobby), cap(hobby))
	for _, name := range hobby {
		fmt.Println(name)
	}
	// channel
	ch := make(chan int, 3)
	ch <- 1
	ch <- 2
	ch <- 8
	close(ch)
	fmt.Println("\nchannel:")
	for val := range ch { // 遍历数据
		fmt.Println(val)
	}
}

Salida:

[root@localhost test]# go run main.go 
map:
nameId 
type: map[string]int{}
name = Golang, id = 1
name = C++, id = 2
name = PHP, id = 3

slice:
length = 2  caps = 100
打篮球
乒乓球

channel:
1
2
8
[root@localhost test]#

Tres, la diferencia entre new y make

1. Tanto new como make se utilizan para asignar memoria;

2. Tanto new como make asignan memoria en el montón;

3. New asigna memoria para tipos de puntero, y el valor de retorno es un puntero de tipo de asignación. New no puede asignar memoria directamente para segmento, mapa y canal;

4. Make solo se usa para la inicialización de slice, map y channel, y el valor de retorno es el tipo en sí, no un puntero;