Trébucher lors de la conversion d'une liste bidirectionnelle en JSON dans Go

Qu'est-il arrivé

Lors du codage avec Go, j'ai dû convertir quelque chose comme une liste bidirectionnelle en mon propre & JSON. Je prévois d'utiliser ʻencoding / json` comme politique, mais c'est un gâchis.

en bref

• Si vous êtes dans la structure, faites-en un pointeur
• S'il y a une possibilité qu'il circule lors de la conversion en JSON, ignorons-le avec json:" - " et évitons cela.

type récursif invalide si vous êtes dans la structure

C'est une évidence.

Échec

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type Person struct {
	Name   string
	Parent Person
	Child  Person
}

func main() {
	sora := Person{}
	sora.Name = "Sora Amamiya"
	j, err := json.Marshal(sora)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(j))
}

Je me fâche comme ça.

$ go run main.go
# command-line-arguments
./main.go:9:6: invalid recursive type Person

C'est vrai. Il semble qu'ils se fâchent même en cas de récurrence mutuelle. excellence.

Succès

Résolu en le fixant à un pointeur.

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type Person struct {
	Name   string
	Parent *Person
	Child  *Person
}

func main() {
	sora := Person{}
	sora.Name = "Sora Amamiya"
	j, err := json.Marshal(sora)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(j))
}

$ go run main.go
{"Name":"Sora Amamiya","Parent":null,"Child":null}

Bloc de circulation JSON

C'est le sujet principal. Je me demande à quelle fréquence je veux transformer une liste bidirectionnelle en JSON en premier lieu.

La structure de «Person» est la même qu'avant. Faites une petite liste bidirectionnelle comme celle-ci.

Échec

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type Person struct {
	Name   string  `json:"name"`
	Parent *Person 
	Child  *Person `json:"child"`
}


func main() {
	m := Person{}
	n := Person{}
	m.Name = "Momo Asakura"
	m.Child = &n
	n.Name = "Shiina Natsukawa"
	n.Parent = &m

	j, err := json.Marshal([]Person{m, n})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(j))
}

La sortie est littéralement en colère comme ça. C'est une erreur récursive.

runtime: goroutine stack exceeds 1000000000-byte limit
fatal error: stack overflow

runtime stack:
runtime.throw(0x4f30b2, 0xe)
        /usr/local/go/src/runtime/panic.go:774 +0x72
runtime.newstack()
        /usr/local/go/src/runtime/stack.go:1046 +0x6e9
runtime.morestack()
        /usr/local/go/src/runtime/asm_amd64.s:449 +0x8f

goroutine 1 [running]:
encoding/json.stringEncoder(0xc00007c000, 0x4c8f80, 0xc00000c080, 0x198, 0x100)
        /usr/local/go/src/encoding/json/encode.go:589 +0x389 fp=0xc02009a380 sp=0xc02009a378 pc=0x4a94c9
encoding/json.structEncoder.encode(0xc000082000, 0x3, 0x4, 0xc00005e2a0, 0xc00007c000, 0x4dcee0, 0xc00000c

C'est tout à fait naturel. Il n'est pas bon d'avoir une idée superficielle, "Si vous n'attachez pas de balise JSON à Parent, pouvez-vous ignorer Wanchan?" Par défaut, le nom du champ est utilisé tel quel pour la conversion. Une très bonne bibliothèque.

Succès

Donc ce que je voulais faire était "d'ignorer les champs arbitraires dans la bibliothèque JSON". Pour ce faire, utilisez la balise json:" - ".

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type Person struct {
	Name   string  `json:"name"`
	Parent *Person `json:"-"`
	Child  *Person `json:"child"`
}

func main() {
	m := Person{}
	n := Person{}
	m.Name = "Momo Asakura"
	m.Child = &n
	n.Name = "Shiina Natsukawa"
	n.Parent = &m

	j, err := json.Marshal([]Person{m, n})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(j))
}

Cliquez ici pour le résultat de la sortie. Il m'apporte uniquement Enfant correctement. Si vous tirez de Root, vous n'avez pas besoin de sortir Parent séparément.

$ go run main.go
[{"name":"Momo Asakura","child":{"name":"Shiina Natsukawa","child":null}},{"name":"Shiina Natsukawa","chil
d":null}]

Sommaire

• Allez, facile à écrire et agréable.
• Facile à changer en JSON et agréable.
• Seuls ceux qui utilisent un langage qui n'a pas besoin de connaître les pointeurs apprendront ou se souviendront des pointeurs.
• Allons-y, c'est amusant (comme un débutant).