Aller - Guide rapide

Go est un langage polyvalent conçu pour la programmation de systèmes. Il a été initialement développé chez Google en 2007 par Robert Griesemer, Rob Pike et Ken Thompson. Il est fortement et statiquement typé, fournit une prise en charge intégrée de la récupération de place 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 de Go utilisent un modèle de compilation et de liaison traditionnel pour générer des binaires exécutables. Le langage de programmation Go a été annoncé en novembre 2009 et est utilisé dans certains des systèmes de production de Google.

Caractéristiques de la programmation Go

Les fonctionnalités les plus importantes de la programmation Go sont répertoriées ci-dessous -

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 intégrée de la concurrence: processus légers (via les routines go), canaux, instruction select.
Les programmes Go sont simples, concis et sûrs.
Prise en charge des interfaces et de l'incorporation de types.
Production de binaires natifs liés statiquement sans dépendances externes.

Fonctionnalités exclues intentionnellement

Pour garder le langage simple et concis, les fonctionnalités suivantes généralement disponibles dans d'autres langues similaires sont omises dans Go -

Prise en charge de l'héritage de type
Prise en charge de la surcharge de méthode ou d'opérateur
Prise en charge des dépendances circulaires entre les packages
Prise en charge de l'arithmétique du pointeur
Prise en charge des assertions
Prise en charge de la programmation générique

Programmes Go

Un programme Go peut varier en longueur de 3 lignes à des millions de lignes et il doit être écrit dans un ou plusieurs fichiers texte avec l'extension ".go". Par exemple, hello.go.

Vous pouvez utiliser "vi", "vim" ou tout autre éditeur de texte pour écrire votre programme Go dans un fichier.

Configuration de l'environnement local

Si vous souhaitez toujours configurer votre environnement pour le langage de programmation Go, vous avez besoin des deux logiciels suivants disponibles sur votre ordinateur:

Un éditeur de texte
Aller compilateur

Éditeur de texte

Vous aurez besoin d'un éditeur de texte pour taper vos programmes. Les exemples d'éditeurs de texte incluent le bloc-notes Windows, la commande d'édition du système d'exploitation, Brief, Epsilon, EMACS et vim ou vi.

Le nom et la version des éditeurs de texte peuvent varier selon les systèmes d'exploitation. Par exemple, Notepad est utilisé sous Windows, et vim ou vi est utilisé sous Windows ainsi que Linux ou UNIX.

Les fichiers que vous créez avec l'éditeur de texte sont appelés source files. Ils contiennent le code source du programme. Les fichiers source des programmes Go sont généralement nommés avec l'extension".go".

Avant de commencer votre programmation, assurez-vous d'avoir un éditeur de texte en place et que vous avez suffisamment d'expérience pour écrire un programme informatique, l'enregistrer dans un fichier, le compiler et enfin l'exécuter.

Le compilateur Go

Le code source écrit dans le fichier source est la source lisible par l'homme pour votre programme. Il doit être compilé et transformé en langage machine afin que votre CPU puisse réellement exécuter le programme selon les instructions données. Le compilateur du langage de programmation Go compile le code source dans son programme exécutable final.

La distribution Go se présente sous la forme d'un binaire installable pour les systèmes d'exploitation FreeBSD (version 8 et supérieure), Linux, Mac OS X (Snow Leopard et supérieur) et Windows avec des architectures de processeur x86 32 bits (386) et 64 bits (amd64).

La section suivante explique comment installer la distribution binaire Go sur différents systèmes d'exploitation.

Télécharger Go Archive

Téléchargez la dernière version du fichier d'archive installable Go à partir de Go Downloads . La version suivante est utilisée dans ce didacticiel: go1.4.windows-amd64.msi .

Il est copié dans le dossier C: \> go.

OS	Nom de l'archive
les fenêtres	go1.4.windows-amd64.msi
Linux	go1.4.linux-amd64.tar.gz
Mac	go1.4.darwin-amd64-osx10.8.pkg
FreeBSD	go1.4.freebsd-amd64.tar.gz

Installation sous UNIX / Linux / Mac OS X et FreeBSD

Extrayez l'archive de téléchargement dans le dossier / usr / local, en créant une arborescence Go dans / usr / local / go. Par exemple -

tar -C / usr / local -xzf go1.4.linux-amd64.tar.gz

Ajoutez / usr / local / go / bin à la variable d'environnement PATH.

OS	Production
Linux	export PATH = $ PATH: / usr / local / go / bin
Mac	export PATH = $ PATH: / usr / local / go / bin
FreeBSD	export PATH = $ PATH: / usr / local / go / bin

Installation sous Windows

Utilisez le fichier MSI et suivez les invites pour installer les outils Go. Par défaut, le programme d'installation utilise la distribution Go dans c: \ Go. Le programme d'installation doit définir le répertoire c: \ Go \ bin dans la variable d'environnement PATH de Windows. Redémarrez toutes les commandes ouvertes pour que la modification prenne effet.

Vérification de l'installation

Créez un fichier go nommé test.go dans C:\>Go_WorkSpace.

Fichier: test.go

package main

import "fmt"

func main() {
   fmt.Println("Hello, World!")
}

Maintenant, lancez test.go pour voir le résultat -

C:\Go_WorkSpace>go run test.go

Production

Hello, World!

Avant d'étudier les blocs de construction de base du langage de programmation Go, parlons d'abord de la structure minimale des programmes Go afin que nous puissions la prendre comme référence dans les chapitres suivants.

Exemple Hello World

Un programme Go se compose essentiellement des parties suivantes -

Déclaration de paquet
Importer des packages
Functions
Variables
Déclarations et expressions
Comments

Regardons un code simple qui afficherait les mots "Hello World" -

package main

import "fmt"

func main() {
   /* This is my first sample program. */
   fmt.Println("Hello, World!")
}

Jetons un coup d'œil aux différentes parties du programme ci-dessus -

La première ligne du package de programme main définit le nom du package dans lequel ce programme doit se trouver. C'est une déclaration obligatoire, car les programmes Go s'exécutent dans des packages. Le package principal est le point de départ pour exécuter le programme. Chaque package a un chemin et un nom qui lui sont associés.
La ligne suivante import "fmt" est une commande de préprocesseur qui indique au compilateur Go d'inclure les fichiers se trouvant dans le package fmt.
La ligne suivante func main () est la fonction principale où commence l'exécution du programme.
La ligne suivante /*...*/ est ignorée par le compilateur et elle est là pour ajouter des commentaires dans le programme. Les commentaires sont également représentés en utilisant // similaire aux commentaires Java ou C ++.
La ligne suivante fmt.Println (...) est une autre fonction disponible dans Go qui provoque le message "Hello, World!" à afficher à l'écran. Ici, le package fmt a exporté la méthode Println qui est utilisée pour afficher le message à l'écran.
Notez le P majuscule de la méthode Println. En langue Go, un nom est exporté s'il commence par une majuscule. Exporté signifie que la fonction ou la variable / constante est accessible à l'importateur du package respectif.

Exécution d'un programme Go

Voyons comment enregistrer le code source dans un fichier, le compiler et enfin exécuter le programme. Veuillez suivre les étapes ci-dessous -

Ouvrez un éditeur de texte et ajoutez le code mentionné ci-dessus.
Enregistrez le fichier sous hello.go
Ouvrez l'invite de commande.
Accédez au répertoire dans lequel vous avez enregistré le fichier.
Tapez go run hello.go et appuyez sur Entrée pour exécuter votre code.
S'il n'y a aucune erreur dans votre code, vous verrez alors "Hello World!" imprimé sur l'écran.

$ go run hello.go
Hello, World!

Assurez-vous que le compilateur Go est dans votre chemin et que vous l'exécutez dans le répertoire contenant le fichier source hello.go.

Nous avons discuté de la structure de base d'un programme Go dans le chapitre précédent. Il sera désormais facile de comprendre les autres éléments de base du langage de programmation Go.

Jetons en Go

Un programme Go se compose de plusieurs jetons. Un jeton est soit un mot-clé, un identificateur, une constante, une chaîne littérale ou un symbole. Par exemple, l'instruction Go suivante se compose de six jetons -

fmt.Println("Hello, World!")

Les jetons individuels sont -

fmt
.
Println
(
   "Hello, World!"
)

Séparateur de ligne

Dans un programme Go, la touche de séparation de ligne est un terminateur d'instruction. Autrement dit, les instructions individuelles n'ont pas besoin d'un séparateur spécial tel que ";" dans C. Le compilateur Go place en interne «;» comme terminateur d'instruction pour indiquer la fin d'une entité logique.

Par exemple, jetez un œil aux déclarations suivantes -

fmt.Println("Hello, World!")
fmt.Println("I am in Go Programming World!")

commentaires

Les commentaires sont comme des textes d'aide dans votre programme Go et ils sont ignorés par le compilateur. Ils commencent par / * et se terminent par les caractères * / comme indiqué ci-dessous -

/* my first program in Go */

Vous ne pouvez pas avoir de commentaires dans les commentaires et ils n'apparaissent pas dans une chaîne ou des caractères littéraux.

Identifiants

Un identifiant Go est un nom utilisé pour identifier une variable, une fonction ou tout autre élément défini par l'utilisateur. Un identificateur commence par une lettre A à Z ou a à z ou un trait de soulignement _ suivi de zéro ou plusieurs lettres, traits de soulignement et chiffres (0 à 9).

identifiant = lettre {lettre | unicode_digit}.

Go n'autorise pas les caractères de ponctuation tels que @, $ et% dans les identifiants. Go est uncase-sensitivelangage de programmation. Ainsi, la main - d'œuvre et la main - d'œuvre sont deux identifiants différents Go. Voici quelques exemples d'identifiants acceptables -

mahesh      kumar   abc   move_name   a_123
myname50   _temp    j      a23b9      retVal

Mots clés

La liste suivante montre les mots réservés dans Go. Ces mots réservés ne peuvent pas être utilisés comme constantes ou variables ou tout autre nom d'identifiant.

Pause	défaut	func	interface	sélectionner
Cas	reporter	Aller	carte	Struct
chan	autre	Aller à	paquet	Commutateur
const	tomber dans	si	intervalle	Type
continuer	pour	importer	revenir	Var

Espace blanc dans Go

L'espace blanc est le terme utilisé dans Go pour décrire les espaces, les tabulations, les caractères de nouvelle ligne et les commentaires. Une ligne ne contenant que des espaces, éventuellement avec un commentaire, est appelée ligne vierge et un compilateur Go l'ignore totalement.

Les espaces séparent une partie d'une instruction d'une autre et permettent au compilateur d'identifier où un élément dans une instruction, comme int, se termine et où commence l'élément suivant. Par conséquent, dans la déclaration suivante -

var age int;

Il doit y avoir au moins un caractère d'espacement (généralement un espace) entre int et age pour que le compilateur puisse les distinguer. D'autre part, dans la déclaration suivante -

fruit = apples + oranges;   // get the total fruit

Aucun espace n'est nécessaire entre les fruits et =, ou entre = et les pommes, bien que vous soyez libre d'en inclure si vous le souhaitez à des fins de lisibilité.

Dans le langage de programmation Go, les types de données font référence à un système étendu utilisé pour déclarer des variables ou des fonctions de différents types. Le type d'une variable détermine l'espace qu'elle occupe dans le stockage et la manière dont le modèle de bits stocké est interprété.

Les types dans Go peuvent être classés comme suit -

Sr.No.	Types et description
1	Boolean types Ce sont des types booléens et se composent des deux constantes prédéfinies: (a) true (b) false
2	Numeric types Ce sont encore des types arithmétiques et ils représentent a) des types entiers ou b) des valeurs à virgule flottante dans tout le programme.
3	String types Un type de chaîne représente l'ensemble des valeurs de chaîne. Sa valeur est une séquence d'octets. Les chaînes sont des types immuables qui une fois créés, il n'est pas possible de modifier le contenu d'une chaîne. Le type de chaîne prédéclaré est string.
4	Derived types Ils comprennent (a) les types de pointeurs, (b) les types de tableaux, (c) les types de structure, (d) les types d'union et (e) les types de fonctions f) les types de tranches g) les types d'interfaces h) les types de mappage i) les types de canaux

Les types de tableaux et les types de structure sont collectivement appelés aggregate types. Le type d'une fonction spécifie l'ensemble de toutes les fonctions avec les mêmes paramètres et types de résultats. Nous discuterons des types de base dans la section suivante, tandis que d'autres types seront traités dans les prochains chapitres.

Types entiers

Les types d'entiers prédéfinis indépendants de l'architecture sont -

Sr.No.	Types et description
1	uint8 Entiers 8 bits non signés (0 à 255)
2	uint16 Entiers 16 bits non signés (0 à 65535)
3	uint32 Entiers 32 bits non signés (0 à 4294967295)
4	uint64 Entiers 64 bits non signés (0 à 18446744073709551615)
5	int8 Entiers 8 bits signés (-128 à 127)
6	int16 Entiers 16 bits signés (-32768 à 32767)
sept	int32 Entiers 32 bits signés (-2147483648 à 2147483647)
8	int64 Entiers 64 bits signés (-9223372036854775808 à 9223372036854775807)

Types flottants

Les types de flotteurs indépendants de l'architecture prédéfinis sont:

Sr.No.	Types et description
1	float32 Nombres à virgule flottante 32 bits IEEE-754
2	float64 Nombres à virgule flottante 64 bits IEEE-754
3	complex64 Nombres complexes avec float32 parties réelles et imaginaires
4	complex128 Nombres complexes avec float64 parties réelles et imaginaires

La valeur d'un entier de n bits est de n bits et est représentée à l'aide d'opérations arithmétiques complémentaires à deux.

Autres types numériques

Il existe également un ensemble de types numériques avec des tailles spécifiques à l'implémentation -

Sr.No.	Types et description
1	byte même que uint8
2	rune identique à int32
3	uint 32 ou 64 bits
4	int même taille que uint
5	uintptr un entier non signé pour stocker les bits non interprétés d'une valeur de pointeur

Une variable n'est rien d'autre qu'un nom donné à une zone de stockage que les programmes peuvent manipuler. Chaque variable dans Go a un type spécifique, qui détermine la taille et la disposition de la mémoire de la variable, la plage de valeurs qui peuvent être stockées dans cette mémoire et l'ensemble des opérations qui peuvent être appliquées à la variable.

Le nom d'une variable peut être composé de lettres, de chiffres et du caractère de soulignement. Il doit commencer par une lettre ou un trait de soulignement. Les lettres majuscules et minuscules sont distinctes car Go est sensible à la casse. Sur la base des types de base expliqués dans le chapitre précédent, il y aura les types de variables de base suivants -

Sr.Non	Type et description
1	byte Généralement un seul octet (un octet). C'est un type d'octet.
2	int La taille entière la plus naturelle de la machine.
3	float32 Valeur à virgule flottante simple précision.

Le langage de programmation Go permet également de définir divers autres types de variables telles que l'énumération, le pointeur, le tableau, la structure et l'union, dont nous parlerons dans les chapitres suivants. Dans ce chapitre, nous nous concentrerons uniquement sur les types de variables de base.

Définition de variable dans Go

Une définition de variable indique au compilateur où et combien de stockage créer pour la variable. Une définition de variable spécifie un type de données et contient une liste d'une ou plusieurs variables de ce type comme suit -

var variable_list optional_data_type;

Ici, optional_data_type est un type de données Go valide incluant byte, int, float32, complex64, boolean ou tout objet défini par l'utilisateur, etc., et variable_listpeut consister en un ou plusieurs noms d'identifiants séparés par des virgules. Certaines déclarations valides sont affichées ici -

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

La déclaration “var i, j, k;”déclare et définit les variables i, j et k; qui demande au compilateur de créer des variables nommées i, j et k de type int.

Les variables peuvent être initialisées (affectées d'une valeur initiale) dans leur déclaration. Le type de variable est automatiquement jugé par le compilateur en fonction de la valeur qui lui est transmise. L'initialiseur se compose d'un signe égal suivi d'une expression constante comme suit -

variable_name = value;

Par exemple,

d = 3, f = 5;    // declaration of d and f. Here d and f are int

Pour une définition sans initialiseur: les variables avec une durée de stockage statique sont implicitement initialisées avec nil (tous les octets ont la valeur 0); la valeur initiale de toutes les autres variables est la valeur zéro de leur type de données.

Déclaration de type statique dans Go

Une déclaration de variable de type statique fournit l'assurance au compilateur qu'il existe une variable disponible avec le type et le nom donnés afin que le compilateur puisse poursuivre la compilation sans avoir besoin du détail complet de la variable. Une déclaration de variable n'a sa signification qu'au moment de la compilation, le compilateur a besoin de la déclaration de variable réelle au moment de la liaison du programme.

Exemple

Essayez l'exemple suivant, où la variable a été déclarée avec un type et initialisée dans la fonction principale -

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

20
x is of type float64

Déclaration de type dynamique / Inférence de type dans Go

Une déclaration de variable de type dynamique nécessite que le compilateur interprète le type de la variable en fonction de la valeur qui lui est transmise. Le compilateur n'exige pas qu'une variable ait un type statique comme condition nécessaire.

Exemple

Essayez l'exemple suivant, où les variables ont été déclarées sans aucun type. Remarquez, en cas d'inférence de type, nous avons initialisé la variabley avec: = opérateur, alors que x est initialisé à l'aide de l'opérateur =.

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)	
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

20
42
x is of type float64
y is of type int

Déclaration de variable mixte dans Go

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

Exemple

package main

import "fmt"

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

3
4
foo
a is of type int
b is of type int
c is of type string

Les lvalues et les rvalues dans Go

Il existe deux types d'expressions dans Go -

lvalue- Les expressions qui font référence à un emplacement mémoire sont appelées expression "lvalue". Une lvalue peut apparaître comme le côté gauche ou droit d'une affectation.
rvalue- Le terme rvalue fait référence à une valeur de données qui est stockée à une certaine adresse en mémoire. Une rvalue est une expression qui ne peut pas avoir de valeur assignée, ce qui signifie qu'une rvalue peut apparaître sur le côté droit mais pas gauche d'une affectation.

Les variables sont des valeurs l et peuvent donc apparaître sur le côté gauche d'une affectation. Les littéraux numériques sont des rvalues et ne peuvent donc pas être affectés et ne peuvent pas apparaître sur le côté gauche.

La déclaration suivante est valide -

x = 20.0

La déclaration suivante n'est pas valide. Cela générerait une erreur de compilation -

10 = 20

Les constantes font référence à des valeurs fixes que le programme ne peut pas modifier lors de son exécution. Ces valeurs fixes sont également appeléesliterals.

Les constantes peuvent être de l'un des types de données de base comme une constante entière, une constante flottante, une constante de caractère ou une chaîne littérale . Il existe également des constantes d'énumération.

Les constantes sont traitées comme des variables régulières sauf que leurs valeurs ne peuvent pas être modifiées après leur définition.

Littéraux entiers

Un littéral entier peut être une constante décimale, octale ou hexadécimale. Un préfixe spécifie la base ou la base: 0x ou 0X pour hexadécimal, 0 pour octal et rien pour décimal.

Un littéral entier peut également avoir un suffixe qui est une combinaison de U et L, pour unsigned et long, respectivement. Le suffixe peut être en majuscules ou en minuscules et peut être dans n'importe quel ordre.

Voici quelques exemples de littéraux entiers -

212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */
078         /* Illegal: 8 is not an octal digit */
032UU       /* Illegal: cannot repeat a suffix */

Voici d'autres exemples de différents types de littéraux entiers -

85         /* decimal */
0213       /* octal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

Littéraux à virgule flottante

Un littéral à virgule flottante a une partie entière, une virgule décimale, une partie fractionnaire et une partie exposant. Vous pouvez représenter des littéraux à virgule flottante sous forme décimale ou exponentielle.

Lors de la représentation sous forme décimale, vous devez inclure la virgule décimale, l'exposant ou les deux et, lors de la représentation sous forme exponentielle, vous devez inclure la partie entière, la partie fractionnaire ou les deux. L'exposant signé est introduit par e ou E.

Voici quelques exemples de littéraux à virgule flottante -

3.14159       /* Legal */
314159E-5L    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

Séquence d'échappement

Lorsque certains caractères sont précédés d'une barre oblique inverse, ils auront une signification particulière dans Go. Ceux-ci sont connus sous le nom de codes de séquence d'échappement qui sont utilisés pour représenter une nouvelle ligne (\ n), une tabulation (\ t), un retour arrière, etc. Ici, vous avez une liste de certains de ces codes de séquence d'échappement -

Séquence d'échappement	Sens
\\	\ personnage
\ '	' personnage
\ "	" personnage
\?	? personnage
\une	Alerte ou cloche
\ b	Retour arrière
\F	Saut de formulaire
\ n	Nouvelle ligne
\ r	Retour chariot
\ t	Onglet horizontal
\ v	Onglet vertical
\ ooo	Numéro octal de un à trois chiffres
\ xhh. . .	Nombre hexadécimal d'un ou plusieurs chiffres

L'exemple suivant montre comment utiliser \t dans un programme -

package main

import "fmt"

func main() {
   fmt.Printf("Hello\tWorld!")
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Hello World!

Littéraux de chaîne dans Go

Les chaînes littérales ou les constantes sont placées entre guillemets doubles "". Une chaîne contient des caractères similaires aux littéraux de caractères: caractères simples, séquences d'échappement et caractères universels.

Vous pouvez diviser une longue ligne en plusieurs lignes en utilisant des chaînes littérales et en les séparant à l'aide d'espaces.

Voici quelques exemples de littéraux de chaîne. Les trois formes sont des chaînes identiques.

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

Le mot-clé const

Vous pouvez utiliser const préfixe pour déclarer des constantes avec un type spécifique comme suit -

const variable type = value;

L'exemple suivant montre comment utiliser le const mot-clé -

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5   
   var area int

   area = LENGTH * WIDTH
   fmt.Printf("value of area : %d", area)   
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

value of area : 50

Notez que c'est une bonne pratique de programmation de définir des constantes dans CAPITALS.

Un opérateur est un symbole qui indique au compilateur d'effectuer des manipulations mathématiques ou logiques spécifiques. Le langage Go est riche en opérateurs intégrés et fournit les types d'opérateurs suivants -

Opérateurs arithmétiques
Opérateurs relationnels
Opérateurs logiques
Opérateurs au niveau du bit
Opérateurs d'affectation
Opérateurs divers

Ce didacticiel explique les opérateurs arithmétiques, relationnels, logiques, au niveau du bit, d'affectation et d'autres un par un.

Opérateurs arithmétiques

Le tableau suivant montre tous les opérateurs arithmétiques pris en charge par le langage Go. Supposons une variableA détient 10 et variable B détient 20 alors -

Afficher des exemples

Opérateur	La description	Exemple
+	Ajoute deux opérandes	A + B donne 30
-	Soustrait le deuxième opérande du premier	A - B donne -10
*	Multiplie les deux opérandes	A * B donne 200
/	Divise le numérateur par le dénominateur.	B / A donne 2
%	Opérateur de module; donne le reste après une division entière.	B% A donne 0
++	Opérateur d'incrémentation. Il augmente la valeur entière de un.	A ++ donne 11
-	Opérateur de décrémentation. Il diminue la valeur entière de un.	A-- donne 9

Opérateurs relationnels

Le tableau suivant répertorie tous les opérateurs relationnels pris en charge par le langage Go. Supposons une variableA détient 10 et variable B détient 20, alors -

Afficher des exemples

Opérateur	La description	Exemple
==	Il vérifie si les valeurs de deux opérandes sont égales ou non; si oui, la condition devient vraie.	(A == B) n'est pas vrai.
! =	Il vérifie si les valeurs de deux opérandes sont égales ou non; si les valeurs ne sont pas égales, la condition devient vraie.	(A! = B) est vrai.
>	Il vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit; si oui, la condition devient vraie.	(A> B) n'est pas vrai.
<	Il vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit; si oui, la condition devient vraie.	(A <B) est vrai.
> =	Il vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit; si oui, la condition devient vraie.	(A> = B) n'est pas vrai.
<=	Il vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit; si oui, la condition devient vraie.	(A <= B) est vrai.

Opérateurs logiques

Le tableau suivant répertorie tous les opérateurs logiques pris en charge par le langage Go. Supposons une variableA contient 1 et variable B détient 0, alors -

Afficher des exemples

Opérateur	La description	Exemple
&&	Opérateur logique ET appelé. Si les deux opérandes sont différents de zéro, la condition devient vraie.	(A && B) est faux.
\|\|	Opérateur OU logique appelé. Si l'un des deux opérandes est différent de zéro, la condition devient vraie.	(A \|\| B) est vrai.
!	Opérateur PAS logique appelé. Utilisez pour inverser l'état logique de son opérande. Si une condition est vraie, l'opérateur NOT logique rendra faux.	! (A && B) est vrai.

Le tableau suivant montre tous les opérateurs logiques pris en charge par le langage Go. Supposons une variableA est vrai et variable B est faux, alors -

Opérateur	La description	Exemple
&&	Opérateur logique ET appelé. Si les deux opérandes sont faux, la condition devient fausse.	(A && B) est faux.
\|\|	Opérateur OU logique appelé. Si l'un des deux opérandes est vrai, la condition devient vraie.	(A \|\| B) est vrai.
!	Opérateur PAS logique appelé. Utilisez pour inverser l'état logique de son opérande. Si une condition est vraie, alors l'opérateur logique NOT la rendra fausse.	! (A && B) est vrai.

Opérateurs au niveau du bit

Les opérateurs au niveau du bit fonctionnent sur les bits et effectuent des opérations bit par bit. Les tables de vérité pour &, | et ^ sont les suivantes:

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Supposons que A = 60; et B = 13. Au format binaire, ils seront comme suit -

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~ A = 1100 0011

Les opérateurs Bitwise pris en charge par le langage C sont répertoriés dans le tableau suivant. Supposons que la variable A a 60 et la variable B 13, alors -

Afficher des exemples

Opérateur	La description	Exemple
&	L'opérateur binaire AND copie un peu le résultat s'il existe dans les deux opérandes.	(A & B) donnera 12, soit 0000 1100
\|	L'opérateur OR binaire copie un bit s'il existe dans l'un ou l'autre des opérandes.	(A \| B) donnera 61, soit 0011 1101
^	L'opérateur XOR binaire copie le bit s'il est défini dans un opérande mais pas dans les deux.	(A ^ B) donnera 49, soit 0011 0001
<<	Opérateur de décalage binaire gauche. La valeur des opérandes de gauche est déplacée vers la gauche du nombre de bits spécifié par l'opérande de droite.	Un << 2 donnera 240, soit 1111 0000
>>	Opérateur de décalage binaire vers la droite. La valeur des opérandes de gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande de droite.	Un >> 2 donnera 15, soit 0000 1111

Opérateurs d'affectation

Le tableau suivant répertorie tous les opérateurs d'affectation pris en charge par la langue Go -

Afficher des exemples

Opérateur	La description	Exemple
=	Opérateur d'affectation simple, attribue des valeurs d'opérandes de droite à l'opérande de gauche	C = A + B attribuera la valeur de A + B à C
+ =	Ajouter l'opérateur d'affectation ET, il ajoute l'opérande droit à l'opérande gauche et attribue le résultat à l'opérande gauche	C + = A équivaut à C = C + A
- =	Soustraire l'opérateur d'affectation ET, il soustrait l'opérande droit de l'opérande gauche et attribuer le résultat à l'opérande gauche	C - = A équivaut à C = C - A
* =	Multiplier l'opérateur d'affectation ET, il multiplie l'opérande droit par l'opérande gauche et attribue le résultat à l'opérande gauche	C * = A équivaut à C = C * A
/ =	Opérateur d'affectation de division ET, il divise l'opérande gauche avec l'opérande droit et affecte le résultat à l'opérande gauche	C / = A équivaut à C = C / A
% =	Opérateur d'assignation de module ET, il prend le module en utilisant deux opérandes et affecte le résultat à l'opérande de gauche	C% = A équivaut à C = C% A
<< =	Opérateur de décalage ET d'affectation à gauche	C << = 2 est identique à C = C << 2
>> =	Opérateur de décalage ET d'affectation à droite	C >> = 2 est identique à C = C >> 2
& =	Opérateur d'affectation AND au niveau du bit	C & = 2 est identique à C = C & 2
^ =	OU exclusif au niveau du bit et opérateur d'affectation	C ^ = 2 est identique à C = C ^ 2
\| =	OR inclusif au niveau du bit et opérateur d'affectation	C \| = 2 est identique à C = C \| 2

Opérateurs divers

Il existe quelques autres opérateurs importants pris en charge par Go Language, notamment sizeof et ?:.

Afficher des exemples

Opérateur	La description	Exemple
&	Renvoie l'adresse d'une variable.	&a; provides actual address of the variable.
*	Pointer to a variable.	*a; provides pointer to a variable.

Operators Precedence in Go

Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.

For example x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.

Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.

Show Examples

Category	Operator	Associativity
Postfix	() [] -> . ++ - -	Left to right
Unary	+ - ! ~ ++ - - (type)* & sizeof	Right to left
Multiplicative	* / %	Left to right
Additive	+ -	Left to right
Shift	<< >>	Left to right
Relational	< <= > >=	Left to right
Equality	== !=	Left to right
Bitwise AND	&	Left to right
Bitwise XOR	^	Left to right
Bitwise OR	\|	Left to right
Logical AND	&&	Left to right
Logical OR	\|\|	Left to right
Assignment	= += -= *= /= %=>>= <<= &= ^= \|=	Right to left
Comma	,	Left to right

Decision making structures require that the programmer specify one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general form of a typical decision making structure found in most of the programming languages −

Go programming language provides the following types of decision making statements. Click the following links to check their detail.

Sr.No	Statement & Description
1	if statement An if statement consists of a boolean expression followed by one or more statements.
2	if...else statement An if statement can be followed by an optional else statement, which executes when the boolean expression is false.
3	nested if statements You can use one if or else if statement inside another if or else if statement(s).
4	switch statement A switch statement allows a variable to be tested for equality against a list of values.
5	select statement A select statement is similar to switch statement with difference that case statements refers to channel communications.

There may be a situation, when you need to execute a block of code several number of times. In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times and following is the general form of a loop statement in most of the programming languages −

Go programming language provides the following types of loop to handle looping requirements.

Sr.No	Loop Type & Description
1	for loop It executes a sequence of statements multiple times and abbreviates the code that manages the loop variable.
2	nested loops These are one or multiple loops inside any for loop.

Loop Control Statements

Loop control statements change an execution from its normal sequence. When an execution leaves its scope, all automatic objects that were created in that scope are destroyed.

Go supports the following control statements −

Sr.No	Control Statement & Description
1	break statement It terminates a for loop or switch statement and transfers execution to the statement immediately following the for loop or switch.
2	continue statement It causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.
3	goto statement It transfers control to the labeled statement.

The Infinite Loop

A loop becomes an infinite loop if its condition never becomes false. The for loop is traditionally used for this purpose. Since none of the three expressions that form the for loop are required, you can make an endless loop by leaving the conditional expression empty or by passing true to it.

package main

import "fmt"

func main() {
   for true  {
       fmt.Printf("This loop will run forever.\n");
   }
}

When the conditional expression is absent, it is assumed to be true. You may have an initialization and increment expression, but C programmers more commonly use the for(;;) construct to signify an infinite loop.

Note − You can terminate an infinite loop by pressing Ctrl + C keys.

A function is a group of statements that together perform a task. Every Go program has at least one function, which is main(). You can divide your code into separate functions. How you divide your code among different functions is up to you, but logically, the division should be such that each function performs a specific task.

A function declaration tells the compiler about a function name, return type, and parameters. A function definition provides the actual body of the function.

The Go standard library provides numerous built-in functions that your program can call. For example, the function len() takes arguments of various types and returns the length of the type. If a string is passed to it, the function returns the length of the string in bytes. If an array is passed to it, the function returns the length of the array.

Functions are also known as method, sub-routine, or procedure.

Defining a Function

The general form of a function definition in Go programming language is as follows −

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

A function definition in Go programming language consists of a function header and a function body. Here are all the parts of a function −

Func − It starts the declaration of a function.
Function Name − It is the actual name of the function. The function name and the parameter list together constitute the function signature.
Parameters − A parameter is like a placeholder. When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters.
Return Type − A function may return a list of values. The return_types is the list of data types of the values the function returns. Some functions perform the desired operations without returning a value. In this case, the return_type is the not required.
Function Body − It contains a collection of statements that define what the function does.

Example

The following source code shows a function called max(). This function takes two parameters num1 and num2 and returns the maximum between the two −

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

Calling a Function

While creating a Go function, you give a definition of what the function has to do. To use a function, you will have to call that function to perform the defined task.

When a program calls a function, the program control is transferred to the called function. A called function performs a defined task and when its return statement is executed or when its function-ending closing brace is reached, it returns the program control back to the main program.

To call a function, you simply need to pass the required parameters along with its function name. If the function returns a value, then you can store the returned value. For example −

package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200
   var ret int

   /* calling a function to get max value */
   ret = max(a, b)

   fmt.Printf( "Max value is : %d\n", ret )
}

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

We have kept the max() function along with the main() function and compiled the source code. While running the final executable, it would produce the following result −

Max value is : 200

Returning multiple values from Function

A Go function can return multiple values. For example −

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)
}

When the above code is compiled and executed, it produces the following result −

Kumar Mahesh

Function Arguments

If a function is to use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function.

The formal parameters behave like other local variables inside the function and are created upon entry into the function and destroyed upon exit.

While calling a function, there are two ways that arguments can be passed to a function −

Sr.No	Call Type & Description
1	Call by value This method copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.
2	Call by reference This method copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the argument.

By default, Go uses call by value to pass arguments. In general, it means the code within a function cannot alter the arguments used to call the function. The above program, while calling the max() function, used the same method.

Function Usage

A function can be used in the following ways:

Sr.No	Function Usage & Description
1	Function as Value Functions can be created on the fly and can be used as values.
2	Function Closures Functions closures are anonymous functions and can be used in dynamic programming.
3	Method Methods are special functions with a receiver.

A scope in any programming is a region of the program where a defined variable can exist and beyond that the variable cannot be accessed. There are three places where variables can be declared in Go programming language −

Inside a function or a block (local variables)
Outside of all functions (global variables)
In the definition of function parameters (formal parameters)

Let us find out what are local and global variables and what are formal parameters.

Local Variables

Variables that are declared inside a function or a block are called local variables. They can be used only by statements that are inside that function or block of code. Local variables are not known to functions outside their own. The following example uses local variables. Here all the variables a, b, and c are local to the main() function.

package main

import "fmt"

func main() {
   /* local variable declaration */
   var a, b, c int 

   /* actual initialization */
   a = 10
   b = 20
   c = a + b

   fmt.Printf ("value of a = %d, b = %d and c = %d\n", a, b, c)
}

When the above code is compiled and executed, it produces the following result −

value of a = 10, b = 20 and c = 30

Variables globales

Les variables globales sont définies en dehors d'une fonction, généralement au-dessus du programme. Les variables globales conservent leur valeur pendant toute la durée de vie du programme et elles sont accessibles à l'intérieur de n'importe quelle fonction définie pour le programme.

Une variable globale est accessible par n'importe quelle fonction. Autrement dit, une variable globale est disponible pour une utilisation dans tout le programme après sa déclaration. L'exemple suivant utilise à la fois des variables globales et locales -

package main

import "fmt"
 
/* global variable declaration */
var g int
 
func main() {
   /* local variable declaration */
   var a, b int

   /* actual initialization */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("value of a = %d, b = %d and g = %d\n", a, b, g)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

value of a = 10, b = 20 and g = 30

Un programme peut avoir le même nom pour les variables locales et globales mais la valeur de la variable locale à l'intérieur d'une fonction a la préférence. Par exemple -

package main

import "fmt"
 
/* global variable declaration */
var g int = 20
 
func main() {
   /* local variable declaration */
   var g int = 10
 
   fmt.Printf ("value of g = %d\n",  g)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

value of g = 10

Paramètres formels

Les paramètres formels sont traités comme des variables locales dans cette fonction et ils ont la préférence sur les variables globales. Par exemple -

package main

import "fmt"
 
/* global variable declaration */
var a int = 20;
 
func main() {
   /* local variable declaration in main function */
   var a int = 10
   var b int = 20
   var c int = 0

   fmt.Printf("value of a in main() = %d\n",  a);
   c = sum( a, b);
   fmt.Printf("value of c in main() = %d\n",  c);
}
/* function to add two integers */
func sum(a, b int) int {
   fmt.Printf("value of a in sum() = %d\n",  a);
   fmt.Printf("value of b in sum() = %d\n",  b);

   return a + b;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30

Initialisation des variables locales et globales

Les variables locales et globales sont initialisées à leur valeur par défaut, qui est 0; tandis que les pointeurs sont initialisés à nil.

Type de données	Valeur par défaut initiale
int	0
float32	0
aiguille	néant

Les chaînes, qui sont largement utilisées dans la programmation Go, sont une tranche d'octets en lecture seule. Dans le langage de programmation Go, les chaînes sontslices. La plate-forme Go fournit diverses bibliothèques pour manipuler des chaînes.

unicode
regexp
strings

Création de chaînes

La façon la plus directe de créer une chaîne est d'écrire -

var greeting = "Hello world!"

Chaque fois qu'il rencontre une chaîne littérale dans votre code, le compilateur crée un objet chaîne avec sa valeur dans ce cas, "Hello world!".

Un littéral de chaîne contient une séquence UTF-8 valide appelée runes. Une chaîne contient des octets arbitraires.

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("normal string: ")
   fmt.Printf("%s", greeting)
   fmt.Printf("\n")
   fmt.Printf("hex bytes: ")
   
   for i := 0; i < len(greeting); i++ {
       fmt.Printf("%x ", greeting[i])
   }
   fmt.Printf("\n")
   
   const sampleText = "\xbd\xb2\x3d\xbc\x20\xe2\x8c\x98" 
   /*q flag escapes unprintable characters, with + flag it escapses non-ascii 
   characters as well to make output unambigous  
   */
   fmt.Printf("quoted string: ")
   fmt.Printf("%+q", sampleText)
   fmt.Printf("\n")  
}

Cela produirait le résultat suivant -

normal string: Hello world!
hex bytes: 48 65 6c 6c 6f 20 77 6f 72 6c 64 21 
quoted string: "\xbd\xb2=\xbc \u2318"

Note - Le littéral de chaîne est immuable, de sorte qu'une fois qu'il est créé, un littéral de chaîne ne peut pas être modifié.

Longueur de chaine

La méthode len (str) renvoie le nombre d'octets contenus dans la chaîne littérale.

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("String Length is: ")
   fmt.Println(len(greeting))  
}

Cela produirait le résultat suivant -

String Length is : 12

Concaténation de chaînes

Le package de chaînes comprend une méthode join pour concaténer plusieurs chaînes -

strings.Join(sample, " ")

Join concatène les éléments d'un tableau pour créer une seule chaîne. Le deuxième paramètre est le séparateur qui est placé entre les éléments du tableau.

Regardons l'exemple suivant -

package main

import ("fmt" "math" )"fmt" "strings")

func main() {
   greetings :=  []string{"Hello","world!"}   
   fmt.Println(strings.Join(greetings, " "))
}

Cela produirait le résultat suivant -

Hello world!

Le langage de programmation Go fournit une structure de données appelée the array, qui peut stocker une collection séquentielle de taille fixe d'éléments du même type. Un tableau est utilisé pour stocker une collection de données, mais il est souvent plus utile de considérer un tableau comme une collection de variables du même type.

Au lieu de déclarer des variables individuelles, telles que nombre0, nombre1, ... et nombre99, vous déclarez une variable de tableau telle que des nombres et utilisez les nombres [0], les nombres [1] et ..., les nombres [99] pour représenter variables individuelles. Un élément spécifique d'un tableau est accessible par un index.

Tous les tableaux sont constitués d'emplacements de mémoire contigus. L'adresse la plus basse correspond au premier élément et l'adresse la plus élevée au dernier élément.

Déclaration de tableaux

Pour déclarer un tableau dans Go, un programmeur spécifie le type des éléments et le nombre d'éléments requis par un tableau comme suit -

var variable_name [SIZE] variable_type

C'est ce qu'on appelle un tableau unidimensionnel . learraySize doit être une constante entière supérieure à zéro et typepeut être n'importe quel type de données Go valide. Par exemple, pour déclarer un tableau de 10 éléments appelébalance de type float32, utilisez cette instruction -

var balance [10] float32

Ici, balance est un tableau de variables pouvant contenir jusqu'à 10 nombres flottants.

Initialisation des tableaux

Vous pouvez initialiser le tableau dans Go un par un ou en utilisant une seule instruction comme suit -

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

Le nombre de valeurs entre accolades {} ne peut pas être supérieur au nombre d'éléments que nous déclarons pour le tableau entre crochets [].

Si vous omettez la taille du tableau, un tableau juste assez grand pour contenir l'initialisation est créé. Par conséquent, si vous écrivez -

var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}

Vous allez créer exactement le même tableau que vous l'avez fait dans l'exemple précédent. Voici un exemple pour affecter un seul élément du tableau -

balance[4] = 50.0

L'instruction ci-dessus attribue au numéro d'élément 5 ^e dans le tableau une valeur de 50,0. Tous les tableaux ont 0 comme index de leur premier élément qui est également appelé index de base et le dernier index d'un tableau sera la taille totale du tableau moins 1. Voici la représentation picturale du même tableau que nous avons discuté ci-dessus -

Accès aux éléments de la baie

Un élément est accessible en indexant le nom du tableau. Cela se fait en plaçant l'index de l'élément entre crochets après le nom du tableau. Par exemple -

float32 salary = balance[9]

L'instruction ci-dessus prendra le ^10ème élément du tableau et attribuera la valeur à la variable de salaire. Voici un exemple qui utilisera tous les trois concepts mentionnés ci-dessus à savoir. déclaration, affectation et accès aux tableaux -

package main

import "fmt"

func main() {
   var n [10]int /* n is an array of 10 integers */
   var i,j int

   /* initialize elements of array n to 0 */         
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* set element at location i to i + 100 */
   }
   /* output each array element's value */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

Go Arrays en détail

Il y a des concepts importants liés au tableau qui devraient être clairs pour un programmeur Go -

Sr.Non	Concept et description
1	Tableaux multidimensionnels Go prend en charge les tableaux multidimensionnels. La forme la plus simple d'un tableau multidimensionnel est le tableau à deux dimensions.
2	Passer des tableaux aux fonctions Vous pouvez passer à la fonction un pointeur vers un tableau en spécifiant le nom du tableau sans index.

Les pointeurs de Go sont faciles et amusants à apprendre. Certaines tâches de programmation Go sont exécutées plus facilement avec des pointeurs, et d'autres tâches, telles que l'appel par référence, ne peuvent pas être effectuées sans l'utilisation de pointeurs. Il devient donc nécessaire d'apprendre les pointeurs pour devenir un programmeur Go parfait.

Comme vous le savez, chaque variable est un emplacement de mémoire et chaque emplacement de mémoire a son adresse définie, accessible à l'aide de l'opérateur perluète (&), qui désigne une adresse en mémoire. Prenons l'exemple suivant, qui affichera l'adresse des variables définies -

package main

import "fmt"

func main() {
   var a int = 10   
   fmt.Printf("Address of a variable: %x\n", &a  )
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Address of a variable: 10328000

Vous avez donc compris ce qu'est l'adresse mémoire et comment y accéder. Voyons maintenant ce que sont les pointeurs.

Que sont les pointeurs?

UNE pointerest une variable dont la valeur est l'adresse d'une autre variable, c'est-à-dire l'adresse directe de l'emplacement mémoire. Comme toute variable ou constante, vous devez déclarer un pointeur avant de pouvoir l'utiliser pour stocker une adresse de variable. La forme générale d'une déclaration de variable de pointeur est -

var var_name *var-type

Ici, typeest le type de base du pointeur; il doit s'agir d'un type de données C valide etvar-nameest le nom de la variable du pointeur. L'astérisque * que vous avez utilisé pour déclarer un pointeur est le même astérisque que vous utilisez pour la multiplication. Cependant, dans cette instruction, l'astérisque est utilisé pour désigner une variable comme pointeur. Voici la déclaration de pointeur valide -

var ip *int        /* pointer to an integer */
var fp *float32    /* pointer to a float */

Le type de données réel de la valeur de tous les pointeurs, qu'il soit entier, flottant ou autre, est le même, un long nombre hexadécimal qui représente une adresse mémoire. La seule différence entre les pointeurs de différents types de données est le type de données de la variable ou de la constante vers laquelle pointe le pointeur.

Comment utiliser les pointeurs?

Il y a quelques opérations importantes, que nous effectuons fréquemment avec des pointeurs: (a) nous définissons des variables de pointeur, (b) assignons l'adresse d'une variable à un pointeur, et (c) accédons à la valeur à l'adresse stockée dans la variable de pointeur .

Toutes ces opérations sont effectuées à l'aide de l'opérateur unaire * qui renvoie la valeur de la variable située à l'adresse spécifiée par son opérande. L'exemple suivant montre comment effectuer ces opérations -

package main

import "fmt"

func main() {
   var a int = 20   /* actual variable declaration */
   var ip *int      /* pointer variable declaration */

   ip = &a  /* store address of a in pointer variable*/

   fmt.Printf("Address of a variable: %x\n", &a  )

   /* address stored in pointer variable */
   fmt.Printf("Address stored in ip variable: %x\n", ip )

   /* access the value using the pointer */
   fmt.Printf("Value of *ip variable: %d\n", *ip )
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20

Aucun pointeur en Go

Le compilateur Go 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é nul est appelé unnil aiguille.

Le pointeur nil est une constante avec une valeur de zéro définie dans plusieurs bibliothèques standard. Considérez le programme suivant -

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("The value of ptr is : %x\n", ptr  )
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

The value of ptr is 0

Sur la plupart des systèmes d'exploitation, les programmes ne sont pas autorisés à accéder à la mémoire à l'adresse 0 car cette mémoire est réservée par le système d'exploitation. Cependant, l'adresse mémoire 0 a une signification particulière; il signale que le pointeur n'est pas destiné à pointer vers un emplacement mémoire accessible. Mais par convention, si un pointeur contient la valeur nil (zéro), il est supposé ne pointer vers rien.

Pour rechercher un pointeur nul, vous pouvez utiliser une instruction if comme suit -

if(ptr != nil)     /* succeeds if p is not nil */
if(ptr == nil)    /* succeeds if p is null */

Go Pointers en détail

Les pointeurs ont des concepts nombreux mais simples et ils sont très importants pour la programmation Go. Les concepts de pointeurs suivants devraient être clairs pour un programmeur Go -

Sr.Non	Concept et description
1	Go - Tableau de pointeurs Vous pouvez définir des tableaux pour contenir un certain nombre de pointeurs.
2	Aller - Pointeur vers pointeur Aller vous permet d'avoir un pointeur sur un pointeur et ainsi de suite.
3	Passer des pointeurs vers des fonctions dans Go Le passage d'un argument par référence ou par adresse permet tous deux de modifier l'argument passé dans la fonction appelante par la fonction appelée.

Les tableaux Go vous permettent de définir des variables pouvant contenir plusieurs éléments de données du même type. 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.

Les structures sont utilisées pour représenter un enregistrement. Supposons que vous souhaitiez garder une trace des livres dans une bibliothèque. Vous voudrez peut-être suivre les attributs suivants de chaque livre -

Title
Author
Subject
ID du livre

Dans un tel scénario, les structures sont très utiles.

Définition d'une structure

Pour définir une structure, vous devez utiliser type et structdéclarations. L'instruction struct définit un nouveau type de données, avec plusieurs membres pour votre programme. L'instruction de type lie un nom au 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;
}

Une fois qu'un type de structure est défini, il peut être utilisé pour déclarer des variables de ce type à l'aide de la syntaxe suivante.

variable_name := structure_variable_type {value1, value2...valuen}

Accès aux membres de la structure

Pour accéder à n'importe quel membre d'une structure, nous utilisons le member access operator (.).L'opérateur d'accès au membre est codé comme un point entre le nom de la variable de structure et le membre de la structure auquel nous souhaitons accéder. Vous utiliseriezstructmot-clé pour définir des variables de type structure. L'exemple suivant explique comment utiliser une structure -

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books    /* Declare Book1 of type Book */
   var Book2 Books    /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   fmt.Printf( "Book 1 title : %s\n", Book1.title)
   fmt.Printf( "Book 1 author : %s\n", Book1.author)
   fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
   fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)

   /* print Book2 info */
   fmt.Printf( "Book 2 title : %s\n", Book2.title)
   fmt.Printf( "Book 2 author : %s\n", Book2.author)
   fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
   fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Book 1 title      : Go Programming
Book 1 author     : Mahesh Kumar
Book 1 subject    : Go Programming Tutorial
Book 1 book_id    : 6495407
Book 2 title      : Telecom Billing
Book 2 author     : Zara Ali
Book 2 subject    : Telecom Billing Tutorial
Book 2 book_id    : 6495700

Structures comme arguments de fonction

Vous pouvez passer une structure en tant qu'argument de fonction de manière très similaire à celle de toute autre variable ou pointeur. Vous accéderiez aux variables de structure de la même manière que vous l'avez fait dans l'exemple ci-dessus -

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books    /* Declare Book1 of type Book */
   var Book2 Books    /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(Book1)

   /* print Book2 info */
   printBook(Book2)
}
func printBook( book Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

Pointeurs vers des structures

Vous pouvez définir des pointeurs vers des structures de la même manière que vous définissez un pointeur vers toute autre variable comme suit -

var struct_pointer *Books

Vous pouvez désormais stocker l'adresse d'une variable de structure dans la variable de pointeur définie ci-dessus. Pour trouver l'adresse d'une variable de structure, placez l'opérateur & avant le nom de la structure comme suit -

struct_pointer = &Book1;

Pour accéder aux membres d'une structure à l'aide d'un pointeur vers cette structure, vous devez utiliser le "." opérateur comme suit -

struct_pointer.title;

Réécrivons l'exemple ci-dessus en utilisant le pointeur de structure -

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books   /* Declare Book1 of type Book */
   var Book2 Books   /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(&Book1)

   /* print Book2 info */
   printBook(&Book2)
}
func printBook( book *Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

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

Définition d'une tranche

Pour définir une tranche, vous pouvez la déclarer en tant que tableau sans spécifier sa taille. Vous pouvez également utilisermake fonction pour créer une tranche.

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*/

Fonctions len () et cap ()

Une tranche est une abstraction sur un tableau. Il utilise en fait des tableaux comme structure sous-jacente. lelen() function renvoie les éléments présents dans la tranche où cap()La fonction renvoie la capacité de la tranche (c'est-à-dire le nombre d'éléments qu'elle peut contenir). L'exemple suivant explique l'utilisation de slice -

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)
   printSlice(numbers)
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

len = 3 cap = 5 slice = [0 0 0]

Tranche nulle

Si une tranche est déclarée sans entrées, alors par défaut, elle est initialisée à nil. Sa longueur et sa capacité sont nulles. Par exemple -

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   if(numbers == nil){
      fmt.Printf("slice is nil")
   }
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

len = 0 cap = 0 slice = []
slice is nil

Subslicing

Slice permet de spécifier la limite inférieure et la limite supérieure pour en obtenir la sous-tranche en utilisant[lower-bound:upper-bound]. Par exemple -

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)
   
   /* print the original slice */
   fmt.Println("numbers ==", numbers)
   
   /* print the sub slice starting from index 1(included) to index 4(excluded)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   
   /* missing lower bound implies 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   
   /* missing upper bound implies len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   
   /* print the sub slice starting from index 0(included) to index 2(excluded) */
   number2 := numbers[:2]
   printSlice(number2)
   
   /* print the sub slice starting from index 2(included) to index 5(excluded) */
   number3 := numbers[2:5]
   printSlice(number3)
   
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

len = 9 cap = 9 slice = [0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len = 0 cap = 5 slice = []
len = 2 cap = 9  slice = [0 1]
len = 3 cap = 7 slice = [2 3 4]

Fonctions append () et copy ()

On peut augmenter la capacité d'une tranche en utilisant le append()fonction. En utilisantcopy()fonction, le contenu d'une tranche source est copié dans une tranche de destination. Par exemple -

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   /* append allows nil slice */
   numbers = append(numbers, 0)
   printSlice(numbers)
   
   /* add one element to slice*/
   numbers = append(numbers, 1)
   printSlice(numbers)
   
   /* add more than one element at a time*/
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
   
   /* create a slice numbers1 with double the capacity of earlier slice*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
   
   /* copy content of numbers to numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]

le range le mot-clé est utilisé dans forboucle 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. Range renvoie une ou deux valeurs. Si une seule valeur est utilisée à gauche d'une expression de plage, il s'agit de la première valeur du tableau suivant.

Expression de plage	1ère valeur	2e valeur (facultatif)
Tableau ou tranche a [n] E	index i int	a [i] E
Type de chaîne de chaîne	index i int	rune int
carte m carte [K] V	clé k K	valeur m [k] V
canal c chan E	élément e E	aucun

Exemple

Le paragraphe suivant montre comment utiliser range -

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8} 
   
   /* print the numbers */
   for i:= range numbers {
      fmt.Println("Slice item",i,"is",numbers[i])
   }
   
   /* create a map*/
   countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo"}
   
   /* print map using keys*/
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* print map using key-value*/
   for country,capital := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",capital)
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Slice item 0 is 0
Slice item 1 is 1
Slice item 2 is 2
Slice item 3 is 3
Slice item 4 is 4
Slice item 5 is 5
Slice item 6 is 6
Slice item 7 is 7
Slice item 8 is 8
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo

Go fournit un autre type de données important appelé map 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 à l'aide de sa clé.

Définition d'une carte

Tu dois utiliser make fonction 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)

Exemple

L'exemple suivant illustre comment créer et utiliser une carte -

package main

import "fmt"

func main() {
   var countryCapitalMap map[string]string
   /* create a map*/
   countryCapitalMap = make(map[string]string)
   
   /* insert key-value pairs in the map*/
   countryCapitalMap["France"] = "Paris"
   countryCapitalMap["Italy"] = "Rome"
   countryCapitalMap["Japan"] = "Tokyo"
   countryCapitalMap["India"] = "New Delhi"
   
   /* print map using keys*/
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* test if entry is present in the map or not*/
   capital, ok := countryCapitalMap["United States"]
   
   /* if ok is true, entry is present otherwise entry is absent*/
   if(ok){
      fmt.Println("Capital of United States is", capital)  
   } else {
      fmt.Println("Capital of United States is not present") 
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Capital of India is New Delhi
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of United States is not present

Fonction delete ()

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

package main

import "fmt"

func main() {   
   /* create a map*/
   countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo","India":"New Delhi"}
   
   fmt.Println("Original map")   
   
   /* print map */
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* delete an entry */
   delete(countryCapitalMap,"France");
   fmt.Println("Entry for France is deleted")  
   
   fmt.Println("Updated map")   
   
   /* print map */
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Original Map
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of India is New Delhi
Entry for France is deleted
Updated Map
Capital of India is New Delhi
Capital of Italy is Rome
Capital of Japan is Tokyo

La récursivité est le processus de répétition d'éléments d'une manière auto-similaire. Le même concept s'applique également aux langages de programmation. Si un programme permet d'appeler une fonction à l'intérieur de la même fonction, alors il est appelé un appel de fonction récursif. Jetez un œil à l'exemple suivant -

func recursion() {
   recursion() /* function calls itself */
}
func main() {
   recursion()
}

Le langage de programmation Go prend en charge la récursivité. Autrement dit, il permet à une fonction de s'appeler. Mais tout en utilisant la récursivité, les programmeurs doivent faire attention à définir une condition de sortie de la fonction, sinon cela deviendra une boucle infinie.

Exemples de récursivité dans Go

Les fonctions récursives sont très utiles pour résoudre de nombreux problèmes mathématiques tels que le calcul factoriel d'un nombre, la génération d'une série de Fibonacci, etc.

Exemple 1: Calcul factoriel à l'aide de la récursivité dans Go

L'exemple suivant calcule la factorielle d'un nombre donné à l'aide d'une fonction récursive -

package main

import "fmt"

func factorial(i int)int {
   if(i <= 1) {
      return 1
   }
   return i * factorial(i - 1)
}
func main() { 
   var i int = 15
   fmt.Printf("Factorial of %d is %d", i, factorial(i))
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Factorial of 15 is 1307674368000

Exemple 2: Série Fibonacci utilisant la récursivité dans Go

L'exemple suivant montre comment générer une série de Fibonacci d'un nombre donné à l'aide d'une fonction récursive -

package main

import "fmt"

func fibonaci(i int) (ret int) {
   if i == 0 {
      return 0
   }
   if i == 1 {
      return 1
   }
   return fibonaci(i-1) + fibonaci(i-2)
}
func main() {
   var i int
   for i = 0; i < 10; i++ {
      fmt.Printf("%d ", fibonaci(i))
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

0 1 1 2 3 5 8 13 21 34

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 ducast operator. Sa syntaxe est la suivante -

type_name(expression)

Exemple

Prenons l'exemple suivant où l'opérateur de conversion entraîne la division d'une variable entière par une autre en tant qu'opération de nombre flottant.

package main

import "fmt"

func main() {
   var sum int = 17
   var count int = 5
   var mean float32
   
   mean = float32(sum)/float32(count)
   fmt.Printf("Value of mean : %f\n",mean)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Value of mean : 3.400000

La programmation Go fournit un autre type de données appelé interfacesqui 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.

Syntaxe

/* define an interface */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* define a struct */
type struct_name struct {
   /* variables */
}

/* implement interface methods*/
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* method implementation */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* method implementation */
}

Exemple

package main

import (
   "fmt" 
   "math" 
)

/* define an interface */
type Shape interface {
   area() float64
}

/* define a circle */
type Circle struct {
   x,y,radius float64
}

/* define a rectangle */
type Rectangle struct {
   width, height float64
}

/* define a method for circle (implementation of Shape.area())*/
func(circle Circle) area() float64 {
   return math.Pi * circle.radius * circle.radius
}

/* define a method for rectangle (implementation of Shape.area())*/
func(rect Rectangle) area() float64 {
   return rect.width * rect.height
}

/* define a method for shape */
func getArea(shape Shape) float64 {
   return shape.area()
}

func main() {
   circle := Circle{x:0,y:0,radius:5}
   rectangle := Rectangle {width:10, height:5}
   
   fmt.Printf("Circle area: %f\n",getArea(circle))
   fmt.Printf("Rectangle area: %f\n",getArea(rectangle))
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Circle area: 78.539816
Rectangle area: 50.000000

La programmation Go fournit un cadre de gestion des erreurs assez simple avec le type d'interface d'erreur intégré de la déclaration suivante -

type error interface {
   Error() string
}

Les fonctions renvoient normalement une erreur comme dernière valeur de retour. Utilisationerrors.New pour construire un message d'erreur de base comme suit -

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value), nil
}

Utilisez la valeur de retour et le message d'erreur.

result, err:= Sqrt(-1)

if err != nil {
   fmt.Println(err)
}

Exemple

package main

import "errors"
import "fmt"
import "math"

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value), nil
}
func main() {
   result, err:= Sqrt(-1)

   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(result)
   }
   
   result, err = Sqrt(9)

   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(result)
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Math: negative number passed to Sqrt
3

Aller - Guide rapide

Caractéristiques de la programmation Go

Fonctionnalités exclues intentionnellement

Programmes Go

Configuration de l'environnement local

Éditeur de texte

Le compilateur Go

Télécharger Go Archive

Installation sous UNIX / Linux / Mac OS X et FreeBSD

Installation sous Windows

Vérification de l'installation

Fichier: test.go

Production

Exemple Hello World

Exécution d'un programme Go

Jetons en Go

Séparateur de ligne

commentaires

Identifiants

Mots clés

Espace blanc dans Go

Types entiers

Types flottants

Autres types numériques

Définition de variable dans Go

Déclaration de type statique dans Go

Exemple

Déclaration de type dynamique / Inférence de type dans Go

Exemple

Déclaration de variable mixte dans Go

Exemple

Les lvalues ​​et les rvalues ​​dans Go

Littéraux entiers

Littéraux à virgule flottante

Séquence d'échappement

Littéraux de chaîne dans Go

Le mot-clé const

Opérateurs arithmétiques

Opérateurs relationnels

Opérateurs logiques

Opérateurs au niveau du bit

Opérateurs d'affectation

Opérateurs divers

Operators Precedence in Go

Loop Control Statements

The Infinite Loop

Defining a Function

Example

Calling a Function

Returning multiple values from Function

Function Arguments

Function Usage

Local Variables

Variables globales

Paramètres formels

Initialisation des variables locales et globales

Création de chaînes

Longueur de chaine

Concaténation de chaînes

Déclaration de tableaux

Initialisation des tableaux

Accès aux éléments de la baie

Go Arrays en détail

Que sont les pointeurs?

Comment utiliser les pointeurs?

Aucun pointeur en Go

Go Pointers en détail

Définition d'une structure

Accès aux membres de la structure

Structures comme arguments de fonction

Pointeurs vers des structures

Définition d'une tranche

Fonctions len () et cap ()

Tranche nulle

Subslicing

Fonctions append () et copy ()

Exemple

Définition d'une carte

Exemple

Fonction delete ()

Les lvalues et les rvalues dans Go