Jak mieć wiele init() z Swift

Question

Czy to możliwe, jeśli tak to w jaki sposób, aby mieć wiele init, bez parametru, w klasie tak (ciąg jest tylko exemple):

aVar: String 

init() { 
    aVar = "simple init" 
} 

initWithAGoodVar() { 
    aVar = "Good Var!" 
} 

initWithFooBar() { 
    aVar = "Foo Bar" 
} 

Answer 1

nie można mieć wiele init S bez parametrów, ponieważ byłoby dwuznaczne który init sposób chciałeś posługiwać się. Alternatywnie można przekazać wartości początkowe do metody init. Biorąc przykład z pytaniem:

class MyClass { 
    var myString: String 

    init(myString: String) { 
     self.myString = myString 
    } 
} 

let a = MyClass(myString: "simple init") 

lub, jeśli myString ma być pewne wartości tylko, można użyć enum:

class MyOtherClass { 
    enum MyEnum: String { 
     case Simple = "Simple" 
     case GoodVar = "GoodVar" 
     case FooBar = "FooBar" 
    } 

    var myString: String 

    init(arg: MyEnum) { 
     myString = arg.rawValue 
    } 
} 

let b = MyOtherClass(arg: .GoodVar) 
println(b.myString) // "GoodVar" 

Answer 2

Możesz mieć utworzyć nową instancję klasy różni startowych z różnymi parameters.When, metoda init wywoływana z argumentami zdałeś w

Answer 3

jej nie możliwe aby mieć wiele init, biorąc taka sama (lub nie) params.

Ale jeśli szukasz sposobu na budowę obiektów z predefiniowanych stanów, można użyć metody statyczne fabryki:

class Test { 

    let aVar: String 

    init(aVar: String) { 
    self.aVar = aVar 
    } 

    static func initWithAGoodVar() -> Test { 
    return Test(aVar: "Good Var!") 
    } 

    static func initWithFooBar() -> Test { 
    return Test(aVar: "Foo Bar") 
    } 
} 

let test = Test.initWithFooBar() 
println(test.aVar) // Prints: "Foo Bar" 

Answer 4

initWithSomething jest styl Objective-C, a to nie będzie działać dokładnie tak jak to w Swift.

W Swift wszystkie inicjalizatory są nazywane init i mogą opcjonalnie przyjmować niektóre parametry.

Można użyć wartości domyślnych tak:

class Example { 
    var aVar: String 

    init(goodVar : String = "Good Var!") { 
     aVar = goodVar 
    } 
} 

let example1 = Example() 
println(example1.aVar) // prints "Good Var!" 

Jednak takie podejście nie będzie działać dokładnie tak, jak w przykładzie, ponieważ po wprowadzić drugą metodę init, jest niejednoznaczna, który chciałeś:

class Example { 
    var aVar: String 

    init(goodVar : String = "Good Var!") { 
     aVar = goodVar 
    } 

    init(fooBar : String = "Foo Bar") { 
     aVar = fooBar 
    } 
} 

let example1 = Example() // error: cannot invoke initializer… 

lepszym rozwiązaniem może być użycie Swift enum:

class Example { 
    enum ExampleType : String { 
     case GoodVar = "Good Var!" 
     case FooBar = "Foo Bar" 
    } 

    var aVar: String 

    init(type : ExampleType) { 
     aVar = type.rawValue 
    } 
} 

let example1 = Example(type: .GoodVar) 
println(example1.aVar) // "Good Var!" 

let example2 = Example(type: .FooBar) 
println(example2.aVar) // "Foo Bar" 

Takie podejście zapewni elastyczność, której potrzebujesz, używając normalnej składni Swift.