Controlla se una mappa contiene una chiave in Go

1. Struttura della map in Go
2. Controlla la chiave in Go-map

Le tabelle hash sono implementate in Go come tipo di dati map. Go Maps può essere visualizzato come una raccolta di coppie non ordinate di coppie chiave-valore. Le map sono uno dei tipi di dati più potenti e versatili in Go grazie alla loro capacità di eseguire ricerche, aggiunte ed eliminazioni rapide. Otteniamo due valori di ritorno quando proviamo a ottenere il valore di chiave in una map. Se il secondo valore è vero, allora chiave è presente sulla map.

Struttura della map in Go

Sintassi per map

var map_name map[KeyType]ValueType

Dove, KeyType è un qualsiasi datatype paragonabile e ValueType è anche qualsiasi datatype, inclusa la stessa map. Il datatype per tutte le key in una map deve essere lo stesso. Allo stesso modo, anche il datatype per tutti i value in una map deve essere lo stesso. Tuttavia, il datatype di key e il datatype di value possono essere diversi.

package main

import "fmt"

func main() {
	map_1 := map[string]string{
		"Jenna": "Sthapit",
	}

	for k, v := range map_1 {
		fmt.Printf("Key:%v\nValue: %s\n", k, v)
	}

}

Produzione:

Key:Jenna
Value: Sthapit

Nell’esempio precedente, map_1 ha il tipo di dati string sia per chiavi che per valori. In map_1, Sthapit è il valore per la chiave Jenna.

Controlla la chiave in Go-map

Sintassi per controllare se una map contiene una chiave in Go

first_value, second_value := map_name[key_name]

La dichiarazione di cui sopra restituisce due valori vale a dire. first_value e second_value. Il first_value dà il valore di chiave. Se map_name non contiene key_name, il first_value sarà il valore zero predefinito. Allo stesso modo, second_value è un valore booleano che sarà true se il key_name è presente nella map. Possiamo interpretare first_value e second_value in modi diversi per verificare se map_name contiene key_name.

package main

import "fmt"

func main() {
    map_name := map[int]string{
        0: "Alok",
        1: "Reman",
        2: "Riken",
        3: "Rudra",
    }
    _, second_value_1 := map_name[1]
    fmt.Printf("second_value for 1: %t\n", second_value_1)

    _, second_value_9 := map_name[9]
    fmt.Printf("second_value for 9: %t\n", second_value_9)
}   

Produzione:

second_value for 1: true
second_value for 9: false

Qui second_value per 0 è true poiché la chiave 0 è presente in map_name. Tuttavia, il second_value per 9 è false poiché la chiave 9 non è presente in map_name.

package main

import "fmt"

func main() {
    map_name := map[string]string{
        "Giri":     "Alok",
        "Nembang":  "Reman",
        "Maharjan": "Riken",
        "Jha":      "Rudra",
    }
    if first_value, second_value := map_name["Giri"]; second_value {
        fmt.Printf("Giri is present in map. Value is: %s\n", first_value)
    } else {
        fmt.Printf("Giri is not present in map.\n")
    }

    if first_value, second_value := map_name["Sthapit"]; second_value {
        fmt.Printf("Sthapit is present in map. Value is: %s\n", first_value)
    } else {
        fmt.Printf("Sthapit is not present in map. \n")
    }
}
   

Produzione:

Giri is present in map. Value is: Alok
Sthapit is not present in map.

In questo esempio, abbiamo usato l’istruzione if per verificare se esiste una chiave nella map. Giri è una chiave e Sthapit non è una chiave di map_name.