Swift Language
Inicializadores

Establecer valores de propiedad predeterminados

Puede usar un inicializador para establecer valores de propiedad predeterminados:

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

O, especifique valores de propiedad predeterminados como parte de la declaración de la propiedad:

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

Las clases y las estructuras deben establecer todas las propiedades almacenadas en un valor inicial adecuado en el momento en que se crea una instancia. Este ejemplo no se compilará, porque el inicializador no dio un valor inicial para downvotes :

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

Personalización de inicialización con paramatizadores.

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

Tenga en cuenta que no puede omitir las etiquetas de parámetros:

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

Para permitir la omisión de etiquetas de parámetros, use un guión bajo _ como la etiqueta:

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

Si las etiquetas de sus argumentos comparten nombres con una o más propiedades, use self para establecer explícitamente los valores de propiedad:

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

Conveniencia inic

Las clases de Swift admiten tener múltiples formas de inicializarse. Siguiendo las especificaciones de Apple, estas 3 reglas deben ser respetadas:

1. Un inicializador designado debe llamar a un inicializador designado desde su superclase inmediata.
2. Un inicializador de conveniencia debe llamar a otro inicializador de la misma clase.
3. Un inicializador de conveniencia debe finalmente llamar a un inicializador designado.

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

Inicializador designado

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

Inicia conveniencia ()

let a = Foo()

Convenience init (otherString: String)

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

Inicializador designado (llamará al inicializador designado de superclase)

let d = Baz(someFloat: 3)

Inicia conveniencia ()

let e = Baz()

Fuente de la imagen: The Swift Programming Languag e

Iniciador Throwable

Uso del manejo de errores para hacer el inicializador Struct (o clase) como inicializador lanzable:

Ejemplo de manejo de errores enumeración:

enum ValidationError: Error {
    case invalid
}

Puede usar la enumeración de manejo de errores para verificar que el parámetro de Struct (o clase) cumpla con el requisito esperado

struct User {
    let name: String

    init(name: String?) throws {

        guard let name = name else { 
           ValidationError.invalid
        }

        self.name = name
    }
}

Ahora, puedes usar inicializador lanzable por:

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