Go est un langage polyvalent conçu pour la programmation de systèmes, initialement développé chez Google en 2007 par Robert Griesemer, Rob Pike et Ken Thompson. Il est fortement et statiquement typé, fournit un support intégré pour le garbage collection et prend en charge la programmation simultanée. Les programmes sont construits à l'aide de packages, pour une gestion efficace des dépendances. Les implémentations de programmation Go utilisent un modèle de compilation et de liaison traditionnel pour générer des binaires exécutables.

Voici les avantages de l'utilisation de la programmation Go -

• Prise en charge de l'environnement adoptant des modèles similaires aux langages dynamiques. Par exemple, l'inférence de type (x: = 0 est une déclaration valide d'une variable x de type int).

• Le temps de compilation est rapide.

• Prise en charge de la concurrence InBuilt: processus légers (via goroutines), canaux, instruction select.

• Concision, simplicité et sécurité.

• Prise en charge des interfaces et de l'embdding de type.

• Production de binaires natifs liés statiquement sans dépendances externes.

Pas de prise en charge de l'héritage de type.

Pas de prise en charge de la surcharge de l'opérateur.

Pas de prise en charge de la surcharge de méthode.

Pas de prise en charge de l'arithmétique du pointeur.

Pas de support pour la programmation générique.

Oui! Go est un langage de programmation sensible à la casse.

La déclaration de variable de type statique fournit l'assurance au compilateur qu'il existe une variable avec le type et le nom donnés, de sorte que le compilateur procède à une compilation ultérieure sans avoir besoin de détails complets sur la variable. Une déclaration de variable a sa signification au moment de la compilation uniquement, le compilateur a besoin d'une déclaration de variable réelle au moment de la liaison du programme.

Une déclaration de variable de type dynamique nécessite que le compilateur interprète le type de variable en fonction de la valeur qui lui est passée. Le compilateur n'a pas besoin d'une variable pour avoir le type statiquement comme condition nécessaire.

Oui Des variables de types différents peuvent être déclarées en une seule fois à l'aide de l'inférence de type.

var a, b, c = 3, 4, "foo"

Le code suivant imprime le type d'une variable -

var a, b, c = 3, 4, "foo"  
fmt.Printf("a is of type %T\n", a)

C'est une variable pointeur qui peut contenir l'adresse d'une variable.

Par exemple -

var x = 5
var p *int
p = &x
fmt.Printf("x = %d", *p)

Ici, x est accessible par * p.

break termine la boucle for ou l'instruction switch et transfère l'exécution à l'instruction immédiatement après la boucle for ou le commutateur.

continue oblige la boucle à sauter le reste de son corps et à retester immédiatement son état avant de réitérer.

goto transfère le contrôle à l'instruction étiquetée.

La syntaxe d'une boucle for dans le langage de programmation Go est -

for [condition |  ( init; condition; increment ) | Range] {
   statement(s);
}

Voici le flux de contrôle dans une boucle for -

• si la condition est disponible, la boucle for s'exécute tant que la condition est vraie.

• si pour la clause qui est (init; condition; incrément) est présente alors

  L'étape d'initialisation est exécutée en premier, et une seule fois. Cette étape vous permet de déclarer et d'initialiser toutes les variables de contrôle de boucle. Vous n'êtes pas obligé de mettre une instruction ici, tant qu'un point-virgule apparaît.

  Ensuite, la condition est évaluée. Si c'est vrai, le corps de la boucle est exécuté. S'il est faux, le corps de la boucle ne s'exécute pas et le flux de contrôle passe à l'instruction suivante juste après la boucle for.

  Une fois le corps de la boucle for exécuté, le flux de contrôle revient à l'instruction d'incrémentation. Cette instruction vous permet de mettre à jour toutes les variables de contrôle de boucle. Cette instruction peut être laissée vide, tant qu'un point-virgule apparaît après la condition.

  La condition est à nouveau évaluée. Si c'est vrai, la boucle s'exécute et le processus se répète (corps de la boucle, puis incrémentation, puis à nouveau condition). Une fois que la condition devient fausse, la boucle for se termine.

• si la plage est disponible, la boucle for s'exécute pour chaque élément de la plage.

La forme générale d'une définition de fonction dans le langage de programmation Go est la suivante -

func function_name( [parameter list] ) [return_types] {
   body of the function
}

Une définition de fonction dans le langage de programmation Go se compose d'un en- tête de fonction et d'un corps de fonction . Voici toutes les parties d'une fonction -

• func func démarre la déclaration d'une fonction.

• Function Name- Il s'agit du nom réel de la fonction. Le nom de la fonction et la liste des paramètres constituent ensemble la signature de la fonction.

• Parameters −Un paramètre est comme un espace réservé. Lorsqu'une fonction est appelée, vous transmettez une valeur au paramètre. Cette valeur est appelée paramètre ou argument réel. La liste des paramètres fait référence au type, à l'ordre et au nombre des paramètres d'une fonction. Les paramètres sont facultatifs; autrement dit, une fonction peut ne contenir aucun paramètre.

• Return Type- Une fonction peut renvoyer une liste de valeurs. lereturn_typesest la liste des types de données des valeurs renvoyées par la fonction. Certaines fonctions exécutent les opérations souhaitées sans renvoyer de valeur. Dans ce cas, le return_type n'est pas obligatoire.

• Function Body - Le corps de la fonction contient une collection d'instructions qui définissent ce que fait la fonction.

Une fonction Go peut renvoyer plusieurs valeurs. Par exemple -

package main
import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}
func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}

Lors de l'appel d'une fonction, les arguments peuvent être passés à une fonction de deux manières:

• Call by value- Cette méthode copie la valeur réelle d'un argument dans le paramètre formel de la fonction. Dans ce cas, les modifications apportées au paramètre à l'intérieur de la fonction n'ont aucun effet sur l'argument.

• Call by reference −Cette méthode copie l'adresse d'un argument dans le paramètre formel. À l'intérieur de la fonction, l'adresse est utilisée pour accéder à l'argument réel utilisé dans l'appel. Cela signifie que les modifications apportées au paramètre affectent l'argument.

Par défaut, Go utilise l'appel par valeur pour transmettre des arguments. En général, cela signifie que le code dans une fonction ne peut pas modifier les arguments utilisés pour appeler la fonction et l'exemple mentionné ci-dessus tout en appelant la fonction max () utilisant la même méthode.

Le langage de programmation Go offre la flexibilité de créer des fonctions à la volée et de les utiliser comme valeurs. Nous pouvons définir une variable avec une définition de fonction et l'utiliser comme paramètre d'une fonction.

Les fonctions de fermeture sont des fonctions anonymes et peuvent être utilisées dans la programmation dynamique.

Le langage de programmation Go prend en charge des types spéciaux de fonctions appelées méthodes. Dans la syntaxe de déclaration de méthode, un "récepteur" est présent pour représenter le conteneur de la fonction. Ce récepteur peut être utilisé pour appeler la fonction en utilisant "." opérateur.

Une variable locale a la valeur par défaut comme valeur 0 correspondante.

Une variable globale a la valeur par défaut comme valeur 0 correspondante.

Le pointeur est initialisé à zéro.

Imprime la sortie formatée.

L'expression apparaissant à droite de l'opérateur d'affectation est appelée rvalue. Rvalue est affecté à lvalue, qui apparaît sur le côté gauche de l'opérateur d'affectation. La lvalue doit désigner une variable et non une constante.

Les paramètres envoyés à la fonction à la fin de l'appel sont appelés en tant que paramètres réels lors de la réception de la définition de fonction appelée en tant que paramètres formels.

La déclaration associe le type à la variable tandis que la définition donne la valeur à la variable.

La division du programme en sous-programmes (modules / fonction) pour réaliser la tâche donnée est une approche modulaire. Une définition de fonctions plus générique donne la possibilité de réutiliser les fonctions, telles que les fonctions de bibliothèque intégrées.

Un programme Go se compose de divers jetons et un jeton est soit un mot-clé, un identificateur, une constante, une chaîne littérale ou un symbole.

aller à

Array est une collection d'éléments de données similaires sous un nom commun.

Go compiler attribue une valeur Nil à une variable de pointeur au cas où vous n'auriez pas d'adresse exacte à attribuer. Cela se fait au moment de la déclaration des variables. Un pointeur qui est assigné nil est appelé un pointeur nil. Le pointeur nil est une constante avec une valeur de zéro définie dans plusieurs bibliothèques standard.

C'est une variable de pointeur qui peut contenir l'adresse d'une autre variable de pointeur. Il supprime deux fois pour pointer vers les données détenues par la variable de pointeur désignée.

var a int
var ptr *int
var pptr **int
a = 3000
ptr = &a
pptr = &ptr
fmt.Printf("Value available at **pptr = %d\n", **pptr)

Par conséquent, «a» est accessible par ** pptr.

La structure est un autre type de données défini par l'utilisateur disponible dans la programmation Go, qui vous permet de combiner des éléments de données de différents types.

Pour définir une structure, vous devez utiliser des instructions type et struct. L'instruction struct définit un nouveau type de données, avec plus d'un membre pour votre programme. L'instruction type lie un nom avec le type qui est struct dans notre cas.

Le format de l'instruction struct est le suivant -

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

Go Slice est une abstraction sur Go Array. As Go Array vous permet de définir le type de variables pouvant contenir plusieurs éléments de données du même type, mais il ne fournit aucune méthode intégrée pour en augmenter la taille de manière dynamique ou obtenir son propre sous-tableau. Slices couvre cette limitation. Il fournit de nombreuses fonctions utilitaires requises sur Array et est largement utilisé dans la programmation Go.

Pour définir une tranche, vous pouvez la déclarer en tant que tableau sans spécifier de taille ou utiliser la fonction make pour créer celle-ci.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

La fonction len () renvoie les éléments présents dans la tranche.

La fonction len () renvoie les éléments présents dans la tranche où la fonction cap () renvoie la capacité de la tranche comme le nombre d'éléments qu'elle peut accueillir.

Slice permet de spécifier la borne inférieure et la borne supérieure pour en obtenir la sous-tranche en utilisant [borne inférieure: borne supérieure].

Le mot-clé range est utilisé dans la boucle for pour parcourir les éléments d'un tableau, d'une tranche, d'un canal ou d'une carte. Avec un tableau et des tranches, il renvoie l'index de l'élément sous forme d'entier. Avec les cartes, il renvoie la clé de la prochaine paire clé-valeur.

Go fournit une autre carte de type de données importante qui mappe des clés uniques à des valeurs. Une clé est un objet que vous utilisez pour récupérer une valeur à une date ultérieure. Étant donné une clé et une valeur, vous pouvez stocker la valeur dans un objet Map. Une fois la valeur stockée, vous pouvez la récupérer en utilisant sa clé.

Vous devez utiliser la fonction make pour créer une carte.

/* declare a variable, by default map will be nil*/
var map_variable map[key_data_type]value_data_type

/* define the map as nil map can not be assigned any value*/
map_variable = make(map[key_data_type]value_data_type)

La fonction delete () est utilisée pour supprimer une entrée de la carte. Il nécessite une carte et la clé correspondante qui doit être supprimée.

La conversion de type est un moyen de convertir une variable d'un type de données à un autre type de données. Par exemple, si vous souhaitez stocker une valeur longue dans un entier simple, vous pouvez taper cast long en int. Vous pouvez convertir des valeurs d'un type à un autre à l'aide de l'opérateur de conversion comme suit:

type_name(expression)

La programmation Go fournit un autre type de données appelé interfaces qui représente un ensemble de signatures de méthode. Le type de données struct implémente ces interfaces pour avoir des définitions de méthode pour la signature de méthode des interfaces.