So führen Sie eine verschachtelte Iteration durch

Der PHP-Editor Youzi zeigt Ihnen, wie Sie eine verschachtelte Iteration durchführen. Bei der verschachtelten Iteration handelt es sich um eine Technik zur Verwendung einer weiteren Schleife innerhalb einer Schleife, die uns beim Umgang mit komplexen Datenstrukturen oder mehrdimensionalen Arrays hilft. Bei verschachtelten Iterationen müssen wir auf die Reihenfolge und Bedingungen der Schleifen achten, um sicherzustellen, dass auf jedes Element zugegriffen und es korrekt verarbeitet wird. In diesem Artikel werden die Prinzipien und die Verwendung der verschachtelten Iteration ausführlich erläutert und einige praktische Beispiele als Referenz bereitgestellt. Egal, ob Sie Anfänger oder erfahrener Entwickler sind, dieser Artikel kann Ihnen helfen, die Techniken der verschachtelten Iteration besser zu verstehen und anzuwenden. Lasst uns gemeinsam erkunden!

Frageninhalt

Ich versuche, eine Erweiterung für eine andere Software zu entwickeln, die Anfragen an eine in go geschriebene Anwendung sendet. In einem Go-Programm (das ich jetzt „Programm“ nennen werde) besteht ein Zweck darin, eine JSON-Datei in ein iterierbares Format zu konvertieren. Hier ist ein Beispiel für das JSON-Format, das ich verwende:

{
  "name": "game-name",
  "tree": {
    "$classname": "datamodel",

    "replicatedstorage": {
      "$path": "src/replicatedstorage"
    },

    "serverscriptservice": {
      "$path": "src/serverscriptservice"
    },

    "replicatedfirst": {
      "$path": "src/replicatedfirst"
    },

    "serverstorage": {
      "$path": "src/serverstorage"
    }
  }
}

Die Idee ist:

• Iteration kann „Name“ erhalten
• Iteration kann „$classname“ erhalten
• Für alle mit „$path“ indizierten Instanzen wird der Name des Ordners im übergeordneten Ordner src 文件夹下创建一个文件夹，其中包含父地图的索引。例如，replicatedstorage 是路径为 src/replicatedstorage gefunden

Hier ist eine Handler-Funktion, um dies zu tun:

func process(in interface{}) {
v := reflect.ValueOf(in)

    if v.Kind() == reflect.Map {
        for _, key := range v.MapKeys() {
            strct := v.MapIndex(key)
    
            index := key.Interface()
            value := reflect.ValueOf(strct.Interface())
    
            if index == "tree" {
                for _, treeKey := range value.MapKeys() {
                    treeIndex := treeKey.Interface()
    
                    fmt.Println("KEY")
                    fmt.Println(treeIndex)
    
                    if treeIndex != "$className" {
                        fmt.Println("bug")
                        fmt.Println(treeKey)
    
                        a := key.MapIndex(value) // panic serving ...: reflect: call of reflect.Value.MapIndex on string Value
                        b := reflect.ValueOf(a.Interface())
    
                        for _, key2 := range b.MapKeys() {
                            index2 := key2.Interface()
                            value2 := reflect.ValueOf(key2.Interface())
    
                            fmt.Println(index2)
                            fmt.Println(value2)
                        }
                    }
                }
            }
        }
    }

}

Kommentare wiesen auf falsche Orte und Inhalte hin. Eine Sache, die ich auch gerne tun würde, ist, die for-Schleifen nicht stapeln zu müssen, denn das ist wirklich schlechter Code.

Problemumgehung

Der übliche Ansatz besteht darin, in einen Go-Typ zu entpacken, der der Datenstruktur entspricht. Das Problem hierbei ist, dass der Baum nicht einfach als Go-Typ dargestellt werden kann (er hat ein Feld $classname vom Typ string, ähnelt aber ansonsten einer Karte mit einem Objektwert, der ein $path-Feld enthält).

Lassen Sie uns mit dem Unmarshalling in interface{} fortfahren, wie Sie es bereits getan haben.

Verwenden Sie Typzusicherungen anstelle von Reflexionspaketen. Verwenden Sie Map Index, um Werte nachzuschlagen, anstatt Schlüssel durchzugehen und Übereinstimmungen zu finden.

func process(in interface{}) error {
    top, ok := in.(map[string]interface{})
    if !ok {
        return errors.New("expected object at top level")
    }
    tree, ok := top["tree"].(map[string]interface{})
    if !ok {
        return errors.New(".tree not found")
    }
    name, ok := top["name"]
    if !ok {
        return errors.New(".name not found")
    }
    className, ok := tree["$className"].(string)
    if !ok {
        return errors.New(".tree.$className not found")
    }
    for k, v := range tree {
        thing, ok := v.(map[string]interface{})
        if !ok {
            continue
        }
        path, ok := thing["$path"].(string)
        if !ok {
            continue
        }
        fmt.Println(name, className, k, path)
    }
    return nil
}

https://www.php.cn/link/8642785813491d703d517ddd00944054

Das obige ist der detaillierte Inhalt vonSo führen Sie eine verschachtelte Iteration durch. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!