Функции в Swift: метки параметров и замыкания

Основы функций

// Простейшая функция
func sayHello() { print("Привет!") }
sayHello()

// С параметрами и возвратом
func add(a: Int, b: Int) -> Int { return a + b }
let result = add(a: 5, b: 3) // 8

Метки параметров — уникальность Swift!

В Swift у каждого параметра два имени: внешняя метка (при вызове) и внутреннее имя (внутри функции).

func greet(to person: String, from sender: String) {
    print("Привет, \(person)! — Привет от \(sender)")
}

// Вызов читается как предложение!
greet(to: "Маша", from: "Саша")

// _ убирает метку
func square(_ number: Int) -> Int { number * number }
let sq = square(5)  // Без метки — чисто!

Default и variadic параметры

// Default параметры
func greet(name: String, language: String = "ru") {
    switch language {
    case "ru": print("Привет, \(name)!")
    case "en": print("Hello, \(name)!")
    default: print("Hi, \(name)!")
    }
}
greet(name: "Саша")              // Привет, Саша!
greet(name: "Alex", language: "en") // Hello, Alex!

// Variadic — переменное число аргументов
func sum(_ numbers: Int...) -> Int {
    return numbers.reduce(0, +)
}
print(sum(1, 2, 3))       // 6
print(sum(10, 20, 30, 40)) // 100

inout — изменение значений снаружи

func swapValues(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}

var x = 10, y = 20
swapValues(&x, &y)  // & означает "передаю по ссылке"
print("x=\(x), y=\(y)") // x=20, y=10

Функции как типы первого класса

func add(_ a: Int, _ b: Int) -> Int { a + b }
func multiply(_ a: Int, _ b: Int) -> Int { a * b }

var operation: (Int, Int) -> Int = add
print(operation(3, 4)) // 7
operation = multiply
print(operation(3, 4)) // 12

// Передача функции как аргумента
func applyOp(_ op: (Int, Int) -> Int, to a: Int, and b: Int) -> Int {
    return op(a, b)
}
print(applyOp(add, to: 5, and: 3))      // 8
print(applyOp(multiply, to: 5, and: 3)) // 15

Замыкания (Closures)

// Полная форма замыкания
let sorted = [3, 1, 4, 1, 5].sorted(by: { (a: Int, b: Int) -> Bool in a < b })

// Постепенное упрощение:
let sorted2 = [3, 1, 4, 1, 5].sorted(by: { a, b in a < b })
let sorted3 = [3, 1, 4, 1, 5].sorted(by: { $0 < $1 })
let sorted4 = [3, 1, 4, 1, 5].sorted { $0 < $1 }  // trailing closure
let sorted5 = [3, 1, 4, 1, 5].sorted(by: <)         // оператор как функция!

map, filter, reduce

let numbers = [5, 3, 8, 1, 9, 2, 7, 4, 6]

let doubled = numbers.map { $0 * 2 }
print(doubled) // [10, 6, 16, 2, 18, 4, 14, 8, 12]

let evens = numbers.filter { $0 % 2 == 0 }
print(evens) // [8, 2, 4, 6]

let total = numbers.reduce(0) { $0 + $1 }
print(total) // 45

// Цепочка операций!
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * $0 }
    .reduce(0, +)
print(result) // 271

Замыкания захватывают значения

func makeCounter() -> () -> Int {
    var count = 0
    return {
        count += 1  // Захватывает 'count' из окружения!
        return count
    }
}

let counter = makeCounter()
print(counter()) // 1
print(counter()) // 2
print(counter()) // 3

Итоги урока