Nous avons donc parlé précédemment des entiers. Abordons à présent un peu les conversions de type. Dans certains cas, vous devez convertir un nombre ou une valeur d'un type à un autre.

Pour cela, vous utilisez la conversion de type. Or, ces conversions ne sont pas toujours possibles. Vous ne pouvez pas nécessairement effectuer ces conversions, mais lorsqu'elles existent, quand vous pouvez les effectuer, voyons comment les effectuer.

Supposons, par exemple, que vous ayez des nombres entiers de différentes longueurs.

var x int32 = 1
var y int16 = 2
 
x = y  //Cette instruction provoquera une erreur

Ci dessus on a la variable x déclarée comme entier de 32 bits, et la variable y comme entier de 16 bits. Je veux écrire x = y pour affecter l'une à l'autre (ligne 4) ou je veux faire quelques opérations en les utilisant ensemble.

Codé tel quel, cela échouerait car ces deux entiers sont en fait deux types d'entiers différents. Ainsi, le compilateur les considère comme deux types différents. int32 est un type différent de int16. Cela génère donc une erreur lorsque vous essayez d'affecter ou d'opérer l'un avec l'autre, car lorsque vous affectez, les deux éléments (côté gauche et du côté droit) doivent être du même type. Le compilateur le voit. Même s'ils sont tous deux des entiers, le fait qu'ils soient de longueur différente signifie qu'ils sont de types différents, ce qui génère une erreur.

Pour pouvoir les utiliser ensemble, vous devez convertir l'un en l'autre. Ainsi, par exemple, vous pourriez dire :

je prend ''y'', de type ''int16'', et je le converti en ''int32'',
puis ensuite le lui attribue ''x''.

Dans ce cas, cela fonctionnerait. Donc, pour effectuer de telles conversions de type, vous utilisez cette l'opération T(), où T est le nom du type. Donc, si je veux convertir y de type int16 en int32, j'utilise simplement la fonction intégrée int32() : cette fonction prendra un argument quelconque et essaiera de le convertir en int32.

x = int32(y)

C'est ce qu'on a écrit ci-dessus : on prend y qui est de type int16, et on le converti en int32. C'est une conversion possible : le compilateur sait étendre l'entier y sur 32 bits.

Notez qu'il existe d'autres types de conversions que vous ne pouvez pas faire aussi facilement et que ce processus peut échouer.

Un autre type, outre les entiers, sont les float(nombres à virgule flottante). Ils permettent de représenter des nombres réels. Selon le nombre de bits de la virgule flottante, disons que vous utilisiez un float32, cela vous donnera une précision d'environ six chiffres décimaux. Un float64 va vous donner une précision d'environ 15 décimaux. Ainsi, vous déterminez le nombre de bits que vous souhaitez utiliser, leur taille en fonction de la précision dont vous avez besoin dans votre application.

Notons qu'il est préférable d' opter pour des représentations longues plutôt que d'essayer de les raccourcir, car les erreurs de précision constituent un problème courant en arithmétique à virgule flottante.

Il est donc préférable d'utiliser une plus grande précision. Plus il y a de précision, mieux c'est. Bien sûr, ce pose le problème de l'espace mémoire. Vous consommez plus de mémoire si vous les allongez et vous impactez aussi les performances. Néanmoins, les erreurs de précision sont parfois un problème.

vous pouvez exprimer des nombres à virgule flottante avec des décimales ou en notation scientifique.

var x float64 = 123.45
var y float64 = 1.2345e2

La première notation ci-dessus est décimale. Cela en fera une représentation à virgule flottante. On représente la même valeur avec une notation scientifique avec ce e suivi de l' exposant de 10 : e2 signifie . On a bien 1.2345e2 =

Vous pouvez également représenter des nombres complexes qui se composent d'une partie réelle et d'une partie imaginaire.

var z complex128 = complex(2, 3)

C'est ainsi que vous créez un nombre complexe. Vous utilisez la fonction complex() avec deux arguments : le premier est la valeur réelle, le second est l'imaginaire.

Avant de parler de chaînes de caractères, nous devons parler des codes ASCII et Unicode. Les chaînes seront donc des séquences d'octets. Nous le verrons ensuite, mais chaque élément, chaque octet, représente un caractère, un symbole. Donc, souvent, les chaînes sont faites pour l'affichage. Les caractères ne sont pas nécessairement destinés à l'affichage, mais ils sont souvent conçus pour représenter des symboles à afficher. Ainsi, par exemple, la chaîne “hello world” est destinée à être affichée et vue par un utilisateur.

Chaque caractère doit être encodé selon un code standardisé. L' ASCII a été le premier code communément accepté, ASCII est l'acronyme de American Standard Code for Information Interchange et il ne s'agit que d'un encodage pour les caractères. Ainsi, chaque caractère que vous souhaitez représenter est encodé par une valeur sur 8 bits.

Par exemple, un A majuscule en ASCII est encodé par le nombre 0x41 en hexadécimal. Je le sais, c'est tout, c'est une valeur arbitraire standardisée. L' ASCII est donc un code long de 8 bits, ce qui signifie qu'il peut représenter au maximum 256 caractères, moins en pratique, 128 parce que l'un des bits est utilisé pour autre chose.

Au final, cela ne permet pas de représenter beaucoup de caractères. Un code à 8 bits est suffisant pour l'anglais car il n'y a pas beaucoup de lettres dans cet alphabet. Mais si vous souhaitez inclure d'autres langues, d'autres caractères comme le chinois ( c'est un bon exemple car il y a beaucoup de caractères en chinois), un code à 8 bits ne suffit pas.

Si vous souhaitez prendre en compte ces caractères de différentes langues et divers symboles qui ne font peut-être même pas partie des langues mais que vous voulez représenter et afficher, il vous faut bien plus que 8 bits.

C' est donc à cela que sert Unicode. Unicode est un encodage de caractère long de 32 bits. Vous pouvez représenter symboles différents, ce qui est beaucoup plus grand.

L'UTF-8 est, disons, un sous-ensemble d'Unicode. Il s'agit d'un code de longueur variable. Il peut utiliser 8 bits, mais il peut aller jusqu'à 32 bits. Le premier ensemble de codes en UTF-8 correspond à l'ASCII. Ainsi, toutes les valeurs du code ASCII sont identiques à en UTF-8. Par exemple, le A majuscule qui vaut 0x41 en ASCII vaut aussi 0x41 en UTF-8.

L'UTF-8 inclut également de nombreux autres symboles comme, par exemple, les caractères chinois. Ils ne sont pas dans les 128 premiers codes, ils sont en dehors de cela. Ils ont besoin de plus d'octets. Vous ne pouvez pas simplement utiliser un code 8 bits pour représenter ceux-ci, il faudra peut-être des codes sur 16 bits ou 32 bits. L' UTF-8 est donc un code de longueur variable et il représente beaucoup plus de caractères que ce que vous pouvez représenter en ASCII.

Go utilise par défaut UTF-8. En UTF-8 et en Unicode, les code points désigne le code d'encodage d'un caractère. Ainsi, il peut y avoir code points. En Go, les codes points sont désignés “runes”.

Ainsi, une rune n'est qu'un terme désignant une valeur d'encodage, un “code point”. Donc, le caractère A possède une rune, dont la valeur est 0x41. C'est ce qu'on appelle “rune”.

Passons maintenant aux chaînes de caractères. Les chaînes de caractères sont des séquences arbitraires de caractères encodés en UTF-8, des séquences de runes.

Les chaînes sont en lecture seule. Vous ne pouvez pas modifier une chaîne. Vous pouvez créer une nouvelle chaîne qui est une version modifiée d'une chaîne existante, mais vous ne pouvez pas modifier une chaîne existante.

Souvent destinée à être imprimée ou affichée à un utilisateur, une chaîne littérale est simplement une chaîne notée entre guillemets.

x := "Hi there" //chaîne littérale

C'est une séquence d'octets. Chacun de ces caractères, H, i, l'espace, t, h, e, r, e, chacun d'entre eux sera représenté sous la forme d'une rune, d' un point de code UTF-8, et ils seront assemblés dans un tableau (nous aborderons bientôt les tableaux).

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