How can I find the index of an item in Swift?

Question

Is there a method called indexof or something similar?

var array = ["Jason", "Charles", "David"]

indexOf(array, "Jason") // Should return 0

Answer 1

EDIT: As of Swift 3.0, you should use the .index(where:) method instead and follow the change in the Swift 2.0 edit below.

EDIT: As of Swift 2.0, you should use the indexOf method instead. It too returns nil or the first index of its argument.

if let i = array.indexOf("Jason") {
    print("Jason is at index \(i)")
} else {
    print("Jason isn't in the array")
}

Use the find function. It returns either nil (if the value isn't found) or the first index of the value in the array.

if let i = find(array, "Jason") {
    println("Jason is at index \(i)")
} else {
    println("Jason isn't in the array")
}

Answer 2

In Swift 2.0 (Xcode 7.1b), you can use

if let result = array.indexOf("Jason")

while find(array, "Jason") is deprecated.

Answer 3

I made this function like above, but it return array of indexes

extension Array {
    func indexesOf<T : Equatable>(object:T) -> [Int] {
        var result: [Int] = []
        for (index,obj) in enumerate(self) {
            if obj as T == object {
                result.append(index)
            }
        }
        return result
    }
}

Maybe it will be useful for you

Answer 4

Array can be bridged to an NSArray, so you can use:

array.bridgeToObjectiveC().indexOfObject("Jason")

Answer 5

An extension of Array can work wonders here. Here's an implementation shared in this StackOverflow answer:

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

Answer 6

You can add an Array Extension that does exactly what you want, i.e:

extension Array {
    func indexOf<T : Equatable>(x:T) -> Int? {
        for i in 0..self.count {
            if self[i] as T == x {
                return i
            }
        }
        return nil
    }
}

Which now lets you use .indexOf() on all Swift arrays, e.g:

["Jason", "Charles", "David"].indexOf("Jason")  //0

Answer 7

While the response from Max is great, it does not let you find multiple indexes of multiple objects, ie. indexes of the subset of the array. If you need that functionality, extensions are, as always, your best friend

func indexesOfSubset<T : Equatable>(objects : [T]) -> [Int] {

    // Create storage for filtered objectsand results
    var unusedObjects = objects
    var result : [Int] = []

    // Enumerate through all objects in array
    for (index, obj) in enumerate(self) {

        // Enumerate again through all objects that has not been found
        for x in unusedObjects {

            // If we hit match, append result, remove it from usused objects
            if obj as! T == x {
                result.append(index)
                unusedObjects = unusedObjects.filter( { $0 != x } )
                break
            }
        }
    }

    // Get results
    return result
}

Note* : Works on Swift 1.2, if you want compatibility with 1.1, replace as! -> as