swift - 方便的 init 与 init 在快速、明确的示例中的区别是什么？

Question

我很难理解两者之间的区别，或者convenience init.

Answer 1

标准init：

指定初始化器是类的主要初始化器。指定的初始化程序完全初始化该类引入的所有属性，并调用适当的超类初始化程序以继续沿超类链的初始化过程。

convenience init：

便利初始化器是次要的，支持类的初始化器。您可以定义一个便利初始化程序，以从与便利初始化程序相同的类调用指定初始化程序，并将一些指定初始化程序的参数设置为默认值。您还可以定义便利初始化程序来为特定用例或输入值类型创建该类的实例。

根据Swift 文档

简而言之，这意味着您可以使用便利初始化程序来更快、更“方便”地调用指定的初始化程序。因此，便利初始化程序需要使用 ofself.init而不是super.init您可能在指定初始化程序的覆盖中看到的。

伪代码示例：

init(param1, param2, param3, ... , paramN) {
     // code
}

// can call this initializer and only enter one parameter,
// set the rest as defaults
convenience init(myParamN) {
     self.init(defaultParam1, defaultParam2, defaultParam3, ... , myParamN)
}

我在创建自定义视图时经常使用这些，并且这些视图有很长的初始化程序，主要是默认值。文档的解释比我做得更好，请查看！

Answer 2

当您有一些具有许多属性的类时使用便利初始化器，这使得总是用所有变量初始化机智有点“痛苦”，所以您使用便利初始化器所做的是您只需传递一些变量来初始化对象，并为其余部分分配默认值。Ray Wenderlich 网站上有一个非常好的视频，不确定它是否免费，因为我有一个付费帐户。这是一个示例，您可以看到，我没有用所有这些变量初始化我的对象，而是给它一个标题。

struct Scene {
  var minutes = 0
}

class Movie {
  var title: String
  var author: String
  var date: Int
  var scenes: [Scene]

  init(title: String, author: String, date: Int) {
    self.title = title
    self.author = author
    self.date = date
    scenes = [Scene]()
  }

  convenience init(title:String) {
    self.init(title:title, author: "Unknown", date:2016)
  }

  func addPage(page: Scene) {
    scenes.append(page)
  }
}


var myMovie = Movie(title: "my title") // Using convenicence initializer
var otherMovie = Movie(title: "My Title", author: "My Author", date: 12) // Using a long normal initializer

Answer 3

这是一个简单的示例，取自Apple Developer 门户。

基本上指定的初始化器是init(name: String)，它确保所有存储的属性都被初始化。

不带参数的init()便捷初始化程序通过使用指定的初始化程序自动将name存储属性的值设置为。[Unnamed]

class Food {
    let name: String

    // MARK: - designated initializer
    init(name: String) {
        self.name = name
    }

    // MARK: - convenience initializer
    convenience init() {
        self.init(name: "[Unnamed]")
    }
}

// MARK: - Examples
let food = Food(name: "Cheese") // name will be "Cheese"
let food = Food()               // name will be "[Unnamed]"

当您处理具有至少一些存储属性的大型类时，它很有用。我建议在Apple Developer 门户网站上阅读更多关于选项和继承的信息。

Answer 4

便利初始化程序优于设置默认参数值的地方

对我来说，convenience initializers如果要做的不仅仅是为类属性设置默认值，这很有用。

具有指定 init() 的类实现

否则，我会简单地在init定义中设置默认值，例如：

class Animal {

    var race: String // enum might be better but I am using string for simplicity
    var name: String
    var legCount: Int

    init(race: String = "Dog", name: String, legCount: Int = 4) {
        self.race = race
        self.name = name
        self.legCount = legCount // will be 4 by default
    }
}

方便的类扩展 init()

但是，除了简单地设置默认值之外，可能还有更多工作要做，这就是convenience initializers派上用场的地方：

extension Animal {
    convenience init(race: String, name: String) {
        var legs: Int

        if race == "Dog" {
            legs = 4
        } else if race == "Spider" {
            legs = 8
        } else {
            fatalError("Race \(race) needs to be implemented!!")
        }

        // will initialize legCount automatically with correct number of legs if race is implemented
        self.init(race: race, name: name, legCount: legs)
    }
}

使用示例

// default init with all default values used
let myFirstDog = Animal(name: "Bello")

// convenience init for Spider as race
let mySpider = Animal(race: "Spider", name: "Itzy")

// default init with all parameters set by user
let myOctopus = Animal(race: "Octopus", name: "Octocat", legCount: 16)

// convenience init with Fatal error: Race AlienSpecies needs to be implemented!!
let myFault = Animal(race: "AlienSpecies", name: "HelloEarth")

Answer 5

如果您的用例是在同一个类的另一个初始化程序中调用初始化程序，那么这是有道理的。

尝试在操场上这样做

class Player {
    let name: String
    let level: Int

    init(name: String, level: Int) {
        self.name = name
        self.level = level
    }
    
    init(name: String) {
        self.init(name: name, level: 0) //<- Call the initializer above?

        //Sorry you can't do that. How about adding a convenience keyword?
    }
}

Player(name:"LoseALot")

使用方便关键字

class Player {
    let name: String
    let level: Int

    init(name: String, level: Int) {
        self.name = name
        self.level = level
    }
    
    //Add the convenience keyword
    convenience init(name: String) {
        self.init(name: name, level: 0) //Yes! I am now allowed to call my fellow initializer!
    }
}

如果你想通过扩展一个类型来创建你自己的自定义初始化器，这也很有用。

class Player {
    let name: String
    let level: Int

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

extension Player {
    convenience init(name: String) {
        self.init(name: name, level: 0) 
    }
}

Answer 6

便利初始化器可以在类扩展中定义。但一个标准的 - 不能。

Answer 7

这convenience init使得用值初始化一个类是可选的。

Answer 8

注：阅读全文

指定初始化器是类的主要初始化器。指定的初始化程序完全初始化该类引入的所有属性，并调用适当的超类初始化程序以继续初始化过程直到超类链。

便利初始化器是次要的，支持类的初始化器。您可以定义一个便利初始化程序，以从与便利初始化程序相同的类调用指定初始化程序，并将一些指定初始化程序的参数设置为默认值。

类的指定初始化器的编写方式与值类型的简单初始化器相同：

init(parameters) {
statements
}

便利初始化器以相同的风格编写，但便利修饰符放在 init 关键字之前，用空格分隔：

convenience init(parameters) {
statements
}

一个实际的例子如下：

class Food {
var name: String
init(name: String) {
    self.name = name
}
convenience init() {
    self.init(name: "[Unnamed]")
}
}
let namedMeat = Food(name: "Bacon")
// namedMeat's name is "Bacon”

Food 类的 init(name: String) 初始化程序作为指定初始化程序提供，因为它确保新 Food 实例的所有存储属性都已完全初始化。Food 类没有超类，因此 init(name: String) 初始化程序不需要调用 super.init() 来完成其初始化。

“Food 类还提供了一个方便的初始化程序 init()，没有参数。init() 初始化程序通过委托给 Food 类的 init(name: String) 为新食物提供默认占位符名称，名称值为 [Unnamed]：”</p>

“let mysteryMeat = Food()
// mysteryMeat's name is "[Unnamed]”

层次结构中的第二个类是 Food 的子类，称为 RecipeIngredient。RecipeIngredient 类对烹饪食谱中的成分进行建模。它引入了一个称为数量的 Int 属性（除了它从 Food 继承的 name 属性）并定义了两个用于创建 RecipeIngredient 实例的初始化程序：

class RecipeIngredient: Food {
var quantity: Int
init(name: String, quantity: Int) {
    self.quantity = quantity
    super.init(name: name)
}
override convenience init(name: String) {
    self.init(name: name, quantity: 1)
}
}

RecipeIngredient 类有一个指定的初始值设定项 init(name: String, quantity: Int)，可用于填充新 RecipeIngredient 实例的所有属性。此初始化程序首先将传递的数量参数分配给数量属性，这是 RecipeIngredient 引入的唯一新属性。这样做之后，初始化程序委托给 Food 类的 init(name: String) 初始化程序。

页码：536 摘自：Apple Inc. “Swift 编程语言 (Swift 4)。” 电子书。https://itunes.apple.com/pk/book/the-swift-programming-language-swift-4-0-3/id881256329?mt=11

Answer 9

因此，当您不需要为类指定每个属性时，它会派上用场。因此，例如，如果我想创建起始 HP 值为 100 的所有冒险，我将使用以下便利 init并添加一个名称。这将大大减少代码。

class Adventure { 

// Instance Properties

    var name: String
    var hp: Int
    let maxHealth: Int = 100

    // Optionals

    var specialMove: String?

    init(name: String, hp: Int) {

        self.name = name
        self.hp = hp
    }

    convenience init(name: String){
        self.init(name: name, hp: 100)
    }
}

Answer 10

所有的答案听起来都不错，但是，让我们用一个简单的例子来理解它

class X{                                     
   var temp1
   init(a: Int){
        self.temp1 = a
       }

现在，我们知道一个类可以继承另一个类，所以

class Z: X{                                     
   var temp2
   init(a: Int, b: Int){
        self.temp2 = b
        super.init(a: a)
       }

现在，在这种情况下，在为类 Z 创建实例时，您必须同时提供值“a”和“b”。

let z = Z(a: 1, b: 2)

但是，如果您只想传递 b 的值并希望 rest 为其他人取默认值，那么在这种情况下，您需要将其他值初始化为默认值。但是等一下怎么办？，因为你只需要在课堂上把它设置好。

//This is inside the class Z, so consider it inside class Z's declaration
convenience init(b: Int){
    self.init(a: 0, b: b)
}
convenience init(){
    self.init(a: 0, b: 0)
}

现在，您可以创建类 Z 的实例，并为变量提供一些、全部或无值。

let z1 = Z(b: 2)
let z2 = Z()