Come hanno init multipla() con Swift

Question

E 'possibile, se sì come, per avere init multipla senza parametri, in una classe come questa (la stringa è solo un exemple):

aVar: String 

init() { 
    aVar = "simple init" 
} 

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

initWithFooBar() { 
    aVar = "Foo Bar" 
} 

Answer 1

non si può avere più init s senza parametri in quanto sarebbe ambiguo che init metodo si voleva uso. In alternativa è possibile passare i valori iniziali al metodo init. Prendendo l'esempio dalla tua domanda:

class MyClass { 
    var myString: String 

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

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

Oppure, se myString si suppone essere solo determinati valori, si potrebbe usare un 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

Si può avere init diverso con diversa parameters.When si crea una nuova istanza della classe, il metodo init viene chiamato con gli argomenti avete passato

Answer 3

La sua non è possibile avere init multipla, prendendo lo stesso (o no) param.

Ma se siete alla ricerca di un modo per costruire oggetti con gli stati predefiniti, si può usare statici metodi di fabbrica:

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

Il initWithSomething è uno stile di Objective-C, e non funzionerà esattamente come quello in Swift.

In Swift, tutti gli inizializzatori sono chiamati init e possono facoltativamente richiedere alcuni parametri.

È possibile utilizzare i valori di default in questo modo:

class Example { 
    var aVar: String 

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

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

Tuttavia, questo approccio non funzionerà esattamente come nel tuo esempio, perché una volta che si introduce il secondo metodo init, è ambigua, che si voleva:

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… 

Un approccio migliore potrebbe essere quella di utilizzare Swift della 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" 

Questo approccio fornirà la flessibilità che desideri utilizzando la normale sintassi Swift.