Swift Language
Inicjatory

Ustawianie domyślnych wartości właściwości

Za pomocą inicjatora można ustawić domyślne wartości właściwości:

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

Lub określ domyślne wartości właściwości jako część deklaracji właściwości:

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

Do czasu utworzenia instancji klasy i struktury muszą ustawić wszystkie przechowywane właściwości na odpowiednią wartość początkową. Ten przykład nie zostanie skompilowany, ponieważ inicjator nie podał wartości początkowej dla downvotes :

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

Dostosowywanie inicjalizacji za pomocą parametrów

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

Pamiętaj, że nie można pominąć etykiet parametrów:

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

Aby umożliwić pominięcie etykiet parametrów, użyj podkreślenia _ jako etykiety:

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

Jeśli etykiety argumentów mają wspólne nazwy z jedną lub więcej właściwości, użyj self aby jawnie ustawić wartości właściwości:

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

Wygodna inicjacja

Klasy Swift obsługują wiele sposobów inicjalizacji. Zgodnie ze specyfikacjami Apple należy przestrzegać 3 zasad:

1. Wyznaczony inicjator musi wywołać wyznaczony inicjator z jego bezpośredniej nadklasy.
2. Inicjator wygody musi wywoływać inny inicjator z tej samej klasy.
3. Inicjator wygody musi ostatecznie wywołać wyznaczony inicjator.

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

Wyznaczony inicjator

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

Wygoda init ()

let a = Foo()

Wygoda init (otherString: String)

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

Wyznaczony inicjator (wywoła superklasę Wyznaczony inicjator)

let d = Baz(someFloat: 3)

Wygoda init ()

let e = Baz()

Źródło obrazu: The Swift Programming Languag e

Inicjator Throwable

Użycie obsługi błędów do zainicjowania Struct (lub class) jako inicjalizatora możliwego do rzucania:

Przykładowy błąd obsługi wyliczenia:

enum ValidationError: Error {
    case invalid
}

Można użyć wyliczenia obsługi błędów, aby sprawdzić, czy parametr struktury (lub klasy) spełnia oczekiwane wymagania

struct User {
    let name: String

    init(name: String?) throws {

        guard let name = name else { 
           ValidationError.invalid
        }

        self.name = name
    }
}

Teraz możesz użyć inicjalizatora wrzucanego przez:

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