Swift How to Get an Index of an Item in an Array

Swift How to Get an Index of an Item in an Array

To get the first index of an item in an array in Swift, use the array.firstIndex(where:) method.

For instance, let’s find the first occurrence of the string “a” in an array:

let arr = ["a", "b", "c", "b", "a"]
let i1 = arr.firstIndex(where: {$0 == "a"})

print(i1!)

Output:

0

How Does It Work

Don’t let the $0 notation confuse you. Here is how it works:

  • The firstIndex() method goes through the array of items.
  • It assigns each item to variable $0 one by one.
  • Then it checks if the condition holds for that item.
  • When it encounters the first item that matches the condition, it returns the index (as an optional).

If you are still confused, feel free to check this article.

You can apply similar logic to find an index of an array of objects.

How to Find the Index of an Object in an Array of Objects

You can use the array.firstIndex(where:) method to find an object that meets a specific criterion. This is useful when you have an array of objects with properties based on which you are searching.

For example, let’s create a class that represents a Student.

class Student {
    let name: String
    init(name: String) {
        self.name = name   
    }
}

Next, let’s create an array of students:

let student1 = Student(name: "Alice")
let student2 = Student(name: "Bob")
let student3 = Student(name: "Charlie")

let students = [student1, student2, student3]

Now, let’s use the array.firstIndex(where:) method to find the position of Bob:

let bob_pos = students.firstIndex(where: {$0.name == "Bob"})

print("Bob is at position \(bob_pos!).")

Output:

Bob is at position 1.

How to Find All Indexes of a Value in an Array in Swift

So far you’ve learned how to find the first index of a specific element in an array in Swift.

But what if you want to find them all?

To find all the indexes of a value in the Swift array:

  1. Group each array element with an index.
  2. Filter the resulting array based on a criterion.
  3. Map the result to only contain the indexes.

Here is a rough sketch:

arr.enumerated().filter{ $0.element == something }.map{ $0.offset }

For example, let’s find the indexes of the letter “a” in the array:

let arr = ["a", "b", "a", "b", "a"]
let idxs = arr.enumerated().filter{ $0.element == "a" }.map{ $0.offset }
print(idxs)

If you have an array of objects, you can use a similar approach.

For example, let’s find out all the Student object whose name is “Bob” in the array:

class Student {
    let name: String
    init(name: String) {
        self.name = name   
    }
}

let students = [
    Student(name: "Alice"),
    Student(name: "Bob"),
    Student(name: "Charlie"),
    Student(name: "Bob")
]

// Find indexes of student Bob:
let indexes = students.enumerated().filter{ $0.element.name == "Bob" }.map{ $0.offset }
print(indexes)

How Does It Work

Take a look at this sketch:

arr.enumerated().filter{ $0.element == something }.map{ $0.offset }

There are three things that you may be unfamiliar with:

  1. The enumerated() method.
  2. The filter() method with $0.
  3. The map() method with $0.

Let me briefly explain what these do.

  1. The enumerated() method converts an array of items to an array of (index, item) pairs. Swift calls these (offset, element) pairs.
  2. The filter() method filters out all the elements of the (offset, element) pairs where the element does not meet a criterion.
  3. The map() method converts the resulting array of (offset, element) pairs to an array of offsets.

Let’s take a look at the process of finding all elements that equal to “a” step by step:

1. Let’s first enumerate the array with the enumerated() method.

let idxs = arr.enumerated()

for pair in idxs {
    print(pair)
}

Output:

(offset: 0, element: "a")
(offset: 1, element: "b")
(offset: 2, element: "a")
(offset: 3, element: "b")
(offset: 4, element: "a")

2. Filter out all the pairs where the element is not “a”:

let idxs = arr.enumerated().filter{ $0.element == "a" }

for pair in idxs {
    print(pair)
}

Now we are left with pairs that only contain elements that are “a”:

(offset: 0, element: "a")
(offset: 2, element: "a")
(offset: 4, element: "a")

3. Transform pairs to an array of indexes

let idxs = arr.enumerated().filter{ $0.element == "a" }.map { $0.offset }

for pair in idxs {
    print(pair)
}

Output:

0
2
4

And there you have it!

Conclusion

Today you learned how to get the index of the first element of an array that matches a criterion.

arr.firstIndex(where: {$0 == something})

You also learned how to get all the indexes of array items that meet the criterion.

arr.enumerated().filter{ $0.element == something }.map{ $0.offset }

Thanks for reading. I hope you find it useful.

Happy coding!

Further Reading

50 Swift Interview Questions

iOS Development Tips

Share on facebook
Share on twitter
Share on linkedin

Leave a Comment

Your email address will not be published.