catena opzionale Swift
catena opzionale (opzionale concatenamento) è un è un modo di richiedere e chiama la proprietà, l'approccio per processi e sub-script chiama per la richiesta di destinazione o possono essere nullo.
catena opzionale restituisce due valori:
Se il bersaglio ha un valore, la chiamata riesce, il valore di ritorno
Se il bersaglio è pari a zero, la chiamata tornerà a zero
richieste multiple o chiamate possono essere collegati in una catena, se qualsiasi nodo è guasto nullo causerà l'intera catena.
catena alternativa opzionale determinazione forzata
Di proprietà di aggiungere dati, metodi o opzionale copione indice valore messo un punto interrogativo (?), È possibile definire una catena opzionale.
| catena opzionale '?' | Punto esclamativo (!) Per forzare i metodi di espansione, le proprietà, lo script pedice catena opzionale |
| ? Un valore opzionale posto sul metodi, proprietà, lo script pedice successivamente chiamando | ! Valore facoltativo collocati sui metodi di chiamata più tardi, le proprietà, lo script pedice per espandere valori obbligatori |
| Quando l'uscita opzionale è pari a zero i messaggi di errore più amichevole | Quando l'espansione opzionale a zero forzata errore di esecuzione |
Utilizzare il punto esclamativo (!) Esempi di catena opzionale
class Person {
var residence: Residence?
}
class Residence {
var numberOfRooms = 1
}
let john = Person()
//将导致运行时错误
let roomCount = john.residence!.numberOfRooms
L'output sopra l'esecuzione del programma è il seguente:
fatal error: unexpectedly found nil while unwrapping an Optional valueVuoi usare un punto esclamativo (!) Per forzare l'analisi di questo valore numberOfRooms degli immobili di proprietà persona residenza, getterà un errore di runtime, perché allora non vi è alcun valore può essere utilizzato per la residenza risolto.
Utilizzare il punto esclamativo (!) Esempi di catena opzionale
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("不能查看房间号")
}
L'output sopra l'esecuzione del programma è il seguente:
不能查看房间号
Poiché il funzionamento questi tentativi numberOfRooms potrebbe non riuscire, a catena opzionale tornerà Int? Valore di Tipo, o chiamato "opzionale Int". Quando la residenza era vuoto quando (l'esempio), selezionare Int sarà vuota, quindi non ci sarà il caso di numberOfRooms di accesso.
Va notato che anche numberOfRooms non opzionali Int (Int?) Quando questo è anche vero. Fintanto che la richiesta è catena opzionale tramite un numberOfRooms finali sempre tornare Int? Invece Int.
classe del modello è definito come la catena opzionale
È possibile utilizzare una catena opzionale multi-proprietà di chiamata, i metodi e lo script indice. Ciò consente di utilizzare modelli complessi tra loro per ottenere più proprietà sottostanti, e verificare se è possibile ottenere tali proprietà sottostante.
Esempi
Modello definisce quattro classi, tra cui la catena multi-opzionale:
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 le chiamate di metodo a catena opzionale
Metodo per richiamare le impostazioni alternativi è possibile utilizzare una catena opzionale e verificare la chiamata al metodo ha avuto successo. Anche se questo metodo non restituisce un valore, è comunque possibile utilizzare una catena opzionale per raggiungere questo scopo.
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("无法输出房间号")
}
L'output sopra l'esecuzione del programma è il seguente:
无法输出房间号
Utilizzare if per verificare se un metodo printNumberOfRooms chiamata riuscita: se la chiamata al metodo riesce attraverso una catena opzionale, printNumberOfRooms valore di rendimento implicito sarà il Vuoto, se non di successo, restituisce zero.
Usare lo script chiamata pedice catena opzionale
È possibile utilizzare una catena opzionale per cercare di ottenere il valore dallo script standard ed esaminare la prossima sceneggiatura chiamata indice è successo, però, non è possibile impostare uno script indice a catena opzionale.
esempio 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("无法检索到房间")
}
L'output sopra l'esecuzione del programma è il seguente:
无法检索到房间
Lo script di qualità accanto chiama la catena opzionale direttamente dietro circname.print punto interrogativo, la prossima sceneggiatura di serie tra parentesi davanti perché circname.print catena opzionale cercando di ottenere il valore opzionale.
esempio 2
Esempi di casi per creare un john.residence Residence, e una o più istanze della sua gamma camere Camera, quindi è possibile utilizzare la catena opzionale per ottenere camere nell'istanza array di script Residence pedice:
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("无法检索到房间")
}
L'output sopra l'esecuzione del programma è il seguente:
第一个房间名为客厅
Per accedere all'indice tramite chiamata collegamento opzionale
Con la chiamata collegamento opzionale, è possibile utilizzare l'indice per leggere o scrivere un valore opzionale, e determina la chiamata pedice ha avuto successo.
Esempi
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("无法检索到房间")
}
L'output sopra l'esecuzione del programma è il seguente:
第一个房间名为客厅
L'accesso di tipo opzionale dell'indice
Se l'indice può restituire tipo di valore nullo, come Swift nel Dizionario dell'indice chiave. È possibile chiudere il prossimo obiettivo tra parentesi dopo il punto di domanda per mettere un link al soggetto sotto vuoto Valore di ritorno:
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]
L'esempio di cui sopra definisce una matrice testScores contiene due coppie chiave-valore, la chiave di tipo string è mappata a un array di interi.
Questo esempio chiama con un collegamento opzionale a "Dave" è impostato al primo elemento della matrice 91, il primo elemento +1 "Bev" array, e quindi provare a "Brian" Il primo elemento della matrice è impostata su 72 .
Le prime due chiamate hanno successo, perché i due presenza chiave. Ma la chiave "Brian" nel dizionario non esiste, quindi la terza chiamata non è riuscita.
collegamento multi-link
È possibile concatenare più livelli opzionalmente possono essere scavando all'interno delle proprietà modello più in basso i metodi e lo script indice. Tuttavia, un multi-catena opzionale può aggiungere rapporto di valore opzionale è tornato più strati.
Se si tenta di ottenere attraverso la catena del valore Int opzionale, indipendentemente dal numero di link layer restituisce sempre Int?. Allo stesso modo, se si tenta di ottenere attraverso la catena opzionale Int? Valore, indipendentemente dal numero di link layer restituisce sempre Int?.
esempio 1
L'esempio seguente tenta di ottenere le proprietà residenza di Giovanni nel indirizzo della proprietà. Nel presente, i due catena opzionale per contattare gli attributi di residenza e indirizzo, entrambi sono di tipo opzionale:
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("不能检索地址")
}
L'output sopra l'esecuzione del programma è il seguente:
不能检索地址
esempio 2
Se si imposta un esempio per l'indirizzo come john.residence.address valore e impostare un valore per l'indirizzo effettivo via della proprietà, è possibile catena più livelli per ottenere questo i valori degli attributi opzionali.
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("无法检索房间")
}
L'output sopra esempio è:
第一个房间是客厅
Funzione facoltativa del valore del collegamento di ritorno
Possiamo anche chiamare il metodo restituisce un valore nullo da un collegamento opzionale, e si può continuare a sul link impostazioni alternative.
Esempi
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("未指定房间号")
}
L'output sopra l'esecuzione del programma è il seguente:
未指定房间号