JSON (JavaScript Object Notation) est un format de données très polyvalent et très populaire. Il est souvent utilisé pour la communication entre les applications Web et également comme moyen pratique de stocker de grandes quantités de données d'application structurées.

JSON est si utile que presque tous les langages de programmation modernes offrent une prise en charge intégrée pour l'utiliser, y compris Go.

Travailler avec JSON dans Go

Vous pouvez diviser la plupart du travail que vous ferez avec JSON en deux catégories générales: le marshaling et le unmarshaling. Wikipédia définit le marshaling comme :

En informatique, le marshaling est le processus de transformation de la représentation mémoire d'un objet en un format de données adapté au stockage ou à la transmission. Il est généralement utilisé lorsque des données doivent être déplacées entre différentes parties d'un programme informatique ou d'un programme à un autre.

En termes plus simples, le marshaling est le processus de conversion des données stockées dans une variable en une forme plus facile à transmettre à un autre programme. Le démarshaling est le processus inverse: il consiste à prendre des données formatées pour le transport et à les convertir sous une forme plus facile à utiliser pour votre programme.

instagram viewer

À l'aide de Go, vous pouvez marshaler des structures de données natives dans JSON. Et vous pouvez effectuer l'action inverse, en séparant les données JSON dans les variables Go.

Marshaling vers JSON dans Go

Go fournit le encodage/paquet json pour vous permettre de travailler facilement avec JSON. Ce paquet contient plusieurs fonctions, mais celle que vous utiliserez pour le marshaling est la Maréchal fonction. Maréchal a la signature de fonction suivante :

func Maréchal (v interface{}) ([]octet, erreur)

Cela signifie que Maréchal accepte un paramètre de n'importe quel type de données et renvoie deux valeurs: une tranche d'octets et une erreur. En d'autres termes, vous appelez Maréchal avec une valeur Go, et il le convertit en JSON et renvoie l'équivalent JSON. S'il rencontre une erreur pendant le processus de conversion, il renverra l'erreur et une tranche vide.

Voici un exemple de code qui utilise Maréchal pour convertir une carte en JSON. Pour exécuter cet exemple, il vous suffit de créer un fichier Go dans votre éditeur de code préféré, ou utilisez le Aller à l'aire de jeux:

emballer principal
importer (
"encodage/json"
"fmt"
)


fonction principal(){
 val := carte[chaîne]entier{
"John": 25,
"Marie": 19,
"Adam": 5,
 }
res, _ := json. Maréchal (val)
fmt.Println(chaîne(res))
}

Si vous exécutez ce code, il affichera ce qui suit :

Comme mentionné précédemment, vous pouvez marshaler n'importe quel type de données Go vers JSON, bien que dans la vraie vie, vous marshaliez généralement des structures. Pour cette raison, Go fournit une fonctionnalité appelée balises struct pour vous permettre de donner Maréchal instructions supplémentaires pour convertir vos structures.

Une balise struct est une chaîne que vous incluez dans votre déclaration struct à côté du type de données d'un champ. Les balises de structure vous permettent d'ajuster la façon dont Maréchal traite le champ auquel appartient la balise. Vous pouvez utiliser des balises struct pour renommer un champ dans la sortie JSON, ou même l'omettre entièrement. balises de structure (qui Maréchal reconnaît) commencent par la sous-chaîne "json :".

Par exemple, disons que vous avez une structure Voiture qui représente des informations sur une voiture. Voici le code pour créer un Voiture et marshalez-le à JSON :

emballer principal
importer (
"encodage/json"
"fmt"
)
fonction principal(){
taper Structure de voiture {
 Chaîne de marque
 Chaîne de modèle
 Prix entier
 }
 val := Voiture{Marque: "Mercedes", Modèle: "Benz", Prix: 50000}
 res, _ := json. Maréchal (val)
fmt.Println(chaîne(res))
}

Ce code produit la sortie :

Le Marque, Modèle, et Prix champs de Voiture doivent commencer par des lettres majuscules, ou Maréchal ne pourra pas les convertir. Il en résulte que les champs de sortie JSON commencent également par des majuscules. Mais que se passe-t-il si vous voulez que les noms commencent par des minuscules dans le JSON, ou si vous voulez renommer entièrement un champ? C'est là qu'interviennent les balises struct. Voici un exemple :

emballer principal
importer (
"encodage/json"
"fmt"
)
fonction principal(){
taper Structure de voiture {
 ID entier `json :"-"`
 Chaîne de marque `json :"taper"`
 Chaîne de modèle `json :"modèle"`
 Prix ​​int `json :"prix"`
 }
 val := Voiture{ID: 0, Marque: "Mercedes", Modèle: "Benz", Prix: 50000}
 res, _ := json. Maréchal (val)
fmt.Println(chaîne(res))
}

Ce code introduit un nouveau champ ID qui Maréchal omet de la sortie JSON via une balise struct. Le code utilise également des balises struct pour renommer les autres champs struct. Voici la sortie du programme :

Comme vous pouvez le voir, la partie de la balise struct suivant "json:" devient le nom du champ dans la sortie de Marshal. Il y a une exception: s'il s'agit de la chaîne "-", Marshal omet ce champ de la sortie. Vous pouvez en savoir plus sur les balises Marshal et struct dans le Accéder à la documentation.

Démarshaling de JSON dans Go

Le package encoding/json fournit également une fonction de démarshaling, appelée Démaréchal. Il a la signature de fonction suivante :

func Unmarshal (données [] octet, v interface{}) erreur

Contrairement à Maréchal, Démaréchal ne renvoie pas de valeur. Au lieu de cela, il accepte JSON comme une tranche d'octets dans le premier argument, puis stocke les données converties dans l'objet pointé par son deuxième argument. Démaréchal fonctionne aussi avec les balises struct, mais ici, les balises indiquent Démaréchal quels champs JSON correspondent à quels champs de structure.

Lors du démarshaling dans un programme, vous pourriez récupérer les données d'une API, mais ici vous utiliserez des données factices. Voici comment vous utilisez Démaréchal:

emballer principal
importer (
"encodage/json"
"fmt"
)


fonction principal(){
taper Structure de voiture {
 ID entier `json :"-"`
 Chaîne de marque `json :"taper"`
 Chaîne de modèle `json :"modèle"`
 Prix ​​int `json :"prix"`
 }


jsonInput := `{
"taper": "Toyota",
"modèle": "Camry",
"prix": 2000
 }`


var jsonOutput Car
 erreur := json. Unmarshal ([]octet(jsonInput), &jsonOutput)


si err != néant {
 fmt. Imprimerln("Erreur de décodage JSON !")
retour
 }
fmt.Println(jsonSortie)
}

Ce code utilise le même type Car que dans l'exemple précédent, et il démarshale un objet JSON dans une structure de type Car, puis imprime les données dans la structure. Lorsqu'il est exécuté, le programme produit cette sortie :

Cela montre que les données JSON factices ont été désorganisées avec succès dans le jsonSortie structure.

Go facilite le travail avec JSON

Avec le package encoding/json, travailler avec JSON dans Go est aussi simple que deux appels de fonction: Marsha et Unmarshal. Go vous permet également de personnaliser le processus de marshaling/unmarshaling JSON avec des balises struct.

La conversion de données en JSON est un excellent moyen de les partager avec un autre programme ou processus. Le format est si universel que JSON est aussi portable que possible.