Wie finde ich den Index des Listenelements in Swift?

Question

Ich versuche, einen Elementindex zu finden, indem ich eine Liste durchsuche. Weiß jemand, wie das geht?

Ich sehe, dass es Liste.StartIndex und Liste.EndIndex gibt, aber ich möchte etwas ähnliches wie list.index("text") in Python.

Answer 1

Da Swift in gewisser Hinsicht funktionaler als objektorientiert ist (und Arrays Strukturen sind, keine Objekte), verwenden Sie die Funktion "find", um auf das Array zuzugreifen, das einen optionalen Wert zurückgibt. Seien Sie also darauf vorbereitet, einen nil-Wert zu behandeln:

let arr:Array = ["a","b","c"]
find(arr, "c")!              // 2
find(arr, "d")               // nil

Verwenden Sie firstIndex und lastIndex - je nachdem, ob Sie den ersten oder den letzten Index des Elements suchen:

let arr = ["a","b","c","a"]

let indexOfA = arr.firstIndex(of: "a") // 0
let indexOfB = arr.lastIndex(of: "a") // 3

Answer 2

Tl;dr:

Für Klassen suchst du vielleicht nach:

let index = someArray.firstIndex{$0 === someObject}

---

Vollständige Antwort:

Ich denke, es ist erwähnenswert, dass bei Referenztypen (class) möglicherweise eine Identitäts-Vergleich durchgeführt werden soll, in welchem Fall du einfach den === Identitätsoperator im Prädikatverschluss verwenden musst:

Swift 5, Swift 4.2:

let person1 = Person(name: "John")
let person2 = Person(name: "Sue")
let person3 = Person(name: "Maria")
let person4 = Person(name: "Loner")

let people = [person1, person2, person3]

let indexOfPerson1 = people.firstIndex{$0 === person1} // 0
let indexOfPerson2 = people.firstIndex{$0 === person2} // 1
let indexOfPerson3 = people.firstIndex{$0 === person3} // 2
let indexOfPerson4 = people.firstIndex{$0 === person4} // nil

Beachte, dass die obige Syntax die Syntax für Nachlaufverschlüsse verwendet und äquivalent zu ist:

let indexOfPerson1 = people.firstIndex(where: {$0 === person1})

Swift 4 / Swift 3 - die Funktion wurde früher index genannt

Swift 2 - die Funktion wurde früher indexOf genannt

* Beachte den relevanten und nützlichen Kommentar von paulbailey über class Typen, die Equatable implementieren, wo du berücksichtigen musst, ob du mittels === (_Identitäts_operator) oder == (_Gleichheits_operator) vergleichen solltest. Wenn du dich entscheidest, mit == abzugleichen, kannst du einfach die von anderen vorgeschlagene Methode verwenden (people.firstIndex(of: person1)).

Answer 3

Sie können ein Array mit einem Closure filtern:

var myList = [1, 2, 3, 4]
var filtered = myList.filter { $0 == 3 }  // <= gibt [3] zurück

Und Sie können die Anzahl eines Arrays zählen:

filtered.count // <= gibt 1 zurück

Sie können also feststellen, ob ein Array Ihr Element enthält, indem Sie dies kombinieren:

myList.filter { $0 == 3 }.count > 0  // <= gibt true zurück, wenn das Array 3 enthält

Wenn Sie die Position finden möchten, sehe ich keinen eleganten Weg, aber Sie können es sicherlich so machen:

var found: Int?  // <= wird den Index halten, wenn er gefunden wurde, oder anderweitig nil sein
for i in (0..x.count) {
    if x[i] == 3 {
        found = i
    }
}

BEARBEITEN

Da wir dabei sind, als lustige Übung erweitern wir Array, um eine find-Methode zu haben:

extension Array {
    func find(includedElement: T -> Bool) -> Int? {
        for (idx, element) in enumerate(self) {
            if includedElement(element) {
                return idx
            }
        }
        return nil
    }
}

Jetzt können wir dies tun:

myList.find { $0 == 3 }
// gibt die Indexposition von 3 zurück oder nil, wenn nicht gefunden

Answer 4

Swift 5

func firstIndex(of element: Element) -> Int?

var alphabets = ["A", "B", "E", "D"]

Beispiel1

let index = alphabets.firstIndex(where: {$0 == "A"})

Beispiel2

if let i = alphabets.firstIndex(of: "E") {
    alphabets[i] = "C" // i is the index
}
print(alphabets)
// Gibt "["A", "B", "C", "D"]" aus

Answer 5

Während indexOf() perfekt funktioniert, gibt es nur einen Index zurück.

Ich habe nach einer eleganten Möglichkeit gesucht, ein Array von Indizes für Elemente zu erhalten, die eine bestimmte Bedingung erfüllen.

So kann es gemacht werden:

Swift 3:

let array = ["apple", "dog", "log"]

let indexes = array.enumerated().filter {
    $0.element.contains("og")
    }.map{$0.offset}

print(indexes)

Swift 2:

let array = ["apple", "dog", "log"]

let indexes = array.enumerate().filter {
    $0.element.containsString("og")
    }.map{$0.index}

print(indexes)