In diesem Artikel erfahren Sie mehr über die For-In-Schleife, ihre Anwendungsfälle und Varianten.
For-In-Schleifen werden verwendet, um eine Reihe von Aufgaben für eine bestimmte Anzahl von Malen auszuführen. Diese Schleifen durchlaufen alle Sequenzen, z. B. Elemente in einem Array, Bereich oder Zeichen in einer Zeichenfolge.
Wir verwenden auch die For-In-Schleife, um einige sich wiederholende Prozesse für einen festgelegten Zeitraum auszuführen.
Warum brauchen wir eine For-In-Schleife?
Stellen Sie sich vor, jemand hat Ihnen gesagt, Sie sollen ein Programm schreiben, das Hello, World! auf dem Bildschirm. Ihre Lösung lautet:
print ("Hallo Welt!")
Was wäre, wenn sie ihre Meinung ändern und dir sagen würden, du sollst ein Programm schreiben, das Hello, World! fünfmal auf dem Bildschirm… Ohne Kenntnis der Schleife könnte Ihre Lösung sein:
print ("Hallo Welt!") print ("Hallo Welt!") print ("Hallo Welt!") print ("Hallo Welt!") print ("Hallo Welt!")
Hmm. Es sieht zeitaufwändig aus, fünf Mal ähnlichen Code zu schreiben, um dieselbe Arbeit auszuführen. Wenn ja, was würden Sie tun, wenn jemand Sie auffordert, ein Programm zu schreiben, das Hello, World! hundert oder sogar millionenfach auf dem Bildschirm?
Eine naive Lösung besteht darin, die printAnweisung für eine bestimmte Anzahl von Malen zu schreiben . Klingt verrückt, oder? Es gibt jedoch eine bessere Lösung dafür, for-inwenn Schleifen mit wenigen Codezeilen verwendet werden:
for i in 1… 100 ( //outputs Hello world for 100 times in the screen print("Hello, World!") )
Machen Sie sich keine Sorgen um die Syntax, wir werden sie weiter unten untersuchen.
For-in-Loop-Syntax
Sie können in Swift eine for-in-Schleife erstellen als:
für in ( )
Die obige Schleife durchläuft einen Bereich und wir können auf jedes Element zugreifen, das aus dem Bereich in Variable zurückgegeben wird. Wenn Sie nicht über die Reichweite Bescheid wissen, lesen Sie den Artikel: Schnelle Reichweiten.
Wie es funktioniert?
- Die Sequenz, über die iteriert wird, ist a.
- Das wird auf die erste Zahl im Bereich gesetzt, und die Anweisungen innerhalb der Schleife werden ausgeführt.
- Nachdem die Anweisung ausgeführt wurde, wird die aktualisiert, um den zweiten Wert in der zu enthalten, und die Anweisung wird erneut ausgeführt.
- Dieser Vorgang wird fortgesetzt, bis das Ende des Bereichs erreicht ist und die Schleife stoppt.
Beispiel 1: Funktionsweise der For-In-Schleife in Swift
for i in 1… 3 ( print("Hello world!. Value is (i)") )
Wenn Sie das Programm ausführen, lautet die Ausgabe wie folgt:
Hallo Welt!. Wert ist 1 Hallo Welt!. Wert ist 2 Hallo Welt!. Wert ist 3
Im obigen Programm liegt die Sequenz, über die iteriert wird, in einem Bereich von 1 bis 3.
Der Wert von i wird auf die erste Zahl im Bereich (1) gesetzt und bei jeder Iteration auf die nächste Zahl des Bereichs aktualisiert. Dieser Vorgang wird fortgesetzt, bis das Ende des Bereichs (3) erreicht ist.
Ausführungsschritte für For-In-Schleifen| Wiederholung | Aus Bereich (i) zurückgegebener Wert | Ausgabe |
|---|---|---|
| 1 | 1 | Hallo Welt!. Wert ist 1 |
| 2 | 2 | Hallo Welt!. Wert ist 2 |
| 3 | 3 | Hallo Welt!. Wert ist 3 |
Verwerfen des Bereichswerts in einer For-In-Schleife
Wenn Sie den Bereichswert in der Schleife nicht verwenden können, können Sie ihn mit _(Unterstrich) in Swift wie folgt verwerfen :
für in ( )
Beispiel 2: Verwerfen des Bereichswerts in der For-In-Schleife
// This example neglects value and uses half open range operator for _ in 1… <3 ( print("Hello world!") )
Wenn Sie das Programm ausführen, lautet die Ausgabe wie folgt:
Hallo Welt! Hallo Welt!
In dem obigen Programm ist die Sequenz, über die iteriert wird, ein Bereich von 1 bis 2, da der Operator für halboffene Bereiche (… <) verwendet wird, der die Untergrenze (1), aber nicht die Obergrenze (3) enthält.
_vernachlässigt den Wert aus dem Bereich (1) und die print-Anweisung wird ausgeführt. Die print-Anweisung wird für die nächste Iteration erneut aufgerufen und der Prozess endet, da 2 der letzte Wert im Bereich ist.
| Wiederholung | Vom Bereich zurückgegebener Wert | Ausgabe |
|---|---|---|
| 1 | Verworfen | Hallo Welt! |
| 2 | Verworfen | Hallo Welt! |
For-In-Schleife für feste Intervalle mit Schritt
Wenn Sie eine Schleife wünschen, die in jeder Iteration um einen festen Wert anstelle des Bereichs erhöht wird, müssen Sie die Schrittmethode verwenden.
Beispiel 3: For-In-Schleife mit der Schrittmethode
let interval = 2 for i in stride(from: 1, to: 10, by: interval) ( print(i) )
Wenn Sie das Programm ausführen, lautet die Ausgabe wie folgt:
1 3 5 7 9
Im obigen Programm gibt die strideFunktion die Folge von Zahlen zurück: 1, 3, 5, 7, 9.
Der Wert von i wird auf die erste Nummer der Sequenz (1) gesetzt, und die print-Anweisung innerhalb der Schleife wird ausgeführt, die "1" in der Konsole ausgibt.
Nachdem die Anweisung ausgeführt wurde, wird der Wert von i auf einen anderen Wert (3) aktualisiert und die print-Anweisung wird erneut aufgerufen. Dieser Vorgang wird fortgesetzt, bis auf alle Elemente der Sequenz zugegriffen wird.
Ausführungsschritte der For-In-Schleife mit Schritt| Wert | Bedingung (Wert <Ende) | i (Ausgabe) |
|---|---|---|
| 1 | 1 <10 (wahr) | 1 |
| 1 + 2 = 3 | 3 <10 (wahr) | 3 |
| 1 + 2 * 2 = 5 | 5 <10 (wahr) | 5 |
| 1 + 3 * 2 = 7 | 7 <10 (wahr) | 7 |
| 1 + 4 * 2 = 9 | 9 <10 (wahr) | 9 |
| 1 + 5 * 2 = 11 | 11 <10 (falsch) | Stopps |
Wie kann ich mit der For-In-Schleife auf Elemente einer Sammlung zugreifen?
Angenommen, Sie haben ein Array von Zeichenfolgen wie unten. Wenn Sie sich mit Array nicht auskennen, stellen Sie sich Array als einen einzelnen Container vor, in dem mehr als ein Wert gespeichert werden kann. Weitere Informationen finden Sie unter Swift Arrays.
let programmierenLanguages = ("Swift", "Java", "Go", "JavaScript", "Kotlin", "Python")
What if someone told you to print all the programming languages?
A way is to access those elements using index as programmingLanguages(0), programmingLanguages(1)… and so on till you get all the elements. But this is too tedious.
Here comes for-in loop to the rescue. You can iterate using for in loop as:
Example 4: Accessing elements of an array (collection) using for-in loop
let programmingLanguages = ("Swift", "Java", "Go", "JavaScript", "Kotlin", "Python") for language in programmingLanguages ( print(language) )
When you run the program, the output will be:
Swift Java Go JavaScript Kotlin Python
In the above program, the sequence being iterated over is an array of strings.
The value of language is set to the first element of the array, and the print statement inside the loop is executed which outputs "Swift" in the console.
After the statement is executed, language is updated with the next element of the array and the print statement is called again. This process continues until the last element of array is accessed.
Example 5: Accessing elements of a string (collection) using for-in loop
Since, in Swift, strings are also collection, you can access each character in a string using for loop.
for value in "I♥Swift!" ( print(value) )
When you run the program, the output will be:
I ♥ S w i f t !
How to access indices of a collection using for-in loop?
If you want to access the index of the array (position of elements in an array i.e. 0, 1, 2), you need to use enumerated method as:
Example 6: Accessing indices of an array using for-in loop
let programmingLanguages = ("Swift", "Java", "Go", "JavaScript", "Kotlin", "Python") for (index, language) in programmingLanguages.enumerated() ( print("(index):(language)") )
When you run the program, the output will be:
0:Swift 1:Java 2:Go 3:JavaScript 4:Kotlin 5:Python
Here, the enumerated method returns a tuple (Int, String) composed of the index (Int) and the value (String) for each item in the array. For example: (0, Swift), (1, Java)…
Using for-in loop, you can access these items in a tuple one by one. If you don't know about Tuple, you can simply think it as a container that can hold value of different types. For more detailed explanation, see Swift Tuples .
How to filter elements using where clause in a for-in loop?
You can also filter contents from for in loop using where clause as
for value in "I♥Swift!" where value != "!" ( print(value) //removes exclamation sign )
When you run the program, the output will be:
I ♥ S w i f t
In the above program, the sequence being iterated over is string (collection of characters).
Der Wert wird auf das erste Zeichen der Zeichenfolge gesetzt und mit der where-Bedingung überprüft. Wenn die Bedingung zurückkehrt true, wird der Block in der Schleife (print-Anweisung) ausgeführt, der "I" in der Konsole ausgibt.
Nachdem die Anweisung ausgeführt wurde, wird der Wert auf das nächste Zeichen der Zeichenfolge aktualisiert und die Bedingung erneut überprüft. Wenn die Bedingung zurückkehrt false, wird der Block nicht ausgeführt und der Wert wird auf das nächste Zeichen aktualisiert.
Dieser Vorgang wird fortgesetzt, bis auf das letzte Zeichen der Zeichenfolge zugegriffen wird.
Filtern mit Ausführungsschritten für For-In-Schleifen| Wiederholung | Wert | Wert! = "!" | Ausgabe |
|---|---|---|---|
| 1 | ich | wahr | ich |
| 2 | ♥ | wahr | ♥ |
| 3 | S. | wahr | S. |
| 4 | w | wahr | w |
| 5 | ich | wahr | ich |
| 6 | f | wahr | f |
| 7 | t | wahr | t |
| 8 | ! | falsch |
