Основы Swift / 9.1. Замыкания - Основы

let names = ["Саша", "Алекс", "Артемий", "Оля", "Маша"]

Пример использует метод sorted(by:) для сортировки массива значений String в обратном алфавитном порядке.

func backward(_ s1: String, _ s2: String) -> Bool {
    return s1 > s2
}
var reversedNames = names.sorted(by: backward)
// reversedNames теперь равен ["Саша", "Оля", "Маша", "Артемий", "Алекс"]

Если первая строка (s1) больше второй строки (s2), то функция backward(_:_:) вернёт значение true, обозначающее, что s1 должна появиться перед s2 в отсортированном массиве. Для символов в строке "больше чем" означает "появляется позже в алфавите чем". Это означает, что буква "B" "больше чем" буква "A", а строка "Tom" больше нежели строка "Tim". Это даст нам обратную алфавитную сортировку, где "Barry" будет расположен перед "Alex" и так далее.

Однако это крайне длинный способ написать на самом деле одноутробное выражение (a > b). В этом примере предпочтительнее было бы написать сортирующее замыкание встроено, используя синтаксис замыкания-выражения.

reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
    return s1 > s2
} )
// reversedNames теперь равен ["Саша", "Оля", "Маша", "Артемий", "Алекс"]

Пример демонстрирует версию функции backward(_:_:) с помощью выражения-замыкания из примера ранее.

Заметьте, что декларация параметров и возвращаемого типа для этого инлайн-замыкания идентично таковым у функции backward(_:_:). В обоих случаях оно записывается как (s1: String, s2: String) -> Bool. Однако для инлайн-замыкания параметры и возвращаемое значение записываются внутри фигурных скобок, а не снаружи их.

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

reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in return s1 > s2 } )
// reversedNames теперь равен ["Саша", "Оля", "Маша", "Артемий", "Алекс"]

Это иллюстрирует, что в общем вызов метода sorted(by:) остался тем же. Пара круглых скобок продолжает обхватывать весь аргумент для метода. Однако аргумент теперь является инлайн-замыканием.

reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )
// reversedNames теперь равен ["Саша", "Оля", "Маша", "Артемий", "Алекс"]

reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )

Здесь функциональный тип аргумента метода sorted(by:) делает понятным, что из замыкания должно быть возвращено значение типа Bool. Так как тело замыкания содержит единственное выражение (s1 > s2), которое возвращает значение типа Bool, так что нет никакой неопределённости, а ключевое слово return может быть опущено.

reversedNames = names.sorted(by: { $0 > $1 } )

Здесь $0 и $1 ссылаются на первый и второй аргументы типа String.

reversedNames = names.sorted(by: >)

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // здесь будет тело функции
}

// Вот так эта функция вызвается без trailing-замыкания:

someFunctionThatTakesAClosure(closure: {
    // Здесь будет тело замыкания
})

// Вот так эта функция вызвается с помощью trailing-замыкания:

someFunctionThatTakesAClosure() {
    // Здесь будет тело trailing-замыкания
}

Замыкание для сортировки строк выше может быть записано вне круглых скобок метода sorted(by:) в качестве trailing-замыкания.

let names = ["Саша", "Алекс", "Артемий", "Оля", "Маша"]
var reversedNames = names.sorted() { $0 > $1 }

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

reversedNames = names.sorted { $0 > $1 }

Здесь приведён пример того, как Вы можете использовать метод map(_:) с trailing-замыканием для конвертации массива Int в массив значений String. Массив [16, 58, 510] используется для создания нового массива ["OneSix", "FiveEight", "FiveOneZero"].

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

let digitNames = [
    0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "Four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]
let numbers = [16, 58, 510]

let strings = numbers.map{ (number) -> String in
    var number = number
    var output = ""
    repeat {
        output = digitNames[number % 10]! + output
        number /= 10
    } while number > 0
    return output
}
// strings выведено в тип [String]
// его значение равно ["OneSix", "FiveEight", "FiveOneZero"]

Теперь Вы можете использовать массив numbers для создания массива типа String, передав в метод массива map(_:) волочащееся замыкание.

Метод map(_:) вызывает замыкание единожды для каждого элемента в массиве. Вам не нужно явно указывать тип входного параметра замыкания, number, так как этот тип может быть выведен из значений отображаемого массива.

В этом примере переменная number инициализируется значением параметра замыкания number, так что это значение может быть изменено внутри тела замыкания. (Параметры функций и замыканий всегда константы.) Замыкание так же специфицирует возвращаемый тип String, чтобы указать, какиой тип будет храниться в отображённом выходном массиве.

Замыкание строит строку с названием output всякий раз при своём вызове. Оно вычисляет последнюю цифру number с использованием оператора остатка от деления (number % 10) и использует эту цифру для выбора подходящей строки в словаре digitNames. Это замыкание может быть использовано для создания строки, отображающей любое целое число, большее 0.

Вызов сабскрипта словаря digitNames сопровождается восклицательным знаком (!), так как сабскрипты словарей возвращают опциональное значение для индикации того, что выбор значения из словаря может провалиться, если указанный ключ не существует. В примере Выше гарантировано, что number % 10 всегда будет корректным ключом сабскрита для словаря digitNames, так что восклицательный знак используется для принудительной распаковки значения типа String, хранимого в опциональном возвращаемом значении сабскрипта.

Строка, полученная из словаря digitNames прибавляется в переднюю часть output, эффективно создавая строковые представление числа в обратном порядке. (Выражение number % 10 даёт число 6 для 16, 8 для 58 и 0 для 510.)

Переменная number затем делится на 10. Так как это целое число, то оо будет округлено вниз при делении, так что 16 станет 1, 58 станет 5, а 510 станет 51.

Этот процесс повторяется, пока number не станет равен 0, в этот момент строка output будет возвращена замыканием и добавлена в выходной массив метода map(_:).

Использование синтаксиса trailing-замыкания в примере выше позволяет инкаспулировать функциональность замыкания сразу после функции, поддерживающей это замыкание без необходимости оборачивать всё замыкание во внешнюю круглую скобку метода map(_:).