Краткий ответ

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

Исторический контекст

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

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

Постановка проблемы

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

Важно отличать порядок вычисления аргументов от порядка выполнения тела функции. Сначала слева направо вычисляются все аргументы, затем вызывается функция; сама функция не начинает выполняться после вычисления только первого аргумента.

Подробное решение

Для обычного вызова Swift вычисляет выражения аргументов в порядке их записи — слева направо. После завершения этого вычисления полученные значения передаются функции, и только затем начинается выполнение её тела.

var events: [String] = []

func mark(_ name: String) -> Int {
    events.append(name)
    return 0
}

func use(_ first: Int, _ second: Int) {}

use(mark("first"), mark("second"))
print(events) // ["first", "second"]

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

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

Практическое следствие — не стоит строить важную бизнес-логику на побочных эффектах в аргументах. Даже при гарантированном порядке такая запись ухудшает читаемость; безопаснее предварительно вычислить значения в отдельных инструкциях и явно показать последовательность действий.

Ситуация из практики

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

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

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

Что кандидаты часто упускают

Меняется ли порядок вычисления, если функция выбрасывает ошибку?

Нет. Аргументы вычисляются до передачи управления в throwing-функцию. Если вычисление одного из аргументов само завершается ошибкой, последующие аргументы не вычисляются, а вызов функции не начинается.

Влияет ли порядок аргументов на порядок привязки параметров внутри функции?

Нет. Сначала вычисляются выражения в синтаксическом порядке вызова, затем их результаты сопоставляются с параметрами по меткам и позициям. Метка аргумента определяет соответствие параметру, но не меняет порядок вычисления выражений, записанных в вызове.

Может ли компилятор переставить вычисления, если это улучшает производительность?

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