Перейти к основному содержимому

5.20. Управляющие конструкции и операторы

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ
Разработчику Архитектору

Управляющие конструкции и операторы​

Общая философия управления потоком в Zig​

Zig следует принципу «одна задача — один инструмент». Это означает, что язык предоставляет минимальный набор управляющих конструкций, каждая из которых решает конкретную задачу без пересечений с другими. Такой подход упрощает обучение, снижает когнитивную нагрузку при чтении кода и устраняет неоднозначности, возникающие в языках с множеством способов реализовать одно и то же поведение.

Все управляющие конструкции в Zig являются выражениями. Это свойство позволяет использовать их везде, где допустимо значение, включая присваивания, аргументы функций и возвращаемые значения. Такая унификация делает код более компактным и логически целостным.

Блоки как основа структуры​

Блок в Zig — это последовательность выражений, заключённая в фигурные скобки {}. Блок сам по себе является выражением и имеет тип, определяемый последним выражением внутри него. Если блок завершается точкой с запятой или не содержит выражений, его тип — void.

Блоки используются в качестве тел функций, циклов, условных конструкций и могут существовать автономно. Автономные блоки позволяют ограничивать область видимости переменных и группировать логически связанные действия без необходимости выносить их в отдельную функцию.

const result = {
    var x: i32 = 10;
    var y: i32 = 20;
    x + y
};
// result имеет значение 30 и тип i32

Такой подход подчёркивает, что даже простейшие группы операций в Zig обладают семантикой выражения, а не только побочного эффекта.

Условное выполнение: if​

Конструкция if в Zig используется для выбора одного из двух возможных путей выполнения на основе логического условия. Условие должно быть выражением типа bool. В отличие от C-подобных языков, в Zig отсутствуют неявные преобразования значений в логический тип, поэтому любое условие должно быть явно булевым.

Синтаксис if в Zig:

if (условие) {
    // ветка "да"
} else {
    // ветка "нет"
}

Обе ветки необязательны. Если отсутствует ветка else, а условие ложно, выполнение просто продолжается за пределами всей конструкции.

Ключевая особенность if в Zig — возможность использовать его как выражение. Это означает, что if может возвращать значение, которое затем используется в других частях программы.

const max = if (a > b) a else b;

В этом примере переменная max получает значение большего из двух чисел. Такая форма записи заменяет собой тернарный оператор, который в Zig отсутствует как отдельная конструкция. Язык считает, что if как выражение достаточно выразителен и не требует дополнительного синтаксиса.

Когда ветки if содержат несколько выражений, они оформляются как блоки, и последнее выражение в блоке определяет возвращаемое значение:

const message = if (score >= 90) {
    std.debug.print("Отлично!\n", .{});
    "excellent"
} else if (score >= 70) {
    std.debug.print("Хорошо.\n", .{});
    "good"
} else {
    std.debug.print("Нужно улучшить.\n", .{});
    "needs_improvement"
};

Zig поддерживает цепочки else if, что позволяет реализовывать множественные условия без вложения конструкций. Такой стиль повышает читаемость и уменьшает глубину вложенности.

Циклы: while и for​

Zig предоставляет два основных цикла: while и for. Оба являются выражениями и могут возвращать значения.

Цикл while​

Цикл while выполняет тело до тех пор, пока условие остаётся истинным. Условие, как и в if, должно быть типа bool.

var i: usize = 0;
while (i < 10) {
    std.debug.print("{}\n", .{i});
    i += 1;
}

Цикл while в Zig поддерживает дополнительные возможности, расширяющие его гибкость. Одна из таких возможностей — continue expression. Это выражение, вычисляемое перед каждой итерацией и доступное внутри тела цикла через специальный синтаксис.

var i: usize = 0;
while (i < 10) : (i += 1) {
    std.debug.print("{}\n", .{i});
}

Выражение после двоеточия (i += 1) выполняется после каждой итерации, включая случаи, когда используется continue. Это позволяет централизовать логику изменения состояния цикла и избежать дублирования кода.

Цикл while также может возвращать значение. Для этого используется метка и оператор break с передачей значения:

const result = blk: {
    var i: usize = 0;
    while (i < 10) : (i += 1) {
        if (some_condition(i)) {
            break :blk i;
        }
    }
    break :blk 10; // значение по умолчанию, если условие не выполнилось
};

Здесь blk — метка блока, которая позволяет точно указать, из какого контекста происходит выход. Такой механизм обеспечивает безопасный и явный контроль над потоком выполнения.

Цикл for​

Цикл for в Zig предназначен для итерации по массивам, срезам, указателям на массивы и другими последовательностями. Он не является универсальным счётчиком, как в C, а работает исключительно с коллекциями.

const numbers = [_]i32{ 1, 2, 3, 4, 5 };
for (numbers) |value| {
    std.debug.print("{}\n", .{value});
}

Синтаксис |value| называется деструктуризацией. Он извлекает текущий элемент коллекции и связывает его с именем value внутри тела цикла.

Можно одновременно получать и значение, и индекс:

for (numbers) |value, index| {
    std.debug.print("[{}] = {}\n", .{ index, value });
}

Порядок аргументов фиксирован: сначала значение, затем индекс.

Цикл for также может использоваться с изменяемыми коллекциями. Для этого требуется добавить модификатор var:

var mutable_numbers = [_]i32{ 1, 2, 3 };
for (mutable_numbers) |*value| {
    value.* += 10;
}
// теперь mutable_numbers = { 11, 12, 13 }

Здесь |*value| означает, что value — это указатель на текущий элемент. Разыменование value.* даёт доступ к самому элементу для изменения.

Как и while, цикл for может быть частью выражения и возвращать значение через метки и break.

Операторы ветвления и перехода​

Zig предоставляет ограниченный набор операторов управления потоком: break, continue, return и unreachable.

break​

Оператор break немедленно прекращает выполнение ближайшего цикла или блока с меткой. При использовании с меткой он может передавать значение, что делает его ключевым инструментом для возврата результата из цикла.

const found_index = outer: {
    for (items) |item, i| {
        if (item == target) break :outer i;
    }
    break :outer null;
};

continue​

Оператор continue завершает текущую итерацию цикла и переходит к следующей. Если в цикле указано выражение после двоеточия (например, : (i += 1)), оно выполняется перед началом новой итерации.

return​

Оператор return завершает выполнение текущей функции и возвращает значение вызывающему коду. В функциях, возвращающих void, return может использоваться без значения для досрочного выхода.

unreachable​

Оператор unreachable указывает компилятору, что данная точка кода никогда не должна быть достигнута во время выполнения. Он используется в ситуациях, когда логика программы гарантирует, что определённая ветка недостижима. Если выполнение всё же достигает unreachable, программа аварийно завершается.

switch (enum_value) {
    .A => handleA(),
    .B => handleB(),
    .C => handleC(),
    else => unreachable, // все варианты перечисления учтены
}

Этот оператор помогает компилятору проводить более точный анализ кода и генерировать оптимальные инструкции.

Выбор по значению: switch​

Конструкция switch в Zig — это мощный инструмент для выбора одной из множества веток на основе значения. Она работает с целыми числами, перечислениями, символьными литералами и некоторыми другими типами.

const Color = enum { Red, Green, Blue };

fn describeColor(color: Color) []const u8 {
    return switch (color) {
        .Red => "красный",
        .Green => "зелёный",
        .Blue => "синий",
    };
}

Ключевая особенность switch в Zig — исчерпывающий охват. Компилятор требует, чтобы все возможные значения были обработаны явно или покрыты веткой else. Это исключает ошибки, связанные с неполным рассмотрением вариантов.

Для целочисленных типов, где перечисление всех значений невозможно, используется ветка else:

switch (x) {
    0 => handleZero(),
    1 => handleOne(),
    else => handleOther(),
}

Ветка else может быть заменена на конкретные диапазоны с помощью синтаксиса ...:

switch (code) {
    200...299 => handleSuccess(),
    400...499 => handleClientError(),
    500...599 => handleServerError(),
    else => handleUnknown(),
}

Конструкция switch также является выражением и может возвращать значения, что делает её удобной для инициализации переменных или возврата из функций.

Ветки switch не требуют явного break. Выполнение не «проваливается» в следующую ветку, как в C. Каждая ветка завершается автоматически, что устраняет распространённый класс ошибок.

Операторы в Zig​

Zig предоставляет набор арифметических, логических, побитовых и сравнительных операторов, каждый из которых строго типизирован и не допускает неявных преобразований. Это означает, что операции между значениями разных типов требуют явного приведения. Такой подход устраняет классические ошибки переполнения, усечения и неопределённого поведения, часто встречающиеся в C и подобных языках.

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

Основные арифметические операторы: +, -, *, /, %. Все они работают только с совместимыми числовыми типами. Например, сложение i32 и u32 невозможно без явного преобразования одного из операндов.

Особое внимание Zig уделяет безопасности при работе с целочисленными операциями. По умолчанию арифметические операторы проверяют переполнение во время выполнения в режиме отладки. Если происходит переполнение, программа аварийно завершается с диагностическим сообщением. В релизных сборках эти проверки могут быть отключены, но язык предлагает альтернативные формы операторов для явного управления таким поведением:

  • +, -, * — безопасные операторы с проверкой переполнения.
  • +%, -%, *% — «wrapping» операторы, которые игнорируют переполнение и оборачивают значение по модулю размера типа (аналогично поведению в C).
  • +|, -|, *| — операторы, возвращающие ошибку при переполнении вместо аварийного завершения.

Пример использования:

const a: u8 = 255;
const b = a +% 1; // b == 0, без паники

Этот механизм позволяет разработчику точно выбирать стратегию обработки крайних случаев: либо завершить программу при ошибке, либо продолжить выполнение с известным поведением.

Логические и побитовые операторы​

Логические операторы and, or, not работают исключительно с типом bool. Побитовые операторы &, |, ^, ~, <<, >> применяются к целочисленным типам. Zig не смешивает логические и побитовые операции, что исключает путаницу и неожиданные побочные эффекты.

Стоит отметить, что Zig не поддерживает короткозамкнутое вычисление (short-circuit evaluation) как отдельную семантику. Вместо этого язык полагается на явные условные конструкции. Например, вместо:

if (ptr != NULL && ptr->valid)

в Zig пишут:

if (ptr) |p| {
    if (p.valid) {
        // ...
    }
}

Такой стиль делает управление потоком более прозрачным и исключает скрытые зависимости между частями условия.

Операторы сравнения​

Операторы ==, !=, <, <=, >, >= доступны для большинства скалярных типов. Сравнение указателей возможно только если они указывают на один и тот же объект или находятся в пределах одного массива. Сравнение структур выполняется поэлементно, при условии, что все поля поддерживают сравнение.

Zig не разрешает сравнение значений разных типов, даже если они логически совместимы (например, i32 и i64). Это требует явного приведения, что повышает надёжность кода.

Управление ошибками​

Одна из ключевых особенностей Zig — встроенная система управления ошибками без исключений. Ошибки представляются как значения специального типа error, который может комбинироваться с любым другим типом через объединение !.

Например:

const FileError = error{ FileNotFound, AccessDenied, DiskFull };

fn openFile(path: []const u8) FileError!std.fs.File {
    // ...
}

Здесь функция возвращает либо файл, либо одну из перечисленных ошибок. Тип FileError!std.fs.File читается как «либо ошибка из FileError, либо значение типа std.fs.File».

Обработка ошибок: catch и try​

Для обработки ошибок используются два основных механизма: catch и try.

Оператор catch позволяет задать значение по умолчанию в случае ошибки:

const file = openFile("data.txt") catch std.io.getStdOut();

Если openFile завершится ошибкой, переменная file получит стандартный вывод.

Оператор try передаёт ошибку выше по стеку вызовов:

const file = try openFile("data.txt");

Если произойдёт ошибка, текущая функция немедленно завершится и вернёт эту ошибку вызывающему коду. Это эквивалентно:

const file = openFile("data.txt") catch |err| return err;

Такой подход делает распространение ошибок явным и контролируемым, без скрытых переходов, характерных для исключений.

Сопоставление ошибок: switch​

Поскольку ошибки в Zig — это перечислимые значения, их можно обрабатывать с помощью switch:

const result = openFile("config.ini");
switch (result) {
    .FileNotFound => std.debug.print("Файл не найден\n", .{}),
    .AccessDenied => std.debug.print("Доступ запрещён\n", .{}),
    else => |file| {
        // использовать file
    },
}

Такая обработка гарантирует, что все возможные ошибки учтены, а компилятор требует полного покрытия вариантов.

Компиляционное время и управление потоком​

Zig активно использует возможности времени компиляции для генерации эффективного и безопасного кода. Многие управляющие конструкции могут выполняться на этапе компиляции, если их условия известны статически.

if и while во время компиляции​

Конструкции if и while могут быть помечены как comptime, что заставляет их выполняться на этапе компиляции:

comptime {
    if (@import("builtin").mode == .Debug) {
        std.debug.print("Режим отладки\n", .{});
    }
}

Аналогично, циклы while могут использоваться для генерации кода или инициализации структур данных до запуска программы.

comptime-параметры и функции​

Функции в Zig могут принимать параметры времени компиляции. Это позволяет создавать обобщённый код без шаблонов или макросов:

fn createArray(comptime T: type, comptime len: usize) [len]T {
    var arr: [len]T = undefined;
    for (arr) |*elem| {
        elem.* = T(0);
    }
    return arr;
}

const zeros = createArray(i32, 10); // создаёт [10]i32, заполненный нулями

Здесь T и len известны на этапе компиляции, поэтому функция генерирует конкретный код без накладных расходов во время выполнения.

Такой подход заменяет собой метапрограммирование, сохраняя читаемость и типобезопасность.

Отложенное выполнение: defer и errdefer​

Zig предоставляет два специальных оператора для отложенного выполнения кода: defer и errdefer. Оба они гарантируют, что определённый блок кода будет выполнен при выходе из текущей области видимости, но различаются условиями срабатывания.

Оператор defer​

Оператор defer выполняет указанное выражение или блок при любом выходе из текущей области — будь то нормальный возврат через return, выход через break, завершение функции или даже возникновение ошибки. Это делает defer идеальным инструментом для освобождения ресурсов, закрытия файлов, разблокировки мьютексов и других задач очистки.

fn processFile(path: []const u8) !void {
    const file = try std.fs.cwd().openFile(path, .{});
    defer file.close();

    // работа с файлом
    _ = try file.readAllAlloc(std.heap.page_allocator, 1024);
}

В этом примере file.close() будет вызван независимо от того, завершится ли функция успешно или вернёт ошибку. Порядок выполнения defer — обратный порядку их объявления, что соответствует принципу LIFO (last in, first out). Это позволяет корректно управлять вложенными ресурсами.

Оператор errdefer​

Оператор errdefer срабатывает только в том случае, если текущая функция завершается с ошибкой. Он не выполняется при успешном возврате или при обычном выходе из области видимости. Это полезно, когда нужно откатить частично выполненную операцию, но только в случае сбоя.

fn allocateAndInit() ![]u8 {
    const buffer = try std.heap.page_allocator.alloc(u8, 1024);
    errdefer std.heap.page_allocator.free(buffer);

    // попытка инициализации
    if (!try initializeData(buffer)) {
        return error.InitializationFailed;
    }

    return buffer; // при успехе buffer остаётся выделенным
}

Если инициализация завершится ошибкой, errdefer освободит память. Если всё пройдёт успешно, память передаётся вызывающему коду, и ответственность за её освобождение переходит к нему.

Оба оператора работают на уровне лексической области видимости, а не функции, что позволяет использовать их внутри блоков, циклов и условий.

Метки и управление вложенными конструкциями​

Zig поддерживает именованные метки для точного управления потоком выполнения в сложных вложенных структурах. Метка ставится перед блоком, циклом или конструкцией if, и затем используется с break или continue.

outer_loop: for (matrix) |row| {
    for (row) |cell| {
        if (cell == target) break :outer_loop;
    }
}

Без метки break вышел бы только из внутреннего цикла. Метка outer_loop позволяет выйти сразу из внешнего цикла.

Метки особенно полезны при работе с вложенными блоками, где требуется вернуть значение из глубоко вложенной логики:

const result = find_block: {
    for (items) |item| {
        if (item.isValid()) {
            break :find_block item.value;
        }
    }
    break :find_block default_value;
};

Такой стиль заменяет собой флаговые переменные и досрочные возвраты, сохраняя линейную структуру кода.

Указатели и управление памятью в управляющих конструкциях​

Zig не имеет сборщика мусора и не использует автоматическое управление памятью. Вместо этого он предоставляет прямой контроль над памятью через указатели и аллокаторы. Управляющие конструкции тесно интегрированы с этой моделью.

Указатели в Zig бывают двух видов:

  • *T — указатель на одиночное значение типа T,
  • [*]T — указатель на первый элемент массива неизвестной длины.

В циклах for часто используется синтаксис |*elem| для получения указателя на текущий элемент, что позволяет изменять его напрямую:

var numbers = [_]i32{ 1, 2, 3 };
for (numbers) |*n| {
    n.* *= 2;
}
// numbers теперь { 2, 4, 6 }

Поскольку Zig не допускает использования неинициализированной памяти, все переменные должны быть явно инициализированы. Это требование распространяется и на управляющие конструкции: нельзя объявить переменную внутри if и использовать её вне, если обе ветки не гарантируют её инициализацию.

// Это не скомпилируется:
var x: i32;
if (condition) {
    x = 10;
}
// использование x здесь запрещено, если нет else-ветки

Компилятор строго отслеживает поток инициализации, что исключает ошибки использования мусора.

Практические паттерны управления потоком​

Идиоматический код на Zig часто следует определённым паттернам, которые делают его предсказуемым и безопасным.

Паттерн "early return"​

Вместо глубокой вложенности условий Zig поощряет досрочный возврат при ошибках:

fn handleRequest(req: Request) !Response {
    if (req.method != .GET) {
        return error.MethodNotAllowed;
    }
    if (req.path.len == 0) {
        return error.InvalidPath;
    }
    // основная логика
    return buildResponse(req);
}

Такой стиль уменьшает уровень вложенности и делает основной путь выполнения линейным.

Паттерн "optional unwrapping"​

Для работы с опциональными значениями (?T) Zig использует if с деструктуризацией:

if (maybe_value) |value| {
    // value имеет тип T
} else {
    // значение отсутствует
}

Это заменяет собой проверки на null и исключает разыменование пустых указателей.

Паттерн "error union handling"​

Аналогично, ошибки обрабатываются через if или switch:

const result = riskyOperation();
if (result) |data| {
    use(data);
} else |err| {
    logError(err);
}

Такой подход делает обработку ошибок явной и обязательной.

Сравнение с другими языками​

В отличие от C, Zig не допускает «проваливания» в switch, не требует break и обеспечивает полный охват вариантов. В отличие от Rust, Zig не использует шаблоны сопоставления с образцом, но достигает аналогичной выразительности через if и switch с деструктуризацией. В отличие от Go, Zig не имеет goto, но предоставляет более мощные метки с break и continue.

Отсутствие исключений упрощает рассуждение о потоке выполнения: каждая функция имеет один вход и один выход (или несколько явных выходов через return), а ошибки передаются как значения.