Swift Language
inizializzatori

Impostazione dei valori di proprietà predefiniti

È possibile utilizzare un inizializzatore per impostare valori di proprietà predefiniti:

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

Oppure, specifica i valori di proprietà predefiniti come parte della dichiarazione della proprietà:

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

Classi e strutture devono impostare tutte le proprietà archiviate su un valore iniziale appropriato al momento della creazione di un'istanza. Questo esempio non verrà compilato, perché l'inizializzatore non ha fornito un valore iniziale per i downvotes :

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

Personalizzazione dell'inizializzazione con i parametri

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

Nota che non puoi omettere le etichette dei parametri:

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

Per consentire l'omissione delle etichette dei parametri, utilizzare un carattere di sottolineatura _ come etichetta:

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

Se le etichette dei tuoi argomenti condividono nomi con una o più proprietà, usa self per impostare esplicitamente i valori delle proprietà:

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

Convenienza init

Le classi Swift supportano diversi modi di essere inizializzati. Seguendo le specifiche di Apple, queste 3 regole devono essere rispettate:

1. Un inizializzatore designato deve chiamare un inizializzatore designato dalla sua superclasse immediata.
2. Un inizializzatore conveniente deve chiamare un altro inizializzatore dalla stessa classe.
3. Un inizializzatore conveniente deve infine chiamare un inizializzatore designato.

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

Inizializzatore designato

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

Convenienza init ()

let a = Foo()

Convenience init (otherString: String)

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

Inizializzatore designato (chiamerà la superclasse Designated Initializer)

let d = Baz(someFloat: 3)

Convenienza init ()

let e = Baz()

Fonte immagine: The Swift Programming Languag e

Initilizer lanciabile

Utilizzo di Error Handling per rendere l'inizializzatore di Struct (o classe) come inizializzatore lanciabile:

Esempio di errore Gestione enum:

enum ValidationError: Error {
    case invalid
}

È possibile utilizzare enum Gestione errori per verificare il parametro per il requisito previsto di Struct (o classe)

struct User {
    let name: String

    init(name: String?) throws {

        guard let name = name else { 
           ValidationError.invalid
        }

        self.name = name
    }
}

Ora, puoi usare l'iniziatore throwable di:

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