Introduction

Le Go est le langage de Google. Il a été publié en 2012 et a pour but d’être aussi rapide à la compilation/exécution que le C/C++ mais en plus simple. Autrement dit le Go est un langage compilé et typé dont la syntaxe ressemble énormément au C.

Le Go permet de compiler votre code source en un exécutable. Le programme compilé se retrouve dans un .exe. Cependant il est aussi possible d’exécuter son programme sans avoir à créer d’exécutable. Voici un exemple des deux commandes permettant de compiler :

La commande go build file.go permet de créer un exécutable du même nom que votre fichier.

Il suffit ensuite de faire ./nomdel’exécutable.

La seconde commande go run file.go permet de simplement exécuter votre programme.

Nous allons maintenant parler des grands points d’importance du Go.

Les bases de la syntaxe

Le Go a une syntaxe particulière qui ressemble au C avec tout de même quelques différences. Voici comment faire un programme de base qui affiche “Hello World!” :

package main
import "fmt"
//je suis un commentaire
func man() {
Fmt.Println("Hello World!!")
}

Voici le Hello World. En Go chaque programme est composé de paquets et l’exécution commence dans le paquet main (déclaré à la ligne 1). D’autres packages peuvent être importés en utilisant le mot clé  “import”. Ici on importe fmt (ligne 2) qui nous permet d’afficher une variable de type string suivie d’un retour à la ligne, ici cela nous permet d’afficher hello world (ligne 7). Comme vous pouvez le voir cette ligne se trouve dans la fonction d’exécution principale main(). Pour déclarer une fonction il suffit d’utiliser le mot clé “func” suivi par le nom de la fonction (ligne 6). Comme vous pouvez le voir la syntaxe ressemble au langage C.

Les Types

Comme dit précédemment le Go est un langage fortement typé. Voici les types auxquels vous pouvez avoir recourt dans le Go.

  • Les integers (correspond à des nombres entiers)
  • Les floats (correspond à des nombres décimaux)
  • Les strings (chaine de caractères)
  • Les booleans (on simplement pour valeur soit true soit false)

Chacun de ces types peut avoir recours à plusieurs formes d’opérations mathématiques.

  • +  permet de faire une addition (non disponible avec le type Boolean)
  • –  permet de faire une soustraction (non disponible avec le type Boolean)
  • * permet de faire une multiplication (non disponible avec le type Boolean)
  • / permet de faire une division (non disponible avec le type Boolean)
  • % permet de récupérer le reste d’une division euclidienne (non disponible avec le type Boolean)
  • && qui est égale a && en C (and)
  • || qui est égale à || en C (or)
  • ! est égale a != en C (différent)

Les Variables

En Go il existe plusieurs moyens de déclarer des variables le plus courant est d’utiliser le mot clé “var” suivi du nom de la variable ainsi que de son type. Voici un exemple :

func main() {
var x string = "Hello World!!"
fmt.Println(x)
}

Si vous regardez bien cette fonction, elle affiche comme la fonction vue plus haut hello world. Cependant, au lieu de rentrer la string en dur dans Println, ici la string est stocker dans la variable x. Cette déclaration peut aussi être fait sans utiliser de type, le Go, déduira, par ce qui lui est passé en valeur le type qu’il est dû.

func main() {
var x = "Hello World!!"
fmt.Println(x)
}

Il existe un autre type de syntaxe pour exactement faire la même chose :

func main() {
x := "Hello World!!"
fmt.Println(x)
}


Cependant ici vous pouvez voir que le mot clé “var” n’est pas nécessaire car nous utilisons la syntaxe “:=”. Comme vous pouvez vous en douter vous pouvez déclarer une multitude de variables de plusieurs types différents. Pour cela vous pouvez soit déclarer plusieurs “var” ligne par ligne ou bien utiliser cette syntaxe :

func main() {
var (
x = "Hello World!!"
i = 0
test = true
dec = 3.14
)

fmt.Println(x)
}

Dans cet exemple nous déclarons chaque type (string, int, bool, et float). Vous devez comprendre que dans le Go tout comme dans le C les variables ont une durée de vie.

Scope

Ici ces variables n’existent que dans la fonction main. Cependant vous pouvez tout aussi bien la déclarer en dehors ce qui aura pour effet de rendre votre variable utilisable dans tout votre programme.

var x string = "Hello World!!"
func main() {
fmt.Println(x)
}




Ici x sera disponible dans tout votre programme, dans cet exemple nous l’utilisons dans la fonction main.

Les constantes

Les constantes permettent d’indiquer à une variable qu’elle ne sera plus modifiable après sa création, le mot clé pour cela est “const”. Voici un exemple.

func main() {
const var x string = "Hello World!!"
x = "coucou"
fmt.Println(x)
}

Ici nous indiquons à la variable x aura toujours pour valeur “hello world!!”,  comme vous pouvez le voir sur la ligne suivante que nous essayons de lui attribuer une autre valeur. Voici l’output si nous exécutons ce programme.

Ici le Go nous indique une erreur car nous n’avons pas le droit de modifier la variable x.

Les Conditions

Tout comme en C, le Go permet d’avoir recourt aux conditions tels que le if, else if , else ainsi que les switch. Nous allons voir comment les utiliser et leur utilité.

Les If/else if /else

Le if permet d’exécuter une action seulement si la condition est vrai (true). Voici un exemple de déclaration d’un if :

func main() {
var age int = 17
if age >= 18 {
fmt.Println("Vous êtes majeur")
} else {
fmt.Println("Vous êtes mineur")
}
}



Ici comme vous pouvez le voir nous avons créé une variable Age de type int qui a pour valeur 17. Suite à cela nous regardons si la valeur de notre variable est supérieure ou égale à 18 avec notre if, si c’est le cas alors nous affichons (“Vous êtes majeur”) sinon (else) nous affichons (“Vous êtes mineur”). Nous aurions pu rajouter un else if si nous voulions une autre condition. Les “If” et les “else if” ont besoin e de conditions le else quant à lui ne prend pas de condition il se place obligatoirement après un “if” ou un “else if”.

Les switch :

Les switch ont le même fonctionnement que les if cependant la syntaxe est différente.

func main() {
var i int = 0
switch i {
case 0: fmt.Println("ZERO")
case 1: fmt.Println("TWO")
case 2: fmt.Println("THREE")
case 3: fmt.Println("FOUR")
case 4: fmt.Println("FIVE")
default : fmt.Println("Unknown Number")
}
}

Ici nous regardons si i est égale à 0/1/2/3/4 sinon nous affichons Unknown Number. Ici cela nous affichera “zero”.

Les Arrays

En Go vous pouvez déclarer des array de type, ce qui vous permet en réalité de créer une variable qui correspond à une liste de ce type :

func main() {
var x [5]int
x[4] = 100
fmt.Println(x)
}

Dans cet exemple nous déclarons une variable qui contient 5 int, dans ce tableau(array) nous indiquons que dans la position numéro 5 du tableau (un tableau commence à la position 0) nous souhaitons la valeur 100 puis nous l’affichons.

Comme vous pouvez le voir en GO si on ne définit pas la valeur d’une variable elle est à 0. Ici nous avons simplement indiquer que la valeur 5 était 100 donc dans notre tableau seule la dernière valeur n’est pas égale à 0. Il est possible de faire des array (tableau de tout type). Cet exemple vous présente un point important des Array les Slices.

Les Slices

Les slices correspondent au faite d’accéder à une valeur particulière d’un array dans l’exemple précèdent nous montre comment arriver au cinquième emplacement de notre tableau (array) voici d’autre exemple :

func main() {
x := [5]int { 98,93,77,82,83 }
var test = x[0]
fmt.Println(test)
}

Ici dans cet exemple nous déclarons un array composé de 5 int : [98, 93, 77, 82, 83] suite à cela nous récupérons la valeur 0 de notre tableau et nous la stockons dans une variable test puis nous affichons. Voici le résultat de ce programme :

98

Vous pouvez observer que notre programme affiche bien 98 (x[0]).

La commande Append

Imaginons que nous voulions rajouter des valeurs à notre tableau, la commande append est faite pour ça. Essayons de rajouter à notre tableau la valeur 2 et la valeur 3. Voici le code :

func main() {
x := []int { 98,93,77,82,83 }
newTab := append(x, 2, 3)
fmbt.Println(newTab)
}

Comme vous pouvez le voir certains changements sont apportés à notre code :

  • Nous ne définissons plus la taille de notre array
  • Nous stockons dans une nouvelle variable l’array auquel nous avons ajouté 2 et 3
  • Nous affichons cette nouvelle variable

Append permet donc de rajouter des valeurs à un tableau veillez néanmoins à avoir assez de place dans celui-ci.

Passons maintenant à l’explication d’un autre type de variable les Maps.

Les fonctions

En Go il est possible de segmenter son code en différente partie, ces parties se nomment fonctions. Nous allons voir comment en créer une :

func test() {
fmt.Println("Hello world")
}
func main() {
test()
}

Comme vous pouvez le voir dans cet exemple nous avons créé un fonction Test qui a pour but d’afficher “Hello world”. Une fois crée nous faisons appelle à celle-ci en indiquant son nom dans la fonction main suivi par des parenthèses . Imaginez maintenant que vous souhaitez créer une fonction qui vous retourne la somme d’une addition. En Go il suffit d’indiquer à la fonction qu’elle doit renvoyer une valeur.

func Add(nb1 int, nb2 int) int{
return nb1 + nb2
}

func main() {
var result = Add(3, 5)
fmt.Println(result)
}



Dans cet exemple on peut voir que la fonction Add prend deux paramètres (nb1 et nb2) et doit renvoyer une valeur de type Int. Ici nous renvoyons la somme de nb1 + nb2. Dans la fonction main nous pouvons observer que nous passons en paramètres 3 et 5 à notre fonction 3 sera stocké dans nb1 et 5 sera stocker dans nb2 puis nous stockons la valeur renvoyé par notre fonction Add dans une variable nommée result. Voici ce que nous affiche ce programme.

Comme vous pouvez le voir result est donc bien égale à 8.

Les Structures

Imaginez pouvoir créer votre propre type de variables, et bien c’est ce que l’on fait en créant une structure. Une structure est un type de variable dans lequel on définit de quel type de variable il est composé. Imaginons que vous vouliez créer un type personnalisé dans lequel vous souhaitez avoir un type string pour le nom et un type int pour les points de vie. Est bien vous pouvez. Voici le code qui correspond a cet exemple.  


type Personnage struct {
name string
point_de_vie int
}

Pour créer une structure rien de plus simple il suffit d’utiliser le mot clé type suivi par le nom de notre nouveau type, puis d’ajouter struct pour bien définir que ceci est une structure. Après il vous suffit simplement de déclarer des variables suivies de leur type (vous pouvez en déclarer autant que vous le souhaiter). Nous allons maintenant voir comment les utiliser dans une fonction.

func main() {
var perso Personnage
perso.name = "Expert Infeeny"
perso.point_de_vie = 100
fmt.Println("Mon personnage s'appelle " + perso.name)
fmt.Println(perso.point_de_vie)
}



Dans cet exemple nous créons une variable perso suivi de type de notre structure. Pour accéder au contenu de cette variable il suffit d’écrire son nom suivi d’un ‘.’ et du nom de la variable contenu dans la structure (perso.name). Ensuite nous affichons simplement le contenu de notre variable.

Les Channels

Dans ce tutoriel nous allons parler des channels. Les channels sont utilisées avec les goroutines pour envoyer des données (int, string, struct…) d’une goroutine et les recevoir dans une autre goroutine. C’est un moyen de connecter les différentes goroutines, c’est un moyen de communication et de synchronisation entre les goroutines. La transmission des channels se fait qu’avec des goroutines.

Pour déclarer votre channel, vous utiliserez le mot-clé make avec le mot-clé chan suivit du type de donnée que vous souhaitez transiter.

ch := make(chan typeDeValeur)

Voici un programme qui créé un channel

package main
import "fmt"
func run(c chan string, name string) {
   c <- name // envoyer une valeur d'un channel
}

func main() {
   canal := make(chan string)
   go run(canal, "INFEENY")
   fmt.Println(<-canal) // récupérer une valeur d'un channel
}

Ici notre programme nous affichera donc INFEENY.

Conclusion

Pour conclure le Go est un langage simple, qui est facile de prise en main, il a les avantages du C avec la technique de ce langage sans les inconvénients. Il est pratique, simple , et permet énormément de chose, ce langage est parfait pour de la programmation orientée C.

 

Cet article est écrit par les Experts Infeeny et Kevin Ansard.