initialize - Cómo buscar un elemento en una porción de golang

recorrer array golang

Question

Tengo un trozo de estructuras.

type Config struct {
Key string
Value string
}

// I form a slice of the above struct
var myconfig []Config 

// unmarshal a response body into the above slice
if err := json.Unmarshal(respbody, &myconfig); err != nil {
    panic(err)
}

fmt.Println(config)

Here is the output of this
[{key1 test} {web/key1 test2}]

¿Cómo puedo buscar en esta matriz para obtener el elemento donde key="key1" ?

Answer 1

Con un simple for loop:

for _, v := range myconfig {
    if v.Key == "key1" {
        // Found!
    }
}

Tenga en cuenta que dado que el tipo de elemento de la división es una struct (no un puntero), esto puede ser ineficiente si el tipo de estructura es "grande", ya que el bucle copiará cada elemento visitado en la variable de bucle.

Sería más rápido utilizar un bucle de range solo en el índice, esto evita copiar los elementos:

for i := range myconfig {
    if myconfig[i].Key == "key1" {
        // Found!
    }
}

Notas:

Depende de su caso si pueden existir múltiples configuraciones con la misma key , pero si no, debe salir del ciclo si se encuentra una coincidencia (para evitar buscar otros).

for i := range myconfig {
    if myconfig[i].Key == "key1" {
        // Found!
        break
    }
}

Además, si se trata de una operación frecuente, debería considerar la creación de un map partir de él que pueda simplemente indexar, por ejemplo,

// Build a config map:
confMap := map[string]string{}
for _, v := range myconfig {
    confMap[v.Key] = v.Value
}

// And then to find values by key:
if v, ok := confMap["key1"]; ok {
    // Found
}

Answer 2

No hay ninguna función de biblioteca para eso. Tienes que codificar por tu cuenta.

for _, value := range myconfig {
    if value .Key == "key1" {
        // logic
    }
}

Código de trabajo: https://play.golang.org/p/IJIhYWROP_

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    type Config struct {
        Key   string
        Value string
    }

    var respbody = []byte(`[
        {"Key":"Key1", "Value":"Value1"},
        {"Key":"Key2", "Value":"Value2"}
    ]`)

    var myconfig []Config

    err := json.Unmarshal(respbody, &myconfig)
    if err != nil {
        fmt.Println("error:", err)
    }

    fmt.Printf("%+v/n", myconfig)

    for _, v := range myconfig {
        if v.Key == "Key1" {
            fmt.Println("Value: ", v.Value)
        }
    }

}

Answer 3

Puede guardar la estructura en un mapa haciendo coincidir los componentes de la clave y el valor de la estructura con sus partes de valor y clave ficticias en el mapa:

if v, ok := mapConfig["key1"]; ok {
    fmt.Printf("%s exists", v)
}   

Luego, utilizando el idioma de la coma ok de golang, puedes probar la presencia clave:

type Person struct {
    Name string
}

func main() {
    crowd := []Person{{"Zoey"}, {"Anna"}, {"Benni"}, {"Chris"}}

    sort.Slice(crowd, func(i, j int) bool {
        return crowd[i].Name <= crowd[j].Name
    })

    needle := "Benni"
    idx := sort.Search(len(crowd), func(i int) bool {
        return string(crowd[i].Name) >= needle
    })

    if crowd[idx].Name == needle {
        fmt.Println("Found:", idx, crowd[idx])
    } else {
        fmt.Println("Found noting: ", idx)
    }
}

Answer 4

Puedes usar sort.Slice() más sort.Search()

mapConfig := map[string]string{}
for _, v := range myconfig {
   mapConfig[v.Key] = v.Value
}

Consulte: https://play.golang.org/p/47OPrjKb0g_c