Come trovare l’indice dell’elemento della lista in Swift?

Sto cercando di trovare un indice degli oggetti cercando un elenco. Qualcuno sa come farlo?

Vedo che c’è list.StartIndex e list.EndIndex bu Voglio qualcosa come python’s list.index (“text”)

Poiché swift è in qualche modo più funzionale di object-oriented (e le Array sono structs, non objects), usa la funzione “find” per operare sull’array, che restituisce un valore opzionale, quindi preparati a gestire un valore nullo:

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

Aggiornamento per Swift 2.0:

La vecchia funzione di find non è più supportata con Swift 2.0!

Con Swift 2.0, Array ottiene la capacità di trovare l’indice di un elemento utilizzando una funzione definita in un’estensione di CollectionType (che Array implementa):

 let arr = ["a","b","c"] let indexOfA = arr.indexOf("a") // 0 let indexOfB = arr.indexOf("b") // 1 let indexOfD = arr.indexOf("d") // nil 

Inoltre, la ricerca del primo elemento in un array che soddisfa un predicato è supportata da un’altra estensione di CollectionType :

 let arr2 = [1,2,3,4,5,6,7,8,9,10] let indexOfFirstGreaterThanFive = arr2.indexOf({$0 > 5}) // 5 let indexOfFirstGreaterThanOneHundred = arr2.indexOf({$0 > 100}) // nil 

Nota che queste due funzioni restituiscono valori opzionali, come find prima.

Aggiornamento per Swift 3.0:

Nota che la syntax di indexOf è cambiata. Per gli articoli conformi a Equatable puoi usare:

 let indexOfA = arr.index(of: "a") 

Una documentazione dettagliata del metodo può essere trovata su https://developer.apple.com/reference/swift/array/1689674-index

Per gli elementi dell’array che non sono conformi a Equatable dovrai utilizzare l’ index(where:) :

 let index = cells.index(where: { (item) -> Bool in item.foo == 42 // test if this is the item you're looking for }) 

Penso che valga la pena ricordare che con i tipi di riferimento ( class ) si potrebbe voler eseguire un confronto di identity framework , nel qual caso è sufficiente utilizzare l’operatore di identity framework === nella chiusura del predicato:

Swift 3 / Swift 4:

 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.index{$0 === person1} // 0 let indexOfPerson2 = people.index{$0 === person2} // 1 let indexOfPerson3 = people.index{$0 === person3} // 2 let indexOfPerson4 = people.index{$0 === person4} // nil 

Si noti che la syntax precedente utilizza la syntax delle chiusure finali ed è equivalente a:

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

Swift 2: la syntax della funzione index era:

 let indexOfPerson1 = people.indexOf{$0 === person1} 

* Notare il commento pertinente e utile di paulbailey sui tipi di class che implementano Equatable , in cui è necessario considerare se si debba confrontare usando === (operatore id quadro ) o == (operatore uguaglianza ). Se decidi di abbinare usando == , puoi semplicemente usare il metodo suggerito da altri ( people.index(of: person1) ).

Puoi filter un array con una chiusura:

 var myList = [1, 2, 3, 4] var filtered = myList.filter { $0 == 3 } // <= returns [3] 

E puoi contare un array:

 filtered.count // <= returns 1 

Quindi puoi determinare se un array include il tuo elemento combinando questi:

 myList.filter { $0 == 3 }.count > 0 // <= returns true if the array includes 3 

Se vuoi trovare la posizione, non vedo un modo elegante, ma puoi certamente farlo in questo modo:

 var found: Int? // <= will hold the index if it was found, or else will be nil for i in (0..x.count) { if x[i] == 3 { found = i } } 

MODIFICARE

Mentre ci siamo, per un esercizio divertente estendiamo la Array per avere un metodo di find :

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

Ora possiamo fare questo:

 myList.find { $0 == 3 } // returns the index position of 3 or nil if not found 

Mentre indexOf() funziona perfettamente, restituisce solo un indice.

Stavo cercando un modo elegante per ottenere una serie di indici per elementi che soddisfano alcune condizioni.

Ecco come può essere fatto:

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) 

Per la class personalizzata, è necessario implementare il protocollo Equatable.

 import Foundation func ==(l: MyClass, r: MyClass) -> Bool { return l.id == r.id } class MyClass: Equtable { init(id: String) { self.msgID = id } let msgID: String } let item = MyClass(3) let itemList = [MyClass(1), MyClass(2), item] let idx = itemList.indexOf(item) printl(idx) 

Aggiornamento per Swift 2:

sequence.contains (elemento) : restituisce true se una determinata sequenza (come un array) contiene l’elemento specificato.

Swift 1:

Se stai cercando solo di controllare se un elemento è contenuto all’interno di un array, cioè ottieni solo un indicatore booleano, usa contains(sequence, element) invece di find(array, element) :

contains (sequence, element) : restituisce true se una determinata sequenza (come un array) contiene l’elemento specificato.

Vedi l’esempio qui sotto:

 var languages = ["Swift", "Objective-C"] contains(languages, "Swift") == true contains(languages, "Java") == false contains([29, 85, 42, 96, 75], 42) == true if (contains(languages, "Swift")) { // Use contains in these cases, instead of find. } 

Swift 4

 func index(of element: Element) -> Int? var alphabets = ["A", "B", "E", "D"] 

Esempio 1

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

Esempio 2

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

In Swift 2 (con Xcode 7), Array include un metodo indexOf fornito dal protocollo CollectionType . (In realtà, due metodi indexOf : uno che utilizza l’uguaglianza per abbinare un argomento e un altro che utilizza una chiusura.)

Prima di Swift 2, non esisteva un modo per tipi generici come le raccolte per fornire metodi per i tipi concreti derivati ​​da essi (come gli array). Quindi, in Swift 1.x, “index of” è una funzione globale … E anche ribattezzata, quindi in Swift 1.x, quella funzione globale è chiamata find .

È anche ansible (ma non necessario) utilizzare il metodo indexOfObject di NSArray … o uno qualsiasi degli altri metodi di ricerca più sofisticati di Foundation che non hanno equivalenti nella libreria standard di Swift. Basta import Foundation (o un altro modulo che importa in modo NSArray Foundation), lanciare la tua Array su NSArray ed è ansible utilizzare i molti metodi di ricerca su NSArray .

In Swift 4 , se stai attraversando l’array DataModel, assicurati che il tuo modello dati sia conforms a Protocollo Equitable, implementa il metodo lhs = rhs, e solo allora puoi usare “.index (di”.) Ad esempio

 class Photo : Equatable{ var imageURL: URL? init(imageURL: URL){ self.imageURL = imageURL } static func == (lhs: Photo, rhs: Photo) -> Bool{ return lhs.imageURL == rhs.imageURL } } 

E poi,

 let index = self.photos.index(of: aPhoto) 

Puoi anche usare la libreria funzionale Dollar per fare un indexOf su un array come http://www.dollarswift.org/#indexof-indexof

 $.indexOf([1, 2, 3, 1, 2, 3], value: 2) => 1 

Se stai ancora lavorando in Swift 1.x

quindi prova,

 let testArray = ["A","B","C"] let indexOfA = find(testArray, "A") let indexOfB = find(testArray, "B") let indexOfC = find(testArray, "C") 

Swift 2.1

 var array = ["0","1","2","3"] if let index = array.indexOf("1") { array.removeAtIndex(index) } print(array) // ["0","2","3"] 

Swift 3

 var array = ["0","1","2","3"] if let index = array.index(of: "1") { array.remove(at: index) } array.remove(at: 1) 

Swift 4. Se la matrice contiene elementi di tipo [String: AnyObject]. Quindi per trovare l’indice dell’elemento usa il codice qui sotto

 var array = [[String: AnyObject]]()// Save your data in array let objectAtZero = array[0] // get first object let index = (self.array as NSArray).index(of: objectAtZero) 

Oppure Se si desidera trovare l’indice sulla base della chiave dal Dizionario. Qui la matrice contiene gli oggetti della class Model e sto abbinando la proprietà id.

 let userId = 20 if let index = array.index(where: { (dict) -> Bool in return dict.id == userId // Will found index of matched id }) { print("Index found") } 

Qualunque soluzione funziona per me

Questa è la soluzione che ho per Swift 4:

 let monday = Day(name: "M") let tuesday = Day(name: "T") let friday = Day(name: "F") let days = [monday, tuesday, friday] let index = days.index(where: { //important to test with === to be sure it's the same object reference $0 === tuesday }) 

Per SWIFT 3 è ansible utilizzare una semplice funzione

 func find(objecToFind: String?) -> Int? { for i in 0...arrayName.count { if arrayName[i] == objectToFind { return i } } return nil } 

Questo darà la posizione del numero, quindi puoi usare come

 arrayName.remove(at: (find(objecToFind))!) 

Spero di essere utile

Swift 4

Per i tipi di riferimento:

 extension Array where Array.Element: AnyObject { func index(ofElement element: Element) -> Int? { for (currentIndex, currentElement) in self.enumerated() { if currentElement === element { return currentIndex } } return nil } }