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 tipo incorporado para enteros.
Descripción
Tipo de entero con signo de 64 bits. Esto significa que puede tomar valores desde -2^63 hasta 2^63 - 1, es decir, desde -9223372036854775808 hasta 9223372036854775807. Cuando excede estos límites, se ajustará (wrapping around).
Los int se pueden convertir automáticamente a floats cuando sea necesario, por ejemplo, al pasarlos como argumentos en funciones. El float será lo más cercano posible al entero original.
Del mismo modo, los float se pueden convertir automáticamente en ints. Esto truncará el float, descartando cualquier cosa después del punto decimal.
Nota: En un contexto booleano, un int se evaluará como false si es igual a 0, y como true en caso contrario.
var x: int = 1 # x es 1
x = 4.2 # x es 4, porque 4.2 se trunca
var max_int = 9223372036854775807 # El valor más grande que un int puede almacenar
max_int += 1 # max_int es -9223372036854775808, porque se ajustó
int x = 1; // x es 1
x = (int)4.2; // x es 4, porque 4.2 se trunca
// Usamos long a continuación, porque el int de GDScript es de 64 bits mientras que el int de C# es de 32 bits.
long maxLong = 9223372036854775807; // El valor más grande que un long puede almacenar
maxLong++; // maxLong es ahora -9223372036854775808, porque se ajustó.
// Alternativamente con el tipo int de 32 bits de C#, que tiene un valor máximo más pequeño.
int maxInt = 2147483647; // El valor más grande que un int puede almacenar
maxInt++; // maxInt es ahora -2147483648, porque se ajustó
Puedes usar el literal 0b para la representación binaria, el literal 0x para la representación hexadecimal, y el símbolo _ para separar números largos y mejorar la legibilidad.
var x = 0b1001 # x es 9
var y = 0xF5 # y es 245
var z = 10_000_000 # z es 10000000
int x = 0b1001; // x es 9
int y = 0xF5; // y es 245
int z = 10_000_000; // z es 10000000
Constructores
int() |
|
Operadores
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) |
|
Descripciones de Constructores
Construye un int con un valor de 0.
Construye un int como copia del int dado.
Construye un nuevo int a partir de un String, siguiendo las mismas reglas que String.to_int().
Construye un nuevo int a partir de un bool. true se convierte en 1 y false se convierte en 0.
Construye un nuevo int a partir de un float. Esto truncará el float, descartando cualquier cosa después del punto flotante.
Descripciones de Operadores
bool operator !=(right: float) 🔗
Devuelve true si el int no es equivalente al float.
bool operator !=(right: int) 🔗
Devuelve true si los ints no son iguales.
Devuelve el resto de la división de dos ints. Usa división truncada, la cual devuelve un número negativo si el dividendo es negativo. Si esto no es lo deseado, considera usar @GlobalScope.posmod().
print(6 % 2) # Imprime 0
print(11 % 4) # Imprime 3
print(-5 % 3) # Imprime -2
Realiza la operación AND a nivel de bits.
print(0b1100 & 0b1010) # Imprime 8 (binario 1000)
Esto es útil para recuperar banderas binarias de una variable.
var flags = 0b101
# Comprueba si el primer o segundo bit están activados.
if flags & 0b011:
do_stuff() # Esta línea se ejecutará.
Color operator *(right: Color) 🔗
Multiplica cada componente del Color por el int.
Quaternion operator *(right: Quaternion) 🔗
Multiplica cada componente del Quaternion por el int. Esta operación no es significativa por sí misma, pero puede ser usada como parte de una expresión mayor.
Vector2 operator *(right: Vector2) 🔗
Multiplica cada componente del Vector2 por el int.
print(2 * Vector2(1, 4)) # Imprime (2, 8)
Vector2i operator *(right: Vector2i) 🔗
Multiplica cada componente del Vector2i por el int.
Vector3 operator *(right: Vector3) 🔗
Multiplica cada componente del Vector3 por el int.
Vector3i operator *(right: Vector3i) 🔗
Multiplica cada componente del Vector3i por el int.
Vector4 operator *(right: Vector4) 🔗
Multiplica cada componente del Vector4 por el int.
Vector4i operator *(right: Vector4i) 🔗
Multiplica cada componente del Vector4i por el int.
float operator *(right: float) 🔗
Multiplica el float por el int. El resultado es un float.
Multiplica los dos int.
float operator **(right: float) 🔗
Eleva un int a una potencia de float. El resultado es un float.
print(2 ** 0.5) # Imprime 1.4142135623731
Eleva el int izquierdo a una potencia del int derecho.
print(3 ** 4) # Imprime 81
float operator +(right: float) 🔗
Suma el int y el float. El resultado es un float.
Suma los dos int.
float operator -(right: float) 🔗
Resta el float del int. El resultado es un float.
Resta los dos int.
float operator /(right: float) 🔗
Divide el int entre el float. El resultado es un float.
print(10 / 3.0) # Imprime 3.33333333333333
Divide los dos ints. El resultado es un int. Esto truncará el resultado, descartando cualquier cosa después del punto flotante.
print(6 / 2) # Imprime 3
print(5 / 3) # Imprime 1
bool operator <(right: float) 🔗
Devuelve true si el int es menor que el float.
Devuelve true si el int de la izquierda es menor que el int de la derecha.
Realiza la operación de desplazamiento a la izquierda a nivel de bits. Efectivamente es lo mismo que multiplicar por una potencia de 2.
print(0b1010 << 1) # Imprime 20 (binario 10100)
print(0b1010 << 3) # Imprime 80 (binario 1010000)
bool operator <=(right: float) 🔗
Devuelve true si el int es menor o igual que el float.
bool operator <=(right: int) 🔗
Devuelve true si el int de la izquierda es menor o igual que el int de la derecha.
bool operator ==(right: float) 🔗
Devuelve true si el int es igual al float.
bool operator ==(right: int) 🔗
Devuelve true si los dos ints son iguales.
bool operator >(right: float) 🔗
Devuelve true si el int es mayor que el float.
Devuelve true si el int de la izquierda es mayor que el int de la derecha.
bool operator >=(right: float) 🔗
Devuelve true si el int es mayor o igual que el float.
bool operator >=(right: int) 🔗
Devuelve true si el int de la izquierda es mayor o igual que el int de la derecha.
Realiza la operación de desplazamiento a la derecha a nivel de bits. Efectivamente es lo mismo que dividir por una potencia de 2.
print(0b1010 >> 1) # Imprime 5 (binario 101)
print(0b1010 >> 2) # Imprime 2 (binario 10)
Realiza la operación bit a bit XOR.
print(0b1100 ^ 0b1010) # Imprime 6 (binario 110)
Devuelve el mismo valor como si el + no estuviera ahí. El + unario no hace nada, pero a veces puede hacer que tu código sea más legible.
Devuelve el valor negado del int. Si es positivo, lo vuelve negativo. Si es negativo, lo vuelve positivo. Si es cero, no hace nada.
Realiza la operación OR bit a bit.
print(0b1100 | 0b1010) # Imprime 14 (binario 1110)
Esto es útil para almacenar indicadores binarios en una variable.
var flags = 0
flags |= 0b101 # Activa el primer y tercer bit.
Realiza la operación NOT bit a bit sobre el int. Debido al complemento a 2, es efectivamente igual a -(int + 1).
print(~4) # Imprime -5
print(~(-7)) # Imprime 6