Entiers
Les entiers peuvent être largement divisés en deux catégories : les entiers non signés et les entiers signés. Les entiers signés sont les plus largement utilisés.
Non signé signifie qu'il ne peut représenter que des nombres non négatifs (0 et les nombres positifs), tandis que les nombres signés peuvent représenter à la fois des nombres négatifs et non négatifs.
Les entiers non signés peuvent être divisés en quatre tailles : 8 bits, 16 bits, 32 bits et 64 bits, représentés respectivement par uint8, uint16, uint32 et uint64. Les entiers signés correspondants sont int8, int16, int32 et int64. Le tableau suivant montre les différentes plages représentées par chaque type :
| Type |
Description |
Plage |
| uint8 |
Entier non signé sur 8 bits |
De 0 à 255 |
| int8 |
Entier signé sur 8 bits |
De -128 à 127 |
| uint16 |
Entier non signé sur 16 bits |
De 0 à 65535 |
| int16 |
Entier signé sur 16 bits |
De -32768 à 32767 |
| uint32 |
Entier non signé sur 32 bits |
De 0 à 4294967295 |
| int32 |
Entier signé sur 32 bits |
De -2147483648 à 2147483647 |
| uint64 |
Entier non signé sur 64 bits |
De 0 à 18446744073709551615 |
| int64 |
Entier signé sur 64 bits |
De -9223372036854775808 à 9223372036854775807 |
Prenons uint8 et int8 comme exemples. Ce sont tous deux des entiers sur 8 bits et peuvent représenter 256 valeurs. Dans le type d'entier non signé uint8, la plage qu'il peut représenter est de 0 à 255, tandis que dans le type d'entier signé int8, la plage qu'il peut représenter est de -128 à 127.
En plus des 8 types ci-dessus, il existe trois autres types d'entiers spéciaux, uint, int et uintptr, où uint et int peuvent représenter différentes plages sur différentes plateformes, et uintptr peut être utilisé pour stocker des pointeurs.
| Type |
Plage |
uint |
uint32 sur les systèmes 32 bits, uint64 sur les systèmes 64 bits |
int |
int32 sur les systèmes 32 bits, int64 sur les systèmes 64 bits |
uintptr |
Type d'entier non signé utilisé pour stocker des pointeurs |
Maintenant, créons un fichier nommé integer.go pour démontrer l'utilisation des entiers :
cd ~/project
touch integer.go
package main
import (
"fmt"
"unsafe"
)
func main() {
// View the type of int in the current environment
// Declare a as the type int
var a int
// Use unsafe.Sizeof() to output the memory size occupied by the type
fmt.Printf("The type int in the current environment is %d bits\n", unsafe.Sizeof(a)*8)
var b int8 = 125
// Use the %d placeholder in fmt.Printf to output the value of the integer
// Use the %T placeholder in fmt.Printf to output the type of the variable
fmt.Printf("The value of b is %d, and the type is %T\n", b, b)
// Integer operations
// Declare integers c and d, and calculate their sum
c, d := 2, 3
fmt.Printf("c + d = %d\n", c+d)
// 10 - 5
fmt.Printf("10 - 5 = %d\n", 10-5)
// 8 * 10
fmt.Printf("8 * 10 = %d\n", 8*10)
}
Après avoir exécuté le programme, nous obtenons la sortie suivante :
go run integer.go
The type int in the current environment is 64 bits
The value of b is 125, and the type is int8
c + d = 5
10 - 5 = 5
8 * 10 = 80
Explication de la sortie :
The type int in the current environment is 64 bits : Cette ligne montre que le type int sur le système où le code est exécuté est sur 64 bits (ou 8 octets), indiquant qu'il s'agit d'un int64. La fonction unsafe.Sizeof(a) retourne la taille de la variable a en octets, et en la multipliant par 8, on la convertit en bits. Cela signifie que le type int peut stocker des valeurs entières plus grandes.The value of b is 125, and the type is int8 : Ici, nous avons déclaré une variable b de type int8 et lui avons assigné la valeur 125. La sortie confirme cela en montrant à la fois la valeur et le type de données.c + d = 5, 10 - 5 = 5, 8 * 10 = 80 : Ces lignes montrent les opérations arithmétiques de base sur les entiers : addition, soustraction et multiplication. La sortie confirme les résultats corrects de ces calculs.
Dans ce fichier, la fonction unsafe.Sizeof() peut être utilisée pour obtenir le nombre d'octets occupés par le type de variable actuel. 1 octet (byte) est égal à 8 bits, donc unsafe.Sizeof()*8 peut obtenir le nombre de bits occupés par le type. À partir de la sortie, nous pouvons voir que l'environnement en ligne est sur 64 bits. Le type réel de int dans l'environnement en ligne est int64.
Nous pouvons utiliser la commande suivante dans le terminal pour déterminer l'architecture du système actuel :
dpkg --print-architecture
amd64
