Go Academy · Lezione

Map: archivi chiave-valore

Creare, leggere, scrivere ed eliminare elementi dalle map

Map: archivi chiave-valore è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Che cos'è una map

Una map in Go è una raccolta non ordinata di coppie chiave-valore. Le chiavi devono essere di un tipo confrontabile (stringhe, interi e così via). Le map sono tipi riferimento supportati da una tabella hash.

Creare map

Utilizzi un literal o make:

package main
import "fmt"

func main() {
    ages  := map[string]int{"Alice": 30, "Bob": 25}
    cache := make(map[string]string)
    fmt.Println(ages, cache)
}

Leggere e scrivere

Acceda ai valori con m[key] e assegni valori con m[key] = value. La lettura di una chiave mancante restituisce il valore zero:

package main
import "fmt"

func main() {
    m := map[string]int{}
    m["hits"] = 10
    m["hits"]++
    fmt.Println(m["hits"])    // 11
    fmt.Println(m["missing"]) // 0
}

Verificare l'esistenza di una chiave

La forma a due valori distingue una chiave mancante da un valore zero:

package main
import "fmt"

func main() {
    m := map[string]int{"a": 0}
    v, ok := m["a"]
    fmt.Println(v, ok) // 0 true
    v2, ok2 := m["z"]
    fmt.Println(v2, ok2) // 0 false
}

Eliminare voci

Utilizzi la funzione integrata delete. Eliminare una chiave inesistente non ha alcun effetto:

package main
import "fmt"

func main() {
    m := map[string]int{"x": 1, "y": 2}
    delete(m, "x")
    delete(m, "z") // no-op
    fmt.Println(m) // map[y:2]
}

Iterare su una map

Utilizzi range per iterare. L'ordine non è garantito:

package main
import "fmt"

func main() {
    scores := map[string]int{"Alice": 90, "Bob": 85}
    for name, score := range scores {
        fmt.Printf("%s: %d\n", name, score)
    }
}

Map con valori struct

Le map possono contenere struct come valori. Esegua l'aggiornamento tramite una variabile temporanea (le struct nelle map non sono indirizzabili):

package main
import "fmt"

type Point struct{ X, Y int }

func main() {
    points := map[string]Point{"A": {1, 2}}
    p := points["A"]
    p.X = 99
    points["A"] = p
    fmt.Println(points["A"]) // {99 2}
}

Map nil

Una map nil viene letta come una map vuota (restituisce valori zero), ma scrivere in una map nil genera un panic:

package main

func main() {
    var m map[string]int
    _ = m["key"]   // ok — returns 0
    // m["key"] = 1 // PANIC: assignment to nil map
}

Le map non sono sicure per l'uso concorrente

La map integrata di Go non è sicura per l'uso da parte delle goroutine. Le letture concorrenti vanno bene, ma le scritture concorrenti (o una lettura e una scrittura) richiedono un mutex o sync.Map:

package main
import "sync"

func main() {
    var mu sync.Mutex
    m := map[string]int{}
    mu.Lock()
    m["key"] = 1
    mu.Unlock()
    _ = m
}

Contare le frequenze

Un pattern classico delle map: contare le occorrenze:

package main
import "fmt"

func main() {
    words := []string{"go", "is", "fast", "go", "is", "go"}
    freq := map[string]int{}
    for _, w := range words {
        freq[w]++
    }
    fmt.Println(freq) // map[fast:1 go:3 is:2]
}

Verifica rapida

Che cosa accade quando si legge una chiave che non esiste in una map Go?

Riepilogo: map

Punti chiave:

Le map sono raccolte chiave-valore non ordinate
Utilizzi la forma a due valori per verificare l'esistenza di una chiave
Non scriva mai in una map nil
L'ordine di iterazione è casuale: ordini le chiavi se necessario
Protegga le map con un mutex nel codice concorrente

Esercizio

Scriva una funzione che accetti una stringa e restituisca una map[rune]int che conta quante volte compare ogni carattere. La provi con la stringa "hello".

Domande Frequenti

La lezione «Map: archivi chiave-valore» è gratuita?

Sì — il testo completo di «Map: archivi chiave-valore» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Map: archivi chiave-valore»?

Creare, leggere, scrivere ed eliminare elementi dalle map Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Map: archivi chiave-valore»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy