Nous allons continuer à parler des types de base, mais je voudrais notamment aborder les commentaires et les instructions d'affichage. Lorsque vous donnez un cours sur un langage de programmation, vous avez une approche progressive, une chose à la fois. Mais certains concepts de base comme les commentaires et les instructions d'affichages sont utilisés très tôt. Je vais donc détailler un peu avant de continuer avec les variables.

Les commentaires, c'est assez simple, ce sont essentiellement des commentaires de type C, ils ont la même apparence qu'en C. Les commentaires d'une seule ligne commencent par une double barre oblique //.

// Cette ligne est un commentaire
var int x //Le commentaire commence au double-slash

Tout ce qui se trouve à droite des doubles barres obliques sur la ligne est un commentaire. Le commentaire est complètement ignoré par le compilateur. Il s'agit uniquement d'un texte que le programmeur doit examiner, comprendre, afin de faciliter la compréhension du code. Ce qui est utile.

Les commentaires sont d'excellentes choses lorsqu'ils sont utilisés de manière appropriée.

Le commentaire peut être utilisé sur une ligne une complète ou à la suite d'une instruction, dans ce cas, la barre oblique et tout ce qui se trouve à droite de la barre oblique sur cette ligne est un commentaire, mais le contenu de gauche est toujours un code valide. Ainsi, les éléments de gauche sont compilés, les éléments de droite sont ignorés par le compilateur.

En plus des commentaires d'une seule ligne, vous avez des commentaires en blocs.

/* Commentaire 1
   Commentaire 2
   ...
   Commentaire n */
var x int

Ceux-ci sont délimités par /* et */. Tout ce qui se trouve entre le /* et */ est un commentaire. Donc, dans ce cas, il ne s'agit que de quatre lignes, mais vous pouvez avoir autant de lignes de code que vous le souhaitez. Si je voulais avoir un texte quelconque décrivant une fonction, je peux le mettre sous forme d'un bloc avant la fonction. Ce sont donc des commentaires.

Autre chose que j' ai déjà utilisé dans les exemples d'introduction, ce sont les instructions d’affichage simplement parce qu'elles sont très utiles.

L’affichage se fait à l'aide du package FMT. Vous devez donc importer ce paquetage en haut de votre programme. En général, printf() est la première fonction d'affichage standard qu'on utilise. printf() affiche une chaîne de caractères : on passe donc une chaîne comme argument à printf().

hello.go

package main
import ("fmt")
 
func main() {
 
   fmt.Printf("Hello from Go!")
}

Une chaîne est délimitée par des guillemets. Dans l'exemple ci-dessus “Hello from Go!” est une chaîne de caractères, nous en parlerons davantage plus tard.

x := "Joe"
fmt.Printf("Hi " + x)

On peut également utiliser l'opérateur de concaténation + comme ci-dessus, qui concatène la chaîne “Hi ” et celle contenue par la variable x. Printf() affiche alors “Hi Joe”.

Maintenant, nous allons également utiliser des chaînes de formatage. Les chaînes de format sont des chaînes utilisées pour mettre en forme la sortie afin de lui donner l' aspect, la forme souhaitée. Les chaînes de format sont aussi des chaînes entre guillemets, mais à l'intérieur de la chaîne, certains caractères seront interprétés (on utilise ce que l'on appelle des caractères de conversion ou métacaractères). En Go, on utilise le caractère pourcentage % suivi de certains caractères.

x := "Joe"
fmt.Printf("Hi %s", x)

Dans la chaîne de format, le “%s” désigne une conversion de chaîne de caractère. Chaque occurrence %s sera remplacée par une variable de type chaîne de caractère. Si nous examinons les arguments de Printf(), le premier argument est la chaîne de format.

L'argument suivant est la variable x. Ce x contient la chaîne qui sera remplacée par %s. Donc, si x est le mot “Joe”, l'exécution cette instruction d'affichage produira “Hi Joe”, parce que le format %s sera remplacé par “Joe”. Ces chaînes de format sont couramment utilisées pour donner une apparence/mise en forme préçise des données lors de l'affichage.

Outre les commentaires et l'affichage, commençons à parler un peu des entiers et de la nature des entiers.

var x int

Voici la déclaration générique d'un type entier, comme nous l' avons déjà fait.

Il existe différentes variétés d'entiers. En général, cela ne nous intéresse pas, nous écrivons simplement var x int, et nous laissons au compilateur le soin de déterminer quel type d'entier, quelle longueur d'entier il doit utiliser.

Mais vous pouvez avoir des nombres entiers de différentes longueurs. Ainsi, par exemple, ici, vous avez int8, int16, int32 et int64. Ces nombres qui suffixe le type sont le nombre de bits utilisés pour représenter le nombre entier en mémoire. Donc, des entiers codés sur 8 bits, 16 bits, 32 bits, 64 bits.

Ensuite, si vous travaillez sur des entiers strictement positifs vous avez de la même manière les types uint8 unit16, uint32, unit64 (unsigned integers). Cet encodage des valeurs entières non signées permet de stocker des nombres plus grands. En effet le bit de poids fort est utilisé pour représenter le signe. Dans un entier non signé, le bit le plus significatif n'est pas utilisé pour le signe, il permet donc de coder aussi le nombre. Ainsi, la valeur absolue de l'entier non signé peut augmenter simplement parce que vous avez ce bit supplémentaire qui aurait été utilisé pour signer un entier relatif.

La différence entre ces types d' entiers réside dans la taille qu'ils doivent avoir pour satisfaire les besoins de notre application.

On peut voir qu'un entier codé sur 8 bits pourra prendre 256 valeurs de 0 à 255, car c'est le plus grand nombre que vous pouvez représenter avec 8 bits. Un entier non signé de 16 bits peut aller de 0à environ 65 000. C'est donc beaucoup plus grand. Ainsi, plus vous utilisez de bits, plus la représentation numérique peut être grande.

Dans la plupart des cas on déclare simplement un entier et on laisse le compilateur déterminer, mais si vous connaissez l'amplitude des nombres que vous souhaitez, vous pouvez contrôler cela en spécifiant la taille de l'entier que vous souhaitez utiliser.

Les entiers ont également un ensemble d'opérateurs. Des opérateurs unaires existent également mais on liste ici les opérateurs binaires :

• Opérateurs arithmétiques : + - * / % << >>
• Opérateur de comparaison : == != > < >= <=
• Opérateurs Booléens : && ||

Ils existent dans tous les langages, toutes les opérations arithmétiques, de décalage, le modulo. Les opérateurs de comparaison, il existe des opérateurs booléens et des opérateurs bit à bit, effectuant des opérations booléennes bit à bit. Ce sont des opérations classiques que l'on peut retrouver dans la plupart des langages.

◁ Précédent | ⌂ Retour au sommaire | Suivant ▷