Swift Language
Initializers

Ställer in standardegenskapsvärden

Du kan använda en initialisator för att ställa in standardegenskaper för värden:

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

Eller ange standardegenskapsvärden som en del av egenskapens deklaration:

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

Klasser och strukturer måste ställa in alla lagrade egenskaper till ett lämpligt initialvärde när en instans skapas. Det här exemplet kommer inte att kompilera, eftersom initialiseraren inte gav ett initialt värde för downvotes :

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

Anpassa initialisering med paramatrar

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

Observera att du inte kan utelämna parameteretiketterna:

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

För att tillåta utelämnande av parameteretiketter, använd en understruk _ som etikett:

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

Om dina argumentetiketter delar namn med en eller flera egenskaper, använd self att uttryckligen ange egenskapens värden:

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

Bekvämlighet init

Snabbklasser stöder flera olika sätt att initieras. Efter Apples specifikationer måste dessa 3 regler respekteras:

1. En utsedd initialisering måste ringa en utsedd initialisator från sin omedelbara superklass.
2. En bekvämhetsinitierare måste ringa en annan initierare från samma klass.
3. En bekvämlighetsinitierare måste i slutändan ringa en utsedd initialisator.

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

Designated Initializer

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

Bekvämlighet init ()

let a = Foo()

Convenience init (otherString: String)

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

Designated Initializer (kommer att kalla superklassen Designated Initializer)

let d = Baz(someFloat: 3)

Bekvämlighet init ()

let e = Baz()

Bildkälla: The Swift Programming Languag e

Kastbar initilizer

Använda felhantering för att göra struktur (eller klass) initialiserare som kastbar initialisator:

Exempel Felhantering enum:

enum ValidationError: Error {
    case invalid
}

Du kan använda felhantering enum för att kontrollera parametern för att strukturen (eller klassen) uppfyller förväntat krav

struct User {
    let name: String

    init(name: String?) throws {

        guard let name = name else { 
           ValidationError.invalid
        }

        self.name = name
    }
}

Nu kan du använda kasta initialiseraren genom att:

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