Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
int
Un type intégré pour les entiers.
Description
Type d'entier 64 bits signé. Cela signifie qu'il peut prendre des valeurs de -2^63 à 2^63 - 1, c'est-à-dire de -9223372036854775808 à 9223372036854775807. Quand il dépassera ces limites, il rebouclera.
Les ints peut être automatiquement converti en floats lorsque cela est nécessaire, par exemple lors du passage comme arguments dans des fonctions. Le float sera le plus proche possible de l'entier original.
De même, les floats peuvent être automatiquement convertis en ints. Cela tronquera le float, défaussant n'importe quoi après la virgule flottante.
Note : Dans un contexte booléen, un int évaluera à false s'il est égal à 0, et à true autrement.
var x: int = 1 # x vaut 1
x = 4.2 # x vaut 4, car 4.2 est tronqué
var entier_max = 9223372036854775807 # La plus grande valeur qu'un int peut stocker
entier_max += 1 # entier_max vaut maintenant -9223372036854775808 (la plus petite valeur), car il a rebouclé
int x = 1; // x vaut 1
x = (int)4.2; // x vaut 4, car 4.2 est tronqué
// Nous utilisons le type long ci-dessous, car le int de GDScript est sur 64 bits, alors que celui de C# est sur 32
long longMax = 9223372036854775807; // La plus grande valeur qu'un long peut stocker
longMax++; // longMax vaut maintenant -9223372036854775808 (la plus petite valeur), car il a rebouclé
// Sinon avec le type int de C# sur 32 bits, qui a une plus petite valeur maximale.
int intMax= 2147483647; // La plus grande valeur qu'un int peut stocker
intMax++; // longMax vaut maintenant -2147483648 (la plus petite valeur), car il a rebouclé
Vous pouvez utiliser le littéral 0b pour la représentation binaire, le littéral 0x pour la représentation hexadécimale et le symbole _ pour séparer les nombres longs et améliorer la lisibilité.
var x = 0b1001 # x vaut 9
var y = 0xF5 # y vaut 245
var z = 10_000_000 # z vaut 10000000
int x = 0b1001; // x vaut 9
int y = 0xF5; // y vaut 245
int z = 10_000_000; // z vaut 10000000
Constructeurs
int() |
|
Opérateurs
operator !=(right: float) |
|
operator !=(right: int) |
|
operator %(right: int) |
|
operator &(right: int) |
|
operator *(right: Color) |
|
operator *(right: Quaternion) |
|
operator *(right: Vector2) |
|
operator *(right: Vector2i) |
|
operator *(right: Vector3) |
|
operator *(right: Vector3i) |
|
operator *(right: Vector4) |
|
operator *(right: Vector4i) |
|
operator *(right: float) |
|
operator *(right: int) |
|
operator **(right: float) |
|
operator **(right: int) |
|
operator +(right: float) |
|
operator +(right: int) |
|
operator -(right: float) |
|
operator -(right: int) |
|
operator /(right: float) |
|
operator /(right: int) |
|
operator <(right: float) |
|
operator <(right: int) |
|
operator <<(right: int) |
|
operator <=(right: float) |
|
operator <=(right: int) |
|
operator ==(right: float) |
|
operator ==(right: int) |
|
operator >(right: float) |
|
operator >(right: int) |
|
operator >=(right: float) |
|
operator >=(right: int) |
|
operator >>(right: int) |
|
operator ^(right: int) |
|
operator |(right: int) |
|
Descriptions des constructeurs
Construit un entier int défini à 0.
Construit un entier int comme copie de l'entier int donné.
Construit un nouveau int à partir d'un String, en suivant les mêmes règles que String.to_int().
Construit un nouvel entier int depuis un bool. true est converti en 1et false est converti en 0.
Construit un nouveau int à partir d'un String. Cela tronquera le float, défaussant tout ce qui se trouve après la virgule flottante.
Descriptions des opérateurs
bool operator !=(right: float) 🔗
Renvoie true si le int n'est pas équivalent au float.
bool operator !=(right: int) 🔗
Renvoie true si les entiers int ne sont pas égaux.
Renvoie le reste après avoir divisé deux int. Utilise la division tronquée, qui renvoie un nombre négatif si le dividende est négatif. Si cela n'est pas souhaité, envisagez d'utiliser @GlobalScope.posmod().
print(6 % 2) # Affiche 0
print(11 % 4) # Affiche 3
print(-5 % 3) # Affiche -2
Effectue l'opération par bit AND.
print(0b1100 & 0b1010) # Affiche 8 (1000 en binaire)
Ceci est utile pour récupérer les drapeaux binaires d'une variable.
var drapeaux = 0b101
# Vérifier si le premier ou le second bit est actif.
if drapeaux & 0b011:
do_stuff() # Cette ligne va s'exécuter
Color operator *(right: Color) 🔗
Multiplie chaque composante de la couleur Color par l'entier int donné.
Quaternion operator *(right: Quaternion) 🔗
Multiplie chaque composante du Quaternion par l'entier int donné. Cette opération ne veut rien dire seule, mais peut-être utilisée comme partie d'une plus grande expression.
Vector2 operator *(right: Vector2) 🔗
Multiplie chaque composante du Vector2 par l'entier int donné.
print(2 * Vector2(1, 4)) # Affiche (2, 8)
Vector2i operator *(right: Vector2i) 🔗
Multiplie chaque composante du Vector2i par l'entier int donné.
Vector3 operator *(right: Vector3) 🔗
Multiplie chaque composante du Vector3 par l'entier int donné.
Vector3i operator *(right: Vector3i) 🔗
Multiplie chaque composante du Vector3i par l'entier int donné.
Vector4 operator *(right: Vector4) 🔗
Multiplie chaque composante du Vector4 par l'entier int.
Vector4i operator *(right: Vector4i) 🔗
Multiplie chaque composante du Vector4i par l'entier int.
float operator *(right: float) 🔗
Multiplie un float par l'int. Le résultat est un float.
Multiplie les deux ints.
float operator **(right: float) 🔗
Élève un int à la puissance d'un float. Le résultat est un float.
print(2 ** 0.5) # Affiche 1.4142135623731
Élève un int de gauche à la puissance du float de droite.
print(3 ** 4) # Affiche 81
float operator +(right: float) 🔗
Ajoute le int et le float. Le résultat est un float.
Additionne les deux ints.
float operator -(right: float) 🔗
Soustrait le float du int. Le résultat est un float.
Soustrait les deux ints.
float operator /(right: float) 🔗
Divise le int par le float. Le résultat est un float.
print(10 / 3.0) # Affiche 3.333333333333333333
Divise les deux ints. Le résultat est un int. Cela va tronquer le float, défaussant tout après la virgule flottante.
print(6 / 2) # Affiche 3
print(5 / 3) # Affiche 1
bool operator <(right: float) 🔗
Renvoie true si l'entier int est inférieur au float.
Renvoie true si le int de gauche est inférieur au int de droite.
Effectue l'opération de décalage sur la gauche par bit. Effectivement la même chose que la multiplication par une puissance de 2.
print(0b1010 << 1) # Affiche 20 (10100 en binaire)
print(0b1010 << 3) # Affiche 80 (1010000 en binaire)
bool operator <=(right: float) 🔗
Renvoie true si l'entier int est inférieur ou égal au float.
bool operator <=(right: int) 🔗
Renvoie true si le int de gauche est inférieur ou égal au int de droite.
bool operator ==(right: float) 🔗
Renvoie true si le int est égal au float.
bool operator ==(right: int) 🔗
Renvoie true si les entiers int sont égaux.
bool operator >(right: float) 🔗
Renvoie true si le int est supérieur au float.
Renvoie true si le int de gauche est supérieur au int de droite.
bool operator >=(right: float) 🔗
Renvoie true si le int est supérieur ou égal au float.
bool operator >=(right: int) 🔗
Renvoie true si le int de gauche est supérieur ou égal au int de droite.
Effectue l'opération de décalage à droite par bits. Effectivement la même chose que la division par une puissance de 2.
print(0b1010 >> 1) # Affiche 5 (101 en binaire)
print(0b1010 >> 2) # Affiche 2 (10 en binaire)
Effectue l'opération XOR par bit.
print(0b1100 ^ 0b1010) # Affiche 6 (0110 en binaire)
Renvoie la même valeur comme si + n'était pas là. Le + unaire ne fait rien, mais peut parfois rendre votre code plus lisible.
Renvoie la valeur négative du int. Si positif, rend le nombre négatif. Si négatif, rend le nombre positif. Si zéro, ne fait rien.
Effectue l'opération OR par bit.
print(0b1100 | 0b1010) # Affiche 14 (1110 en binaire)
Ceci est utile pour stocker des drapeaux binaires dans une variable.
var drapeaux = 0
drapeaux |= 0b101 # Allume le premier et le troisième bit
Effectue l'opération NOT par bits sur l'int. En raison du complément à 2, c'est effectivement égal à -(int + 1).
print(~4) # Affiche -5
print(~(-7)) # Affiche 6