Ответ 1

$0 - это первый параметр, переданный в замыкание. $1 - второй параметр и т.д. Это закрытие, которое вы указали, является сокращением для:

let sortedNumbers = numbers.sort { (firstObject, secondObject) in 
    return firstObject > secondObject
}

Ответ 2

Он представляет сокращенные аргументы, отправленные в закрытие, этот пример прерывает его:

Swift 4:

var add = { (arg1: Int, arg2: Int) -> Int in
    return arg1 + arg2
}
add = { (arg1, arg2) -> Int in
    return arg1 + arg2
}
add = { arg1, arg2 in
    arg1 + arg2
}
add = {
    $0 + $1
}

let result = add(20, 20) // 40

Ответ 3

Swift 5.1

В вашем примере $0 и $1 являются замыканиями первого и второго строковых аргументов в Shorthand Argument Names. Сокращенные имена аргументов автоматически предоставляются Swift. На первый аргумент может ссылаться $0, на второй аргумент может ссылаться $1, на третий аргумент - $2 и т.д. на.

Как вы знаете, замыкание, очень близкое к лямбда-функции, или малая анонимная функция, является автономным блоком функциональности, который можно передать вокруг и используется в вашем коде. У Closure разные названия в других языках программирования, а также небольшие различия в значении - это лямбда в Python и котлин или блок в C и Objective-C.

Давайте посмотрим, как это замыкание можно сократить до формы, называемой Shorthand Argument Names:

FIRST EXAMPLE :

let coffee: [String] = ["Cappuccino", "Espresso", "Latte", "Ristretto"]

1. Нормальная функция

func backward(_ n1: String, _ n2: String) -> Bool {
    return n1 > n2
}
var reverseOrder = coffee.sorted(by: backward)


/* RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"] */

2. Встроенное выражение закрытия

reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in return n1 > n2 } )

3. Вывод типа из контекста

reverseOrder = coffee.sorted(by: { n1, n2 in return n1 > n2 } )

4. Неявные возвраты из замыканий с одним выражением

reverseOrder = coffee.sorted(by: { n1, n2 in n1 > n2 } )

5. Сокращенные имена аргументов

reverseOrder = coffee.sorted(by: { $0 > $1 } )

/* $0 and $1 are closures first and second String arguments. */

6. Методы оператора

reverseOrder = coffee.sorted(by: >)

/* RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"] */

SECOND EXAMPLE :

let companies = ["bmw", "kfc", "ibm", "htc"]

Без сокращенного имени аргумента:

let uppercasedCompanies = companies.map { (item) -> String in item.uppercased() }

/* RESULT: ["BMW", "KFC", "IBM", "HTC"] */

с сокращенным именем аргумента:

let uppercasedCompanies = companies.map { $0.uppercased() }

/* RESULT: ["BMW", "KFC", "IBM", "HTC"] */

THIRD EXAMPLE :

Имя оставшегося оператора и сокращенное имя аргумента в функции высшего порядка filter:

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

let filteredNumbers = numbers.filter { ($0 % 2) == 0 }

print(filteredNumbers)

/* RESULT: [2, 4, 6, 8, 10] */

FOURTH EXAMPLE :

Повторяющееся $0 сокращенное название аргумента для кубической степени:

let cubedNumber = { $0 * $0 * $0 } (25)

print(cubedNumber)

/* RESULT:  25^3 = 15625 */

FIFTH EXAMPLE :

Три сокращенных имени аргумента - $0, $1, $2:

let math: (Int8, Int8, Int8) -> Int8 = { $0 + $1 - $2 }

func feedClosure() -> (Int8, Int8, Int8) -> Int8 {
    return math
}
feedClosure()(10, 20, 100)

/* RESULT:  (10 + 20 - 100) = -70 */

SIXTH EXAMPLE :

Пять сокращенных имен аргументов - $0, $1, $2, $3, $4:

let factorial = { $0 * $1 * $2 * $3 * $4 } (1, 2, 3, 4, 5)

print(factorial)

/* RESULT:  5! = 120 */

SEVENTH EXAMPLE – Swift vs Kotlin vs Python :

Кроме того, давайте посмотрим, как Kotlin лямбда похожа на закрытие Swift:

Swift

let element: [String] = ["Argentum","Aurum","Platinum"]

let characterCount = element.map { $0.count }

print(characterCount)

/* RESULT:  [8, 5, 8] */ 

Котлин

Часто лямбда-выражение Kotlin имеет только один параметр с неявным именем: it.

val element = listOf("Argentum","Aurum","Platinum")

val characterCount = element.map { it.length }

println(characterCount)

/* RESULT:  [8, 5, 8] */ 

But in Python there no equivalent of Shorthand Argument Name.

Python

element = ["Argentum","Aurum","Platinum"]

characterCount = list(map(lambda x: len(x), element))

print(characterCount)

/* RESULT:  [8, 5, 8] */

Ответ 4

Ссылка на первый и второй аргументы сортировки. Здесь sort сравнивает 2 элемента и упорядочивает их. Вы можете найти официальную документацию Swift для получения дополнительной информации:

Swift автоматически предоставляет сокращенные имена аргументов для встроенного замыкания, которые можно использовать для ссылки на значения замыканий аргументы с именами $ 0, $ 1, $ 2 и так далее.

Ответ 5

В дополнение к ответу @Bobby я хотел бы добавить пример

var add: (Int,Int,Int)->Int
add = {
//So here the $0 is first argument $1 is second argument $3 is third argument
    return $0 + $1 + $2
//The above statement can also be written as $0 + $1 + $2 i.e is return is optional
}

let result = add(20, 30, 40) 
print(result) // Prints 90

Ответ 6

Это имена сокращенных аргументов.

Swift автоматически предоставляет имена сокращенных аргументов для встроенных закрытий, которые могут использоваться для ссылки на значения аргументов замыканий именами $0, $1, $2 и т.д.

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

    reversed = names.sort( { $0 > $1 } )

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