Introduction to NSPredicate

NSPredicate is a powerful class in Swift that allows you to filter and search data in collections, such as arrays and Core Data objects. It provides a way to specify conditions or rules for filtering data based on specific criteria. NSPredicate uses a syntax similar to SQL for writing conditions, making it easy to understand and use.

In this tutorial, we will explore the basics of using NSPredicate in Swift, including creating predicates, filtering arrays, and using compound predicates. We will also cover some common use cases and provide examples to illustrate how NSPredicate can be used in real-world scenarios.

Creating Predicates

To create an NSPredicate, you can use the `NSPredicate(format:)` initializer, which takes a format string as its argument. The format string describes the conditions or rules that the predicate will evaluate.

Here’s an example of creating a predicate that filters an array of numbers to only include even numbers:

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let predicate = NSPredicate(format: "self %% 2 == 0")
let filteredNumbers = numbers.filter { predicate.evaluate(with: $0) }
print(filteredNumbers) // Output: [2, 4, 6, 8, 10]

In this example, the format string self %% 2 == 0 specifies that the predicate should evaluate to `true` for elements in the array that are divisible by 2, i.e., even numbers.

Filtering Arrays

NSPredicate can be used to filter arrays based on specific criteria. You can use predicates to filter arrays of any type, including custom objects.

Here’s an example of using NSPredicate to filter an array of strings based on a specific condition:

let names = ["Alice", "Bob", "Charlie", "David", "Eve"]
let predicate = NSPredicate(format: "length > 4")
let filteredNames = names.filter { predicate.evaluate(with: $0) }
print(filteredNames) // Output: ["Alice", "Charlie"]

In this example, the predicate `length > 4` filters the array to only include strings that have a length greater than 4 characters.

Compound Predicates

NSPredicate also supports compound predicates, which allow you to combine multiple predicates using logical operators such as AND, OR, and NOT.

Here’s an example of using a compound predicate to filter an array of numbers:

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let evenPredicate = NSPredicate(format: "self %% 2 == 0")
let greaterThanFivePredicate = NSPredicate(format: "self > 5")
let compoundPredicate = NSCompoundPredicate(andPredicateWithSubpredicates: [evenPredicate, greaterThanFivePredicate])
let filteredNumbers = numbers.filter { compoundPredicate.evaluate(with: $0) }
print(filteredNumbers) // Output: [6, 8, 10]

In this example, we create two separate predicates, `evenPredicate` and `greaterThanFivePredicate`, and combine them using the `andPredicateWithSubpredicates` method of `NSCompoundPredicate`. The resulting compound predicate filters the array to only include numbers that are both even and greater than 5.

Common Use Cases

NSPredicate is a versatile tool that can be used in a variety of scenarios. Here are some common use cases where NSPredicate can be helpful:

– Filtering arrays of objects based on specific properties, such as filtering an array of `Person` objects to only include those with a certain age or name.
– Searching and filtering Core Data objects based on specific conditions, such as filtering a list of books to only include those with a certain genre or author.
– Filtering and searching large collections of data efficiently, reducing the need for manual iteration and comparison.


NSPredicate is a powerful tool for filtering and searching data in Swift. It provides a flexible and easy-to-use way to specify conditions and rules for filtering arrays and collections. In this tutorial, we covered the basics of creating predicates, filtering arrays, using compound predicates, and discussed common use cases. NSPredicate is a valuable addition to your Swift toolkit and can help you efficiently work with and manipulate data.

Leave a Reply