Swift Language
Initialiseurs

Définition des valeurs de propriété par défaut

Vous pouvez utiliser un initialiseur pour définir les valeurs de propriété par défaut:

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

Ou, spécifiez les valeurs de propriété par défaut dans le cadre de la déclaration de la propriété:

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

Les classes et les structures doivent définir toutes les propriétés stockées sur une valeur initiale appropriée au moment de la création d'une instance. Cet exemple ne sera pas compilé, car l'initialiseur n'a pas donné de valeur initiale pour les downvotes :

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

Personnalisation de l'initialisation avec les paramètres

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

Notez que vous ne pouvez pas omettre les étiquettes de paramètre:

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

Pour permettre l’omission des étiquettes de paramètres, utilisez un trait de soulignement _ comme étiquette:

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

Si vos étiquettes d'argument partagent des noms avec une ou plusieurs propriétés, utilisez self pour définir explicitement les valeurs de propriété:

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

Commencement init

Les classes Swift prennent en charge plusieurs manières d'être initialisées. Suivant les spécifications d'Apple, ces 3 règles doivent être respectées:

1. Un initialiseur désigné doit appeler un initialiseur désigné à partir de sa super-classe immédiate.
2. Un initialiseur de commodité doit appeler un autre initialiseur de la même classe.
3. Un initialiseur de commodité doit finalement appeler un initialiseur désigné.

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

Initialiseur désigné

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

Commodité init ()

let a = Foo()

Init initiale (otherString: String)

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

Initialisateur désigné (appellera l'initialiseur désigné de la superclasse)

let d = Baz(someFloat: 3)

Commodité init ()

let e = Baz()

Source d'image: La langue de programmation Swift

Lanceur Jetable

Utilisation de la gestion des erreurs pour créer un initialiseur Struct (ou de classe) en tant qu'initialiseur pouvant être lancé:

Exemple de gestion des erreurs enum:

enum ValidationError: Error {
    case invalid
}

Vous pouvez utiliser l'énumération de gestion des erreurs pour vérifier le paramètre de la structure (ou de la classe) répondant aux exigences requises

struct User {
    let name: String

    init(name: String?) throws {

        guard let name = name else { 
           ValidationError.invalid
        }

        self.name = name
    }
}

Maintenant, vous pouvez utiliser l'initialiseur lancable par:

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