Swift Language
Initialisierer

Standardeigenschaftswerte festlegen

Sie können einen Initialisierer verwenden, um Standardeigenschaftswerte festzulegen:

struct Example {
    var upvotes: Int
    init() {
        upvotes = 42
    }
}
let myExample = Example() // call the initializer
print(myExample.upvotes) // prints: 42

Oder geben Sie Standardeigenschaftswerte als Teil der Deklaration der Eigenschaft an:

struct Example {
    var upvotes = 42 // the type 'Int' is inferred here
}

Klassen und Strukturen müssen alle gespeicherten Eigenschaften zum Zeitpunkt der Erstellung einer Instanz auf einen geeigneten Anfangswert setzen. Dieses Beispiel wird nicht kompiliert, da der Initialisierer keinen Startwert für downvotes :

struct Example {
    var upvotes: Int
    var downvotes: Int
    init() {
         upvotes = 0
    } // error: Return from initializer without initializing all stored properties
}

Initialisierung mit Parametern anpassen

struct MetricDistance {
    var distanceInMeters: Double

    init(fromCentimeters centimeters: Double) {
        distanceInMeters = centimeters / 100
    }
    init(fromKilometers kilos: Double) {
        distanceInMeters = kilos * 1000
    }
}

let myDistance = MetricDistance(fromCentimeters: 42)
// myDistance.distanceInMeters is 0.42
let myOtherDistance = MetricDistance(fromKilometers: 42)
// myOtherDistance.distanceInMeters is 42000

Beachten Sie, dass Sie die Parameterbezeichnungen nicht weglassen können:

let myBadDistance = MetricDistance(42) // error: argument labels do not match any available overloads

Um das Auslassen von Parameterbezeichnungen zu ermöglichen, verwenden Sie einen Unterstrich _ als Bezeichnung:

struct MetricDistance {
    var distanceInMeters: Double
    init(_ meters: Double) {
        distanceInMeters = meters
    }
}
let myDistance = MetricDistance(42) // distanceInMeters = 42

Wenn Ihre Argumentbeschriftungen Namen mit einer oder mehreren Eigenschaften teilen, verwenden Sie self , um die Eigenschaftenwerte explizit festzulegen:

struct Color {
    var red, green, blue: Double
    init(red: Double, green: Double, blue: Double) {
        self.red = red
        self.green = green
        self.blue = blue
    }
}

Convenience init

Swift-Klassen unterstützen mehrere Initialisierungsmöglichkeiten. Nach den Spezifikationen von Apple müssen diese 3 Regeln beachtet werden:

1. Ein ausgewiesener Initialisierer muss einen bestimmten Initialisierer von seiner unmittelbaren Oberklasse aufrufen.
2. Ein praktischer Initialisierer muss einen anderen Initialisierer derselben Klasse aufrufen.
3. Ein komfortabler Initialisierer muss schließlich einen festgelegten Initialisierer aufrufen.

class Foo {

    var someString: String
    var someValue: Int
    var someBool: Bool

    // Designated Initializer
    init(someString: String, someValue: Int, someBool: Bool)
    {
        self.someString = someString
        self.someValue = someValue
        self.someBool = someBool
    }

    // A convenience initializer must call another initializer from the same class.
    convenience init()
    {
        self.init(otherString: "")
    }
    
    // A convenience initializer must ultimately call a designated initializer.
convenience init(otherString: String)
    {
        self.init(someString: otherString, someValue:  0, someBool: false)
    }
}


class Baz: Foo
{
    var someFloat: Float
    
    // Designed initializer
    init(someFloat: Float)
    {
        self.someFloat = someFloat
        
        // A designated initializer must call a designated initializer from its immediate superclass.
        super.init(someString: "", someValue: 0, someBool: false)
    }
    
    // A convenience initializer must call another initializer from the same class.
    convenience init()
    {
        self.init(someFloat: 0)
    }
}

Designierter Initialisierer

let c = Foo(someString: "Some string", someValue: 10, someBool: true)

Convenience init ()

let a = Foo()

Convenience-Init (otherString: String)

let b = Foo(otherString: "Some string")

Designated Initializer (benennt den Superklasse Designated Initializer)

let d = Baz(someFloat: 3)

Convenience init ()

let e = Baz()

Bildquelle: Die schnelle Programmiersprache e

Ausstoßbarer Initilizer

Verwenden der Fehlerbehandlung, um den Initialisierer von Struct (oder Klassen) als auslösbaren Initialisierer festzulegen:

Beispiel Fehlerbehandlung enum:

enum ValidationError: Error {
    case invalid
}

Sie können die Fehlerbehandlungs-Enumeration verwenden, um zu überprüfen, ob die Parameter (oder Klasse) die erwartete Anforderung erfüllen

struct User {
    let name: String

    init(name: String?) throws {

        guard let name = name else { 
           ValidationError.invalid
        }

        self.name = name
    }
}

Jetzt können Sie den startbaren Initialisierer verwenden, indem Sie:

do {
   let user = try User(name: "Sample name")
            
   // success
}
catch ValidationError.invalid {
     // handle error
}