Что такое обновление для find () в Swift 3? [Дубликат]

Обновление для Swift 2:

sequence.contains (element): Возвращает true, если заданная последовательность (такая как массив) содержит указанный элемент.

Swift 1:

Если вы хотите просто проверить, содержится ли элемент внутри массива, то есть просто получить логический индикатор, используйте contains(sequence, element) вместо find(array, element):

содержит (sequence, element): Возвращает true, если заданная последовательность (такая как массив) содержит указанный элемент.

См. пример ниже:

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 2 (с Xcode 7) Array включает метод indexOf , предоставляемый протоколом CollectionType . (На самом деле два метода indexOf - один, который использует равенство для соответствия аргументу, и другой , который использует замыкание.)

До Swift 2 не было путь для общих типов, таких как коллекции, для предоставления методов для конкретных типов, полученных из них (например, массивов). Итак, в Swift 1.x «index of» является глобальной функцией ... И он также переименован, поэтому в Swift 1.x эта глобальная функция называется find.

Это также возможно (но не обязательно) использовать метод indexOfObject из NSArray ... или любого другого более сложного метода поиска из Foundation, не имеющего эквивалентов в стандартной библиотеке Swift. Просто import Foundation (или другой модуль, который транзитивно импортирует Foundation), отрисуйте Array до NSArray, и вы можете использовать множество методов поиска на NSArray.

Вы также можете использовать функциональную библиотеку Dollar для создания indexOf для массива как такового http://www.dollarswift.org/#indexof-indexof

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

Swift 4. Если ваш массив содержит элементы типа [String: AnyObject]. Итак, чтобы найти индекс элемента, используйте приведенный ниже код

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)

Или Если вы хотите найти индекс на основе ключа из словаря. Здесь массив содержит объекты класса Model, и я сопоставляю свойство 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")
}

Вы можете filter массив с закрытием:

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

И вы можете подсчитать массив:

filtered.count // <= returns 1

. Таким образом, вы можете определить , если массив включает ваш элемент, объединив их:

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

Если вы хотите найти позицию, я не вижу причудливого пути, но вы можете сделать это следующим образом:

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
    }
}

EDIT

Пока мы находимся в этом, для забавного упражнения продолжим Array, чтобы иметь способ find:

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

Теперь мы можем это сделать:

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

Если вы все еще работаете в Swift 1.x

, попробуйте,

let testArray = ["A","B","C"]

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

Любое из этого решения работает для меня

Это решение i для 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
        })

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 3 вы можете использовать простую функцию

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

. Это даст номер позиции, поэтому вы можете использовать, например,

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

Надеюсь быть полезным

Swift 4

Для ссылочных типов:

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
    }
}

В Swift 4, если вы проходите через массив DataModel, убедитесь, что ваша модель данных соответствует Equatable Protocol, реализуйте метод lhs = rhs, и только тогда вы можете использовать «.index (от«. Например

class Photo : Equatable{
    var imageURL: URL?
    init(imageURL: URL){
        self.imageURL = imageURL
    }

    static func == (lhs: Photo, rhs: Photo) -> Bool{
        return lhs.imageURL == rhs.imageURL
    }
}

И затем,

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

Я думаю, что стоит упомянуть, что со ссылочными типами (class) вам может понадобиться сравнение identity , и в этом случае вам просто нужно использовать оператор идентификации === в предикате Закрытие:

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

Обратите внимание, что в приведенном выше синтаксисе используется синтаксис закрывающих замыканий и эквивалентен:

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

Swift 2 - синтаксис функции index:

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

* Обратите внимание на соответствующие и полезные комментарий от paulbailey о class типах, которые реализуют Equatable, где вам нужно рассмотреть, следует ли сравнивать, используя === ( identity ]) или == ( равенство ). Если вы решите сопоставить с помощью ==, вы можете просто использовать метод, предложенный другими (people.index(of: person1)).

Swift 4

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

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

Пример1

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

Пример2

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

Пока indexOf() работает отлично, он возвращает только один индекс.

Я искал элегантный способ получить массив индексов для элементов, которые удовлетворяют некоторому условию.

Вот как это можно сделать:

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)

Для настраиваемого класса вам необходимо реализовать Equatable protocol.

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)