Vérification de la présence d'un élément dans un tableau Swift : meilleures pratiques 2025

🔍 Pourquoi vérifier la présence d'un élément dans un tableau Swift ? Et comment le faire correctement en 2025 ?

Imaginez : vous développez une application de commande de pizzas. L'utilisateur a choisi "Pepperoni", "Hawaïenne" et "Margherita". Votre code doit s'assurer que "Pepperoni" est déjà dans le panier pour éviter d'ajouter un doublon. Ou vous travaillez avec une base de données clients et vérifiez si un email est enregistré dans le système. Vérifier la présence d'un élément dans un tableau est l'une des opérations les plus fréquentes en développement Swift.

Cela semble simple, n'est-ce pas ? Mais en 2025, alors que Swift évolue rapidement et que les performances des applications mobiles sont cruciales, choisir la mauvaise méthode peut vous coûter des ralentissements dans l'interface utilisateur ou des heures de débogage supplémentaires. Dans cet article, nous allons passer en revue toutes les façons de vérifier un élément dans un tableau Swift : du simple contains() aux closures avancées et au travail avec des types personnalisés. Vous découvrirez quelle méthode choisir pour votre tâche et pourquoi.

D'ailleurs, cette question est l'une des plus populaires sur Stack Overflow (plus de 200 000 vues). Et nous allons y apporter une réponse exhaustive et moderne. C'est parti ! 🚀

📦 Les tableaux en Swift : aperçu de base (pour ceux qui sont pressés)

Un tableau (Array) est une collection ordonnée d'éléments du même type. En Swift, les tableaux sont type-safe, ce qui signifie que vous ne pouvez pas ajouter accidentellement une chaîne de caractères à un tableau de nombres. C'est à la fois un avantage (moins de bugs) et un défi (il faut spécifier strictement les types).

let pizzaMenu: [String] = ["Margherita", "Pepperoni", "Hawaïenne", "Quatre fromages"]\nlet numbers: [Int] = [1, 2, 3, 4, 5]\n

Passons maintenant à l'essentiel : comment vérifier si un élément est présent dans un tableau ?

🛠️ Top 5 des méthodes pour vérifier la présence d'un élément dans un tableau Swift

1. contains() — le roi de la simplicité (Equatable)

La méthode la plus évidente et la plus utilisée. La méthode contains(_:) retourne true si l'élément est trouvé. Elle fonctionne uniquement avec les types conformes au protocole Equatable (ce qui inclut tous les types de base : String, Int, Double, etc.).

let pizzas = ["Margherita", "Pepperoni", "Hawaïenne"]\nif pizzas.contains("Pepperoni") {\n    print("Cette pizza existe !") // ✅ Affichera ceci\n} else {\n    print("Pizza non trouvée")\n}\n

Avantages : lisible, concis, rapide.

Inconvénients : ne fonctionne pas si vous avez un objet complexe (structure/classe) sans Equatable.

2. contains(where:) — pour les vérifications complexes

Si vous devez vérifier non pas une correspondance exacte, mais une condition (par exemple, "y a-t-il une pizza coûtant plus de 500 roubles ?"), utilisez contains(where:). Il prend une closure qui retourne un Bool.

struct Pizza {\n    let name: String\n    let price: Int\n}\n\nlet order: [Pizza] = [\n    Pizza(name: "Margherita", price: 450),\n    Pizza(name: "Pepperoni", price: 550),\n    Pizza(name: "Hawaïenne", price: 500)\n]\n\nlet hasExpensivePizza = order.contains { $0.price > 500 }\nprint("Y a-t-il une pizza chère ? \\(hasExpensivePizza)") // true\n

Avantages : flexibilité, fonctionne avec tous les types.

Inconvénients : légèrement plus lent que contains() (mais pour 99% des cas, la différence est imperceptible).

3. firstIndex(of:) — quand l'index est important

Parfois, vous avez besoin non seulement de savoir si un élément existe, mais aussi d'obtenir sa position. Par exemple, pour le supprimer ou le remplacer. La méthode firstIndex(of:) retourne un Int? optionnel.

let pizzas = ["Margherita", "Pepperoni", "Hawaïenne"]\nif let index = pizzas.firstIndex(of: "Pepperoni") {\n    print("Pepperoni à la position \\(index)") // 1\n} else {\n    print("Non trouvé")\n}\n

Important : firstIndex nécessite également Equatable. Si votre type n'est pas conforme