de cadena opcional Swift

Anterior: Cuenta de Swift Automático de referencia (ARC)

cadena opcional (opcional encadenamiento) es una es una manera de solicitar y llama a la propiedad, el enfoque basado en procesos y sub-script llama para la solicitud de destino o puede ser nulo.

de cadena opcional devuelve dos valores:

Si el objetivo tiene un valor, la llamada tiene éxito, el valor de retorno
Si el destino es nulo, la llamada se devuelve nil

Múltiples solicitudes o las llamadas pueden ser vinculados en una cadena, si cualquier nodo es nulo fracaso hará que toda la cadena.

alternativa de cadena opcional determinación forzada

Por propiedades anexas, métodos o secuencia de comandos índice de valor opcional poner un signo de interrogación (?), Se puede definir una cadena opcional.

de cadena opcional '?'	signo de admiración (!) Para forzar métodos de expansión, propiedades, escritura subíndice de cadena opcional
? Un valor opcional colocado en los métodos, propiedades, escritura subíndice después de llamar	! Valor opcional colocado en los métodos de llamada más tarde, las propiedades, la escritura subíndice para expandir los valores obligatorios
Cuando la salida opcional es nula mensajes de error más amigables	Cuando la expansión opcional a cero error de ejecución forzosa

Utilice el signo de exclamación (!) Ejemplos de cadena opcional

class Person {
    var residence: Residence?
}

class Residence {
    var numberOfRooms = 1
}

let john = Person()

//将导致运行时错误
let roomCount = john.residence!.numberOfRooms

La salida por encima de la ejecución del programa es:

fatal error: unexpectedly found nil while unwrapping an Optional value

¿Quieres usar un signo de admiración (!) Para forzar el análisis de este valor numberOfRooms propiedad inmueble persona residencia, se lanzará un error de ejecución, porque entonces no hay ningún valor puede ser utilizada para la residencia resuelto.

Utilice el signo de exclamación (!) Ejemplos de cadena opcional

class Person {
    var residence: Residence?
}

class Residence {
    var numberOfRooms = 1
}

let john = Person()

// 链接可选residence?属性，如果residence存在则取回numberOfRooms的值
if let roomCount = john.residence?.numberOfRooms {
    print("John 的房间号为 \(roomCount)。")
} else {
    print("不能查看房间号")
}

La salida por encima de la ejecución del programa es:

不能查看房间号

Debido a que el funcionamiento de estos intentos numberOfRooms puede fallar, de cadena opcional volverá Int? Tipo de valor, o llamado "Opcional Int". Cuando la residencia estaba vacía cuando (el ejemplo), seleccione Int estará vacío, por lo que no será el caso de numberOfRooms de acceso.

Cabe señalar que incluso numberOfRooms no opcionales Int (Int?) Cuando esto también es cierto. Como siempre que la solicitud es de cadena opcional por medio de un numberOfRooms finales siempre volver Int? En lugar Int.

clase del modelo se define como la cadena opcional

Se puede utilizar una cadena opcional a las propiedades de múltiples llamadas, los métodos y la escritura de índice. Esto le permite utilizar modelos complejos entre ellos para obtener más propiedades subyacentes, y comprobar si puede obtener dicha propiedad subyacente.

Ejemplos

Modelo define cuatro clases, incluyendo la cadena de múltiples opcionales:

class Person {
    var residence: Residence?
}

// 定义了一个变量 rooms，它被初始化为一个Room[]类型的空数组
class Residence {
    var rooms = [Room]()
    var numberOfRooms: Int {
        return rooms.count
    }
    subscript(i: Int) -> Room {
        return rooms[i]
    }
    func printNumberOfRooms() {
        print("房间号为 \(numberOfRooms)")
    }
    var address: Address?
}

// Room 定义一个name属性和一个设定room名的初始化器
class Room {
    let name: String
    init(name: String) { self.name = name }
}

// 模型中的最终类叫做Address
class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if (buildingName != nil) {
            return buildingName
        } else if (buildingNumber != nil) {
            return buildingNumber
        } else {
            return nil
        }
    }
}

Con las llamadas de método de cadena opcional

Método para invocar la configuración alternativa se puede utilizar una cadena opcional y comprobar la llamada al método se ha realizado correctamente. Incluso si este método no devuelve un valor, aún puede utilizar una cadena opcional para lograr este propósito.

class Person {
    var residence: Residence?
}

// 定义了一个变量 rooms，它被初始化为一个Room[]类型的空数组
class Residence {
    var rooms = [Room]()
    var numberOfRooms: Int {
        return rooms.count
    }
    subscript(i: Int) -> Room {
        return rooms[i]
    }
    func printNumberOfRooms() {
        print("房间号为 \(numberOfRooms)")
    }
    var address: Address?
}

// Room 定义一个name属性和一个设定room名的初始化器
class Room {
    let name: String
    init(name: String) { self.name = name }
}

// 模型中的最终类叫做Address
class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if (buildingName != nil) {
            return buildingName
        } else if (buildingNumber != nil) {
            return buildingNumber
        } else {
            return nil
        }
    }
}

let john = Person()


if ((john.residence?.printNumberOfRooms()) != nil) {
    print("输出房间号")
} else {
    print("无法输出房间号")
}

La salida por encima de la ejecución del programa es:

无法输出房间号

Utilice if para comprobar si un exitoso método printNumberOfRooms de llamada: Si la llamada al método tiene éxito a través de una cadena opcional, printNumberOfRooms valor de retorno implícito será el vacío, si no tiene éxito, devuelve nil.

Usando la secuencia de comandos llamada subíndice de cadena opcional

Se puede utilizar una cadena opcional para tratar de obtener el valor de la escritura estándar y examinar la siguiente secuencia de comandos llamada subíndice tiene éxito, sin embargo, no se puede establecer una secuencia de comandos de índice en cadena opcional.

Ejemplo 1

class Person {
    var residence: Residence?
}

// 定义了一个变量 rooms，它被初始化为一个Room[]类型的空数组
class Residence {
    var rooms = [Room]()
    var numberOfRooms: Int {
        return rooms.count
    }
    subscript(i: Int) -> Room {
        return rooms[i]
    }
    func printNumberOfRooms() {
        print("房间号为 \(numberOfRooms)")
    }
    var address: Address?
}

// Room 定义一个name属性和一个设定room名的初始化器
class Room {
    let name: String
    init(name: String) { self.name = name }
}

// 模型中的最终类叫做Address
class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if (buildingName != nil) {
            return buildingName
        } else if (buildingNumber != nil) {
            return buildingNumber
        } else {
            return nil
        }
    }
}

let john = Person()
if let firstRoomName = john.residence?[0].name {
    print("第一个房间名 \(firstRoomName).")
} else {
    print("无法检索到房间")
}

La salida por encima de la ejecución del programa es:

无法检索到房间

La siguiente secuencia de comandos estándar de llamadas de la cadena opcional directamente detrás del signo de interrogación circname.print, la siguiente secuencia de comandos estándar entre paréntesis frente porque circname.print de cadena opcional tratando de obtener el valor opcional.

Ejemplo 2

Ejemplos de casos para crear un john.residence residencia, y una o más instancias de su matriz habitaciones habitación, entonces se puede utilizar la cadena opcional de conseguir habitaciones en la instancia de una matriz mediante una secuencia de comandos Residencia subíndice:

class Person {
    var residence: Residence?
}

// 定义了一个变量 rooms，它被初始化为一个Room[]类型的空数组
class Residence {
    var rooms = [Room]()
    var numberOfRooms: Int {
        return rooms.count
    }
    subscript(i: Int) -> Room {
        return rooms[i]
    }
    func printNumberOfRooms() {
        print("房间号为 \(numberOfRooms)")
    }
    var address: Address?
}

// Room 定义一个name属性和一个设定room名的初始化器
class Room {
    let name: String
    init(name: String) { self.name = name }
}

// 模型中的最终类叫做Address
class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if (buildingName != nil) {
            return buildingName
        } else if (buildingNumber != nil) {
            return buildingNumber
        } else {
            return nil
        }
    }
}

let john = Person()
let johnsHouse = Residence()
johnsHouse.rooms.append(Room(name: "客厅"))
johnsHouse.rooms.append(Room(name: "厨房"))
john.residence = johnsHouse

if let firstRoomName = john.residence?[0].name {
    print("第一个房间名为\(firstRoomName)")
} else {
    print("无法检索到房间")
}

La salida por encima de la ejecución del programa es:

第一个房间名为客厅

Para acceder al índice a través de llamada de enlace opcional

Con la llamada de enlace opcional, podemos utilizar el índice para leer o escribir a un valor opcional, y determina la llamada subíndice se ha realizado correctamente.

Ejemplos

class Person {
    var residence: Residence?
}

// 定义了一个变量 rooms，它被初始化为一个Room[]类型的空数组
class Residence {
    var rooms = [Room]()
    var numberOfRooms: Int {
        return rooms.count
    }
    subscript(i: Int) -> Room {
        return rooms[i]
    }
    func printNumberOfRooms() {
        print("房间号为 \(numberOfRooms)")
    }
    var address: Address?
}

// Room 定义一个name属性和一个设定room名的初始化器
class Room {
    let name: String
    init(name: String) { self.name = name }
}

// 模型中的最终类叫做Address
class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if (buildingName != nil) {
            return buildingName
        } else if (buildingNumber != nil) {
            return buildingNumber
        } else {
            return nil
        }
    }
}

let john = Person()

let johnsHouse = Residence()
johnsHouse.rooms.append(Room(name: "客厅"))
johnsHouse.rooms.append(Room(name: "厨房"))
john.residence = johnsHouse

if let firstRoomName = john.residence?[0].name {
    print("第一个房间名为\(firstRoomName)")
} else {
    print("无法检索到房间")
}

La salida por encima de la ejecución del programa es:

第一个房间名为客厅

El acceso opcional tipo de índice

Si el índice puede devolver tipo de valor nulo, como Swift en el Diccionario de la clave de índice. Puede cerrar el próximo objetivo entre paréntesis después del signo de interrogación para poner un enlace al tema en Valor de retorno vacío:

var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
testScores["Dave"]?[0] = 91
testScores["Bev"]?[0]++
testScores["Brian"]?[0] = 72
// the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81]

El ejemplo anterior define una matriz testScores contiene dos pares de valores clave, la clave de tipo de cadena se asigna a una matriz de enteros.

Este ejemplo llama con un enlace opcional a "Dave" se establece en el primer elemento de la matriz 91, el primer elemento 1 "Bev" matriz, y luego tratar de "Brian" El primer elemento de la matriz se establece en 72 .

Las dos primeras tienen éxito, porque los dos presencia clave. Pero la clave "Brian" en el diccionario no existe, por lo que la tercera llamada falla.

conexión multi-link

Usted puede encadenar múltiples capas pueden opcionalmente estar cavando dentro de las Características del modelo más abajo en los métodos y la escritura de índice. Sin embargo, un multi-cadena opcional se puede añadir valor opcional relación ha vuelto más capas.

Si usted intenta conseguir a través de la cadena de valor Int opcional, independientemente del número de capa de enlace devuelve siempre Int?. Del mismo modo, si se intenta conseguir a través de la cadena opcional Int? Valor, independientemente del número de capa de enlace devuelve siempre Int?.

Ejemplo 1

El siguiente ejemplo intenta obtener las propiedades de residencia de Juan en la dirección de la calle de la propiedad. Tal como se usa en este documento, los dos de cadena opcional para contactar atributos de residencia y dirección, tanto de ellos son de tipo opcional:

class Person {
    var residence: Residence?
}

// 定义了一个变量 rooms，它被初始化为一个Room[]类型的空数组
class Residence {
    var rooms = [Room]()
    var numberOfRooms: Int {
        return rooms.count
    }
    subscript(i: Int) -> Room {
        return rooms[i]
    }
    func printNumberOfRooms() {
        print("房间号为 \(numberOfRooms)")
    }
    var address: Address?
}

// Room 定义一个name属性和一个设定room名的初始化器
class Room {
    let name: String
    init(name: String) { self.name = name }
}

// 模型中的最终类叫做Address
class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if (buildingName != nil) {
            return buildingName
        } else if (buildingNumber != nil) {
            return buildingNumber
        } else {
            return nil
        }
    }
}

let john = Person()

if let johnsStreet = john.residence?.address?.street {
    print("John 的地址为 \(johnsStreet).")
} else {
    print("不能检索地址")
}

La salida por encima de la ejecución del programa es:

不能检索地址

Ejemplo 2

Si establece un ejemplo para la dirección como john.residence.address valor y establece un valor para la dirección de la calle real de la propiedad, puede cadena de múltiples capas para obtener estos valores de atributos opcionales.

class Person {
   var residence: Residence?
}

class Residence {
    
    var rooms = [Room]()
    var numberOfRooms: Int {
        return rooms.count
    }
    subscript(i: Int) -> Room {
        get{
            return rooms[i]
        }
        set {
            rooms[i] = newValue
        }
    }
    func printNumberOfRooms() {
        print("房间号为 \(numberOfRooms)")
    }
    var address: Address?
}

class Room {
    let name: String
    init(name: String) { self.name = name }
}

class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if (buildingName != nil) {
            return buildingName
        } else if (buildingNumber != nil) {
            return buildingNumber
        } else {
            return nil
        }
    }
}
let john = Person()
john.residence?[0] = Room(name: "浴室")

let johnsHouse = Residence()
johnsHouse.rooms.append(Room(name: "客厅"))
johnsHouse.rooms.append(Room(name: "厨房"))
john.residence = johnsHouse

if let firstRoomName = john.residence?[0].name {
    print("第一个房间是\(firstRoomName)")
} else {
    print("无法检索房间")
}

La salida del ejemplo anterior es:

第一个房间是客厅

Función opcional del valor del enlace de retorno

También podemos llamar al método devuelve un valor nulo por un enlace opcional, y se puede continuar en el enlace de configuración alternativa.

Ejemplos

class Person {
    var residence: Residence?
}

// 定义了一个变量 rooms，它被初始化为一个Room[]类型的空数组
class Residence {
    var rooms = [Room]()
    var numberOfRooms: Int {
        return rooms.count
    }
    subscript(i: Int) -> Room {
        return rooms[i]
    }
    func printNumberOfRooms() {
        print("房间号为 \(numberOfRooms)")
    }
    var address: Address?
}

// Room 定义一个name属性和一个设定room名的初始化器
class Room {
    let name: String
    init(name: String) { self.name = name }
}

// 模型中的最终类叫做Address
class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if (buildingName != nil) {
            return buildingName
        } else if (buildingNumber != nil) {
            return buildingNumber
        } else {
            return nil
        }
    }
}

let john = Person()

if john.residence?.printNumberOfRooms() != nil {
    print("指定了房间号)")
}  else {
    print("未指定房间号")
}

La salida por encima de la ejecución del programa es:

未指定房间号

Anterior: Cuenta de Swift Automático de referencia (ARC)

Siguiente: Conversión de tipos Swift

Swift curso

de cadena opcional Swift

alternativa de cadena opcional determinación forzada

Utilice el signo de exclamación (!) Ejemplos de cadena opcional

Utilice el signo de exclamación (!) Ejemplos de cadena opcional

clase del modelo se define como la cadena opcional

Ejemplos

Con las llamadas de método de cadena opcional

Usando la secuencia de comandos llamada subíndice de cadena opcional

Ejemplo 1

Ejemplo 2

Para acceder al índice a través de llamada de enlace opcional

Ejemplos

El acceso opcional tipo de índice

conexión multi-link

Ejemplo 1

Ejemplo 2

Función opcional del valor del enlace de retorno

Ejemplos