Литералы и операторы

Литерал — это константные данные, напрямую прописанные в коде, значение которых видно сразу. Это самая базовая форма представления данных в программе.

Значение фиксировано и не меняется, жестко прописано в коде и не может измениться во время выполнения. Не требует вычислений или разбора переменных, дословно означает «значение, написанное как есть».

Пример: числа 13 и 3.14 ниже являются литералами, в других языках их также называют значениями литералов.

fn main() {
    println!("{}", 13);
    println!("{}", 3.14);
}Code language: JavaScript (javascript)

Для удобства изучения официальная команда предоставляет онлайн-редактор Rust. Не нужно устанавливать локальную среду для отработки базового синтаксиса Rust, нажмите ссылку ниже

Rust Playground

Литералы

Rust поддерживает литералы следующих типов: целое число, число с плавающей точкой, символ, строка, булево значение, юнит (unit).

• Целое число: 11
• Символ: 'a' (одинарные кавычки)
• Строка: "abc" (двойные кавычки)
• Булево значение: true / false
• Тип юнит: ()

Различные системы счисления для целых чисел

Системы счисления различаются по префиксу, работает только для целых чисел:

• Шестнадцатеричная: начинается с 0x, пример: 0x1F
• Восьмеричная: начинается с 0o, пример: 0o77
• Двоичная: начинается с 0b, пример: 0b1010

Разделитель чисел

В числовых литералах можно вставить подчеркивание _ для улучшения читаемости, оно не влияет на реальное значение числа:

• Целое число: 1_000 = 1000
• Число с плавающей точкой: 0.000_001 = 0.000001

Научная запись

Числа с плавающей точкой поддерживают научную запись через E, стандартный тип — f64:

• 1e6 = 1000000
• 7.6e-4 = 0.00076

Суффиксы типов литералов (важно)

В Rust необходимо явно указывать тип литерала, часто используемые суффиксы:

• u32: 32-битное беззнаковое целое число (только неотрицательные значения)
• i32: 32-битное знаковое целое число (поддерживает положительные и отрицательные числа)

Внимание: нельзя смешивать знаковые и беззнаковые целые числа в операциях, это сразу вызовет ошибку.

Пример кода:

fn main() {
    // 1. Обычный целочисленный литерал
    println!("Целое число: {}", 13);
    // Двоичное, восьмеричное, шестнадцатеричное целое
    println!("Двоичное: {}", 0b1010);
    println!("Восьмеричное: {}", 0o77);
    println!("Шестнадцатеричное: {}", 0x2A);
    // Целое с разделителем (улучшает читаемость)
    println!("Целое с подчеркиванием: {}", 1_000_000);
    // Целое с суффиксом типа
    println!("u32 беззнаковое целое: {}", 100u32);
    println!("i32 знаковое целое: {}", -50i32);

    // 2. Литерал числа с плавающей точкой
    println!("Число с плавающей точкой: {}", 3.14);
    // Число с плавающей точкой с подчеркиванием
    println!("Число с подчеркиванием: {}", 0.000_001);
    // Научная запись для дробных чисел
    println!("Научная запись: {}", 1e6);
    println!("Отрицательная научная запись: {}", 7.6e-4);

    // 3. Строковой литерал (двойные кавычки)
    println!("Строка: {}", "hello world");

    // 4. Символьный литерал (одинарные кавычки, только один символ)
    println!("Символ: {}", 'a');
    println!("Китайский символ: {}", '中');

    // 5. Булевы литералы
    println!("Булево true: {}", true);
    println!("Булево false: {}", false);

    // 6. Юнит-литерал () (тип юнит в Rust)
    println!("Тип юнит: {:?}", ());
}Code language: JavaScript (javascript)

Операторы

Правила и приоритет операторов Rust почти совпадают с языками семейства C.

1. Арифметические операторы

Базовые вычисления, такие как сложение и вычитание, используются вместе с суффиксами типов целых чисел:

• Сложение: +
• Вычитание: -

2. Булевы логические операторы (краткое замыкание)

Работают только с булевыми значениями true/false:

• Логическое И &&: результат true только если обе части равны true
• Логическое ИЛИ ||: результат true если хотя бы одна часть равна true
• Логическое НЕ !: инвертирует булево значение

Выражение	Результат вычисления
true && true	true
true && false	false
false && true	false
false && false	false
true || true	true
true || false	true
false || true	true
false || false	false
!true	false
!false	true

3. Побитовые операторы (работа с двоичными битами)

В основном применяются для целых чисел, в примере используется {:04b} для форматированного вывода 4-битного двоичного числа:

1. Побитовое И &: бит результата равен 1 только если оба бита на той же позиции равны 1
2. Побитовое ИЛИ |: бит результата равен 1 если хотя бы один бит на той же позиции равен 1
3. Побитовое XOR ^: бит результата равен 1 если биты на одной позиции разные, иначе 0
4. Сдвиг влево <<: сдвиг всех двоичных битов влево (равносильно ×2ⁿ)
5. Сдвиг вправо >>: сдвиг всех двоичных битов вправо (равносильно ÷2ⁿ)

  0 0 1 1
& 0 1 0 1
-----------
  0 0 0 1  

  0 0 1 1
| 0 1 0 1
-----------
  0 1 1 1

  0 0 1 1
^ 0 1 0 1
-----------
  0 1 1 0

Сдвиг влево <<
Двоичное: 00000001
Сдвиг на 5 бит → 00100000, результат = 32

Сдвиг вправо >>
0x80 двоичное: 10000000
Сдвиг на 2 бита → 00100000 (шестнадцатеричное 0x20), результат = 32

fn main() {
    // ========== Арифметические операторы ==========
    // Сложение целого: u32 32-битное беззнаковое целое
    // Результат: 1 + 2 = 3
    println!("1 + 2 = {}", 1u32 + 2);

    // Вычитание целого: i32 32-битное знаковое целое, поддерживает отрицательные числа
    // При замене на 1u32 возникнет ошибка, беззнаковое целое не хранит отрицательные значения
    // Результат: 1 - 2 = -1
    println!("1 - 2 = {}", 1i32 - 2);

    // ========== Литералы с плавающей точкой - научная запись ==========
    // Результат: 1e4 равно 10000, -2.5e-3 равно -0.0025
    println!("1e4 равно {}, -2.5e-3 равно {}", 1e4, -2.5e-3);

    // ========== Булевы логические операторы (краткое замыкание) ==========
    // Логическое И &&: результат true только если обе части true
    // Результат: true И false = false
    println!("true И false = {}", true && false);

    // Логическое ИЛИ ||: результат true если одна из частей true
    // Результат: true ИЛИ false = true
    println!("true ИЛИ false = {}", true || false);

    // Логическое НЕ !: инвертирует булево значение
    // Результат: НЕ true = false
    println!("НЕ true = {}", !true);

    // ========== Побитовые операторы (работа с двоичными битами) ==========
    // {:04b} всегда выводит 4 двоичных бита, недостающие позиции заполняет нулями слева
    // Побитовое И &: бит результата 1 только если оба соответствующих бита равны 1
    // Результат: 0011 Побитовое И 0101 = 0001
    println!("0011 Побитовое И 0101 = {:04b}", 0b0011u32 & 0b0101);

    // Побитовое ИЛИ |: бит результата 1 если любой соответствующий бит равен 1
    // Результат: 0011 Побитовое ИЛИ 0101 = 0111
    println!("0011 Побитовое ИЛИ 0101 = {:04b}", 0b0011u32 | 0b0101);

    // Побитовое XOR ^: бит результата 1 при разных соответствующих битах
    // Результат: 0011 Побитовое XOR 0101 = 0110
    println!("0011 Побитовое XOR 0101 = {:04b}", 0b0011u32 ^ 0b0101);

    // Сдвиг влево <<: сдвинуть все биты на 5 позиций влево
    // Результат: 1 сдвинуто на 5 бит влево = 32
    println!("1 сдвинуто на 5 бит влево = {}", 1u32 << 5);

    // Сдвиг вправо >>: сдвинуть все биты на 2 позиции вправо, {:x} вывод шестнадцатеричного формата
    // Результат: 0x80 сдвинуто на 2 бита вправо = 0x20
    println!("0x80 сдвинуто на 2 бита вправо = 0x{:x}", 0x80u32 >> 2);

    // ========== Разделитель чисел _ ==========
    // Подчеркивание только улучшает читаемость, не меняет само число
    // Результат: Один миллион записывается как: 1000000
    println!("Один миллион записывается как: {}", 1_000_000u32);
}Code language: JavaScript (javascript)

---

III. Дополнительные пояснения по запуску кода

1. Если заменить 1i32 на 1u32 и выполнить вычитание 1u32 - 2, появится ошибка: беззнаковые целые не могут представлять отрицательные числа.
2. {:04b}: синтаксис форматирования, b означает двоичный формат, 04 дополняет разряды нулями слева если битов меньше четырех.
3. Для больших чисел рекомендуется использовать подчеркивание как разделитель (например 1_000_000u32), код читается намного легче.