Contexte de Golang

L'une des fonctionnalités les plus utiles du langage de programmation Go est les contextes. Le contexte fournit des fonctionnalités polyvalentes pour des applications telles que le partage des données, les annulations des appels, les délais, etc.

Le contexte est si utile que de nombreuses bibliothèques de l'écosystème Go les utilisent. Vous les trouverez également dans des applications qui interagissent avec des serveurs distants, des bases de données, des appels API et plus.

Pour cet article, nous fournirons une introduction débutante au Package de contexte en Go et comment utiliser le contexte pour divers cas d'utilisation.

Contexte avec

L'un des principaux cas d'utilisation de contextes dans GO est le partage de données ou l'utilisation de valeurs à la demande. Le package de contexte Golang vous offre la fonction de réalisation qui vous permet de partager des données.

La syntaxe de fonction est comme indiqué:

Func Watchalue (Contexte parent, clé, interface Val ) contexte

La fonction prend un contexte, une clé et une valeur comme les paramètres. La fonction créera alors un nouveau contexte basé sur le parent fourni et ajoutera une valeur spécifiée à la touche SET.

Considérez-le comme un contexte interne avec un type de paire de valeurs clés à l'intérieur. Vous pouvez ensuite récupérer ou récupérer des valeurs à partir du type.

Considérez l'exemple ci-dessous qui illustre comment utiliser la fonction de réalisation et en récupérer des valeurs.

package principal
Importer "FMT"
importer "contexte"
funcmain ()
ctx: = contexte.Arrière-plan()
ctx = addvalues ​​(ctx)
rétriveValue (CTX)

funcaddvalues ​​(contexte CTX.Contexte) contexte.Contexte
contexte de retour.WitchValue (CTX, "Key", "Value")

FuncretvieveValue (contexte CTX.Contexte)
valeur: = ctx.Valeur ("clé")
fmt.Println (valeur)

Concentrez-vous sur la fonction principale du code ci-dessus. Nous commençons par créer un nouvel objet de contexte, CTX, avec le contexte.Background () Fonction.

La fonction d'arrière-plan renverra ensuite un contexte non non nulle sans annulation, sans valeurs et sans délais.

La fonction de fond sert d'initialisation des demandes de contexte entrant.

Valeurs de définition de contexte

La deuxième partie de la fonction est la fonction addvalues ​​(). Nous prenons un nouveau contexte et le lions à un contexte existant dans cet exemple. Le nouveau contexte contient la clé à ajouter au contexte.

Notez que la fonction de retenue renvoie une copie du contexte parent et ne modifie pas le contexte existant.

Contexte Récupérer les valeurs

La deuxième partie du programme est la fonction rétriveValue (). Dans ce cas, nous prenons la structure de contexte et récupérons les valeurs associées à la clé spécifiée.

Si la clé existe dans le contexte, la fonction doit renvoyer la valeur associée.

Si la clé n'existe pas, la fonction doit retourner nulle. Nous pouvons implémenter la logique conditionnelle pour vérifier si la valeur de retour est nulle et renvoyer une erreur si vraie.

Contexte avec le temps mort

Un autre cas d'utilisation courant des contextes est de gérer les délais d'expiration. Par exemple, vous devrez peut-être définir un délai d'expiration dans certaines applications si une action spécifiée n'est pas effectuée. Ceci est incroyablement simple à implémenter en utilisant la fonction Withtimeout à partir du package de contexte. Voyons comment nous pouvons mettre en œuvre le délai d'expiration en utilisant le package de contexte.

package principal
importer (
"contexte"
"FMT"
"temps"
)
funcmain ()
ctx, annuler: = contexte.Withtimeout (contexte.Fond (), 5 * Temps.Deuxième)
Déférer annuler ()
ctx = addvalues ​​(ctx)
GO RETRUEVEVALUES (CTX)
sélectionner
cas<-ctx.Done():
fmt.Println ("a pris trop de temps!")

temps.Sommeil (5 * fois.Deuxième)

funcaddvalues ​​(contexte CTX.Contexte) contexte.Contexte
contexte de retour.WitchValue (CTX, "Key", "Value")

FuncretvieveValues ​​(contexte CTX.Contexte)
pour
sélectionner
cas<-ctx.Done():
fmt.Println ("temps mort")
retour
défaut:
valeur: = ctx.Valeur ("clé")
fmt.Println (valeur)

temps.Sommeil (1 * temps.Deuxième)

Dans cet exemple, nous définissons une fonction d'annulation en utilisant le contexte.Fonction avec temps. Nous pouvons alors déclencher la fonction d'annulation manuellement si nous le voyons.

Une fois la valeur de délai de temps atteint, la fonction d'annulation est appelée et exécute la logique spécifiée.

Dans notre fonction de valeur de récupération, nous récupérons en continu la valeur avec la touche spécifiée en utilisant la boucle pour. Nous vérifions également si le canal terminé du contexte principal est toujours en vie. Si le délai d'attente n'a pas dépassé, le contexte parent sera toujours ouvert, mais une fois le délai d'attente atteint, le contexte est annulé.

Dans notre exemple, la fonction fonctionnera toutes les 1 secondes avant le temps mort. Un exemple de sortie est comme indiqué:

valeur
valeur
valeur
valeur
valeur
A pris trop de temps!
Temps libre

Conclusion

C'était un tutoriel court et fondamental pour discuter des contextes et comment les utiliser dans vos programmes GO. Vous pouvez consulter la documentation pour en explorer plus sur les contextes GO.