Swift opcjonalnie łańcucha
Opcjonalny łańcuch (opcja Łańcuch) jest to sposób na żądania i wywołuje nieruchomości, podejście procesowe i sub-skrypt wymaga wniosku docelowego lub może być zerowa.
Opcjonalny łańcuch zwraca dwie wartości:
Jeśli cel ma wartość, wywołanie się powiedzie, wartości zwracanej
Jeśli cel jest zerowa, wywołanie zwróci nil
Wielokrotne prośby lub połączenia mogą być połączone w łańcuch, jeśli węzeł jest zerowa awaria spowoduje cały łańcuch.
Opcjonalny alternatywny łańcuch zmuszony rozwiązać
Załączonych przez właściwości, metod, lub opcjonalnie skrypt indeksu wartości stawiają pod znakiem zapytania (?), Można zdefiniować opcjonalny łańcuch.
| Opcjonalny łańcuch '?' | Wykrzyknik (!) Aby wymusić metod rozszerzeń, właściwości, indeks skrypt opcjonalnie łańcucha |
| ? Opcjonalna wartość umieszczona na później wywoływanie metod, właściwości, skrypt indeksem | ! Wartość Opcjonalnie umieszczone na późniejszych metod telefonicznych, właściwości, skrypt indeks rozszerzyć wartości obowiązkowe |
| Gdy opcjonalne wyjście jest zerowa bardziej przyjaznych komunikatów o błędach | Gdy opcjonalne rozszerzenie do zera zmuszony błędu wykonania |
Użyj wykrzyknik (!) Przykłady ewentualnego łańcucha
class Person {
var residence: Residence?
}
class Residence {
var numberOfRooms = 1
}
let john = Person()
//将导致运行时错误
let roomCount = john.residence!.numberOfRooms
Wyjście powyżej wykonywanie programu jest:
fatal error: unexpectedly found nil while unwrapping an Optional valueChcesz skorzystać wykrzyknik (!) Aby wymusić analizowania tej osoby przebywania wartości nieruchomości numberOfRooms własności, to wyrzucić błąd wykonania, bo wtedy nie ma wartości mogą być wykorzystane do zamieszkania rozwiązany.
Użyj wykrzyknik (!) Przykłady ewentualnego łańcucha
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("不能查看房间号")
}
Wyjście powyżej wykonywanie programu jest:
不能查看房间号
Ponieważ praca tych prób numberOfRooms może zakończyć się niepowodzeniem, opcjonalnie łańcuch powróci Int? Wartość Typ lub nazwie "Opcjonalnie Int". Gdy rezydencja była pusta, kiedy (na przykładzie), wybierz Int będzie pusta, więc nie będzie przypadek numberOfRooms dostępu.
Należy zauważyć, że nawet nie opcjonalne numberOfRooms Int (int?), gdy jest to prawdziwe. Dopóki wniosek jest opcjonalny łańcuch za pomocą końcowych numberOfRooms zawsze zwraca Int? Zamiast Int.
Klasa modelu określa się jako opcjonalny łańcucha
Można użyć opcjonalnego łańcuch do właściwości wielu połączeń, metod i skrypt indeksu. To pozwala na użycie skomplikowanych modeli między nimi, aby uzyskać więcej właściwości bazowych, i sprawdzić, czy można uzyskać taką podstawową właściwość.
Przykłady
Model definiuje cztery klasy, w tym wielu opcjonalnym łańcucha:
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
}
}
}
Dzięki opcjonalnemu łańcucha wywołań metod
Sposób powoływania alternatywnych ustawień można użyć opcjonalnego łańcucha i sprawdzić wywołanie metody był udany. Nawet jeśli ta metoda nie zwraca wartości, można nadal korzystać z opcjonalnego łańcuch, aby osiągnąć ten cel.
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("无法输出房间号")
}
Wyjście powyżej wykonywanie programu jest:
无法输出房间号
Za pomocą instrukcji if, aby sprawdzić, czy udanego sposobu printNumberOfRooms połączeń: Jeśli wywołanie metody powiedzie przez opcjonalny łańcucha printNumberOfRooms niejawna wartość zwracana będzie nieważna, gdy nie powiedzie, zwraca nil.
Używanie skryptu wywołanie indeksu dolnego opcjonalnie łańcucha
Można użyć opcjonalnego łańcuch postarać się o wartość od standardowego scenariusza i zbadać następne wywołanie skryptu indeks jest skuteczne, jednak nie można ustawić opcjonalny skrypt indeksu łańcucha.
Przykład 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("无法检索到房间")
}
Wyjście powyżej wykonywanie programu jest:
无法检索到房间
Następnego standardowy skrypt wymaga opcjonalnego łańcuch bezpośrednio za circname.print znakiem zapytania, następny standardowy skrypt nawiasach przód bo circname.print opcjonalnie łańcucha próbuje uzyskać wartość opcjonalna.
Przykład 2
Przykłady przypadkach stworzyć john.residence Residence, oraz jeden lub więcej wystąpień swojej tablicy Room, a następnie można użyć opcjonalnego łańcuch dostać pokoje w instancji tablicy przez skrypt Residence hotel indeks dolny:
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("无法检索到房间")
}
Wyjście powyżej wykonywanie programu jest:
第一个房间名为客厅
Aby uzyskać dostęp do indeksu za pomocą opcjonalnego połączenia łącza
Dzięki opcjonalnemu połączenia łącza, możemy skorzystać z indeksu, aby być odczytywane lub zapisywane na opcjonalnej wartości i określa wywołanie indeks był udany.
Przykłady
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("无法检索到房间")
}
Wyjście powyżej wykonywanie programu jest:
第一个房间名为客厅
Dostęp opcjonalny rodzaj indeksu
Jeśli indeks może zwracać typ wartości null, takie jak Swift w słowniku indeksu klucza. Można zamknąć następny cel w nawiasie po znaku zapytania, aby umieścić link do tematu pod pustym Zwracana wartość:
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]
Powyższy przykład definiuje tablicę testScores zawiera dwie pary klucz-wartość, klucz String typ jest odwzorowywany na tablicy liczb całkowitych.
Próbka ta wywołuje z opcjonalnym linkiem do "Dave" jest ustawiony na pierwszym elemencie tablicy 91, pierwszy element +1 "Bev" tablicą, a następnie spróbuj "Brian" pierwszym elementem tablicy jest ustawiony na 72 ,
Pierwsze dwa połączenia są udane, ponieważ dwa kluczem obecność. Ale kluczem "Brian" w słowniku nie istnieje, więc trzecie zaproszenie powiodło się.
Połączenie wielowahaczowe
Można łańcuchowe razem wiele warstw może być ewentualnie kopania obrębie właściwości modelu niżej metod i skrypt indeksu. Jednak opcjonalnie multi-chain można dodać opcjonalny stosunek wartości powrócił więcej warstw.
Jeśli próbujesz uzyskać poprzez opcjonalną łańcucha wartości Int, niezależnie od tego, ile warstwa łącza zawsze zwraca Int?. Podobnie, jeśli starają się uzyskać poprzez opcjonalną łańcucha Int? Value, niezależnie od tego, ile warstwa łącza zawsze zwraca Int?.
Przykład 1
Poniższy przykład próbuje uzyskać właściwości pobyt Jana adres ulicy nieruchomości. Jak stosuje się w niniejszym opisie, opcjonalnie dwie łańcucha kontakt zamieszkania i adres cech, oba są opcjonalne Typ:
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("不能检索地址")
}
Wyjście powyżej wykonywanie programu jest:
不能检索地址
Przykład 2
Jeśli przykład ustawić na Adres jako wartość john.residence.address i ustawić wartość dla rzeczywistego adresu ulicy nieruchomości, można łańcuchowe wielu warstw, aby uzyskać to opcjonalne wartości atrybutów.
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("无法检索房间")
}
Powyższy przykład wyjście jest:
第一个房间是客厅
Opcjonalna funkcja wartości łącza zwrotnego
Możemy również zadzwonić metoda zwraca wartość null opcjonalnym linku, można kontynuować na alternatywnym ustawień link.
Przykłady
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("未指定房间号")
}
Wyjście powyżej wykonywanie programu jest:
未指定房间号