len și cap în Go

func len(v Type) int
func cap(v Type) int

Ce face len și cap

len(v) dă lungimea: numărul de elemente pentru slice-uri, array-uri și map-uri, numărul de octeți pentru texte (string) și numărul de valori aflate în buffer pentru canale. Pentru un slice, map sau canal nil, len dă 0, fără eroare.

cap(v) dă capacitatea: câte elemente încap în array-ul de sub un slice fără realocare, lungimea unui array sau dimensiunea buffer-ului unui canal. cap nu se aplică map-urilor și textelor.

Pe array-uri și pe texte constante, len este calculat la compilare și poate fi folosit în constante: const n = len("Iași").

Parametri

Parametru	Descriere
v	Un slice, array, pointer la array, map (doar len), string (doar len) sau canal.

Ce returnează

Un int: lungimea sau capacitatea.

Exemple

Exemplul 1: len pe tipuri diferite

La text, len numără octeții: „Iași” are 4 litere, dar 5 octeți.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    note := []int{9, 7, 10}
    zile := [7]string{}
    stoc := map[string]int{"mere": 5, "pere": 2}
    oras := "Iași"
    var gol []int

    fmt.Println(len(note), len(zile), len(stoc), len(gol))
    fmt.Println("octeți:", len(oras), "litere:", utf8.RuneCountInString(oras))
}

Rezultat

3 7 2 0
octeți: 5 litere: 4

Exemplul 2: cap la slice și la canal

package main

import "fmt"

func main() {
    s := make([]int, 2, 5)
    fmt.Println("len", len(s), "cap", cap(s))
    parte := s[1:2]
    fmt.Println("parte: len", len(parte), "cap", cap(parte)) // până la capătul array-ului

    c := make(chan string, 4)
    c <- "a"
    c <- "b"
    fmt.Println("canal: len", len(c), "cap", cap(c))
}

Rezultat

len 2 cap 5
parte: len 1 cap 4
canal: len 2 cap 4

Greșeli frecvente

• len(text) folosit ca număr de litere: greșit pentru diacritice.
• cap(m) pe un map: invalid argument: m (variable of type map[string]int) for built-in cap.
• Buclă for i := 0; i <= len(s); i++: ultimul pas dă index out of range. Condiția corectă este i < len(s).

Comenzi înrudite

• slice-uri: Lista dinamică din Go: o fereastră peste un array, cu lungime (len) și capacitate (cap), care crește cu append.
• append: Adaugă elemente la finalul unui slice și returnează slice-ul rezultat, mărind memoria când e nevoie.
• make: Creează și inițializează slice-uri, map-uri și canale, cu lungime, capacitate sau buffer dat.
• string-uri, rune și byte: Textul în Go este UTF-8: len dă octeți, range dă rune (caractere), byte este un octet, rune un caracter.
• chan și canale (channels): Canalele (chan) transmit valori între goroutine în siguranță și le sincronizează; se creează cu make.