tranche de golang en json

Golang est un langage de programmation puissant largement utilisé dans la programmation réseau, le traitement de données, etc. Dans Golang, le découpage est une structure de données très couramment utilisée qui peut croître ou diminuer de manière dynamique et est très adaptée au traitement de quantités variables de collections de données. Lorsque nous devons sérialiser des tranches au format JSON, nous pouvons utiliser le package json fourni dans la bibliothèque standard Golang.

Cet article expliquera comment utiliser Golang pour convertir des tranches au format JSON et fournira quelques exemples de code pratiques, dans l'espoir d'aider les lecteurs à mieux comprendre et utiliser la technologie de conversion JSON dans Golang.

1. Bases de la tranche

Dans Golang, une tranche est un type de référence, qui consiste en un pointeur vers le tableau sous-jacent, la longueur et la capacité. Nous pouvons utiliser la fonction make pour créer une tranche et spécifier sa longueur et sa capacité :

s := make([]int, 5, 10)  // 创建一个长度为5，容量为10的切片

Lors de la création d'une tranche, si la capacité n'est pas spécifiée, la valeur par défaut et la longueur sont les mêmes :

s := make([]int, 5)  // 创建一个长度为5，容量也为5的切片

Nous pouvons accéder et modifier la tranche dans la tranche via les éléments indices, vous pouvez également utiliser la fonction append pour ajouter dynamiquement des éléments dans la tranche. Par exemple :

s := []int{1, 2, 3}
fmt.Println(s[0])  // 输出1
s[1] = 4
fmt.Println(s)  // 输出[1 4 3]
s = append(s, 5)
fmt.Println(s)  // 输出[1 4 3 5]

2. JSON Basics

JSON (JavaScript Object Notation) est un format d'échange de données léger qui utilise des paires clé-valeur pour décrire la structure des données et est généralement utilisé pour la transmission de données entre clients et serveurs. Les données au format JSON peuvent être traitées à l'aide de n'importe quel langage de programmation, y compris Golang.

Un objet JSON est entouré d'une paire d'accolades et contient plusieurs paires clé-valeur. Par exemple :

{
  "name": "Tom",
  "age": 20,
  "score": [80, 90, 95]
}

Dans l'objet JSON ci-dessus, la clé de la paire clé-valeur est entourée de guillemets doubles et la valeur peut être une chaîne, un nombre, une valeur booléenne, un tableau ou un autre objet JSON.

Dans Golang, vous pouvez utiliser le package json pour sérialiser et désérialiser les données JSON. Voyons comment convertir des tranches Golang au format JSON.

3. Slice to JSON

Utiliser le package json pour convertir des tranches au format JSON est très simple, il suffit de suivre les étapes suivantes :

1. Définir un type de structure dont les champs correspondent aux clés de l'objet JSON ; a Découpez l'objet et remplissez les données qui doivent être sérialisées ;
2. Appelez la fonction json.Marshal() pour sérialiser et assignez le résultat à une variable de type []byte ;
3. Convertissez le résultat de type []byte ; chaîne Tapez et affichez sur le terminal ou enregistrez dans un fichier.
Ce qui suit est un exemple de code réel :

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    persons := []Person{
        {Name: "Tom", Age: 20},
        {Name: "Jerry", Age: 22},
        {Name: "Alice", Age: 24},
        {Name: "Bob", Age: 26},
    }

    data, err := json.Marshal(persons)
    if err != nil {
        fmt.Println("JSON转换失败：", err)
        return
    }

    fmt.Println(string(data))
}

Dans le code ci-dessus, nous définissons un type de structure Personne et créons une tranche de type Personne, qui contient quatre objets Personne. Ensuite, nous utilisons la fonction json.Marshal() pour sérialiser la tranche au format JSON, convertir le résultat en type chaîne et l'envoyer au terminal.

De même, nous pouvons également utiliser le package json pour désérialiser les données au format JSON en tranches Golang. Les étapes sont les suivantes :

1. Lire les données JSON (peuvent être lues à partir d'un fichier ou obtenues à partir d'une requête réseau) ; () La fonction effectue une désérialisation et attribue le résultat à une variable de tranche.
Ce qui suit est un exemple de code réel :

3. package main
   
   import (
       "encoding/json"
       "fmt"
       "io/ioutil"
   )
   
   type Person struct {
       Name string
       Age  int
   }
   
   func main() {
       data, err := ioutil.ReadFile("persons.json")
       if err != nil {
           fmt.Println("读取文件失败：", err)
           return
       }
   
       persons := []Person{}
       err = json.Unmarshal(data, &persons)
       if err != nil {
           fmt.Println("JSON解析失败：", err)
           return
       }
   
       for _, p := range persons {
           fmt.Println(p.Name, p.Age)
       }
   }

   Copier après la connexion
   Dans le code ci-dessus, nous lisons un fichier nommé "persons.json", qui contient un tableau JSON de type Person. Ensuite, nous utilisons la fonction json.Unmarshal() pour désérialiser les données JSON dans un type de tranche, et enfin parcourir les tranches et afficher le nom et l'âge de chaque objet Person.
   Résumé
   Dans cet article, nous avons présenté comment sérialiser des tranches au format JSON à l'aide de Golang et fourni un exemple de code pratique. Nous avons également expliqué comment désérialiser les données JSON en tranches Golang et avons également fourni un exemple de code pratique. J'espère que ce contenu pourra aider les lecteurs à mieux comprendre et utiliser la technologie de conversion JSON dans Golang.

   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!