# Swift contains and allSatisfy: Check Collection Values Source: https://devdocs10.com/articles/swift/swift-collection-contains-allsatisfy By Murat Bo · Published 2026-05-12 · DevDocs10 (https://devdocs10.com) Swift collections often need simple yes-or-no checks: does this collection include a value, and do all elements match a rule? That is exactly what `contains` and `allSatisfy` are for. In this article, you will learn what each method does, how their closure-based forms work, when to use one instead of the other, and how to avoid common mistakes when checking arrays, sets, and other sequences. > **Quick answer:** Use `contains` when you want to know whether at least one element matches a value or condition. Use `allSatisfy` when you want to know whether every element in the collection matches a condition. > **Difficulty:** Beginner > > **Helpful to know first:** You will understand this better if you know basic Swift syntax, how arrays store values, and how simple closures return `Bool` values. ## 1. What Is contains and allSatisfy? `contains` and `allSatisfy` are standard library methods available on Swift sequences such as arrays, sets, ranges, and many other collection-like types. - `contains` answers: “Is there at least one matching element?” - `allSatisfy` answers: “Do all elements match this rule?” - Both methods return a `Bool`. - `contains` can check for a specific value or use a closure to test a condition. - `allSatisfy` always uses a closure-based condition. These methods solve a very common problem: checking a collection without writing a full loop yourself. Instead of manually iterating and tracking a flag variable, you can express your intent directly. These two methods are also naturally compared because they sound similar but answer different questions. `contains` looks for any match. `allSatisfy` checks whether every element passes. ## 2. Why contains and allSatisfy Matters These methods make code easier to read because they describe the exact question you are asking. For example, in real projects you may need to: - Check whether a shopping cart contains a specific product ID. - Check whether any username in a list is empty. - Verify that all form fields are valid before submitting. - Confirm that all downloaded values are positive. - See whether a set of permissions contains an expected role. Without these methods, you would often write a loop, compare each element, and stop manually when the answer is known. That works, but it is more verbose and easier to get wrong. Using `contains` or `allSatisfy` makes the code shorter and clearer. > Both methods can stop early. For example, `contains` can return as soon as it finds a match, and `allSatisfy` can return as soon as it finds an element that fails the rule. ## 3. Basic Syntax ### Using contains with a value If the collection elements are comparable for equality, you can ask whether a collection contains a specific value. ```swift let numbers = [10, 20, 30] let hasTwenty = numbers.contains(20) print(hasTwenty) // true ``` Output (tested with Swift 6.4): ```text true ``` This form is simple: Swift checks whether any element equals `20`. ### Using contains with a closure Use the closure form when you want to match a condition instead of one exact value. ```swift let numbers = [10, 20, 30] let hasLargeValue = numbers.contains { number in number > 25 } print(hasLargeValue) // true ``` Output (tested with Swift 6.4): ```text true ``` The closure returns `true` for a matching element. If any element returns `true`, then `contains` returns `true`. ### Using allSatisfy with a closure `allSatisfy` checks whether every element passes the condition. ```swift let scores = [80, 92, 88] let allPassed = scores.allSatisfy { score in score >= 50 } print(allPassed) // true ``` Output (tested with Swift 6.4): ```text true ``` If even one score fails the condition, `allSatisfy` returns `false`. ### The core difference Think of them like this: - `contains` = at least one match - `allSatisfy` = every element matches ## 4. Step-by-Step Examples ### Example 1: Check for a specific string This example uses `contains` to check whether a list of names includes a specific value. ```swift let names = ["Ava", "Noah", "Mia"] let hasMia = names.contains("Mia") print(hasMia) // true ``` Output (tested with Swift 6.4): ```text true ``` This is the best form when you know the exact value you want to find. ### Example 2: Check whether any number is even Here, an exact value is not enough. We want to test a rule, so the closure form of `contains` is the right choice. ```swift let values = [3, 7, 10, 13] let hasEven = values.contains { value in value % 2 == 0 } print(hasEven) // true ``` Output (tested with Swift 6.4): ```text true ``` The method returns `true` because `10` matches the condition. ### Example 3: Check whether all strings are non-empty `allSatisfy` is useful when every element must meet a rule. ```swift let usernames = ["alice", "bob", "charlie"] let allHaveText = usernames.allSatisfy { !$0.isEmpty } print(allHaveText) // true ``` Output (tested with Swift 6.4): ```text true ``` This reads cleanly: all usernames satisfy the rule of being non-empty. ### Example 4: Check object properties with contains These methods are especially useful with custom types. In this example, we check whether any task is overdue. ```swift struct Task { let title: String let isOverdue: Bool } let tasks = [ Task(title: "Send invoice", isOverdue: false), Task(title: "Reply to email", isOverdue: true) ] let hasOverdueTask = tasks.contains { task in task.isOverdue } print(hasOverdueTask) // true ``` Output (tested with Swift 6.4): ```text true ``` This approach avoids writing a manual loop and clearly expresses the intent. ## 5. Practical Use Cases - Checking whether a cart contains a product before allowing checkout changes. - Verifying that all password rules are met for a list of imported accounts. - Testing whether any log message contains an error keyword. - Confirming that all API response items have valid IDs. - Checking whether a permissions set contains a required role. - Verifying that all uploaded filenames have an allowed extension. - Detecting whether any score falls below a minimum threshold. ## 6. Common Mistakes ### Mistake 1: Using contains when you really mean allSatisfy A common beginner mistake is choosing `contains` for a rule that every element must satisfy. **Problem:** This code only checks whether at least one number is positive, not whether all numbers are positive. The result can be `true` even when some elements fail the rule. ```swift let numbers = [5, -2, 8] let allPositive = numbers.contains { $0 > 0 } print(allPositive) // true, but misleading ``` Output (tested with Swift 6.4): ```text true ``` **Fix:** Use `allSatisfy` when the condition must hold for every element. ```swift let numbers = [5, -2, 8] let allPositive = numbers.allSatisfy { $0 > 0 } print(allPositive) // false ``` Output (tested with Swift 6.4): ```text false ``` The corrected version works because `allSatisfy` checks every element instead of stopping at the first success. ### Mistake 2: Trying to pass a value to allSatisfy `allSatisfy` does not have the same direct-value form as `contains`. It expects a closure that returns `Bool`. **Problem:** This code is not valid Swift because `allSatisfy` requires a predicate closure, not a single value to compare against. ```swift let statuses = ["ready", "ready", "ready"] let allReady = statuses.allSatisfy("ready") ``` **Fix:** Provide a closure that compares each element with the expected value. ```swift let statuses = ["ready", "ready", "ready"] let allReady = statuses.allSatisfy { $0 == "ready" } print(allReady) // true ``` Output (tested with Swift 6.4): ```text true ``` The corrected version works because the closure checks each element one at a time. ### Mistake 3: Forgetting that empty collections affect allSatisfy Many developers expect `allSatisfy` to return `false` for an empty collection, but that is not how it works. **Problem:** An empty collection has no elements that fail the condition, so `allSatisfy` returns `true`. This can surprise you if you also need at least one element. ```swift let scores: [Int] = [] let allPassed = scores.allSatisfy { $0 >= 50 } print(allPassed) // true ``` Output (tested with Swift 6.4): ```text true ``` **Fix:** If your rule requires a non-empty collection, combine `allSatisfy` with an emptiness check. ```swift let scores: [Int] = [] let allPassed = !scores.isEmpty && scores.allSatisfy { $0 >= 50 } print(allPassed) // false ``` Output (tested with Swift 6.4): ```text false ``` The corrected version works because it checks both requirements: there must be elements, and they must all pass. ## 7. Best Practices ### Practice 1: Use the simplest form of contains when checking one exact value If you only need to find one exact value, prefer the direct-value form of `contains`. It is more readable than writing a closure for the same comparison. ```swift // Less preferred let roles = ["admin", "editor", "viewer"] let hasAdmin = roles.contains { $0 == "admin" } // Preferred let betterHasAdmin = roles.contains("admin") ``` The preferred version is easier to scan because it directly communicates the search value. ### Practice 2: Choose method names that reflect the question you are asking Store the result in a variable whose name makes the logic obvious. This becomes especially useful in conditions and validation code. ```swift let emails = ["a@example.com", "b@example.com"] let allEmailsValid = emails.allSatisfy { $0.contains("@") } if allEmailsValid { print("Ready to submit") } ``` Output (tested with Swift 6.4): ```text Ready to submit ``` A descriptive Boolean name helps the condition read like plain English. ### Practice 3: Keep closure conditions focused and easy to read If the condition is too complex, move the logic into a helper property or function. This keeps collection checks expressive instead of cluttered. ```swift struct User { let name: String let age: Int var isAdult: Bool { age >= 18 } } let users = [ User(name: "Anna", age: 21), User(name: "Ben", age: 19) ] let allAdults = users.allSatisfy { $0.isAdult } ``` This version is cleaner than putting a long rule directly inside the closure. ## 8. Limitations and Edge Cases - `contains` with a direct value requires elements that can be compared for equality. For custom types, you may need to conform to `Equatable`, or use the closure form. - `allSatisfy` returns `true` for empty collections. This is correct behavior, but it may not match business rules that require at least one element. - Both methods return only a Boolean. If you need the matching element itself, methods such as `first(where:)` may be more appropriate. - If your closure has side effects, the code becomes harder to reason about. Prefer pure checks that simply return `true` or `false`. - On unordered collections such as sets, you should not depend on any specific checking order, even though the Boolean result is correct. - If a collection is very large, these methods still need to inspect elements until the answer is known. They are concise, but not magically free. ## 9. Practical Mini Project This mini project validates a list of orders. We want to know whether any order is urgent and whether all orders are ready to ship. ```swift struct Order { let id: Int let isUrgent: Bool let isPacked: Bool } let orders = [ Order(id: 101, isUrgent: false, isPacked: true), Order(id: 102, isUrgent: true, isPacked: true), Order(id: 103, isUrgent: false, isPacked: true) ] let hasUrgentOrder = orders.contains { $0.isUrgent } let allOrdersPacked = orders.allSatisfy { $0.isPacked } print("Urgent order present:", hasUrgentOrder) print("All orders packed:", allOrdersPacked) ``` Output (tested with Swift 6.4): ```text Urgent order present: true All orders packed: true ``` This example shows both methods working together in a realistic validation scenario. `contains` answers whether at least one urgent order exists, while `allSatisfy` confirms whether every order is packed. ## 10. Key Points - `contains` checks whether at least one element matches. - `allSatisfy` checks whether every element matches. - `contains` can compare a direct value or use a closure. - `allSatisfy` uses a closure that returns `Bool`. - Use `contains` for “any?” questions and `allSatisfy` for “all?” questions. - Be careful with empty collections because `allSatisfy` returns `true` for them. ## 11. Practice Exercise Create a Swift program that works with an array of temperatures. - Store several `Int` temperature values in an array. - Use `contains` to check whether any temperature is below zero. - Use `allSatisfy` to check whether all temperatures are below 40. - Print both results. **Expected output:** Two printed Boolean results: one for whether any temperature is freezing, and one for whether all temperatures are under the limit. **Hint:** Use closure expressions such as `{ $0 < 0 }` and `{ $0 < 40 }`. ```swift let temperatures = [12, -3, 18, 25] let hasFreezingTemperature = temperatures.contains { $0 < 0 } let allBelowLimit = temperatures.allSatisfy { $0 < 40 } print("Any below zero:", hasFreezingTemperature) print("All below 40:", allBelowLimit) ``` Output (tested with Swift 6.4): ```text Any below zero: true All below 40: true ``` ## 12. Final Summary `contains` and `allSatisfy` are small methods, but they solve very common collection-checking problems in a clear and expressive way. Use `contains` when you want to know whether any matching element exists, and use `allSatisfy` when every element must follow the same rule. You also saw that the direct-value form of `contains` is ideal for exact matches, while closure-based checks are better for custom logic. Just be careful with empty collections and choose the method that matches your real question: “any?” or “all?” A good next step is to learn related collection methods such as `first(where:)`, `filter`, and `map` so you can do more than just Boolean checks.