Suche…


Syntax

  • für Konstante in Reihenfolge {Anweisungen}
  • für Konstante in Reihenfolge, wo Bedingung {Anweisungen}
  • für var-Variable in Reihenfolge {Anweisungen}
  • für _ in sequence {Anweisungen}
  • für den Fall, dass Konstante in Reihenfolge {Anweisungen}
  • für den Fall konstant in der Reihenfolge, wo die Bedingung {Anweisungen}
  • für Variable variabel in Reihenfolge {Anweisungen}
  • while-Bedingung {Anweisungen}
  • Wiederholen Sie {Anweisungen} solange Bedingung
  • sequence.forEach (Körper: (Element) wirft -> Void)

For-in-Schleife

Mit der For-in- Schleife können Sie eine beliebige Sequenz durchlaufen.

Iteration über einen Bereich

Sie können sowohl halboffen als auch geschlossene Bereiche durchlaufen:

for i in 0..<3 {
    print(i)
}

for i in 0...2 {
    print(i)
}

// Both print:
// 0
// 1
// 2

Iteration über ein Array oder Set

let names = ["James", "Emily", "Miles"]

for name in names {
   print(name)
}

// James
// Emily
// Miles
2.1 2.2

Wenn Sie den Index für jedes Element im Array benötigen, können Sie die Methode enumerate() für SequenceType .

for (index, name) in names.enumerate() {
   print("The index of \(name) is \(index).")
}

// The index of James is 0.
// The index of Emily is 1.
// The index of Miles is 2.

enumerate() gibt eine Lazy-Sequenz zurück, die Elementpaare mit aufeinander folgenden Int s enthält, beginnend mit 0. Daher entsprechen diese Zahlen bei Arrays dem angegebenen Index jedes Elements. Dies kann jedoch bei anderen Auflistungen nicht der Fall sein.

3,0

In Swift 3 wurde enumerate() in enumerated() :

for (index, name) in names.enumerated() {
   print("The index of \(name) is \(index).")
}

Iteration über ein Wörterbuch

let ages = ["James": 29, "Emily": 24]

for (name, age) in ages {
    print(name, "is", age, "years old.")
}

// Emily is 24 years old.
// James is 29 years old.

Iteration in umgekehrter Richtung

2.1 2.2

Sie können die reverse() Methode für SequenceType verwenden, um eine umgekehrte Reihenfolge zu durchlaufen:

for i in (0..<3).reverse() {
    print(i)
}

for i in (0...2).reverse() {
    print(i)
}

// Both print:
// 2
// 1
// 0

let names = ["James", "Emily", "Miles"]

for name in names.reverse() {
    print(name)
}

// Miles
// Emily
// James
3,0

In Swift 3 wurde reverse() in reversed() :

for i in (0..<3).reversed() {
    print(i)
}

Durchlaufen von Bereichen mit benutzerdefinierten Schritten

2.1 2.2

Mit den stride(_:_:) -Methoden von Strideable können Sie einen Bereich mit einem benutzerdefinierten Schritt Strideable :

for i in 4.stride(to: 0, by: -2) {
    print(i)
}

// 4
// 2

for i in 4.stride(through: 0, by: -2) {
    print(i)
}

// 4
// 2
// 0
1,2 3,0

In Swift 3 wurden die stride(_:_:) -Methoden von Stridable durch die globalen stride(_:_:_:) -Funktionen ersetzt:

for i in stride(from: 4, to: 0, by: -2) {
    print(i)
}

for i in stride(from: 4, through: 0, by: -2) {
    print(i)
}

Wiederholungsschleife

Ähnlich wie die while-Schleife wird nur die Steueranweisung nach der Schleife ausgewertet. Daher wird die Schleife immer mindestens einmal ausgeführt.

var i: Int = 0

repeat {
   print(i)
   i += 1
} while i < 3

// 0
// 1
// 2

while-Schleife

Eine while Schleife wird ausgeführt, solange die Bedingung erfüllt ist.

var count = 1

while count < 10 {
    print("This is the \(count) run of the loop")
    count += 1
}

Sequenztyp für jeden Block

Ein Typ, der dem SequenceType-Protokoll entspricht, kann durch seine Elemente innerhalb eines Abschlusses iterieren:

collection.forEach { print($0) }

Dasselbe kann auch mit einem benannten Parameter durchgeführt werden:

collection.forEach { item in
    print(item)
}

* Hinweis: Steuerflussanweisungen (wie break oder continue) dürfen in diesen Blöcken nicht verwendet werden. Ein return kann aufgerufen werden, und bei Aufruf wird der Block sofort für die aktuelle Iteration zurückgegeben (ähnlich wie bei einem continue). Die nächste Iteration wird dann ausgeführt.

let arr = [1,2,3,4]

arr.forEach {
    
    // blocks for 3 and 4 will still be called
    if $0 == 2 {
        return
    }
}

For-in-Schleife mit Filterung

  1. where Klausel

Durch das Hinzufügen einer where Klausel können Sie die Iterationen auf diejenigen beschränken, die die angegebene Bedingung erfüllen.

for i in 0..<5 where i % 2 == 0 {
    print(i)
}

// 0
// 2
// 4


let names = ["James", "Emily", "Miles"]

for name in names where name.characters.contains("s") {
    print(name)
}

// James
// Miles
  1. case - Klausel

Dies ist nützlich, wenn Sie nur die Werte durchlaufen müssen, die einem bestimmten Muster entsprechen:

let points = [(5, 0), (31, 0), (5, 31)]
for case (_, 0) in points {
    print("point on x-axis")
}

//point on x-axis
//point on x-axis

Sie können auch optionale Werte filtern und diese ggf. durch Hinzufügen von Unpack auslösen ? Markierung nach Bindungskonstante:

let optionalNumbers = [31, 5, nil]
for case let number? in optionalNumbers {
    print(number)
}

//31    
//5

Eine Schleife brechen

Eine Schleife wird ausgeführt, solange ihre Bedingung erfüllt ist. Sie können sie jedoch mit dem Schlüsselwort break manuell stoppen. Zum Beispiel:

var peopleArray = ["John", "Nicole", "Thomas", "Richard", "Brian", "Novak", "Vick", "Amanda", "Sonya"]
var positionOfNovak = 0

for person in peopleArray {
    if person == "Novak" { break }
    positionOfNovak += 1
}

print("Novak is the element located on position [\(positionOfNovak)] in peopleArray.")
//prints out: Novak is the element located on position 5 in peopleArray. (which is true)


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow