Swift Closures中$ 0和$ 1的含义是什么？

Question

import java.util.Scanner;
import java.util.InputMismatchException;

public class Guess {
    public static void main(String[] args) { // No need to throw IOException
        int input = -1, answer = 64; // Initialize input for if the user types
                                     // in invalid input on the first loop

        Scanner scan = new Scanner(System.in);

        do {
            System.out.println("I'm thinking of a number between 1 and 100.");
            System.out.println("Can you guess it?");

            try {
                input = scan.nextInt();
            } catch (InputMismatchException ex) {
                System.out.println("Invalid Input!");
                continue; // Skips to the next loop iteration if invalid input
            }

            if (input == answer) 
                System.out.println("**RIGHT**");
            else {
                System.out.println("...Sorry, you're too " + (input < answer ? "low" : "high"));
                // ^ Ternary operator; you may not have learned this yet, but it 
                // just does a conditional return (if the value before the '?' is
                // true, then return the value before the ':'; else return the 
                // value after.)
                System.out.println("Try again!");
            }
        } while (answer != input);
    }
}

任何人都可以解释一下，let sortedNumbers = numbers.sort { $0 > $1 } print(sortedNumbers) 和$0在swift中意味着什么？

更多样本

$1

Answer 1

$0是传递给闭包的第一个参数。 $1是第二个参数，等等。您显示的闭包是：

的缩写

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

Answer 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

Answer 3

引用sort的第一个和第二个参数。在这里，alex john比较2个元素并对它们进行排序。 您可以查看Swift official documentation以获取更多信息：

  

Swift自动为内联提供速记参数名称   闭包，可用于引用闭包的值   名称为$ 0，$ 1，$ 2等的参数。

Answer 4

雨燕4.2

  

在您的示例中， $0 和 $1 是中Closure的第一个和第二个String的参数 Shorthand Argument Names 。速记参数名称由Swift自动提供。第一个参数可以由 $0 引用，第二个参数可以由 $1 引用，第三个参数可以由 {{1 }} ，依此类推。

您知道， 关闭 非常接近 Lambda函数 或 小匿名功能 ，是一个自包含的功能块，可以在代码中传递和使用。闭包在其他编程语言中的名称不同，含义也略有不同-在 Python 和 Kotlin 中是 Lambda 或 C 和 Objective-C 中的 阻止 。

让我们看看使用速记参数名称的闭包如何工作：

  

第一个示例：

$2

1。正常功能

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

2。闭包表达式

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


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

3。内联闭包表达式

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

4。从上下文推断类型

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

5。单表达式闭包的隐式返回

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

6。速记参数名称

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

7。运算符方法

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

/* $0 and $1 are closure’s first and second String arguments. */

  

第二个示例：

reverseOrder = coffee.sorted(by: >)

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

没有速记参数名称：

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"] */

希望这会有所帮助。

Answer 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

Answer 6

这是简写参数名称。

Swift自动为内联闭包提供简写参数名称，可用于通过名称$ 0，$ 1，$ 2等来引用闭包参数的值。

如果在闭包表达式中使用这些简写参数名称，则可以从其定义中省略闭包的参数列表，并且将从期望的函数类型推断出简写参数名称的数量和类型。也可以省略in关键字，因为闭包表达式完全由其主体组成：

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

这里，$ 0和$ 1引用闭包的第一个和第二个String参数。