make în Go

Creează și inițializează slice-uri, map-uri și canale, cu lungime, capacitate sau buffer dat.

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

make([]T, lungime)
make([]T, lungime, capacitate)
make(map[K]V)
make(map[K]V, dimensiuneEstimata)
make(chan T)
make(chan T, buffer)

Ce face make

make creează doar trei feluri de valori: slice-uri, map-uri și canale. Spre deosebire de new, returnează valoarea gata de folosit (nu un pointer).

Pentru slice: make([]int, 5) creează 5 elemente egale cu 0; make([]int, 0, 100) creează un slice gol cu loc rezervat pentru 100, util înaintea multor append. Pentru map: make(map[string]int) creează un map gol în care poți scrie; al doilea argument este doar o estimare a dimensiunii. Pentru canal: make(chan int) este fără buffer, make(chan int, 10) are buffer de 10.

Parametri

Parametru Descriere
t Tipul: []T, map[K]V sau chan T.
size Slice: lungimea și, opțional, capacitatea. Map: dimensiunea estimată (opțională). Canal: mărimea buffer-ului (opțională, implicit 0).

Ce returnează

Valoarea creată, de tipul t (nu un pointer).

Exemple

Exemplul 1: Cele trei utilizări

package main

import "fmt"

func main() {
    note := make([]int, 3)
    fmt.Println(note, len(note), cap(note))

    rezervat := make([]string, 0, 10)
    rezervat = append(rezervat, "Iași")
    fmt.Println(rezervat, len(rezervat), cap(rezervat))

    stoc := make(map[string]int)
    stoc["mere"] = 12
    fmt.Println(stoc)

    mesaje := make(chan string, 2)
    mesaje <- "salut"
    fmt.Println(<-mesaje, cap(mesaje))
}

Rezultat

[0 0 0] 3 3
[Iași] 1 10
map[mere:12]
salut 2

Exemplul 2: Matrice creată cu make

Fiecare rând este un slice separat, creat tot cu make.

package main

import "fmt"

func main() {
    randuri, coloane := 3, 4
    sala := make([][]rune, randuri)
    for i := range sala {
        sala[i] = make([]rune, coloane)
        for j := range sala[i] {
            sala[i][j] = 'o'
        }
    }
    sala[1][2] = 'x' // loc ocupat
    for _, r := range sala {
        fmt.Println(string(r))
    }
}

Rezultat

oooo
ooxo
oooo

Greșeli frecvente

  • make([]int, 10) urmat de append: rezultatul are 10 zerouri la început. Pentru un slice gol cu loc rezervat scrie make([]int, 0, 10).
  • make pentru alte tipuri: make(int) sau make(Struct) nu compilează (invalid argument: cannot make int: type must be slice, map, or channel).
  • Lungime mai mare decât capacitatea: make([]int, 5, 2) dă invalid argument: length and capacity swapped.

Comenzi înrudite

  • new: Alocă o variabilă nouă și returnează un pointer la ea; primește un tip (valoare zero) sau, din Go 1.26, o expresie.
  • slice-uri: Lista dinamică din Go: o fereastră peste un array, cu lungime (len) și capacitate (cap), care crește cu append.
  • map și map-uri: Tabel cheie-valoare (dicționar): căutare rapidă după cheie, adăugare, ștergere și verificare cu v, ok.
  • chan și canale (channels): Canalele (chan) transmit valori între goroutine în siguranță și le sincronizează; se creează cu make.
  • append: Adaugă elemente la finalul unui slice și returnează slice-ul rezultat, mărind memoria când e nevoie.