dictionary - meaning - went definition




¿Cómo comprobar si un mapa contiene una clave en ir? (7)

Respuesta corta

_, exists := timeZone[tz]    // Just checks for key existence
val, exists := timeZone[tz]  // Checks for key existence and retrieves the value

Ejemplo

Aquí hay un ejemplo en el Go Playground .

Respuesta más larga

Por la sección de Maps de Maps :

Un intento de obtener un valor de mapa con una clave que no está presente en el mapa devolverá el valor cero para el tipo de las entradas en el mapa. Por ejemplo, si el mapa contiene enteros, buscar una clave no existente devolverá 0.

A veces es necesario distinguir una entrada que falta de un valor cero. ¿Hay una entrada para "UTC" o es la cadena vacía porque no está en el mapa en absoluto? Puedes discriminar con una forma de asignación múltiple.

var seconds int
var ok bool
seconds, ok = timeZone[tz]

Por razones obvias, esto se llama el idioma "coma bien". En este ejemplo, si tz está presente, los segundos se establecerán adecuadamente y ok será cierto; Si no, los segundos se establecerán en cero y ok será falso. Aquí hay una función que lo pone junto con un buen informe de errores:

func offset(tz string) int {
    if seconds, ok := timeZone[tz]; ok {
        return seconds
    }
    log.Println("unknown time zone:", tz)
    return 0
}

Para probar la presencia en el mapa sin preocuparse por el valor real, puede usar el identificador en blanco (_) en lugar de la variable habitual para el valor.

_, present := timeZone[tz]

Sé que puedo recorrer un mapa m,

for k, v := range m { ... }

y busque una clave, pero ¿existe una manera más eficiente de probar la existencia de una clave en un mapa? Gracias. No pude encontrar una respuesta en la especificación de idioma .


Busqué en la lista de correos electrónicos de idiotas y encontré una solución publicada por Peter Froehlich el 15/11/2009.

package main

import "fmt"

func main() {
        dict := map[string]int {"foo" : 1, "bar" : 2}
        value, ok := dict["baz"]
        if ok {
                fmt.Println("value: ", value)
        } else {
                fmt.Println("key not found")
        }
}

O, más compacto,

if value, ok := dict["baz"]; ok {
    fmt.Println("value: ", value)
} else {
    fmt.Println("key not found")
}

Tenga en cuenta que, utilizando esta forma de la declaración if , el value y las variables ok solo son visibles dentro de las condiciones if .


Se menciona en "Expresiones de índice" .

Una expresión de índice en un mapa de tipo map [K] V utilizado en una asignación o inicialización de la forma especial

v, ok = a[x] 
v, ok := a[x] 
var v, ok = a[x]

produce un valor booleano sin tipo adicional. El valor de ok es verdadero si la clave x está presente en el mapa y, de lo contrario, es falso.


Se puede usar una asignación de dos valores para este propósito. Por favor, consulte mi programa de muestra a continuación

package main

import (
        "fmt"
)

func main(){
    //creating a map with 3 key-value pairs
    sampleMap := map[string]int {"key1" : 100, "key2" : 500, "key3" : 999}
    //A two value assignment can be used to check existence of a key. 
    value, isKeyPresent := sampleMap["key2"]
    //isKeyPresent will be true if key present in sampleMap        
    if isKeyPresent {
        //key exist
            fmt.Println("key present, value =  ", value)
    } else {
            //key does not exist
            fmt.Println("key does not exist")
    }
}

Una línea de respuesta:

if val, ok := dict["foo"]; ok {
    //do something here
}

Explicación:

if declaraciones en Go pueden incluir una condición y una instrucción de inicialización. El ejemplo anterior utiliza ambos:

  • inicializa dos variables: val recibirá el valor de "foo" del mapa o un "valor cero" (en este caso, la cadena vacía) y ok recibirá un valor bool que se establecerá en true si "foo" estaba realmente presente en el mapa

  • evalúa ok , lo que será true si "foo" estaba en el mapa

Si "foo" está presente en el mapa, el cuerpo de la sentencia if se ejecutará y val será local para ese alcance.


mejor camino aquí

if _, ok := dict["foo"]; ok {
    //do something here
}

    var empty struct{}
    var ok bool
    var m map[string]struct{}
    m = make(map[string]struct{})
    m["somestring"] = empty


    _, ok = m["somestring"]
    fmt.Println("somestring exists?", ok) 
    _, ok = m["not"]
    fmt.Println("not exists?", ok)

Entonces, ve a correr maps.go existe alguna cosa? verdad no existe? falso





go