Schnelle Lernnotizen (1) grundlegende Grammatik

---

Vorwort

浅学一下Swift，这篇笔记做个记录

---

Entwicklungswerkzeuge

Es ist immer noch Xcode, daher werde ich nicht viel über Xcode vorstellen.

Variablen und Konstanten

Das Schlüsselwort let und das Schlüsselwort var werden zur Darstellung von Konstanten bzw. Variablen verwendet. Unabhängig davon, ob es sich um let oder var handelt, besteht die Funktion darin, einen Namen für einen bestimmten Wert zu übernehmen. Diese Methode wird als Deklaration des Werts bezeichnet. Innerhalb des effektiven Bereichs des Werts können Entwickler diese Namen verwenden, um bestimmte Werte zu erhalten. In der Programmierung gibt es zwei Grundkonzepte: Wert und Ausdruck.
Es versteht sich, dass die Größe das Ergebnis ist. 3 ist ein ganzzahliger Wert und die Zeichenfolge „Hallo“ ist ein Zeichenfolgenwert.
Ein Ausdruck kann als Rechenvorgang aufgefasst werden, das Ergebnis ist eine Größe. 1+2 ist ein Ausdruck, dessen Ergebnis die Größe 3 ist.
hello+world ist auch ein Ausdruck, dessen Ergebnis die Größe hallo Welt ist.
Die meisten Ausdrücke bestehen aus Mengen und Operatoren.

Definition und Verwendung von Variablen und Konstanten

//引入UIKit框架
import UIKit
//定义一个变量，赋值为字符串“hello，playground”
var greeting = "Hello, playground"

//定义一个变量，赋值为字符串“hello，playground”
var greeting = "Hello, playground"



//这句代码和下面这句代码等效

//声明字符串变量
var str: String
//对字符串变量str进行赋值
str = "hello,playground"




//量值的打印
print(str)
//在使用常量或者变量时，开发者可以直接通过名称来调用对应的量值，
str = "newValue"

//在str后追加hello
str = str + "hello"

Swift unterstützt auch die Deklaration mehrerer Konstanten oder Variablen in derselben Zeilenanweisung, muss jedoch dem Prinzip des klaren Typs folgen

var a = 1, b = 2, c = "string"
var a2 : Int = 1, b2 : Float = 2.9, c2 : String = "string"

Wenn mehrere Variablen in derselben Codezeile deklariert werden und kein Anfangswert angegeben wird, kann der Typ angegeben werden, indem der Typ der letzten Variablen als Ganzes angegeben wird

var one, two, three : Int

Die im obigen Code deklarierten Variablen eins, zwei und drei sind alle Variablen vom Typ Int

(1) Die Swift-Sprache ist eine sehr schnelle und prägnante Sprache. Sie ermöglicht Entwicklern, Semikolons wegzulassen und Anweisungen automatisch durch Zeilenumbrüche zu trennen. Gleichzeitig unterstützt sie das Schreiben mehrerer Codesätze in einer Zeile. In diesem Fall sind Semikolons erforderlich um Anweisungen zu trennen. Zum Beispiel:
var str:String;str = „hello,playground“;print(str)
(2) Die Typinferenz der Swift-Sprache ist eine sehr gute Funktion des Xcode-Compilers. In der tatsächlichen Entwicklung sollten Entwickler dies tun Nutzen Sie diese Eigenschaft so weit wie möglich.
(3) Wenn Sie den Wert der Variablen ändern müssen, können Sie die Variable direkt neu zuweisen. Es ist zu beachten, dass der Typ des zugewiesenen Werts mit dem Typ der Variablen übereinstimmen muss.

Namenskonventionen für Variablen und Konstanten

In der Swift-Sprache sind die Benennungsregeln für Konstanten und Variablen sehr weit gefasst und können Unicode-Zeichen und -Zahlen umfassen. Es ist zu beachten, dass reservierte Schlüsselwörter nicht als Namen von Konstanten oder Variablen verwendet werden können, wie z. B. let und var. value name verkünden. Darüber hinaus dürfen die Namen von Konstanten und Variablen nicht mit Zahlen beginnen und Symbole wie Leerzeichen, mathematische Symbole, Tabulatoren und Pfeile dürfen nicht in Namen verwendet werden.

Sie können zur Benennung auch eingestreute Zahlen verwenden. Beachten Sie, dass Zahlen nicht als Anfang verwendet werden können:
//Zahlen, die Zahlen enthalten var pen2 = „pen“
können auch mit Unterstrichen benannt werden: //Unterstriche für Namen verwenden
var Swift = „swift“

Obwohl Swift eine Vielzahl von Benennungsmethoden unterstützt, kann ein guter Benennungsstil in der tatsächlichen Entwicklung die Codierungseffizienz und die Lesbarkeit des Codes erheblich verbessern. In der offiziellen Swift-Sprachdokumentation wird die Benennung in Kamel-Kasten verwendet. Die sogenannte Buckelbenennung bezieht sich auf das Zusammenfügen von Namen und Wörtern. Der erste Buchstabe des Namens ist im Allgemeinen kleingeschrieben, und der erste Buchstabe jedes Wortes danach wird großgeschrieben, und die anderen Buchstaben sind alle kleingeschrieben. Das Beispiel ist wie folgt : //Hump benennt var userName = „Hun
Shao
“

(1) Unicode (Unicode, Universalcode, Single Code) ist ein Industriestandard im Bereich der Informatik, einschließlich Zeichensätzen, Kodierungsschemata usw. Unicode wurde entwickelt, um die Einschränkungen herkömmlicher Zeichenkodierungsschemata zu überwinden. Es legt eine einheitliche und eindeutige Binärkodierung für jedes Zeichen in jeder Sprache fest, um sprach- und plattformübergreifende Textkonvertierungs- und Verarbeitungsanforderungen zu erfüllen. Unicode begann 1990 mit der Forschung und Entwicklung und wurde 1994 offiziell angekündigt.
(2) Für die Benennung in Swift gelten auch einige übliche Regeln. Beispielsweise wird der erste Buchstabe von Wertattributen in Kleinbuchstaben geschrieben, und der erste Buchstabe von Klassennamen, Objektnamen und Strukturnamen wird in Großbuchstaben geschrieben.
(3) Wenn Sie für die Benennung wirklich reservierte Schlüsselwörter verwenden müssen, können Sie 符号迚行包装，但是除非 万不得已，开収中尽量不要使用这种斱式命名，包装示例如下: //用预留关键字迚行命名 var var` = 2 verwenden

Notiz

Einzeilige Kommentare und mehrzeilige Kommentare sind mit OC-Kommentaren identisch.
Aber Swift kann Anmerkungen verschachteln.

//单行注释//注释中的注释 /*
多行注释
/*
*/
注释 注释 */

Lernen Sie grundlegende Datentypen kennen

Ganzzahlige Daten in der Swift-Sprache werden in vorzeichenbehaftete Ganzzahldaten und vorzeichenlose Ganzzahldaten unterteilt. Das sogenannte Signierte und Unsignierte, das weit verbreitete Verständnis ist, dass es Zeichen und keine Zeichen gibt.
Für vorzeichenlose Ganzzahlen stellt Swift 5 Datentypen und 4 Speicherplätze bereit, und die 4 Speicherplätze belegen jeweils 8 Bit, 16 Bit, 32 Bit und 64 Bit Speicher. Erstellen Sie mit dem Xcode-Entwicklungstool einen neuen Playground, nennen Sie ihn BasicDataType und schreiben Sie den folgenden Demonstrationscode:
Für vorzeichenlose Ganzzahlen stellt Swift 5 Datentypen mit 4 Speicherplätzen bereit, und die 4 Speicherplätze belegen 8 Bit Speicher. 16 -Bit, 32-Bit und 64-Bit. Erstellen Sie mit dem Xcode-Entwicklungstool einen neuen Playground, nennen Sie ihn BasicDataType und schreiben Sie den folgenden Democode:

//8 位无符号整型数的最大值 255 
var a1 = UInt8.max
//16 位无符号整型数的最大值 65535 
var a2 = UInt16.max
//32 位无符号整型数的最大值 4294967295
var a3 = UInt32.max
//64 位无符号整型数的最大值 18446744073709551615 
var a4 = UInt64.max

Im obigen Code werden 4 Variablen a1, a2, a3, a4 erstellt. In der Swift-Sprache wird der Integer-Datentyp tatsächlich in Form einer Struktur implementiert, und das Max-Attribut kann den Maximalwert des aktuellen Typs erhalten. Leser haben möglicherweise Zweifel, welcher Typ ausgewählt werden sollte, um vorzeichenlose Ganzzahlen in der tatsächlichen Entwicklung auszudrücken? Wie oben erwähnt, gibt es in der Swift-Sprache tatsächlich fünf vorzeichenlose Ganzzahlen, und eine davon ist der UInt-Typ. Dieser Compilertyp passt sich automatisch an, es ist UInt64 Auf einem 64-Bit-Computer und UInt32 auf einem 32-Bit-Computer lautet der Beispielcode wie folgt:

var a6 = MemoryLayout<UInt>.size

MemoryLayout ist eine in der Swift-Standardbibliothek definierte Aufzählung. Wie der Name schon sagt, wird sie zum Abrufen speicherbezogener Informationen verwendet. MemoryLayout ist eine generische Verwendung. Durch Aufrufen seiner Größeneigenschaft kann die Anzahl der Bytes des von bestimmten Daten belegten Speicherplatzes ermittelt werden Typ.
Vorzeichenbehaftete Ganzzahldaten sind den vorzeichenlosen Ganzzahldaten sehr ähnlich, mit der Ausnahme, dass das erste Binärbit ein Vorzeichenbit ist, das in numerischen Berechnungen nicht berücksichtigt wird. Der Beispielcode lautet wie folgt:

var maxInt8 = Int8.max //127
var mimInt8 = Int8.min //-128
var maxInt16 = Int16.max //32767
var minInt16 = Int16.min //-32768
var maxInt32 = Int32.max //2147483647
var minInt32 = Int32.min //-2147483648
var maxInt64 = Int64.max //9223372036854775807 var minInt64 = Int64.min //-9223372036854775808 var intSize = sizeof(Int) //8位

Entsprechend dem Max-Attribut wird das Min-Attribut verwendet, um den Mindestwert ganzzahliger Daten zu erhalten.

Gleitkommadaten

var b = MemoryLayout<Float>.size 
var b1 = MemoryLayout<Float32>.size 
var b2 = MemoryLayout<Float64>.size 
var b3 = MemoryLayout<Float80>.size 
var c = MemoryLayout<Double>.size
//4字节 
//4字节 
//8字节 
//16字节 
//8字节

Die Swift-Sprache unterstützt die Verwendung der wissenschaftlichen Notation zur Darstellung von Zahlen. Im Dezimalformat verwenden Sie e, um 10 hoch n-tel darzustellen. Im Hexadezimalformat verwenden Sie p, um 2 hoch n-tel darzustellen. Der Beispielcode lautet wie folgt:

var sum = 1.25e3 //1.25*(10^3) ​​​​= 1250 var sun2 = 0x1p3 //1*(2^3) = 8

Es gibt auch eine sehr interessante Funktion in der Swift-Sprache: Unabhängig davon, ob es sich um Ganzzahldaten oder Gleitkommadaten handelt, können Sie vor der Zahl eine beliebige Anzahl von Nullen hinzufügen, um die Anzahl der Ziffern zu füllen, oder Sie können der Zahl einen Unterstrich hinzufügen Um die Lesbarkeit zu erhöhen, wirken sich diese Vorgänge nicht auf den ursprünglichen Wert aus, sondern verbessern die Benutzerfreundlichkeit der Programmierung für Entwickler und machen die Struktur des Codes klarer. Beispiele sind wie folgt:

var num1 = 001.23 //1.23
var num2 = 1_000  //1000
var num3 = 1_000.1_ 001 //1000.1001

Boolesche Daten

Der boolesche Typ wird häufig als logischer Typ bezeichnet. Leser, die mit der Programmiersprache Objective-C vertraut sind, verstehen möglicherweise, dass der Bool-Typ in der Objective-C-Sprache kein logischer boolescher Typ im engeren Sinne ist. Null und nicht können in verwendet werden Objective-C. Null, um logisch falsch und logisch wahr auszudrücken. In der Swift-Sprache ist dies anders. Der Bool-Typ der Swift-Sprache ist sehr streng. Es gibt nur zwei Werte von true und false, die true bzw. false darstellen. Ebenso muss in der bedingten Anweisung der Swift-Sprache und in der Anweisung, die eine logische Beurteilung erfordert, der Wert des verwendeten bedingten Ausdrucks ebenfalls vom Typ Bool sein.

Zwei spezielle primitive Datentypen

Die Swift-Sprache unterstützt außerdem zwei spezielle Basisdatentypen, nämlich den Tupeltyp und den optionalen Werttyp. Tupel werden in der tatsächlichen Entwicklung sehr häufig verwendet. Entwickler können Tupel verwenden, um benutzerdefinierte Datentypen mit einer beliebigen Kombination von Datentypen zu erstellen. Optionale Werttypen sind ein Hauptmerkmal der Swift-Sprache. Durch optionale Werttypen werden logarithmische Werte der Swift-Sprache streng kontrolliert raus an die Luft.

Tupel

Tupel stellen einen der wichtigsten Datentypen in der Swift-Sprache dar. Tupel ermöglichen die freie Kombination einiger nicht verwandter Typen zu neuen Sammlungstypen. Die Objective-C-Sprache unterstützt keine Datentypen wie Tupel, was den Entwicklern in vielen Fällen Probleme bereiten wird. Analog zu einer Situation im Leben ähnelt der Tupeltyp dem Paket im täglichen Leben. Inzwischen haben verschiedene Dienstleistungsbranchen viele unterschiedliche Pakete auf den Markt gebracht, aus denen Kunden wählen können, um den Kunden einen Service aus einer Hand zu bieten. Tupel stellen eine solche Programmierstruktur bereit. Stellen Sie sich eine Situation in der Programmierung vor: Ein Produkt hat einen Namen und einen Preis. Mithilfe von Tupeln kann diese Art von Produkt sehr gut simuliert werden. Beispiele sind wie folgt:

//创建钢笔元组类型，其中有两种类型，字符串类型的名称和整数类型的价钱
var pen : (name : String, pricr : Int) = ("钢笔", 2)

Der obige Code gibt die Namen der Parameter beim Erstellen des Tupels an, dh der Namensparameter ist Name und der Preisparameter ist Preis. Entwickler können diese Parameternamen verwenden, um die Werte jedes Parameters im Tupel zu erhalten.

var name = pen.name
var price = pen.price

Beim Erstellen eines Tupels müssen Sie den Parameternamen nicht angeben. Das Tupel weist jedem Parameter automatisch einen Index zu, und der Indexwert erhöht sich sequentiell von 0 an

var car : (String, Int) = ("奔驰", 20000000)
var carName = car.0
var carPrice = car.1

Nachdem die Tupelinstanz erstellt wurde, können Entwickler sie auch zerlegen, indem sie Variablen oder Konstanten angeben.

//不指定参数名称的元组
var car : (String, Int) = ("奔驰", 2000000)

//进行元组的分解
var (theName, thePrice) = car
//此时theName变量被赋值为“奔驰“, thePrice被赋值为2000000
print(theName, thePrice)

Der obige Code zerlegt jedes Komponentenelement der Tupelinstanz auto in bestimmte Variablen. Es gibt einen Punkt, auf den die Leser achten müssen.Die zerlegten Variablen müssen nacheinander den Elementen im Tupel entsprechen (die Anzahl ist gleich), sonst macht der Compiler einen Fehler.
Die Funktion print() ist eine Ausdruckfunktion. Die Funktion print() kann mehrere Parameter empfangen, die durch getrennt werden können. Manchmal müssen Entwickler
möglicherweise nicht die Werte aller Elemente in einer Tupelinstanz abrufen. In diesem Fall In In diesem Fall können Entwickler einige Elemente, die nicht erworben werden müssen, auch anonym erhalten, wie in den folgenden Beispielen gezeigt:

//不指定参数名称的元组
var car : (String, Int) = ("奔驰", 2000000)
//进行元组的分解，将Int型参数进行匿名
var (theName, _) = car
//此时theName被赋值为“奔驰”
print(theName)

In der Swift-Sprache wird das Symbol „ “ häufig zur Darstellung des anonymen Konzepts verwendet, daher wird „ “ auch als anonymer Bezeichner bezeichnet. Der obige Code zerlegt tatsächlich nur das erste Element (String-Typ) im Tupelwagen.
Obwohl Tupel sehr praktisch zu verwenden sind, eignen sie sich nur für die Kombination einfacher Daten. Für Daten mit komplexer Struktur sollten Strukturen oder Klassen verwendet werden, um sie zu realisieren.

optionaler Werttyp

Der optionale Werttyp (optionaler Typ) ist ein einzigartiger Typ der Swift-Sprache. Erstens ist die Swift-Sprache eine Sprache, die großen Wert auf Typsicherheit legt. Wenn ein Entwickler eine bestimmte Variable verwendet, versucht der Compiler sein Bestes, um die Klarheit des Typs und Werts der Variablen sicherzustellen, um unkontrollierbare Faktoren bei der Programmierung zu reduzieren . Bei der tatsächlichen Programmierung tritt jedoch bei jeder Art von Variable eine Situation auf, in der der Wert leer ist. In der Objective-C-Sprache gibt es keinen Mechanismus, um leere Variablen gezielt zu überwachen und zu verwalten. Die Sicherheit des Programms wird vollständig manuell gesteuert der Entwickler. . Die Swift-Sprache bietet eine Wrapping-Methode zum optionalen Wrapping für gängige Typen, um die Überwachung von Nullwerten zu realisieren.
Wenn Sie in der Swift-Sprache eine Variable verwenden, der kein Wert zugewiesen wurde, meldet das Programm direkt einen Fehler und stoppt die Ausführung. Leser denken möglicherweise, dass einer Variablen, wenn ihr bei der Deklaration kein Anfangswert zugewiesen wird, möglicherweise später im Programm ein Wert zugewiesen wird. Was sollten wir also für dieses Anwendungsszenario tun, bei dem „zuerst Deklaration und dann Zuweisung“ erfolgt? In Objective- C, dieses Problem ist leicht zu lösen. Bei der Verwendung muss lediglich beurteilt werden, ob die Variable Null ist. Ist es möglich, dasselbe in Swift zu tun? Verwenden Sie zum Testen den folgenden Code:
Wenn Sie in der Swift-Sprache eine nicht zugewiesene Variable verwenden, meldet das Programm direkt einen Fehler und stoppt die Ausführung. Leser denken möglicherweise, dass einer Variablen, wenn ihr bei der Deklaration kein Anfangswert zugewiesen wird, möglicherweise später im Programm ein Wert zugewiesen wird. Was sollten wir also für dieses Anwendungsszenario tun, bei dem „zuerst Deklaration und dann Zuweisung“ erfolgt? In Objective- C, dieses Problem ist leicht zu lösen. Bei der Verwendung muss lediglich beurteilt werden, ob die Variable Null ist. Ist es möglich, dasselbe in Swift zu tun? Verwenden Sie zum Experimentieren den folgenden Code:

var obj:String 
if obj==nil {
    
    
}

Nachdem Sie den obigen Code geschrieben haben, können Sie sehen, dass das Xcode-Tool immer noch eine Fehlermeldung ausgibt. Tatsächlich dürfen in der Swift-Sprache gewöhnliche Typen, die nicht initialisiert wurden, nicht verwendet werden, selbst wenn sie für die Nullbeurteilungsverarbeitung verwendet werden Natürlich ist es nicht möglich, Vergleichsoperationen mit Null durchzuführen. Dieser Mechanismus reduziert die Unkontrollierbarkeit des Codes erheblich. Daher müssen Entwickler sicherstellen, dass Variablen vor der Verwendung initialisiert werden. Der Code lautet wie folgt:

var obj0 : String
obj0 = "HS"
print(obj0)

Der obige Ansatz wird jedoch in der tatsächlichen Entwicklung nicht häufig verwendet. Wenn eine Variable logischerweise Null sein kann, muss der Entwickler sie als optionalen Typ umschließen. Schreiben Sie den obigen Code wie folgt um:

var obj : String?
if obj == nil {
    
    
    
}

Zu diesem Zeitpunkt sollte der Code normal ausgeführt werden. Analysieren Sie den obigen Code und deklarieren Sie die obj-Variable. Hier wird sie als String?-Typ deklariert.Fügen Sie nach dem gewöhnlichen Typ das Symbol „?“ hinzu, um den gewöhnlichen Typ in einen optionalen Typ zu verpacken.
Der optionale Typ existiert nicht unabhängig. Er ist immer einem bestimmten Datentyp zugeordnet. Der spezifische Datentyp kann ein Basisdatentyp, eine Struktur oder eine Klasse sein. Der optionale Typ hat nur zwei Werte, die der Leser wie folgt verstehen kann:

• Wenn die Größe, die ihrem Anhangstyp entspricht, einen konkreten Wert hat, ist sie ein Wrapper für den konkreten Wert.
• Es ist Null, wenn die Größe, die seinem Bindungstyp entspricht, keinen bestimmten Wert hat.
• Der Null-Leser im optionalen Typ kann auch als Wert verstanden werden, der leer darstellt

Der optionale Typ ist eine Art Verpackung für gewöhnliche Typen. Daher muss er bei Verwendung entpackt werden. Zum Entpacken wird in Swift der Operator „!“ verwendet. Die beiden Operatoren „?“ und „!“ sind für viele Anfänger der Swift-Sprache ein Albtraum. Wenn der Leser den optionalen Typ versteht, wird es viel einfacher sein, diese beiden Operatoren zu verstehen und zu verwenden. Zunächst ist zu beachten, dass das „?“-Symbol nach dem Typ oder nach der Instanz erscheinen kann. Wenn es nach dem Typ erscheint, stellt es den optionalen Typ dar, der diesem Typ entspricht. Wenn es nach der Instanz erscheint, repräsentiert es optional. Der Aufruf der Kette wird in den folgenden Kapiteln ausführlich vorgestellt. Das „!“-Symbol kann auch hinter dem Typ und der Instanz erscheinen. Es erscheint nach dem Typ und stellt eine implizit analysierte grammatikalische Struktur dar, die in späteren Kapiteln eingeführt wird; es erscheint nach der Instanz und stellt das Entpacken der optionalen Typinstanzoperation dar. Beispiele sind wie folgt:

//声明obj为String？类型
var obj : String? = "HS"
//进行拆包操作
obj!

Der Leser muss darauf achten, dass bei Verwendung von „!“ zum Entpacken des optionalen Werts sichergestellt werden muss, dass der zu entpackende Wert nicht Null ist, da das Programm sonst fehlerhaft ausgeführt wird. Sie können die if-Anweisung verwenden, um vor dem Entpacken eine Sicherheitsbeurteilung vorzunehmen. Das Beispiel lautet wie folgt:

var obj : String? = "HS"
if obj != nil {
    
    
    obj!
}

Wenn obj einen Wert hat, erstellt die if-let-Struktur eine temporäre Konstante tmp, um den entpackten Wert von obj zu empfangen, und führt den entsprechenden Codeblock aus, wenn if wahr ist. Im ausgeführten Codeblock können Entwickler das entpackte Paket direkt verwenden obj-Wert ist tmp. Wenn obj null ist, wird es in den Codeblock eingegeben, wobei if falsch ist, und der Entwickler kann obj neu zuweisen, um es im else-Codeblock zu verwenden. Diese If-Let-Struktur vervollständigt tatsächlich die drei Prozesse des Beurteilens, Entpackens und Bindens des entpackten Werts an eine temporäre Konstante.
In der if-let-Struktur können auch mehrere Werte vom Typ Optional gleichzeitig gebunden werden, getrennt durch Kommas, Beispiele sind wie folgt:

//if-let多Optional值绑定
var obj1 : Int? = 1
var obj2 : Int? = 2
if let tmp1 = obj1, let tmp2 = obj2 {
    
    
    print(tmp1, tmp2)
}

Beim gleichzeitigen Binden mehrerer optionaler Werte ist die Bindung nur dann erfolgreich, wenn alle optionalen Werte nicht Null sind, und die Codeausführung wird in den Codeblock „Wenn wahr“ eingegeben.

//if-let多Optional值绑定
var obj1 : Int? = 1
var obj2 : Int? = 2
if let tmp1 = obj1, let tmp2 = obj2, tmp1 < tmp2 {
    
    
    print(tmp1, tmp2)
}

Der obige Code gibt nur dann den Codeblock „if is true“ ein, wenn obj1 nicht Null ist, obj2 nicht Null ist und der Entpackwert, der obj1 entspricht, kleiner ist als der Entpackwert, der obj2 entspricht, dh die gebundenen Werte für tmp1 und tmp2 werden gedruckt.
Für eine Variable mit optionalem Werttyp müssen wir sie jedes Mal entpacken, wenn wir sie verwenden, was relativ mühsam ist. Tatsächlich gibt es in Swift eine andere Syntax: implizite Analyse. Implizites Parsen ist für ein solches Szenario geeignet: Wenn wir klarstellen, dass eine Variable zunächst Null ist und ihr ein Wert zugewiesen werden muss, bevor sie später verwendet wird, können wir sie als optionalen Wert für implizites Parsen deklarieren und dort dann die Verwendung durchführen Es sind keine Entpackvorgänge erforderlich. Der folgende Code erzeugt beispielsweise einen Laufzeitfehler:
Kompiliert Fehler, da obj4 nicht entpackt ist

//声明obj4为隐式解析的变量
var obj4 : Int!
obj4 = 3
//使用时，无须再进行拆包操作，Swift会自动帮我们拆包
print(obj4 + 1)

Alias ​​für den Typ

Sprachen wie C, C++ und Objective-C stellen alle Schlüsselwörter wie typedef bereit, um einen Alias ​​für einen bestimmten Typ zu verwenden. In der
Swift-Sprache wird das Schlüsselwort typealias verwendet, um den gleichen Effekt zu erzielen. Beispiele sind wie folgt:

//为Int类型取一个别名Price
typealias Price = Int
//使用Price代替Int， 效果完全一样
var penPrice : Price = 100

Der obige Code verwendet den Alias ​​„Price“ für den Typ „Int“. Bei der späteren Verwendung ist der Typ „Price“ genau derselbe wie der Typ „Int“. In der tatsächlichen Entwicklung kann die flexible Verwendung von Typalias zur Aliasierung des Typs die Lesbarkeit des Codes optimieren.

Scheininterview

(1) Die Symbole „?“ und „!“ sind zwei sehr häufige Symbole in Swift-Projekten. Bitte beschreiben Sie kurz Ihr Verständnis davon. Tipps zur Beantwortung wichtiger Punkte: 1. Verstehen Sie zunächst die beiden Aspekte Typ und Instanz: „?“ erscheint nach dem Typ, um den optionalen Typ anzuzeigen, und erscheint nach der Instanz, um den optionalen Kettenaufruf anzuzeigen
. „!“ Das Erscheinen nach dem Typ bedeutet standardmäßiges implizites Parsen, und das Erscheinen nach der Instanz bedeutet erzwungenes Entpacken. 2 Diese beiden Symbole beziehen sich auf den optionalen Typ in Swift. Der optionale Typ ist eine
Möglichkeit für die Swift-Sprache, die Sicherheit hervorzuheben. eine Variable leer sein kann, sollte logisch bestimmt werden und nicht unvorhersehbar und unkontrollierbar. 3Die Kombination aus if-let-Struktur und optionalem Typwert kann eleganten und sicheren Logikcode schreiben.
Kerninhalte zum Verständnis:
Verschaffen Sie sich ein umfassendes Verständnis des optionalen Typs in Swift. (2) Welche Vorteile haben Dezimal-, Binär-, Oktal- und Hexadezimalzahlen und in welchen Szenarien werden sie verwendet? Tipps zur Beantwortung wichtiger Punkte: 1. Die Vorteile des Dezimalsystems Selbstverständlich verwenden fast alle mathematischen Berechnungen im täglichen Leben das Dezimalsystem
. 2Binär ist für Computer die bequemste Möglichkeit, das Basissystem zu verstehen. Die Zustände auf hoher und niedriger Ebene lassen sich sehr einfach als binäre 0 und 1 darstellen und sind außerdem die
stabilste Möglichkeit, Daten im Computer zu speichern. 3 Oktal und Hexadezimal sind eigentlich binäre Aggregationsmethoden. Im Oktal kann jede Ziffer
3 Bits im Binärformat darstellen, und im Hexadezimalsystem kann jede Ziffer 4 Bits im Binärformat darstellen, was die Länge der Binärzahl erheblich verkürzt und lesbar macht. Hexadezimal wird häufig zur Darstellung von Farbdaten verwendet.
Kerninhalt des Verständnisses:
Basisprinzip und Konvertierungsmethode.
(3) Gibt es in der Swift-Sprache nur zwei Datentypen, var und let?
Tipps zur Beantwortung wichtiger Punkte: 1. Diese Aussage ist sehr falsch. In Swift sind var und let keine Datentypen, sondern zwei Methoden zum Deklarieren von Variablen .
Modus. 2Swift ist ein starker Datentyp, genau wie C, C++, Objective-C, Java und andere Sprachen. Wenn Variablen deklariert werden, werden ihre Daten analysiert. Beispielanalyse: Der
Typ
wurde bereits bestimmt, manchmal geben wir ihn nicht explizit an, da Xcode dies getan hat Automatische Typinferenzfunktion. Zu den Datentypen in 3Swift gehören Basisdatentypen und Referenzdatentypen. Zu den Basisdatentypen gehören Ganzzahlen, Gleitkommatypen,
Boolesche Typen, Tupel usw.
Kerninhalt des Verständnisses:
Verstehen Sie die Bedeutung von Datentypen, verstehen Sie die Beziehung zwischen Variablen und Datentypen und verstehen Sie die automatische Typinferenzfunktion von Xcode.

Zeichen-, Zeichenfolgen- und Sammlungstypen

In der Programmentwicklung ist die Verwendung von Zeichenfolgen von wesentlicher Bedeutung, einem sehr wichtigen Datentyp in der Programmierung. Tatsächlich sind Zeichenfolgen auch eine Sammlung von Zeichen. B. die C-Sprache, die häufig Zeichenarrays als Zeichenfolgentypen verwendet. Die Objective-C-Sprache kapselt den objektorientierten Zeichenfolgentyp NSString und kapselt darin eine große Anzahl verwandter Methoden. . Und Swift ist eine Sprache, die Zeiger schwächt. Sie bietet String-Typen und Zeichentypen zur Beschreibung von Zeichenfolgen und Zeichen.

String-Typ

Wie der Name schon sagt, ist der String-Typ eine Kombination aus einer Zeichenfolge, die in der Entwicklung häufig verwendet wird. Die Szenenlogik wie der Name des Produkts, die Klasse des Schülers und der Text der Musik müssen vorhanden sein durch die Zeichenfolge verarbeitet.

var str = "hello, world"

var str = ""

Der Wert einer String-Variablen ist ein leerer String und der Wert einer String-Variablen ist Null, das sind zwei völlig unterschiedliche Konzepte. Wenn einer Variable vom Typ Optional kein Wert zugewiesen wird, ist sie Null. Wenn ihr ein leerer String zugewiesen wird, ist sie es nicht gleich Null. .
In der Swift-Sprache ist der String-Typ eigentlich eine Struktur. Tatsächlich werden die in den vorherigen Kapiteln erlernten Ganzzahl-, Gleitkomma- und Booleschen Typen auch durch die Struktur implementiert. Die Struktur der Swift-Sprache ist sehr leistungsfähig und kann Eigenschaften und Methoden wie eine Klasse definieren.

var str : String = "Hello, playground"
print(str)
str = ""
print(str)

str = String()
print(str)

str = String("hello")
print(str)

str = String(666)
print(str)

str = String(6.66)
print(str)

str = String("a")
print(str)

str = String(false)
print(str)

str = String(describing: (1, 2.0, true))
print(str)

str = String(describing: [1, 2, 3])
print(str)

str = String(format: "我是%@", "会少")
print(str)

Der String-Typ bietet viele überladene Konstruktionsmethoden und Entwickler können verschiedene Parametertypen übergeben, um die erforderliche Zeichenfolge zu erstellen. Tatsächlich bietet der String-Typ in der Swift-Sprache eine breite Palette von Konstruktionsmethoden, und sogar andere Typen können
durch Konstruktionsmethoden in Zeichenfolgen umgewandelt werden, wie in den folgenden Beispielen gezeigt:

var str : String = "Hello, playground"
print(str)

str = String(describing: Int.self)
print(str)

var a = Int(1.5)
print(a)
var b = Float(a)
print(b)

Kombination von Saiten

Der String-Typ in Swift implementiert die Überladung des „+“-Operators, d. h. Entwickler können das „+“-Symbol direkt verwenden, um
mehrere String-Kombinationen zu einem neuen String zu verketten.

var c1 = "Hello"

var c2 = "world"

var c3 = c1 + " " + c2
print(c3)

Durch den Additionsoperator können Entwickler Zeichenfolgenvariablen einfach kombinieren. Manchmal müssen Entwickler eine weitere Zeichenfolge in die Mitte einer Zeichenfolge einfügen. Zusätzlich zur Verwendung der formatierten Konstruktionsmethode bietet Swift auch eine sehr praktische Methode zur Zeichenfolgeninterpolation

String-Interpolation mit ()

var d = "Hello\(123)"
print(d)
var d2 = "Hello\(d)"
print(d2)
var d3 = "Hello\(1 + 2)"
print(d3)

Die Struktur „()“ kann andere Datentypen in Zeichenfolgentypen umwandeln und an der entsprechenden Position der Zeichenfolgendaten einfügen oder das Ergebnis nach Ausführung einer einfachen Operationslogik in die ursprüngliche Zeichenfolge einfügen. Diese Methode ist für Zeichenfolgen sehr praktisch. Die Formatierung ist weit verbreitet in der Entwicklung.

Zeichentyp

Der Zeichentyp wird zur Darstellung eines einzelnen Zeichens verwendet, z. B. numerische Zeichen, englische Zeichen, Symbolzeichen und chinesische Zeichen usw., die durch den Zeichentyp dargestellt werden können,
und die Zeichen in der Zeichenfolge können auch durch Durchlaufen der Zeichenfolge zerlegt werden.

Ähnlich wie Char in der C-Sprache wird Character in der Swift-Sprache zur Beschreibung von Zeichentypen verwendet, und sowohl der Zeichentyp als auch der String-Typ belegen 16 Byte Speicherplatz. In Swift können Sie die MemoryLayout-Enumeration verwenden, um den von einem bestimmten Typ belegten Speicherplatz abzurufen. Die Einheit ist Byte. Das Beispiel lautet wie folgt:

print(MemoryLayout<String>.size)

Mit „Character“ wird ein Zeichen beschrieben. Wir kombinieren eine Gruppe von Zeichen in einem Array, um eine Zeichenfolge zu erstellen. Beispiele sind wie folgt
:

var e : Character = "a"
var e2 : [Character] = ["H", "E", "L", "L", "O"]
var e3 = String(e2)
print(e, e2, e3)

Verwenden Sie For-In-Traversal, um die Zeichen in der Zeichenfolge zu zerlegen. Diese Methode ist manchmal sehr nützlich. For-In-Traversal ist eine wichtige Codeflussstruktur in der Swift-Sprache. Der String-Typ implementiert standardmäßig das iteratorbezogene Protokoll. Durch direktes Durchlaufen kann jedes Zeichenelement in der Zeichenfolge extrahiert werden. Der Beispielcode lautet wie folgt:

let name = "China"
for character in name {
    
    
    print(character)
}

Die for-in-Struktur ist eine wichtige Schleifenstruktur. Im obigen Beispielcode muss das Schlüsselwort „in“ ein iterierbarer Typ sein, und dem Schlüsselwort „in“ werden die aus dem Iterator für jede Schleife entnommenen Elemente vorangestellt. Der Typ wird automatisch von abgeleitet der Xcode-Compiler

Escape-Zeichen

Die Swift-Sprache ähnelt der C-Sprache. Zusätzlich zu einigen herkömmlichen sichtbaren Zeichen bietet sie auch einige spezielle Escape-Zeichen, die
durch spezielle Symbolkombinationen bestimmte Bedeutungen ausdrücken können. Beispiele sind wie folgt:

• \0: Nützliche Anzeigeraummarkierung.
• \: wird zur Darstellung eines Backslashs verwendet
• \t: Verwenden Sie 杢, um Tabulatorzeichen darzustellen.
• \n: Verwenden Sie 杢, um ein Zeilenumbruchzeichen darzustellen.
• \r: Verwenden Sie 杢, um das Wagenrücklaufzeichen darzustellen.
• ': Verwenden Sie 杢, um ein einfaches Anführungszeichen darzustellen
• ": Verwenden Sie 杢, um doppelte Anführungszeichen darzustellen.
• \u{}: Erstellen Sie Zeichen mit Unicode-Codes.
  Unter anderem wird \u{} zum Erstellen von Zeichen mithilfe von Unicode-Codes verwendet. Geben Sie einfach die Unicode-Codes in geschweiften Klammern ein. Das Beispiel lautet wie folgt: // Verwenden Sie Unicode-Codes zum Erstellen von Zeichen. Das durch Unicode dargestellte Zeichen ist 21! \u
  {einundzwanzig}"

Gängige Methoden im String-Typ

Der String-Typ der Swift-Sprache kapselt viele praktische Eigenschaften und Methoden, wie z. B. String-Inspektion, Operationen zum Hinzufügen, Einfügen und Löschen von Zeichen sowie Statistiken zur Zeichenanzahl. Durch die kompetente Verwendung dieser Attribute und Methoden können Entwickler Daten bei der Programmierung problemlos verarbeiten.
Wie bereits erwähnt, sind der Wert einer String-Variablen ein leerer String und der Wert einer String-Variablen leer. Dies sind zwei verschiedene Konzepte. Die Instanz des String-Typs verwendet die Methode isEmpty, um zu bestimmen, ob der Wert des Strings ein leerer String ist

var obj1 = ""
if obj1.isEmpty {
    
    
    print("字符串为空字符串")
}

Es gibt eine andere Möglichkeit zu beurteilen, ob eine Zeichenfolgenvariable eine leere Zeichenfolge ist: Wenn die Anzahl der Zeichen in der Zeichenfolgenvariablen 0 ist, kann die Zeichenfolge auch als leere Zeichenfolge betrachtet werden, dh über das Zählattribut von string Bestimmen Sie, ob die Anzahl der darin enthaltenen Zeichen 0 ist

var obj1 = ""
if obj1.count == 0 {
    
    
    print("字符串为空字符串")
}

Zusätzlich zur Verwendung von „+“ zum direkten Verketten von String-Typ-Instanzen können Sie auch Vergleichsoperatoren verwenden

var com1 = "30a"
var com2 = "31a"
if com1 == com2 {
    
    
    print("com1 = com2")
}
if com1 < com2 {
    
    
    print("com1 < com2")
}

Beim Vergleich der Größe zweier Zeichenfolgen wird die Größe der Zeichen einzeln verglichen, bis ein ungleiches Zeichen gefunden wird. Der obige Beispielcode kann wie folgt verstanden werden: Vergleichen Sie zuerst das erste Zeichen der Zeichenfolge com1 und die Zeichenfolge com2. Wenn sie gleich sind, vergleichen Sie dann das zweite Zeichen und so weiter. Da das 4. Zeichen (2) von com2 größer ist als das 4. Zeichen (1) von com1, ist die Zeichenfolge „com2“ größer als die Zeichenfolge „com1“.

var string = "Hello - Swift"

var startIndex = string.startIndex

var endIndex = string.endIndex

print(string)
print(startIndex)
print(endIndex)

var char = string[string.index(after: startIndex)]

var char2 = string[string.index(before: string.endIndex)]

print(char)
print(char2)

Hierbei ist zu beachten, dass die von startIndex und endIndex erhaltenen Werte vom Indextyp und nicht vom Ganzzahltyp sind. Sie können nicht direkt addiert oder subtrahiert werden und zum Verschieben des Indexes muss die entsprechende Methode verwendet werden. Der Index(danach Die Methode :) wird verwendet, um den aktuellen Index zu erhalten
. Der nächste Index, die Methode index(before:), wird verwendet, um den vorherigen Index des aktuellen Index zu erhalten. Sie können auch einen bestimmten Teilstring in der Zeichenfolge abfangen, indem Sie den Indexbereich übergeben

var string = "Hello - Swift"
var startIndex = string.startIndex

var endIndex = string.endIndex

var subString = string[startIndex...string.index(startIndex, offsetBy: 4)]
var subString2 = string[string.index(endIndex, offsetBy: -5)..<endIndex]

print(string)
print(startIndex)
print(endIndex)
print(subString)
print(subString2)

Im obigen Beispielcode ist „…“ ein Bereichsoperator, der in den folgenden Kapiteln ausführlich vorgestellt wird. Der Parameter offsetBy wird in der Anzahl der Stellen übergeben, um den Index zu verschieben. Wenn ihm eine positive Zahl übergeben wird , der Index bewegt sich um die entsprechende Anzahl von Ziffern rückwärts. Wenn eine negative Zahl übergeben wird, bewegt sich der Index um die entsprechende Anzahl von Ziffern vorwärts. Es ist sehr praktisch, diese Methode zum Abfangen von Zeichenfolgen zu verwenden. Der String-Typ kapselt auch einige Methoden, die Entwicklern dabei helfen können, Vorgänge wie das Anhängen, Einfügen, Ersetzen und Löschen von Zeichenfolgen bequem durchzuführen. Beispiele sind wie folgt

var string = "Hello - Swift"
//获取某个子串在父串中的范围
var range = string.range(of: "Hello")
//追加一个字符，此时 string = "Hello-Swfit!"
string.append(Character("!"))
//追加字符串操作，此时string = "Hello-Swift! Hello-World"
string.append(" Hello-World")
//在指定位置插入一个字符，此时string = "Hello-Swift!~ Hello-World"
string.insert("~", at: string.index(string.startIndex, offsetBy: 12))
//在指定位置插入一组字符，此时string = "Hello-Swift!~~~~ Hello-World"
string.insert(contentsOf: ["~","~","~"], at: string.index(string.startIndex,
offsetBy: 12))
//在指定范围替换一个字符串，此时string = "Hi-Swift!~~~~ Hello-World"
string.replaceSubrange(string.startIndex...string.index(string.startIndex,
offsetBy: 4), with: "Hi")
//在指定位置删除一个字符，此时string = "Hi-Swift!~~~~ Hello-Worl"
string.remove(at: string.index(before:string.endIndex)) //删除指定范围的字符，此时string = "Swift!~~~~ Hello-Worl"
string.removeSubrange(string.startIndex...string.index(string.startIndex, offsetBy: 2))
//删除所有字符，此时string = ""
string.removeAll()

var string2 = "My name is Jaki"
print(string2)
//全部转换为大写
string2 = string2.uppercased()
print(string2)
//全部转换为小写
string2 = string2.lowercased()
print(string2)

//检查字符串是否有 My 前缀
string2.hasPrefix("My")
//检查字符串是否有 jaki 后缀
string2.hasSuffix("jaki")

Sammlungstyp

In der Swift-Sprache stehen drei Sammlungstypen zur Verfügung: Array (Array), Sammlung (Set) und Wörterbuch (Dictionary). Der Array-Typ ist eine geordnete Sammlung, und die darin eingegebenen Daten haben eine Nummer, und die Nummer beginnt bei 0 und erhöht sich sequentiell. Anhand der Zahl können Entwickler den entsprechenden Wert im Array-Array finden. Eine Sammlung ist ein Satz ungeordneter Daten, und die darin gespeicherten Daten haben keine Nummer. Entwickler können die Traversal-Methode verwenden, um alle darin enthaltenen Daten abzurufen. Eine Sammlung ist eine Schlüssel-Wert-Zuordnungsstruktur, in der jeder gespeicherte Wert einem bestimmten Schlüssel entsprechen muss und der Schlüssel nicht wiederholt werden kann. Entwickler können den entsprechenden Wert direkt über den Schlüssel erhalten. Ein Beispielbild in der offiziellen Entwicklungsdokumentation von Swift kann die Ähnlichkeiten und Unterschiede dieser drei Sammlungstypen deutlich beschreiben

Array-Typ (Array).

Die Elemente, die im Array gespeichert werden können, sind nicht nur Zahlen, es kann jede Art von Daten speichern, aber alle Datentypen müssen vereinheitlicht werden. In der tatsächlichen Entwicklung bestimmt der Typ der Elemente im Array den Typ des Arrays

//Int整形数组
var array1 : [Int]
var array2 : Array<Int>

Die beiden obigen Codezeilen deklarieren beide eine Instanz eines Arrays vom Typ Int. Es gibt zwei Möglichkeiten, ein Array zu erstellen: Eine besteht darin, die Konstruktormethode des Arrays zu verwenden, um es zu erstellen, und die andere darin, eckige Klammern zum Erstellen zu verwenden es schnell.

var array1 : [Int]
var array2 : Array<Int>
//创建空数组
array1 = []
array2 = Array()
//创建整形数组
array1 = [1, 2, 3]
//通过一组元素创建数组
array2 = Array(arrayLiteral: 1, 2, 3)

Ähnlich wie beim String-Typ bedeutet ein leeres Array nicht, dass die Variable Null ist, sondern dass die Elemente im Array leer sind. In Swift können nur Variablen vom Typ Optional Null sein.

In der Swift-Sprache werden Arrays mithilfe von Strukturen implementiert. Bei Arrays mit einer großen Anzahl wiederholter Elemente können Entwickler direkt Verknüpfungsmethoden zum Erstellen verwenden

//创建大量有相同元素的数组
//创建有10个String类型元素的数组，并且每个元素都为字符串“Hello”
var array3 = [String](repeating: "Hello", count: 10)
print(array3)
//创建有10个Int类型元素的数组，并且每个元素都是1
var array4 = Array(repeating: 1, count: 10)
print(array4)

Leser sollten beachten, dass der Typ des Arrays bei der Deklaration angegeben werden muss, der Entwickler den Typ jedoch nicht unbedingt explizit angeben muss. Wenn der Anfangswert auch bei der Deklaration des Arrays festgelegt wird, leitet der Compiler den Wert automatisch ab des Arrays basierend auf dem Zuweisungstyp. Typ
Array Der Additionsoperator wird auch im Array überladen. Entwickler können „+“ verwenden, um zwei Arrays hinzuzufügen. Das Ergebnis der Addition besteht darin, die Elemente im zweiten Array nach hinten zu verbinden das erste Array. Es ist zu beachten, dass die hinzugefügten Array-Typen gleich sein müssen

var array5 = [1, 2, 3] + [4, 5, 6]
print(array5)

Das Array bietet Entwicklern viele Methoden, um die relevanten Informationen der Array-Instanz abzurufen oder das Array hinzuzufügen, zu löschen, zu ändern und zu überprüfen

print(array.count)
if array.isEmpty {
    
    
    print("array为空数组")
}
var a = array[0]
print(a)
var subArray = array[0...3]
print(subArray)
var b = array.first
print(b)
var c = array.last
print(c)
array[0] = 0
print(array)
array[0...3] = [1, 2, 3, 4]
print(array)
array.append(10)
print(array)
array.append(contentsOf: [11, 12, 13])
print(array)
array.insert(0, at: 0)
print(array)
array.insert(contentsOf: [-2, -1], at: 0)
print(array)
array.remove(at: 1)
print(array)
array.removeFirst()
print(array)
array.removeLast()
print(array)
array.removeFirst(2)
print(array)
array.removeLast(2)
print(array)
array.removeSubrange(0...2)
print(array)
array.replaceSubrange(0...2, with: [0, 1])
print(array)
array.removeAll()
print(array)
if array.contains(1) {
    
    
    print(true)
}
print(array)

Hierbei ist zu beachten, dass Methoden wie Hinzufügen, Löschen und Ändern nur dann verwendet werden können, wenn die Array-Instanz eine Variable ist, und dass mit der Änderung verbundene Vorgänge nicht für konstante Arrays ausgeführt werden können.

//Int型数组
let arrayLet = [0, 1, 2, 3, 4]
//（Int， Int）型数组
let arrayLet2 = [(1, 2), (2, 3), (3, 4)]
//直接遍历数组
for item in arrayLet {
    
    
    print(item)
}
//进行数组枚举遍历
for item in arrayLet.enumerated() {
    
    
    print(item)
}
//进行数组角标遍历
for index in arrayLet2.indices {
    
    
    print(arrayLet2[index], separator:"")
}

Array-Instanzen können direkt durchlaufen werden. Es gibt immer noch einige Unterschiede zwischen der For-In-Struktur in Swift und der For-In-Struktur in Objective-C. Die For-In-Struktur in Swift wird beim Durchlaufen des Arrays der Reihe nach durchlaufen. Es gibt auch eine enumerated()-Methode in der Array-Instanz, die eine Reihe von Tupeln sowie den Index und die entsprechenden Elemente des Arrays zurückgibt. Entwickler können die Elemente im Array auch erhalten, indem sie die Indizes des Arrays durchlaufen. Im Gegensatz zum String-Typ können die Indizes im Array vom Typ Int sein, während die Indizes im String ausschließlich vom Typ Index sind. Beachten Sie hier: Lassen Sie sich nicht verwirren.

Es gibt ein Indexattribut im Array-Typ, das einen Bereich (Range) zurückgibt, der dem Bereich des Array-Index entspricht.
Der Array-Typ bietet auch eine Sortierfunktion. Wenn es sich bei den Elementen im Array um ganzzahlige Daten handelt, können Sie die vom System bereitgestellte Methode sorted(by:) verwenden, um den Sortiervorgang durchzuführen. Wenn es sich um einen benutzerdefinierten Typ handelt, kann der Entwickler dies auch tun Legen Sie fest, dass die Methode sorted(by:) den Schließungsparameter übergibt, um eine neue Sortierregel zu implementieren, die in den folgenden Kapiteln ausführlich beschrieben wird. Der Beispielcode für die Methode zum Sortieren des Arrays lautet wie folgt:

var arraySort = [1, 3, 5, 6, 7]
arraySort = arraySort.sorted(by: >)
print(arraySort)
arraySort = arraySort.sorted(by: <)
print(arraySort)

print(arraySort.max())
print(arraySort.min())

Sammlungstyp (Set).

Der Sammlungstyp achtet nicht auf die Reihenfolge der Elemente, aber die darin enthaltenen Elemente können nicht wiederholt werden, und der Leser kann sie auch als ungeordnete Sammlung verstehen. Wie ein Array muss eine Sammlung bei der Deklaration ihren Typ angeben oder ihr einen Anfangswert zuweisen, damit der Compiler selbst auf den Typ der Sammlung schließen kann

var set1 : Set<Int> = [1, 2, 3, 4]
var set2 = Set(arrayLiteral: 1, 2, 3, 4)
var a = set1[set1.startIndex]
var b = set1[set1.index(after: set1.startIndex)]
var c = set1[set1.index(set1.startIndex, offsetBy: 3)]
print(a, b, c)

Da die Sammlung nicht auf die Reihenfolge der darin enthaltenen Elemente achtet, ist es für die Sammlung nicht sinnvoll, den Wert per Index abzurufen. Der Sammlungstyp unterstützt jedoch weiterhin den Index, um die darin enthaltenen Elemente abzurufen. Es sollte beachtet werden Die Indexoperation der Sammlung ist
irreversibel. Die Operation kann nur rückwärts und nicht vorwärts erfolgen.
Mit der folgenden Methode können einige Informationen in der Sammlungsinstanz abgerufen werden

//获取元素个数
set1.count
//判断集合是否为空集合
if set1.isEmpty {
    
    
print("集合为空") }
//判断集合中是否包含某个元素
if set1.contains(1){
    
    
print("集合包含") }
//获取集合中的最大值
set1.max()
//获取集合中的最小值
set1.min()

Sammlungen unterstützen auch Hinzufügungs-, Lösch-, Änderungs- und Abfragevorgänge

//向集合中插入一个元素
set1.insert(5)
//移除集合中的某个元素
set1.remove(1)
//移除集合中的第一个元素
set1.removeFirst() //移除集合中某个位置的元素
set1.remove(at: set1.firstIndex(of: 3)!)
//移除集合中所有的元素
set1.removeAll()

Wenn Sie die Methode „remove(at:)“ verwenden, um ein Element an einer bestimmten Position in der Sammlung zu löschen, ist es erforderlich, den Indexwert eines Sammlungselements zu übergeben, und der Indexwert eines bestimmten Elements kann über firstIndex( abgerufen werden of:) Methode der Sammlungsinstanz. Es ist zu beachten, dass diese Methode einen optionalen Wert vom Typ „Optional“ zurückgibt, da das zu findende Element möglicherweise nicht vorhanden ist und der Entwickler es bei der Verwendung entpacken muss.
Neben dem Unterschied zwischen geordneten und ungeordneten Mengen und Arrays weisen Mengen auch eine einzigartige Eigenschaft auf: Sie können mathematische Operationen ausführen, beispielsweise Schnittoperationen, Vereinigungsoperationen und Komplementoperationen. Ein Bild im offiziellen Entwicklungsdokument von Swift zeigt die Szene, in der die Menge mathematische Operationen ausführt.
Es ist ersichtlich, dass die Menge vier Arten mathematischer Operationen unterstützt, nämlich Schnittoperation (Schnittoperation), symmetrische Differenzoperation (Komplement der Schnittmenge) und Vereinigung (Vereinigung). )-Operation und Subtraktionsoperation (Komplementsatz). Das Ergebnis der Schnittoperation ist die Schnittmenge zweier Mengen. Das Ergebnis der Komplementoperation der Schnittmenge ist die Vereinigung der a-Menge und der b-Menge, mit Ausnahme der Schnittmenge der a-Menge und der b-Menge. Das Ergebnis der Vereinigung Operation ist die Vereinigung der beiden Mengen. Das Ergebnis der Mengenoperation ist Menge a minus dem Schnittpunkt von Menge a und Menge b. Die Beispielcodes für die oben genannten vier Operationen lauten wie folgt:

var set3:Set<Int> = [1,2,3,4]
var set4:Set<Int> = [1,2,5,6] //返回交集 {1，2}
var setInter = set3.intersection(set4) //返回交集的补集{3，4，5，6}
var setEx = set3.symmetricDifference(set4) //返回并集{1，2，3，4，5，6}
var setUni = set3.union(set4) //返回第二个集合的补集{3，4}
var setSub = set3.subtracting(set4)

Verwenden Sie den Vergleichsoperator „==“, um zu vergleichen, ob zwei Sammlungen gleich sind. Wenn alle Elemente in den beiden Sammlungen gleich sind, sind die beiden Sammlungen gleich. Die Sammlung bietet auch einige Methoden zur Beurteilung der Beziehung zwischen Sammlungen

var set5:Set = [1,2]
var set6:Set = [2,3]
var set7:Set = [1,2,3]
var set8:Set = [1,2,3]
//判断是否是某个集合的子集，set5 是 set7 的子集，返回 ture 
set5.isSubset(of: set7)
//判断是否是某个集合的超集，set7 是 set5 的超集，返回 ture 
set7.isSuperset(of: set5)
//判断是否是某个集合的真子集，set5 是 set7 的真子集，返回 ture 
set5.isStrictSubset(of: set7) //判断是否是某个集合的真超集，set7 不是 set8 的真超集，返回 false 
set7.isStrictSuperset(of: set8)

Ähnlich wie ein Array kann eine Sammlung auch alle Daten in der Sammlung durch For-In-Traversierung erhalten. Sie kann auf drei Arten durchlaufen werden: Durchlaufen von Elementen, Aufzählung der durchquerenden Sammlung und Indizes der durchquerenden Sammlung. Die Set-Aufzählung gibt ein Tupel zurück, in dem der Set-Index und der entsprechende Wert zusammen zurückgegeben werden

//遍历元素
for item in set7 {
    
    
	print(item) 
}
//遍历集合的枚举
for item in set7.enumerated() {
    
    
	print(item) 
}
//遍历集合的下标
for index in set7.indices {
    
    
	print(set7[index]) 
}

Obwohl die Sammlung keinen Schwerpunkt auf die Reihenfolge der Elemente legt, können Entwickler diese beim Durchlaufen vor dem Durchlaufen sortieren

for item in set7.sorted(by: >) {
    
    
	print(item) 
}

Typ Wörterbuch (Wörterbuch).

Wenn ein Wörterbuch verwendet wird, wird ein Ergebnis über einen Index gefunden.
Dieser Datenspeichermodus wird als Schlüsselwert-Zuordnungsmodus bezeichnet, dh ein bestimmter Wert kann über einen bestimmten Schlüssel gefunden werden.

//声明字典[param1:param2]，这种结构用于表示字典类型，param1 为键类型，param2 为值类型 
var dic1:[Int:String]
//这种方式和[:]效果一样，dic2 与 dic1 为相同的类型
var dic2:Dictionary<Int,String>
//字典创建与赋值
dic1 = [1:"1",2:"2",3:"3"]
dic2 = Dictionary(dictionaryLiteral: (1,"1"),(2,"2"),(3,"3")) //在创建字典时，也可以不显式声明字典的类型，可以通过赋初值的方式来使编译器自动推断 
var dic3 = ["1":"one"]
//创建空字典
var dic4:[Int:Int] = [:]
var dic5:Dictionary<Int,Int> = Dictionary()

Wörterbücher verwenden Schlüssel, um bestimmte Werte zu finden. Werte können in einem Wörterbuch wiederholt werden, Schlüssel müssen jedoch eindeutig sein. Dadurch wird sichergestellt, dass ein bestimmter Schlüssel einen bestimmten Wert finden kann. Wenn der Entwickler doppelte Schlüssel im Wörterbuch erstellt, meldet der Compiler ebenfalls einen Fehler.
Der Wörterbuchtyp unterstützt auch die Verwendung von isEmpty und count, um zu bestimmen, ob es leer ist, und um die Anzahl der Elemente zu erhalten

//获取字典中的元素个数 
dic1.count 
//判断字典是否为空
if dic4.isEmpty{
    
    
	print("字典为空") 
}

Der der Änderung entsprechende Wert kann über einen bestimmten Schlüssel abgerufen werden

//通过键操作值 //获取值
dic1[2]
//修改值 
dic1[1]="0" 
//添加一对新的键值 
dic1[4] = "4"

dic1[1]="0" und dic1[4]="4" im obigen Code führen tatsächlich denselben Vorgang aus, der wie folgt verstanden werden kann: Wenn einem Schlüssel ein Wert zugewiesen wird, ist der Schlüssel vorhanden sein Die Aktualisierung des Werts. Wenn der Schlüssel nicht vorhanden ist, wird ein neues Schlüssel-Wert-Paar hinzugefügt. In der Entwicklung ist es jedoch in vielen Fällen erforderlich, einen vorhandenen Schlüssel zu aktualisieren. Wenn der Schlüssel nicht vorhanden ist, wird kein neues Schlüssel-Wert-Paar hinzugefügt. Um diesen Effekt zu erzielen, können Sie die Methode zum Aktualisieren des Schlüssel-Werts von verwenden das Wörterbuch

//对键值进行更新 
dic1.updateValue("1", forKey: 1)

Die Methode updateValue(value:forkey:) wird verwendet, um ein vorhandenes Schlüssel-Wert-Paar zu aktualisieren, wobei der erste Parameter der neue Wert und der zweite Parameter der zu aktualisierende Schlüssel ist. Diese Methode gibt bei der Ausführung einen Wert vom Typ „Optional“ zurück. Wenn der Schlüssel im Wörterbuch vorhanden ist, ist die Aktualisierung erfolgreich und der alte Wert des Schlüssels wird in einen optionalen Wert eingeschlossen und zurückgegeben. Wenn der Schlüssel nicht vorhanden ist, Es wird Null zurückgegeben. In der Entwicklung wird häufig die If-Let-Struktur zur Handhabung verwendet

if let oldValue = dic1.updateValue("One", forKey: 1) {
    
     print("Old Value is \(oldValue)")
}

Wenn der Wert im Wörterbuch über den Schlüssel abgerufen wird, wird tatsächlich auch ein optionaler Wert zurückgegeben. Wenn der Schlüssel nicht vorhanden ist, ist der optionale Wert Null, sodass die If-Let-Struktur auch verwendet werden kann, um die Sicherheit von zu gewährleisten das Programm.

//通过键获取的数据也将返回Optional类型的值，也可以使用
if let if let value = dic2[1] {
    
    
print("The Value is \(value)") }
下面的方法可以实现对字典中键值对的删除操作:
//通过键删除某个键值对 
dic1.removeValue(forKey: 1) 
//删除所有键值对 
dic1.removeAll()

Beim Durchlaufen eines Wörterbuchs können Sie die Sammlung aller Schlüssel im Wörterbuch oder die Sammlung aller Werte im Wörterbuch durchlaufen und alle Schlüssel und Werte des Wörterbuchs durchsuchen das Schlüsselattribut und das Werteattribut der Wörterbuchinstanz.

//通过键来遍历字典
for item in dic2.keys {
    
    
	print(item) 
}
//通过值来遍历字典
for item in dic2.values {
    
    
	print(item) 
}
//直接遍历字典
for item in dic2 {
    
    
	print(item) 
}
for (key,value) in dic2 {
    
     
	print("\(key):\(value)")
}

Sie können die Wörterbuchinstanz auch direkt durchlaufen. Der Schlüssel und der Wert eines umschließenden Wörterbuchs vom Tupeltyp werden während des Durchlaufs zurückgegeben.
Beim Durchlaufen von Wörterbuchschlüsseln oder -werten wird auch das Sortierdurchlaufen unterstützt

for item in dic2.keys.dic2.keys.sorted(by: >) {
    
     print(dic2[item]!)
}

Grundlegende Operatoren und Programmflusskontrolle

• Unärer Operator: Ein unärer Operator wirkt auf einen Operanden, der vor dem Operanden stehen kann, wie zum Beispiel die positiven und negativen Operatoren „+“ und „-“ und der logische NICHT-Operator „!“.
• Binäre Operatoren: Binäre Operatoren wirken zwischen zwei Operanden, beispielsweise die Additions- und Subtraktionsoperatoren „+“ und „-“.
• Ternärer Operator: Der ternäre Operator wirkt auf drei Operanden. Zu den klassischen ternären Operatoren gehören Fragezeichen- und Y-Mark-Operatoren, mit denen sich
  einfache Beurteilungs- und Auswahlstrukturen leicht realisieren lassen.

//字符串赋值
var str = "Hello, playground" //整型赋值
var count = 5
//元组赋值
var group = (1,2,"12")
//Bool 赋值
var bol = true

Wenn Sie die Werte in einem Tupel der Reihe nach dem angegebenen Wert zuweisen möchten, unterstützt Swift auch die Verwendung einer destrukturierenden Zuweisungssyntax für die Zuweisung

Zuweisungsoperatoren werden zur Übergabe von Werten verwendet. Das Ergebnis ist, dass der Menge ein bestimmter Wert zugewiesen wird. Für Vergleichsoperationen werden Gleichheitsoperatoren verwendet, die einen logischen Wert vom Typ Bool zurückgeben
Seit der Swift-Sprachversion 2.2 wurden der Auto-Inkrement-Operator „++“ und der Auto-Dekrement-Operator „–“ gelöscht.
Diese beiden Operatoren können in der aktuellen Version der Swift-Sprache nicht verwendet werden .

Null-Koaleszenzoperator

Der optionale Werttyp ist eine einzigartige Funktion der Swift-Sprache, und der Null-Koaleszenzoperator ist ein Operator, der für den optionalen Werttyp entwickelt wurde

var q:Int? = 8 
var value:Int 
if q != nil {
    
    
	value = q! 
} else {
    
    
	value = 0 
}

Das obige Beispiel stellt eine einfache if-else-Auswahlstruktur dar. Mit dem in Abschnitt 4.1.5 eingeführten bedingten Operator (ternärer Operator) kann der obige Code wie folgt abgekürzt werden

var q:Int? = 8
var value:Int
value = (q != nil) ? (q!) : 0

Der mit dem bedingten Operator neu geschriebene Code ist viel einfacher. Die Swift-Sprache bietet auch einen Null-Koaleszier-Operator, um die bedingte Auswahlstruktur dieses optionalen Typwerts prägnanter zu handhaben. Der Null-Koaleszier-Operator wird durch „??“ und den obigen Code dargestellt kann wie folgt umgeschrieben werden:

//空合并运算符 
var q:Int? = 8 
var value:Int value = q ?? 0

Der Null-Koaleszenzoperator „??“ ist ein binärer Operator, und der mit dem Null-Koaleszenzoperator neu geschriebene Code ist prägnanter. Es sind zwei Operanden erforderlich. Der erste Operand muss ein optionaler Wert sein. Wenn der optionale Wert nicht Null ist, wird er entpackt und als Ergebnis der Null-Koaleszenzoperation verwendet. Wenn der Wert dieses Optionals Null ist, wird der zweite Operand als Ergebnis der Null-Koaleszenzoperation zurückgegeben. Es ist praktisch, den Nullkoaleszenzoperator zu verwenden, um die Auswahllogik für optionale Werte zu verwalten

Intervalloperator

Swift unterstützt nicht nur die Range-Struktur zur Beschreibung des Bereichs, sondern bietet auch einen Intervalloperator, um das Bereichsintervall schnell und intuitiv auszudrücken.

//创建范围 >=0 且<=10 的闭区间 
var range1 = 0...10 
//创建范围>=0 且<10 的半开区间 
var range2 = 0..<10

Sie können auch den Operator „~=" verwenden, um zu prüfen, ob eine Zahl in einem Bereich enthalten ist

//8 是否在 range1 中
print(range1 ~= 8) //输出 true

Intervalloperatoren werden häufig in For-In-Schleifenstrukturen verwendet. Entwickler verwenden häufig Intervalloperatoren, um die Anzahl der Schleifen zu definieren. Beispiele sind wie folgt:

//a...b 为闭区间写法 
for index in 0...3 {
    
    
	print(index) 
}
//a..<b 为左闭右开区间 
for index in 0..<3 {
    
    
	print(index) 
}

Wenn in der for-in-Schleifenstruktur auf das Schlüsselwort in eine Sammlung folgt, erhält der Variablenindex automatisch die Elemente in der Sammlung. Wenn auf das Schlüsselwort in ein Bereich folgt, wird der erhaltene Index von links nach rechts durchlaufen Anzahl der zu erreichenden Bereichsindizes.

Schleifenstruktur

for-in-Schleifenstruktur

Den Lesern ist die For-In-Struktur nicht fremd, und viele der in den vorherigen Kapiteln vorgestellten Inhalte verwenden die For-In-Struktur zur Demonstration. Wenn der Leser die Sprache C/Objective-C versteht, sollte hier beachtet werden, dass die for-in-Schleifenstruktur auch in der Sprache C/Objective-C unterstützt wird, sie jedoch als schnelle Traversierung bezeichnet wird und die damit ausgeführten Schleifenoperationen sind außer Betrieb. Die for-in-Struktur in der Swift-Sprache ist viel leistungsfähiger und kann einen ungeordneten Schleifendurchlauf und auch einen geordneten Schleifendurchlauf durchführen

//将打印 1，2，3，4，5 
for index in 1...5 {
    
    
print(index) }

Die for-in-Struktur erfordert zwei Parameter. Der zweite Parameter kann eine Instanz eines Sammlungstyps oder eines Bereichsintervalls sein. Der erste Parameter ist ein Erfassungsparameter. Die Elemente, die jedes Mal vom zweiten Parameter durchlaufen werden, werden ihm zugewiesen, und Entwickler können es direkt in der Schleifenstruktur verwenden.
Beim Durchlaufen einer For-In-Schleife müssen Entwickler die durchlaufenen Werte nicht erfassen und können anonyme Parameter verwenden, um sie zu empfangen. Swift verwendet das Symbol „_“, um anonyme Parameter darzustellen.

//如果不需要获取循环中的循环次序，可以使用如下方式 var sum=0;
for _ in 1...3 {
    
    
sum += 1 }

Das Durchlaufen von Sammlungen ist eines der am häufigsten verwendeten Szenarios für For-In-Schleifen, die in den vorherigen Kapiteln zur Erläuterung von Sammlungstypen ausführlich vorgestellt wurden

//遍历集合类型
var collection1:Array = [1,2,3,4]
var collection2:Dictionary = [1:1,2:2,3:4,4:4] var collection3:Set = [1,2,3,4]
for obj in collection1 {
    
    
print(obj) }
for (key , value) in collection2 {
    
     print(key,value)
}
for obj in collection3 {
    
    
print(obj) }

While- und Repeat-While-Bedingungsschleifenstruktur

Die Strukturen „while“ und „repeat-while“ werden auch in der C/Objective-C-Sprache unterstützt, und die Funktionen sind im Grunde die gleichen, aber die Swift-Sprache ändert die Struktur „do-while“ in „repeat-while“.
In der Entwicklung ist häufig eine bedingte Zirkulation erforderlich, z. B. die Simulation des Prozesses der Wasserspeicherung in einem Pool, wobei jedes Mal 1/10 des Wassers gespeichert wird und die Wasserspeicherung gestoppt wird, wenn sie voll ist. Die While-Schleifenstruktur kann sehr praktisch sein, um diese Art von Schleifencode zu erstellen

var i=0
//当 i 不小于 10 时跳出循环 while i<10 {
    
    
print("while",i) //进行 i 的自增加 i+=1
}

In der While-Schleifenstruktur müssen Sie nach dem Schlüsselwort while einen logischen Wert oder einen Ausdruck mit einem logischen Wert als Ergebnis der Schleifenbedingung eingeben. Wenn der logische Wert wahr ist, gibt das Programm den Körper von while ein Schleife. Nachdem der Code des Schleifenkörpers ausgeführt wurde, wird die Schleifenbedingung beurteilt. Wenn die Schleifenbedingung immer noch wahr ist, wird der Schleifenkörper erneut eingegeben, andernfalls endet die Schleife. Da die While-Schleife anhand der Schleifenbedingung beurteilt, ob in den Schleifenkörper eingetreten werden soll, wird die Schleife endlos wiederholt, wenn die Schleifenbedingung immer wahr ist. Daher sollten Entwickler bei Verwendung der While-Schleife darauf achten, die Schleifenbedingung in der Schleife zu ändern body und changes Das Ergebnis ist, dass die Schleifenbedingung nicht erfüllt ist, da sonst eine Endlosschleife auftritt.

//使用 Switch 语句进行元组的匹配 
var tuple = (0,0)
switch tuple {
    
     //进行完全匹配
case (0,1): 
	print("Sure")
//进行选择性匹配 
case (_,1):
	print("Sim")
//进行元组元素的范围匹配 
case(0...3,0...3):
	print("SIM") 
default:
	print("") }

Wie im obigen Code gezeigt, gibt es beim Abgleichen von Tupeln drei Möglichkeiten zur Auswahl: Der erste Weg ist der exakte Abgleich, das heißt, alle Elemente im Tupel müssen vollständig gleich sein, bevor der Abgleich erfolgreich ist; der zweite Weg ist der optionale Abgleich Das heißt, der Entwickler muss nur einige Elemente im Tupel für den Abgleich angeben, und die Elemente, die nicht berücksichtigt werden müssen, können durch anonyme Parameterbezeichner ersetzt werden. Auf diese Weise ist die Übereinstimmung gegeben, solange die angegebenen Parameter gleich sind erfolgreich; die dritte Die erste Methode ist der Bereichsabgleich, dh der durch die entsprechende Position angegebene Bereich enthält den Wert der entsprechenden Position des abzugleichenden Tupels, auch wenn der Abgleich erfolgreich ist. Die zweite Matching-Methode kann mit der dritten Matching-Methode kombiniert werden.
Die Case-Klausel in der Swift-Sprache kann auch die Parameter des Switch-Tupels erfassen, und die erfassten Parameter können direkt im entsprechenden Case-Codeblock verwendet werden. Dies befindet sich in der Entwicklung Der geschriebene Code kann vereinfacht werden

var tuple = (1,0) //进行数据绑定

switch tuple {
    
    
//对元组中的第一个元素进行捕获
case (let a,1):
    print(a)
case (let b,0):
    print(b)
//捕获元组中的两个元素，let(a,b) 与 (let a,let b)意义相同
case let(a,b):
    print(a,b)
default:
    print("")
    
}

Der Leser muss hier darauf achten, dass die zu erfassenden Elemente keine übereinstimmende Rolle spielen können. Beispielsweise gibt es zwei Elemente im Tupel. Wenn die Fallbedingung (sei a, 1) lautet, wird das zweite Element im Tupel abgeglichen Wenn der Parameter beim Vergleich erfolgreich ist, wird der Wert des ersten Parameters des Tupels an die Konstante a übergeben und der Codeblock wird in diesem Fall ausgeführt. In diesem Codeblock kann der Entwickler die Konstante direkt verwenden A. Daher fungiert das zu erfassende Element beim Abgleich tatsächlich als anonymer Bezeichner, wie z. B. die dritte Case-Klausel im obigen Code. Seine Bedingung lautet let(a,b). Tatsächlich wird diese Bedingung immer erfolgreich abgeglichen. Wenn der Entwickler außerdem alle Elemente im Tupel erfasst, kann er im Hinblick auf die Codeleistung als (let a, let b) geschrieben werden oder das gesamte Tupel direkt als let (a, b) erfassen. Die beiden Die Wege unterscheiden sich nur in der Schrift und es gibt keinen Unterschied in der Verwendung.

var tuple = (0,0) //进行数据绑定
//对于进行了数据捕获的 Switch-case 结构，可以使用 where 关键字来进行条件判断
switch tuple {
    
    
    case (let a,1):
        print(a)
//当元组中的两个元素都等于 0 时才匹配成功，并且捕获第一个元素的值
    case (let b,0) where b==0:
        print(b) //当元组中的两个元素相同时，才会进入下面的case
    case let(a,b) where a==b:
        print(a,b)
    default:
        print("")
}

Flow-Jump-Anweisung in Swift-Sprache

Die Sprunganweisung kann die Schleifenstruktur im Voraus unterbrechen und auch den Sprung der ausgewählten Struktur künstlich steuern, wodurch die Ausführung des Codes flexibler und veränderbarer wird. Swift stellt Entwicklern eine große Anzahl von Prozesssprunganweisungen zur Verfügung. Wenn Sie mit der Struktur und den Eigenschaften dieser Anweisungen vertraut sind, kann die Entwicklungseffizienz erheblich verbessert werden. Zu den in Swift bereitgestellten Flow-Jump-Anweisungen gehören hauptsächlich Continue-, Break-, Fallthrough-, Return-, Throw- und Guard-
Fortsetzungsanweisungen, die in der Schleifenstruktur verwendet werden und deren Funktion darin besteht, diese Schleife zu überspringen und die nächste Schleife direkt zu starten. Hierbei ist zu beachten, dass die Funktion von continue nicht darin besteht, aus der Schleifenstruktur zu springen, sondern diese Schleife zu überspringen und den nächsten Zyklus direkt auszuführen

for index in 0...9 {
    
    
    if index == 6 {
    
    
        continue
    }
    print("第\(index)次循环")
}

Der Standardoperationsbereich der continue-Anweisung umfasst direkt ihre Schleifenstruktur. Wenn im Code mehrere Ebenen von Schleifenstrukturen verschachtelt sind, überspringt die continue-Anweisung diese Schleife. Wenn Sie also diese Schleife überspringen möchten, springen Sie direkt zu der vom Entwickler angegebenen Ebene der Schleifenstruktur

MyLabel:for indexI in 0...2 {
    
    
    for indexJ in 0...2 {
    
    
        if indexI == 1 {
    
    
            continue MyLabel
        }
    print("第\(indexI)\(indexJ)次循环")
    }
}

Der obige Code erstellt eine zweischichtige Schleifenstruktur. Die continue-Anweisung wird in der inneren Schleife zum Springen verwendet. MyLabel ist die Beschriftung der äußeren Schleife. Wenn IndexI gleich 1 ist, springt der Fortsetzungssprung hier aus der äußeren Schleife , und starten Sie direkt die Schleifenoperation mit indexI gleich 2.

Die Break-Anweisung ist eine Interrupt-Anweisung, die auch in einer Schleifenstruktur verwendet werden kann. Im Gegensatz zur Continue-Anweisung unterbricht die Break-Anweisung direkt die Schleifenstruktur, die sie direkt enthält, dh wenn die Schleifenstruktur eine Ebene ist, wenn die Schleife nicht ausgeführt wurde, werden alle nachfolgenden Schleifen übersprungen. Wenn mehrere Schichten einer Schleifenstruktur vorhanden sind, unterbricht das Programm direkt die Schleifenstruktur, die sie direkt enthält, und führt die Schleifenstruktur außerhalb der Schleifenstruktur weiter aus

for index in 0...9 {
    
    
    if index == 6 {
    
    
        break
    }
    print("第\(index)次循环")
}

Der obige Code verwendet eine Break-Anweisung zum Unterbrechen, wenn der Index gleich 6 ist, und alle Druckinformationen nach dem fünften Zyklus werden übersprungen. Die Break-Anweisung unterbricht standardmäßig die Schleifenstruktur, die sie direkt enthält, und Sie können auch die angegebene Bezeichnung verwenden, um die angegebene Schleifenstruktur zu unterbrechen

MyLabel:for indexI in 0...2 {
    
    
    for indexJ in 0...2 {
    
    
        if indexI == 1 {
    
    
            break MyLabel
        }
    print("第\(indexI)\(indexJ)次循环")  
    }
}

Die break-Anweisung kann auch in der Switch-Struktur verwendet werden. In der Switch-Struktur unterbricht die Break-Anweisung alle nachfolgenden Matching-Prozesse direkt und springt direkt aus der Switch-Struktur heraus. In der Swift-Sprache verwendet die Switch-Case-Auswahl-Übereinstimmungsstruktur standardmäßig den Break-Vorgang, sodass Entwickler den Break-Code nicht manuell hinzufügen müssen. Die Fallthrough-Anweisung ist eine
eindeutige Flusskontrollanweisung in Swift. Wie bereits erwähnt, wenn der Switch- Fall in der Swift-Sprache Nachdem die Struktur mit einem Fall übereinstimmt, wird der Übereinstimmungsvorgang aller nachfolgenden Fälle automatisch unterbrochen. Wenn die Switch-Case-Struktur den Vorgang in der tatsächlichen Entwicklung nicht automatisch unterbricht, können Sie die Fallthrough-Anweisung verwenden

var tuple = (0,0)
switch tuple {
    
    
    case (0,0):
        print("Sure")
        //fallthrough 会继续执行下面的 case
        fallthrough
    case (_,0):
        print("Sim")
        fallthrough
    case(0...3,0...3):
        print("SIM")
    default:
        print("")
}

Die Return-Anweisung sollte dem Leser sehr vertraut sein. Sie wird in einer Funktion verwendet, um einen Ergebniswert zurückzugeben, und sie kann auch verwendet werden, um eine Funktion vorzeitig zu beenden, die keinen Werttyp zurückgibt. Natürlich sind die Anwendungsszenarien der Return-Anweisung nicht auf Funktionen beschränkt, und Return kann auch in Abschlüssen zur Rückgabe verwendet werden

//有返回值函数的返回
func myFunc()->Int{
    
    
    return 0
}
//无返回值函数的返回
func myFunc(){
    
    
    return
}

Die Throw-Anweisung wird zum Auslösen von Ausnahmen verwendet. Wenn die von der Throw-Anweisung ausgelöste Ausnahme nicht abgefangen und verarbeitet wird, wird das Programm ebenfalls unterbrochen.

//定义异常类型
enum MyError:Error{
    
    
    case errorOne
    case errorTwo
    
}
func newFunc() throws{
    
    
    //抛出异常
    throw MyError.errorOne
}

Die Guard-Else-Strukturanweisung ist eine neue grammatikalische Struktur, die nach Swift 2.0 hinzugefügt wurde. Das Swift-Team hat sie erstellt, um die Struktur und Logik des Codes klarer zu machen. In der tatsächlichen Entwicklung, insbesondere beim Schreiben von Funktionen, tritt häufig ein solches Szenario auf: Wenn die Parameter eine bestimmte Bedingung erfüllen, kann die Funktion normal ausgeführt werden. Andernfalls wird die Ausführung der Funktion direkt durch Rückgabe beendet, wenn Sie sie nicht verwenden Guard-Else-Struktur

Grundlegende Anwendung von Funktionen

Grammatische Struktur von Verschlüssen