it-swarm.com.de

Swift for Schleife: für Index, Element im Array?

Gibt es eine Funktion, mit der ich über ein Array iterieren kann und die sowohl einen Index als auch ein Element hat, wie die Aufzählung von Python?

for index, element in enumerate(list):
    ...
717
metaphy

Ja. Ab Swift 3.0 können Sie mit der enumerated() -Methode über das Array iterieren, wenn Sie den Index für jedes Element zusammen mit seinem Wert benötigen. Es gibt eine Folge von Paaren aus dem Index und dem Wert für jedes Element im Array zurück. Zum Beispiel:

for (index, element) in list.enumerated() {
  print("Item \(index): \(element)")
}

Vor Swift 3.0 und nach Swift 2.0 wurde die Funktion enumerate() aufgerufen:

for (index, element) in list.enumerate() {
    print("Item \(index): \(element)")
}

Vor Swift 2.0 war enumerate eine globale Funktion.

for (index, element) in enumerate(list) {
    println("Item \(index): \(element)")
}
1511
Cezar

Swift 5 bietet eine Methode namens enumerated() für Array. enumerated() hat die folgende Deklaration:

func enumerated() -> EnumeratedSequence<Array<Element>>

Gibt eine Folge von Paaren (n, x) zurück, wobei n eine fortlaufende Ganzzahl beginnend bei Null darstellt und x ein Element der Folge darstellt.


In den einfachsten Fällen können Sie enumerated() mit einer for-Schleife verwenden. Zum Beispiel:

let list = ["Car", "Bike", "Plane", "Boat"]
for (index, element) in list.enumerated() {
    print(index, ":", element)
}

/*
prints:
0 : Car
1 : Bike
2 : Plane
3 : Boat
*/

Beachten Sie jedoch, dass Sie nicht darauf beschränkt sind, enumerated() mit einer for-Schleife zu verwenden. Wenn Sie vorhaben, enumerated() mit einer for-Schleife für etwas zu verwenden, das dem folgenden Code ähnelt, machen Sie das falsch:

let list = [Int](1...5)
var arrayOfTuples = [(Int, Int)]()

for (index, element) in list.enumerated() {
    arrayOfTuples += [(index, element)]
}

print(arrayOfTuples) // prints [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]

Ein schnellerer Weg, dies zu tun, ist:

let list = [Int](1...5)
let arrayOfTuples = Array(list.enumerated())
print(arrayOfTuples) // prints [(offset: 0, element: 1), (offset: 1, element: 2), (offset: 2, element: 3), (offset: 3, element: 4), (offset: 4, element: 5)]

Alternativ können Sie auch enumerated() mit map verwenden:

let list = [Int](1...5)
let arrayOfDictionaries = list.enumerated().map { (a, b) in return [a : b] }
print(arrayOfDictionaries) // prints [[0: 1], [1: 2], [2: 3], [3: 4], [4: 5]]

Obwohl es einige Einschränkungen gibt, kann forEach ein guter Ersatz für eine for-Schleife sein:

let list = [Int](1...5)
list.reversed().enumerated().forEach { print($0, ":", $1) }

/*
prints:
0 : 5
1 : 4
2 : 3
3 : 2
4 : 1
*/

Durch die Verwendung von enumerated() und makeIterator() können Sie sogar manuell auf Ihrem Array iterieren. Zum Beispiel:

import UIKit
import PlaygroundSupport

class ViewController: UIViewController {

    var generator = ["Car", "Bike", "Plane", "Boat"].enumerated().makeIterator()

    override func viewDidLoad() {
        super.viewDidLoad()

        let button = UIButton(type: .system)
        button.setTitle("Tap", for: .normal)
        button.frame = CGRect(x: 100, y: 100, width: 100, height: 100)
        button.addTarget(self, action: #selector(iterate(_:)), for: .touchUpInside)
        view.addSubview(button)
    }

    @objc func iterate(_ sender: UIButton) {
        let Tuple = generator.next()
        print(String(describing: Tuple))
    }

}

PlaygroundPage.current.liveView = ViewController()

/*
 Optional((offset: 0, element: "Car"))
 Optional((offset: 1, element: "Bike"))
 Optional((offset: 2, element: "Plane"))
 Optional((offset: 3, element: "Boat"))
 nil
 nil
 nil
 */
91
Imanou Petit

Beginnend mit Swift 2 muss die Aufzählungsfunktion für die Auflistung folgendermaßen aufgerufen werden:

for (index, element) in list.enumerate() {
    print("Item \(index): \(element)")
}
50
Ricky

Ich habe diese Antwort gefunden, als ich nach einer Möglichkeit gesucht habe, dies mit einem Dictionary zu tun, und es hat sich herausgestellt, dass es ziemlich einfach ist, sie anzupassen. Übergeben Sie einfach ein Tuple für das Element.

// Swift 2

var list = ["a": 1, "b": 2]

for (index, (letter, value)) in list.enumerate() {
    print("Item \(index): \(letter) \(value)")
}
42
Nycen

Sie können einfach eine Aufzählungsschleife verwenden, um das gewünschte Ergebnis zu erzielen:

Swift 2:

for (index, element) in elements.enumerate() {
    print("\(index): \(element)")
}

Swift 3 & 4:

for (index, element) in elements.enumerated() {
    print("\(index): \(element)")
}

Oder Sie können einfach eine for-Schleife durchlaufen, um das gleiche Ergebnis zu erhalten:

for index in 0..<elements.count {
    let element = elements[index]
    print("\(index): \(element)")
}

Ich hoffe es hilft.

14
Riajur Rahman

Grundlegende Aufzählung

for (index, element) in arrayOfValues.enumerate() {
// do something useful
}

oder mit Swift 3 ...

for (index, element) in arrayOfValues.enumerated() {
// do something useful
}

Auflisten, filtern und zuordnen

Am häufigsten verwende ich Enumerate jedoch in Kombination mit Map oder Filter. Zum Beispiel beim Betrieb auf ein paar Arrays.

In diesem Array wollte ich ungerade oder gerade indizierte Elemente filtern und von Ints in Doubles konvertieren. enumerate() holt sich also den Index und das Element, filtert den Index und ordnet ihn schließlich nur dem Element zu, um das resultierende Tupel zu entfernen.

let evens = arrayOfValues.enumerate().filter({
                            (index: Int, element: Int) -> Bool in
                            return index % 2 == 0
                        }).map({ (_: Int, element: Int) -> Double in
                            return Double(element)
                        })
let odds = arrayOfValues.enumerate().filter({
                            (index: Int, element: Int) -> Bool in
                            return index % 2 != 0
                        }).map({ (_: Int, element: Int) -> Double in
                            return Double(element)
                        })
13

Beginnend mit Swift 3 ist es

for (index, element) in list.enumerated() {
  print("Item \(index): \(element)")
}
8
Jake Lin

Die Verwendung von .enumerate() funktioniert, liefert jedoch nicht den wahren Index des Elements. Es gibt nur ein Int an, das mit 0 beginnt und für jedes nachfolgende Element um 1 erhöht wird. Dies ist normalerweise irrelevant, kann jedoch bei Verwendung des Typs ArraySlice zu unerwartetem Verhalten führen. Nimm den folgenden Code:

let a = ["a", "b", "c", "d", "e"]
a.indices //=> 0..<5

let aSlice = a[1..<4] //=> ArraySlice with ["b", "c", "d"]
aSlice.indices //=> 1..<4

var test = [Int: String]()
for (index, element) in aSlice.enumerate() {
    test[index] = element
}
test //=> [0: "b", 1: "c", 2: "d"] // indices presented as 0..<3, but they are actually 1..<4
test[0] == aSlice[0] // ERROR: out of bounds

Es ist ein etwas ausgeklügeltes Beispiel und in der Praxis kein alltägliches Problem, aber ich denke, es lohnt sich zu wissen, dass dies passieren kann.

7
Cole Campbell

Dies ist die Formel der Aufzählungsschleife:

for (index, value) in shoppingList.enumerate() {
print("Item \(index + 1): \(value)")
}

für weitere Informationen können Sie hier .

7
Dara Tith

Xcode 8 und Swift 3: Array kann mit tempArray.enumerated() aufgezählt werden

Beispiel:

var someStrs = [String]()

someStrs.append("Apple")  
someStrs.append("Amazon")  
someStrs += ["Google"]    


for (index, item) in someStrs.enumerated()  
{  
        print("Value at index = \(index) is \(item)").  
}

konsole:

Value at index = 0 is Apple
Value at index = 1 is Amazon
Value at index = 2 is Google
4
Anil Gupta

Der Vollständigkeit halber können Sie einfach Ihre Array-Indizes durchlaufen und mit dem Index auf das Element am entsprechenden Index zugreifen:

let list = [100,200,300,400,500]
for index in list.indices {
    print("Element at:", index, " Value:", list[index])
}

Verwenden Sie forEach

list.indices.forEach {
    print("Element at:", $0, " Value:", list[$0])
}

Verwendung der Methode collection enumerated(). Beachten Sie, dass eine Auflistung von Tupeln mit dem offset und dem element zurückgegeben wird:

for item in list.enumerated() {
    print("Element at:", item.offset, " Value:", item.element)
}

mit forEach:

list.enumerated().forEach {
    print("Element at:", $0.offset, " Value:", $0.element)
}

Diese werden gedruckt

Element bei: 0 Wert: 100

Element bei: 1 Wert: 200

Element bei: 2 Wert: 300

Element bei: 3 Wert: 400

Element bei: 4 Wert: 500

Wenn Sie den Array-Index (nicht den Offset) und sein Element benötigen, können Sie Collection erweitern und Ihre eigene Methode erstellen, um seine Indizes aufzulisten:

extension Collection {
    func enumeratedIndices(body: ((index: Index, element: Element)) throws -> ()) rethrows {
        var index = startIndex
        for element in self {
            try body((index,element))
            formIndex(after: &index)
        }
    }
}

Testen:

let list =  ["100","200","300","400","500"]
list.dropFirst(2).enumeratedIndices {
    print("Index:", $0.index, "Element:", $0.element)
}

Dies wird gedruckt

Index: 2 Element: 300

Index: 3 Element: 400

Index: 4 Element: 500

4
Leo Dabus

Für diejenigen, die forEach verwenden möchten.

Schnell 4

extension Array {
  func forEachWithIndex(_ body: (Int, Element) throws -> Void) rethrows {
    try Zip((startIndex ..< endIndex), self).forEach(body)
  }
}

Oder

array.enumerated().forEach { ... }
3
Vincent

Ich persönlich bevorzuge die Methode forEach:

list.enumerated().forEach { (index, element) in
    ...
}

Sie können auch die Kurzversion verwenden:

list.enumerated().forEach { print("index: \($0.0), value: \($0.1)") }
2
davebcn87

Verwenden Sie für das, was Sie tun möchten, die Methode enumerated() in Ihrem Array:

for (index, element) in list.enumerated() {
    print("\(index) - \(element)")
}
0
Ale Mohamad