Golang Marshal et Unmarshal

Le maréchalage fait référence à la transformation d'un objet en un format de données spécifique qui convient à la transmission.

JSON est l'un des formats d'interchange de données les plus populaires. Il est simpliste, lisible par l'homme et très flexible. C'est un excellent choix pour les API et la plupart des transfert de données. L'appareil que vous avez utilise probablement JSON pour effectuer une tâche spécifique.

Dans un tel cas, apprendre à travailler avec JSON est important. Dans ce guide, nous apprendrons à travailler.

Maréchal de Golang

Le codage et le décodage des informations JSON dans GO sont fournis par le package d'encodage / JSON. Il fait partie de la bibliothèque standard; par conséquent vous n'avez pas besoin de l'installer.

Vous devrez cependant l'importer avant de pouvoir l'utiliser.

Le package ECONDING / JSON code tout type de données à une chaîne JSON valide, comme nous le verrons dans ces exemples.

Avant de discuter de la façon de coder les structures GO, commençons par les types de données de base.

Fonction JSON Marshal

Ce qui suit décrit la syntaxe de la fonction de maréchal telle que définie dans le package.

Func Marshal (V Interface ) ([] octet, erreur)

La fonction prend tout type de données comme argument. La fonction renvoie une tranche d'octets et une erreur est rencontrée pendant le processus de maréchal.

Marshal Int

Nous pouvons rassembler un type entier comme indiqué dans l'exemple ci-dessous:

package principal
importer (
"Encoding / JSON"
"FMT"
"refléter"
)
funcmain ()
i: = 100
Marshal_int, _: = JSON.Maréchal (i)
// Vérifiez le type
fmt.Println ("avant le casting:", reflét.Typeof (marshal_int))
fmt.Println ("After Cast:", Réfléchissez.Typeof (String (marshal_int)))

Dans l'exemple ci-dessus, nous commençons par importer les packages requis. Nous avons besoin de l'encodage / JSON, FMT et du package de réflexion dans notre exemple.

Nous utilisons le JSON.Méthode Marshal () pour le maréchal et la valeur entière. Vous remarquerez que la fonction renvoie un unint8 (un entier non signé 8 bits) ou un octet. Nous devons le lancer sur une chaîne comme indiqué dans la sortie ci-dessous:

$ va courir Marshall.aller
Avant le casting: [] uint8
Après le casting: chaîne

Cela renvoie une chaîne entière.

Marshal String.

Nous pouvons rassembler un type de chaîne comme indiqué dans l'exemple ci-dessous:

funcmarshal_str ()
Marshaled_str, _: = JSON.Maréchal ("Linuxhint")
fmt.Println ("String maréchalé:", Marshaled_str)

Si nous exécutons le code ci-dessus, nous devons faire en sorte que la chaîne soit rassemblée dans une tranche d'octets comme:

Chaîne marécatrice: [34 76 105 110 117 120 104 105 110 116 34]

Marshall Bool

Vous pouvez également rassembler un type booléen en utilisant la fonction Marshal. Considérez l'exemple ci-dessous:

funcmarshal_bool ()
Marshaled_bool, _: = JSON.Maréchal (faux)
fmt.Println (marshaled_bool)

Marshal Float

Marshal un type flottant comme indiqué:

funcmarshal_float ()
Marshaled_float, _: = JSON.Maréchal (3.14159)
fmt.Println (marshaled_float)

Tranche de maréchal

L'exemple ci-dessous illustre comment rassembler une tranche en Go:

funcmarshal_slice ()
Slice_raw: = [] String "Microsoft", "Google", "Amazon"
Marshaled_slice, _: = JSON.Maréchal (Slice_raw)
fmt.Println (String (marshaled_slice))

Maréchal structure

Pour rassembler une structure en Go, considérez l'exemple ci-dessous:

funcmarshal_struct ()
Type Struct des employés
Chaîne full_name
Âge int
Bool à la retraite
Salaire int

Marshal_struct, _: = JSON.Marshal (Employé Full_name: "John Doe", âge: 32, retraité: faux, salaire: 140000)
fmt.Println (String (marshal_struct))

L'exemple de fonction ci-dessus illustre comment rassembler un type de structure dans Go.

La sortie résultante est comme indiqué:

"Full_name": "John Doe", "Age": 32, "Retired": False, "Salaire": 140000

Ce qui précède représente la structure marécatrice en une chaîne JSON valide.

Golang Unmarshal

Unmarshal est le contraire du maréchal. Il vous permet de convertir les données d'octets en structure de données d'origine.

En go, le non-compartiment est géré par le JSON.Méthode unmarshal ().

Considérez un exemple de chaîne JSON comme:

"Full_name": "John Doe", "Age": 32, "Retired": False, "Salaire": 140000

Commençons par créer une structure pour correspondre au code d'octet après avoir effectué le Unmarshal.

Tapez user struct
Full_name String 'JSON: "full_name"'
Age String 'JSON: "Age"'
Bool à la retraite 'JSON: "Retiré"
Salaire int 'json: "salaire"'

L'étape suivante consiste à créer la chaîne JSON en code d'octet. Une fois que nous avons le code d'octet, nous pouvons le désarracher dans une structure.

user_info_bytes: = [] byte (user_info)

Une fois que nous avons le code d'octet, nous pouvons le désarraître dans Struct.

Utilisateur de l'employé var
json.Unmarshal (user_info_bytes, & employé)

Une fois que nous avons la structure, nous pouvons accéder aux valeurs comme:

fmt.Println (employé.Nom et prénom)
fmt.Println (employé.Âge)
fmt.Println (employé.À la retraite)
fmt.Println (employé.Salaire)

Le code ci-dessus doit retourner:

John Doe
32
FAUX
140000

Le code source complet est comme indiqué ci-dessous:

func unmarshal_struct ()
user_info: = '"full_name": "John Doe", "Age": 32, "Retired": false, "salaire": 140000'
Tapez user struct
Full_name String 'JSON: "full_name"'
Age String 'JSON: "Age"'
Bool à la retraite 'JSON: "Retiré"
Salaire int 'json: "salaire"'

user_info_bytes: = [] byte (user_info)
Utilisateur de l'employé var
json.Unmarshal (user_info_bytes, & employé)
fmt.Println (employé.Nom et prénom)
fmt.Println (employé.Âge)
fmt.Println (employé.À la retraite)
fmt.Println (employé.Salaire)

Conclusion

Le maréchal et le Unmarshal représentent une exigence importante de transformation des données. En tant que programmeurs, il est important de nous familiariser sur la façon d'effectuer de telles opérations. Ce tutoriel sert à ce but avec facilité.

Merci d'avoir lu et codage heureux!