La valeur logique est représentée par le type booléen. Comme indiqué ci-dessous, s'il est vrai, il prend une valeur de ** true **, et s'il est faux, il prend une valeur de ** false **. Vous pouvez également le définir par inférence de type.
var a bool //Définir la variable a comme type booléen
a = true //Attribuer true à la variable a
a := true
Les types entiers sont disponibles sous forme de types numériques, et il en existe deux types: ** type entier signé ** et ** type entier non signé **.
Les types d'entiers signés incluent int8, int16, int32 et int64, et les nombres représentent la taille.
Les types d'entiers non signés incluent uint8 (byte) `` `,` `ʻuint16, ʻuint32,` `ʻuint64 Représente. Contrairement à signé, uint8 peut également être défini avec un alias de type byte```, et il se comporte de la même manière que uint8.
De plus, dans Go avec une implémentation 64 bits, le type int se comporte de la même manière que le int64, mais comme indiqué ci-dessous, c'est une variable qui représente un entier 64 bits avec le même signe. Cependant, comme les types sont différents, la conversion de type implicite entraînera une erreur de compilation.
a := int(10)
b := int64(5)
b = a //Erreur de compilation
fmt.Printf("%v\n", b)
De cette façon, si vous essayez d'effectuer une conversion de type implicitement, vous obtiendrez une erreur de compilation. Cependant, si vous spécifiez le type fermement comme indiqué ci-dessous et effectuez une conversion de type explicitement, vous pouvez l'exécuter sans provoquer d'erreur de compilation.
a := int(10)
b := int64(a)
fmt.Printf("%v\n", b)
Cette méthode vous permet de traiter les nombres qui dépassent la taille de texte maximale.
a := int8(128) //Erreur de compilation
fmt.Printf("%v\n", a)
a := 128
b := int8(a)
fmt.Printf("%v\n", b)
Il est désormais possible de traiter à 128, ce qui dépasse la valeur maximale de ** int8, 127 **. En faisant cela explicitement, un ** débordement ** se produit dans la représentation binaire lorsque 1 est ajouté à la valeur maximale 127, ** wraparound ** et la valeur est la valeur minimale. Parce qu'il reviendra. Donc, dans ce cas, la valeur de sortie sera -128 **, qui est la valeur minimale de ** int8.
En guise de contre-mesure pour le up-around, en important et en utilisant le ** package math **, vous pouvez écrire du code tout en étant conscient du débordement de chiffres.
Il existe deux types de types à virgule flottante: `float32: virgule flottante simple précision et `float64: virgule flottante double précision `. Au fait, float32 est moins précis que float64, et si vous ne considérez pas l'aspect de l'efficacité d'utilisation de la mémoire, il semble qu'il n'y ait guère d'intérêt à l'utiliser à moins qu'il n'y ait une raison particulière.
a := 1.0 //float64
b := float32(1.0) //float32
Les types à virgule flottante ont également des constantes qui représentent une plage de nombres dans le package mathématique, et vous devez effectuer une conversion de type explicite si vous souhaitez utiliser des littéraux à virgule flottante pour prendre différents types de valeurs. Cependant, la partie décimale est tronquée.
Vient ensuite la valeur spéciale qui rend impossible le calcul. Les résultats de sortie des opérations suivantes ont les significations de + Int (** infini positif ), -Int ( infini négatif ) et NaN ( non-nombre **), respectivement.
1.0 / 0.0 //+Int
-1.0 / 0.0 //-Int
0.0 / 0.0 //NaN
A est la partie réelle, b est la partie imaginaire et i est l'unité imaginaire, qui est représentée par le littéral ** a + bi **. Est préparé. Float32 '' est utilisé pour la partie réelle et la partie imaginaire de type complex64, respectivement, et float64``` est utilisé pour la partie réelle et la partie imaginaire de type complex128.
Voici une méthode d'affectation utilisant des littéraux complexes. Au fait, le signe + n'est qu'une partie du littéral, pas un opérateur. Vous pouvez également utiliser la fonction complexe pour renvoyer et générer chaque valeur en prenant les arguments de la partie réelle et de la partie imaginaire.
a := 1.0 + 2i
a := complex(1.0, 2)
Il existe également une fonction pour récupérer les valeurs réelles et imaginaires de ce littéral.
a := 1.0 + 2i
real(a) //1.0
imag(a) //2
Il s'agit d'un type qui représente un caractère et le caractère entre guillemets simples est représenté par des points de code Unicode et une sortie. Vous pouvez également représenter des caractères Unicode en ajoutant un préfixe commençant par une barre oblique inverse. Il existe également une séquence d'échappement pour les représentations sous forme de chaîne. Il est défini comme un autre nom int32 et fonctionne de la même manière.
a := 'Exemple'
fmt.Printf("%v", a) //20363
a := '\U00101234'
fmt.Printf("%v", a) //1053236
Il est défini comme un type de chaîne et fournit un littéral de chaîne entre guillemets.
a := "exemple"
fmt.Printf("%v", a) //exemple
a := "\u65e 5 pièces\U00008a9e"
fmt.Printf("%v", a) //Japonais
Il existe un autre format pour les littéraux de chaîne, ** littéraux de chaîne RAW **. Il a la propriété d'utiliser des guillemets pour prendre en charge les chaînes multilignes et de ne pas traiter ces caractères.
a := '
exemple
exemple
exemple
'
fmt.Printf("%v", a) //exemple
exemple
exemple
Cette fois, nous avons résumé les types de base de Go! Je pense que vous pourriez comprendre non seulement la surface du type de base lui-même, mais aussi le sens et le mécanisme dans une certaine mesure.
Je vais continuer à sortir à ce rythme!
Recommended Posts