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

Встроенный тип для целых чисел.

Описание

Знаковый 64-битный целочисленный тип. Это означает, что он может принимать значения от -2^63 до 2^63 - 1, т.е. от -9223372036854775808 до 9223372036854775807. При выходе за эти границы произойдет циклический возврат.

int-ы могут быть автоматически преобразованы в float-ы при необходимости, например, при передаче их в качестве аргументов в функциях. float будет максимально близок к исходному целому числу.

Аналогично, float-ы можно автоматически преобразовать в int-ы. Это усечет float, отбросив все после плавающей точки.

Примечание: В булевом контексте int будет оцениваться как false, если он равен 0, и как true в противном случае.

var x: int = 1 # х равен 1
x = 4.2 # x равен 4, потому что 4.2 усекается
var max_int = 9223372036854775807 # Наибольшее значение, которое может хранить int
max_int += 1 # max_int равен -9223372036854775808, потому что он обернулся вокруг

Вы можете использовать литерал 0b для двоичного представления, литерал 0x для шестнадцатеричного представления и символ _ для разделения длинных чисел и улучшения читаемости.

var x = 0b1001 # x равен 9
var y = 0xF5 # y равен 245
var z = 10_000_000 # z равен 10000000

Конструкторы

int

int()

int

int(from: int)

int

int(from: String)

int

int(from: bool)

int

int(from: float)

Операторы

bool

operator !=(right: float)

bool

operator !=(right: int)

int

operator %(right: int)

int

operator &(right: int)

Color

operator *(right: Color)

Quaternion

operator *(right: Quaternion)

Vector2

operator *(right: Vector2)

Vector2i

operator *(right: Vector2i)

Vector3

operator *(right: Vector3)

Vector3i

operator *(right: Vector3i)

Vector4

operator *(right: Vector4)

Vector4i

operator *(right: Vector4i)

float

operator *(right: float)

int

operator *(right: int)

float

operator **(right: float)

int

operator **(right: int)

float

operator +(right: float)

int

operator +(right: int)

float

operator -(right: float)

int

operator -(right: int)

float

operator /(right: float)

int

operator /(right: int)

bool

operator <(right: float)

bool

operator <(right: int)

int

operator <<(right: int)

bool

operator <=(right: float)

bool

operator <=(right: int)

bool

operator ==(right: float)

bool

operator ==(right: int)

bool

operator >(right: float)

bool

operator >(right: int)

bool

operator >=(right: float)

bool

operator >=(right: int)

int

operator >>(right: int)

int

operator ^(right: int)

int

operator unary+()

int

operator unary-()

int

operator |(right: int)

int

operator ~()

Описания конструктора

int int() 🔗

Создает int, установленный на 0.

int int(from: int)

Создает int как копию заданного int.

int int(from: String)

Создает новый int из String по тем же правилам, что и String.to_int().

int int(from: bool)

Создает новый int из bool. true преобразуется в 1, а false преобразуется в 0.

int int(from: float)

Конструирует новый int из float. Это обрежет float, отбросив все, что находится после плавающей точки.

Описания оператора

bool operator !=(right: float) 🔗

Возвращает true, если int не эквивалентно float.

bool operator !=(right: int) 🔗

Возвращает true, если int-ы не равны.

int operator %(right: int) 🔗

Возвращает остаток после деления двух int. Использует усеченное деление, которое возвращает отрицательное число, если делимое отрицательно. Если это нежелательно, рассмотрите возможность использования @GlobalScope.posmod().

print(6 % 2) # Prints 0
print(11 % 4) # Prints 3
print(-5 % 3) # Prints -2

int operator &(right: int) 🔗

Выполняет побитовую операцию AND.

print(0b1100 & 0b1010) # Печатает 8 (двоичное 1000)

Это полезно для извлечения двоичных флагов из переменной.

var flags = 0b101
# Проверьте, включен ли первый или второй бит.
if flags & 0b011:
    do_stuff() # Эта линия будет работать.

Color operator *(right: Color) 🔗

Умножает каждый компонент Color на int.

Quaternion operator *(right: Quaternion) 🔗

Умножает каждый компонент Quaternion на int. Эта операция сама по себе не имеет смысла, но ее можно использовать как часть большего выражения.

Vector2 operator *(right: Vector2) 🔗

Умножает каждый компонент Vector2 на int.

print(2 * Vector2(1, 4)) # Выводит (2, 8)

Vector2i operator *(right: Vector2i) 🔗

Умножает каждый компонент Vector2i на int.

Vector3 operator *(right: Vector3) 🔗

Умножает каждый компонент Vector3 на int.

Vector3i operator *(right: Vector3i) 🔗

Умножает каждый компонент Vector3i на int.

Vector4 operator *(right: Vector4) 🔗

Умножает каждый компонент Vector4 на int.

Vector4i operator *(right: Vector4i) 🔗

Умножает каждый компонент Vector4i на int.

float operator *(right: float) 🔗

Умножает float на int. Результат — float.

int operator *(right: int) 🔗

Умножает два int-а.

float operator **(right: float) 🔗

Возводит int в степень float. Результат — float.

print(2 ** 0.5) # Выводит 1.4142135623731

int operator **(right: int) 🔗

Возводит левое int в степень правого int.

print(3 ** 4) # Выводит 81

float operator +(right: float) 🔗

Складывает int и float. Результат — float.

int operator +(right: int) 🔗

Складывает два int-а.

float operator -(right: float) 🔗

Вычитает float из int. Результат — float.

int operator -(right: int) 🔗

Вычитает два int-а.

float operator /(right: float) 🔗

Делит int на float. Результат — float.

print(10 / 3.0) # Выводит 3.33333333333333

int operator /(right: int) 🔗

Делит два int-а. Результат — int. Это обрежет float, отбросив все после плавающей точки.

print(6 / 2) # Prints 3
print(5 / 3) # Prints 1

bool operator <(right: float) 🔗

Возвращает true, если int меньше, чем float.

bool operator <(right: int) 🔗

Возвращает true, если левое int меньше правого int.

int operator <<(right: int) 🔗

Выполняет операцию побитового сдвига влево. По сути то же самое, что и умножение на степень 2.

print(0b1010 << 1) # Печатает 20 (двоичное 10100)
print(0b1010 << 3) # Печатает 80 (двоичное 1010000)

bool operator <=(right: float) 🔗

Возвращает true, если int меньше или равно float.

bool operator <=(right: int) 🔗

Возвращает true, если левое int меньше или равно правому int.

bool operator ==(right: float) 🔗

Возвращает true, если int равно float.

bool operator ==(right: int) 🔗

Возвращает true, если два int-а равны.

bool operator >(right: float) 🔗

Возвращает true, если int больше, чем float.

bool operator >(right: int) 🔗

Возвращает true, если левое int больше правого int.

bool operator >=(right: float) 🔗

Возвращает true, если int больше или равно float.

bool operator >=(right: int) 🔗

Возвращает true, если левое int больше или равно правому int.

int operator >>(right: int) 🔗

Выполняет операцию побитового сдвига вправо. По сути то же самое, что деление на степень числа 2.

print(0b1010 >> 1) # Печатает 5 (двоичное 101)
print(0b1010 >> 2) # Печатает 2 (двоичное 10)

int operator ^(right: int) 🔗

Выполняет побитовую операцию XOR.

print(0b1100 ^ 0b1010) # Печатает 6 (двоичное 110)

int operator unary+() 🔗

Возвращает то же значение, как если бы + не было. Унарный + ничего не делает, но иногда он может сделать ваш код более читаемым.

int operator unary-() 🔗

Возвращает отрицательное значение int. Если положительное, делает число отрицательным. Если отрицательное, делает число положительным. Если ноль, ничего не делает.

int operator |(right: int) 🔗

Выполняет побитовую операцию OR .

print(0b1100 | 0b1010) # Печатает 14 (двоичное 1110)

Это полезно для хранения двоичных флагов в переменной.

var flags = 0
flags |= 0b101 # Включите первый и третий биты.

int operator ~() 🔗

Выполняет побитовую операцию NOT над int. Благодаря 2's complement она фактически равна -(int + 1).

print(~4) # Prints -5
print(~(-7)) # Prints 6