Swift 什么时候需要参数标签？

Question

在回答 this question 时，需要使用参数标签来调用 init。这在 Swift 中很正常。

class Foo {
    init(one: Int, two: String) { }
}

let foo = Foo(42, "Hello world") // Missing argument labels 'one:two:' in call

然而，奇怪的力量在起作用：

extension Foo {
    func run(one: String, two: [Int]) { }
}

foo.run(one: "Goodbye", two: []) // Extraneous argument label 'one:' in call

要在此处使用参数标签，必须明确声明。

我还没有在文档中看到非常详尽的解释所有这些的内容。哪些类/实例/全局函数需要参数标签？ Obj-C 方法是否总是使用参数标签导出和导入？

Answer 1

所有初始化方法都需要参数名称：

var view = NSView(frame: NSRect(x: 10, y: 10, width: 50, height: 50))
class Foo {
    init(one: Int, two: String) { }
}

let foo = Foo(one: 42, two: "Hello world")

对象上调用的所有方法都使用参数名称，但第一个参数除外：

extension Foo {
    func run(one: String, two: [Int]) { }
}
foo.run("Goodbye", two: [])

Swift 和 Objective-c 中的所有类函数都遵循相同的模式。您还可以显式添加外部名称。

extension Foo{
class func baz(one: Int, two: String){}
class func other(exOne one: Int,  exTwo two: String){}
}
Foo.baz(10, two:"str")
Foo.other(exOne: 20, exTwo:"str")

非类函数的 Swift 函数不需要参数名称，但您仍然可以显式添加它们：

func bar(one: Int, two: String){}
bar(1, "hello")

正如 Bryan 所说，当在方法签名中具有参数名称的 Objective-C 方法上调用 Swift 方法时，它是有意义的。 init 方法包含第一个参数，因为 Swift 将 Objective-c 的 init 方法从 initWith:... 更改为 Class()，因此第一个参数名称不再包含在方法名称中。

Answer 2

从 Swift 3.0 开始，这又发生了变化：所有方法、函数和初始化程序都需要 所有 参数的参数标签，除非您已明确选择不使用外部名称 _。这意味着像 addChildViewController(_:) 这样的方法现在写成这样：

func addChildViewController(_ childController: UIViewController)

这是proposed and approved 作为Swift Evolution process 的一部分，并在SR-961 中实现。

Answer 3

斯威夫特 3.0

在 Swift 3.0 中，slated to be released in late 2016，默认行为很简单：

• 默认情况下，所有方法的所有参数都有外部标签。

您可以在Swift API Design Guidelines 中最简洁地找到这些规则。这个最新的行为在SE-0056, "establish consistent label behavior across all parameters including first labels," 中提出并在SR-961 中实现。默认行为可以按照下面“覆盖默认行为”中的描述进行更改。

斯威夫特 2.2

在 Swift 2.2 中，语言对外部参数标签的默认设置已经改变，现在更简单了。默认行为可以总结如下：

• 方法和函数的第一个参数不应有外部参数标签。
• 方法和函数的其他参数应该有外部参数标签。
• 初始化器的所有参数都应该有外部参数标签。

默认行为可能会按照下面“覆盖默认行为”中的说明进行更改。

一个例子

这些规则最好用一个例子来说明：

func printAnimal(animal: String, legCount: Int) {
    let legNoun = legCount == 1 ? "leg" : "legs"
    print("\(animal) has \(legCount) \(legNoun)")
}

struct Player {
    let name: String
    let lives: Int

    init(name: String, lives: Int) {
        self.name = name
        self.lives = lives
    }

    func printCurrentScore(currentScore: Int, highScore: Int) {
        print("\(name)'s score is \(currentScore). Their high score is \(highScore)")
    }
}


// SWIFT 3.0
// In Swift 3.0, all argument labels must be included
printAnimal(animal: "Dog", legCount: 4)
let p = Player(name: "Riley", lives: 3)
p.printCurrentScore(currentScore: 50, highScore: 110)

// SWIFT 2.2
// In Swift 2.2, argument labels must be included or omitted in exactly the following way
// given the definition of the various objects.
printAnimal("Dog", legCount: 4)
let p = Player(name: "Riley", lives: 3)
p.printCurrentScore(50, highScore: 110)

// In Swift 2.2, none of the following will work
printAnimal(animal: "Dog", legCount: 4)  // Extraneous argument label 'animal:' in call
let q = Player("Riley", lives: 3)  // Missing argument label 'name:' in call
p.printCurrentScore(50, 110)  // Missing argument label 'highScore:' in call

覆盖默认行为

对于任何方法或函数的任何参数，您都可能偏离语言的默认值，尽管样式指南正确地警告您不要这样做，除非有充分的理由。

要在通常没有的地方添加一个外部参数标签——仅适用于 Swift 2.2，因为 Swift 3.0 默认为每个参数分配外部标签——或者更改一个外部参数标签——适用于两个版本——编写本地参数标签之前的所需外部参数标签：

func printAnimal(theAnimal animal: String, legCount: Int) {
    let legNoun = legCount == 1 ? "leg" : "legs"
    print("\(animal) has \(legCount) \(legNoun)")
}

printAnimal(theAnimal: "Dog", legCount: 4)

要删除通常会有的外部参数标签，请使用特殊的外部参数标签_：

func printAnimal(animal: String, _ legCount: Int) {
    let legNoun = legCount == 1 ? "leg" : "legs"
    print("\(animal) has \(legCount) \(legNoun)")
}

// SWIFT 3.0
printAnimal(theAnimal: "Dog", 4)

// SWIFT 2.2
printAnimal("Dog", 4)

这些“默认覆盖”适用于任何方法或函数，包括初始化程序。

Answer 4

这是我通过阅读（相当稀疏的）文档和通过简单的实验收集到的信息：

• Init 方法总是需要它们的标签。初始化方法就像标签一样，因为它们清楚地表明了您想要调用的初始化方法。否则，这个：

  FooBar(foos: 5)
  

  还有这个：

  FooBar(bars: 5)
  

  看起来完全一样：

  FooBar(5)
  

  没有其他地方是这种情况 - init 方法是 Swift 中唯一一个它们都具有相同名称但可能具有不同参数的地方。这就是为什么...

• 函数、方法等（任何不是 init 方法的东西）都省略了第一个标签 - 这是为了样式和减少无聊的重复性。而不是

  aDictionary.removeValueForKey(key: "four")
  

  我们有这个：

  aDictionary.removeValueForKey("four")
  

  对于带有 两个 参数的函数，仍然有相当明确且易于阅读的参数。所以不是

  anArray.insert("zebras", 9)
  

  我们有一个更易于阅读的表格：

  anArray.insert("zebras", atIndex: 9)
  

看起来好多了。当我在 WWDC 时，这被吹捧为 Swift 的一个特性：Java 风格的现代、简短的参数，而不牺牲可读性。正如Bryan Chen's answer 所示，这也简化了从 Objective-C 的过渡。

Answer 5

您可以在标签前使用#来制作调用方法所需的参数标签。

例如：

func addLocation(latitude : Double, longitude : Double) { /*...*/ }
addLocation(125.0, -34.1) // Not clear

可以这样改进：

func addLocation(#latitude : Double, #longitude : Double) { /*...*/ }
addLocation(latitude: 125.0, longitude: -34.1) // Better

（来自WWDC 2014 - 416 - Building Modern Frameworks，15 分钟后）

Answer 6

它只是让 ObjC 方法在 Swift 中看起来不错。

Documentation

实例方法

方法的本地和外部参数名称

具体来说，Swift 为方法中的第一个参数名称赋予了一个local 默认参数名称，并给出第二个和后续 默认情况下，参数名称包括本地参数名称和外部参数名称。 此约定与您的典型命名和调用约定相匹配 将熟悉编写 Objective-C 方法，并为 无需限定参数即可表达的方法调用 名字。

...

上述默认行为意味着 Swift 中的方法定义使用与 Objective-C 相同的语法风格编写，并以自然、富有表现力的方式调用。

自定义初始化

本地和外部参数名称

但是，初始化器在括号前没有函数和方法那样的标识函数名称。因此，初始化器参数的名称和类型在确定应该调用哪个初始化器时起着特别重要的作用。因此，如果您自己不提供外部名称，Swift 会为初始化器中的每个参数提供自动外部名称。

例如这个 ObjC 类

@interface Counter : NSObject

@property int count;

- (void)incrementBy:(int)amount numberOfTimes:(int)numberOfTimes;

@end

它是用 Swift 编写的

class Counter {
    var count: Int = 0
    func incrementBy(amount: Int, numberOfTimes: Int) {
        count += amount * numberOfTimes
    }
}

调用 ObjC 版本

[counter incrementBy:10 numberOfTimes:2];

和 Swift 版本

counter.incrementBy(10, numberOfTimes:2)

你可以看到它们几乎一样