Avez-vous déjà eu besoin de modifier des données JSON non structurées dans Go ? Peut-être avez-vous dû supprimer tous les champs de la liste noire, renommer les clés de camelCase en Snake_case ou convertir tous les identifiants numériques en chaînes car JavaScript n'aime pas int64 ? Si votre solution a été de tout regrouper dans une map[string]any en utilisant encoding/json, puis de le regrouper à nouveau... eh bien, soyons réalistes, c'est loin d'être efficace !
Et si vous pouviez parcourir les données JSON, saisir le chemin de chaque élément et décider exactement quoi en faire à la volée ?
Oui ! J'ai une bonne nouvelle ! Avec la nouvelle fonctionnalité itérateur de Go 1.23, il existe une meilleure façon d'itérer et de manipuler JSON. Découvrez ezpkg.io/iter.json — votre compagnon puissant et efficace pour travailler avec JSON dans Go.
Étant donné que nous avons un fichier alice.json :
{
"name": "Alice",
"age": 24,
"scores": [9, 10, 8],
"address": {
"city": "The Sun",
"zip": 10101
}
}
Tout d'abord, utilisons for range Parse() pour parcourir le fichier JSON, puis imprimons le chemin, la clé, le jeton et le niveau de chaque élément. Voir exemples/01.iter.
package main
import (
"fmt"
"ezpkg.io/errorz"
iterjson "ezpkg.io/iter.json"
)
func main() {
data := `{"name": "Alice", "age": 24, "scores": [9, 10, 8], "address": {"city": "The Sun", "zip": 10101}}`
// ?Example: iterate over json
fmt.Printf("| %12v | %10v | %10v |%v|\n", "PATH", "KEY", "TOKEN", "LVL")
fmt.Println("| ------------ | ---------- | ---------- | - |")
for item, err := range iterjson.Parse([]byte(data)) {
errorz.MustZ(err)
fmt.Printf("| %12v | %10v | %10v | %v |\n", item.GetPathString(), item.Key, item.Token, item.Level)
}
}
Le code affichera :
| PATH | KEY | TOKEN |LVL|
| ------------ | ---------- | ---------- | - |
| | | { | 0 |
| name | "name" | "Alice" | 1 |
| age | "age" | 24 | 1 |
| scores | "scores" | [ | 1 |
| scores.0 | | 9 | 2 |
| scores.1 | | 10 | 2 |
| scores.2 | | 8 | 2 |
| scores | | ] | 1 |
| address | "address" | { | 1 |
| address.city | "city" | "The Sun" | 2 |
| address.zip | "zip" | 10101 | 2 |
| address | | } | 1 |
| | | } | 0 |
Utilisez Builder pour créer des données JSON. Il accepte les arguments facultatifs pour l'indentation. Voir exemples/02.builder.
b := iterjson.NewBuilder("", " ")
// open an object
b.Add("", iterjson.TokenObjectOpen)
// add a few fields
b.Add("name", "Alice")
b.Add("age", 22)
b.Add("email", "alice@example.com")
b.Add("phone", "(+84) 123-456-789")
// open an array
b.Add("languages", iterjson.TokenArrayOpen)
b.Add("", "English")
b.Add("", "Vietnamese")
b.Add("", iterjson.TokenArrayClose)
// close the array
// accept any type that can marshal to json
b.Add("address", Address{
HouseNumber: 42,
Street: "Ly Thuong Kiet",
City: "Ha Noi",
Country: "Vietnam",
})
// accept []byte as raw json
b.Add("pets", []byte(`[{"type":"cat","name":"Kitty","age":2},{"type":"dog","name":"Yummy","age":3}]`))
// close the object
b.Add("", iterjson.TokenObjectClose)
out := errorz.Must(b.Bytes())
fmt.Printf("\n--- build json ---\n%s\n", out)
Ce qui affichera le JSON avec indentation :
{
"name": "Alice",
"age": 22,
"email": "alice@example.com",
"phone": "(+84) 123-456-789",
"languages": [
"English",
"Vietnamese"
],
"address": {"house_number":42,"street":"Ly Thuong Kiet","city":"Ha Noi","country":"Vietnam"},
"pets": [
{
"type": "cat",
"name": "Kitty",
"age": 2
},
{
"type": "dog",
"name": "Yummy",
"age": 3
}
]
}
Vous pouvez reconstruire ou formater une donnée JSON en envoyant sa clé et ses valeurs à un Builder. Voir exemples/03.reformat.
{
// ?Example: minify json
b := iterjson.NewBuilder("", "")
for item, err := range iterjson.Parse(data) {
errorz.MustZ(err)
b.AddRaw(item.Key, item.Token)
}
out := errorz.Must(b.Bytes())
fmt.Printf("\n--- minify ---\n%s\n----------\n", out)
}
{
// ?Example: format json
b := iterjson.NewBuilder("? ", "\t")
for item, err := range iterjson.Parse(data) {
errorz.MustZ(err)
b.AddRaw(item.Key, item.Token)
}
out := errorz.Must(b.Bytes())
fmt.Printf("\n--- reformat ---\n%s\n----------\n", out)
}
Le premier exemple réduit le JSON tandis que le deuxième exemple le formate avec le préfixe "?" sur chaque ligne.
--- minify ---
{"name":"Alice","age":24,"scores":[9,10,8],"address":{"city":"The Sun","zip":10101}}
----------
--- reformat ---
? {
? "name": "Alice",
? "age": 24,
? "scores": [
? 9,
? 10,
? 8
? ],
? "address": {
? "city": "The Sun",
? "zip": 10101
? }
? }
----------
Dans cet exemple, nous ajoutons des numéros de ligne à la sortie JSON, en ajoutant un b.WriteNewline() avant l'appel fmt.Fprintf(). Voir exemples/04.line_number.
// ?Example: print with line number
i := 0
b := iterjson.NewBuilder("", " ")
for item, err := range iterjson.Parse(data) {
i++
errorz.MustZ(err)
b.WriteNewline(item.Token.Type())
// ? add line number
fmt.Fprintf(b, "%3d ", i)
b.Add(item.Key, item.Token)
}
out := errorz.Must(b.Bytes())
fmt.Printf("\n--- line number ---\n%s\n----------\n", out)
Cela affichera :
1 {
2 "name": "Alice",
3 "age": 24,
4 "scores": [
5 9,
6 10,
7 8
8 ],
9 "address": {
10 "city": "The Sun",
11 "zip": 10101
12 }
13 }
En mettant un fmt.Fprintf(comment) entre b.WriteComma() et b.WriteNewline(), vous pouvez ajouter un commentaire à la fin de chaque ligne. Voir exemples/05.commentaire.
i, newlineIdx, maxIdx := 0, 0, 30
b := iterjson.NewBuilder("", " ")
for item, err := range iterjson.Parse(data) {
errorz.MustZ(err)
b.WriteComma(item.Token.Type())
// ? add comment
if i > 0 {
length := b.Len() - newlineIdx
fmt.Fprint(b, strings.Repeat(" ", maxIdx-length))
fmt.Fprintf(b, "// %2d", i)
}
i++
b.WriteNewline(item.Token.Type())
newlineIdx = b.Len() // save the newline index
b.Add(item.Key, item.Token)
}
length := b.Len() - newlineIdx
fmt.Fprint(b, strings.Repeat(" ", maxIdx-length))
fmt.Fprintf(b, "// %2d", i)
out := errorz.Must(b.Bytes())
fmt.Printf("\n--- comment ---\n%s\n----------\n", out)
Cela affichera :
{ // 1
"name": "Alice", // 2
"age": 24, // 3
"scores": [ // 4
9, // 5
10, // 6
8 // 7
], // 8
"address": { // 9
"city": "The Sun", // 10
"zip": 10101 // 11
} // 12
} // 13
Il existe item.GetPathString() et item.GetRawPath() pour obtenir le chemin de l'élément actuel. Vous pouvez les utiliser pour filtrer les données JSON. Voir exemples/06.filter_print.
Exemple avec item.GetPathString() et regexp :
fmt.Printf("\n--- filter: GetPathString() ---\n")
i := 0
for item, err := range iterjson.Parse(data) {
i++
errorz.MustZ(err)
path := item.GetPathString()
switch {
case path == "name",
strings.Contains(path, "address"):
// continue
default:
continue
}
// ? print with line number
fmt.Printf("%2d %20s . %s\n", i, item.Token, item.GetPath())
}
Exemple avec item.GetRawPath() et path.Match() :
fmt.Printf("\n--- filter: GetRawPath() ---\n")
i := 0
for item, err := range iterjson.Parse(data) {
i++
errorz.MustZ(err)
path := item.GetRawPath()
switch {
case path.Match("name"),
path.Contains("address"):
// continue
default:
continue
}
// ? print with line number
fmt.Printf("%2d %20s . %s\n", i, item.Token, item.GetPath())
}
Les deux exemples afficheront :
{
"name": "Alice",
"age": 24,
"scores": [9, 10, 8],
"address": {
"city": "The Sun",
"zip": 10101
}
}
En combinant le Builder avec l'option SetSkipEmptyStructures(false) et la logique de filtrage, vous pouvez filtrer les données JSON et renvoyer un nouveau JSON. Voir exemples/07.filter_json
package main
import (
"fmt"
"ezpkg.io/errorz"
iterjson "ezpkg.io/iter.json"
)
func main() {
data := `{"name": "Alice", "age": 24, "scores": [9, 10, 8], "address": {"city": "The Sun", "zip": 10101}}`
// ?Example: iterate over json
fmt.Printf("| %12v | %10v | %10v |%v|\n", "PATH", "KEY", "TOKEN", "LVL")
fmt.Println("| ------------ | ---------- | ---------- | - |")
for item, err := range iterjson.Parse([]byte(data)) {
errorz.MustZ(err)
fmt.Printf("| %12v | %10v | %10v | %v |\n", item.GetPathString(), item.Key, item.Token, item.Level)
}
}
Cet exemple renverra un nouveau JSON avec uniquement les champs filtrés :
| PATH | KEY | TOKEN |LVL|
| ------------ | ---------- | ---------- | - |
| | | { | 0 |
| name | "name" | "Alice" | 1 |
| age | "age" | 24 | 1 |
| scores | "scores" | [ | 1 |
| scores.0 | | 9 | 2 |
| scores.1 | | 10 | 2 |
| scores.2 | | 8 | 2 |
| scores | | ] | 1 |
| address | "address" | { | 1 |
| address.city | "city" | "The Sun" | 2 |
| address.zip | "zip" | 10101 | 2 |
| address | | } | 1 |
| | | } | 0 |
Ceci est un exemple de modification de valeurs dans des données JSON. Supposons que nous utilisons des identifiants numériques pour notre API. Les identifiants sont trop volumineux et JavaScript ne peut pas les gérer. Nous devons les convertir en chaînes. Voir examples/08.number_id et order.json.
Parcourez les données JSON, recherchez tous les champs _id et convertissez les identifiants numériques en chaînes :
b := iterjson.NewBuilder("", " ")
// open an object
b.Add("", iterjson.TokenObjectOpen)
// add a few fields
b.Add("name", "Alice")
b.Add("age", 22)
b.Add("email", "alice@example.com")
b.Add("phone", "(+84) 123-456-789")
// open an array
b.Add("languages", iterjson.TokenArrayOpen)
b.Add("", "English")
b.Add("", "Vietnamese")
b.Add("", iterjson.TokenArrayClose)
// close the array
// accept any type that can marshal to json
b.Add("address", Address{
HouseNumber: 42,
Street: "Ly Thuong Kiet",
City: "Ha Noi",
Country: "Vietnam",
})
// accept []byte as raw json
b.Add("pets", []byte(`[{"type":"cat","name":"Kitty","age":2},{"type":"dog","name":"Yummy","age":3}]`))
// close the object
b.Add("", iterjson.TokenObjectClose)
out := errorz.Must(b.Bytes())
fmt.Printf("\n--- build json ---\n%s\n", out)
Cela ajoutera des guillemets aux identifiants numériques :
{
"name": "Alice",
"age": 22,
"email": "alice@example.com",
"phone": "(+84) 123-456-789",
"languages": [
"English",
"Vietnamese"
],
"address": {"house_number":42,"street":"Ly Thuong Kiet","city":"Ha Noi","country":"Vietnam"},
"pets": [
{
"type": "cat",
"name": "Kitty",
"age": 2
},
{
"type": "dog",
"name": "Yummy",
"age": 3
}
]
}
Le package ezpkg.io/iter.json permet aux développeurs Go de gérer les données JSON avec précision et efficacité. Que vous ayez besoin de parcourir des structures JSON complexes, de créer de nouveaux objets JSON de manière dynamique, de formater ou de réduire des données, de filtrer des champs spécifiques ou même de transformer des valeurs, iter.json offre une solution flexible et puissante.
Je suis ravi de partager ce package avec la communauté en tant qu'outil permettant une manipulation JSON efficace sans avoir besoin d'analyser complètement les données. Bien qu'il en soit encore à ses débuts et qu'il reste de la place pour davantage de fonctionnalités, il fonctionne déjà bien pour de nombreux cas d'utilisation courants.
Si vous avez des exigences spécifiques ou des idées d'amélioration, n'hésitez pas à nous contacter. J'aimerais entendre vos commentaires et vous aider à soutenir vos cas d'utilisation ! ?
Je m'appelle Oliver Nguyen . Un ingénieur logiciel travaillant avec Go et JS. J'aime apprendre et voir une meilleure version de moi-même chaque jour. Lancez occasionnellement de nouveaux projets open source. Partagez vos connaissances et vos réflexions tout au long de mon voyage.
Le message est également publié sur olivernguyen.io.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Comment acheter du Dogecoin
Comment l'Oracle tourne
Quelle interface est audio ?
Comment désactiver les mises à jour automatiques dans Win10
Langage C pour trouver le multiple le plus petit commun
Tutoriel de configuration du mot de passe de démarrage de Windows 10
présentation du moteur MySQL
description de la page de référencement
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
