Swift Language
initialiseerders

Standaard eigenschapswaarden instellen

U kunt een initialisatie gebruiken om standaardeigenschapswaarden in te stellen:

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

Of geef standaardeigenschapswaarden op als onderdeel van de verklaring van de eigenschap:

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

Klassen en structs moeten alle opgeslagen eigenschappen instellen op een geschikte beginwaarde tegen de tijd dat een exemplaar wordt gemaakt. Dit voorbeeld compileert niet, omdat de initialisatie geen beginwaarde heeft gegeven voor downvotes :

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

Initialisatie aanpassen met paramaters

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

Merk op dat u de parameterlabels niet kunt weglaten:

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

Om het weglaten van parameterlabels toe te staan, gebruikt u een onderstrepingsteken _ als het label:

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

Als uw argumentlabels namen delen met een of meer eigenschappen, gebruikt u self om de eigenschapswaarden expliciet in te stellen:

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

Gemak init

Swift-klassen ondersteunen meerdere manieren om te worden geïnitialiseerd. Volgens de specificaties van Apple moeten deze 3 regels worden gerespecteerd:

1. Een aangewezen initializer moet een aangewezen initializer uit zijn directe superklasse oproepen.
2. Een gemakkelijke initialisatie moet een andere initialisatie uit dezelfde klasse aanroepen.
3. Een gemakkelijke initialisatie moet uiteindelijk een aangewezen initialisatie oproepen.

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)
    }
}

Aangewezen initialisatie

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

Gemak init ()

let a = Foo()

Gemak init (otherString: String)

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

Designated Initializer (noemt de superklasse Designated Initializer)

let d = Baz(someFloat: 3)

Gemak init ()

let e = Baz()

Afbeeldingsbron: The Swift Programming Languag e

Throwable Initilizer

Foutafhandeling gebruiken om Struct (of klasse) initializer als throwable initializer te maken:

Voorbeeldfoutafhandeling enum:

enum ValidationError: Error {
    case invalid
}

U kunt Error Handling enum gebruiken om te controleren of de parameter voor de Struct (of klasse) voldoet aan de verwachte vereiste

struct User {
    let name: String

    init(name: String?) throws {

        guard let name = name else { 
           ValidationError.invalid
        }

        self.name = name
    }
}

U kunt nu gooibare initialisatie gebruiken door:

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