Swift Language
Tableaux

Introduction

Syntaxe

• Array <Element> // Le type d'un tableau avec des éléments de type Element
• [Element] // Sucre syntaxique pour le type d'un tableau avec des éléments de type Element
• [element0, element1, element2, ... elementN] // Un littéral tableau
• [Element] () // Crée un nouveau tableau vide de type [Element]
• Array (count: repeatValue :) // Crée un tableau d'éléments count , chacun initialisé à repeatedValue
• Array (_ :) // Crée un tableau à partir d'une séquence arbitraire

Remarques

Sémantique de la valeur

Copier un tableau copiera tous les éléments dans le tableau d'origine.

Changer le nouveau tableau ne changera pas le tableau d'origine.

var originalArray = ["Swift", "is", "great!"]
var newArray = originalArray
newArray[2] = "awesome!"
//originalArray = ["Swift", "is", "great!"]
//newArray = ["Swift", "is", "awesome!"]

Les tableaux copiés partageront le même espace en mémoire que l'original jusqu'à ce qu'ils soient modifiés. Il en résulte un problème de performance lorsque le tableau copié reçoit son propre espace en mémoire car il est modifié pour la première fois.

Bases de tableaux

Array est un type de collection ordonnée dans la bibliothèque standard Swift. Il fournit un accès aléatoire O (1) et une réallocation dynamique. Array est un type générique , de sorte que le type de valeurs qu'il contient est connu à la compilation.

Comme Array est un type de valeur , sa mutabilité est définie par le fait qu'il soit annoté en tant que var (mutable) ou let (immutable).

Le type [Int] (signification: un tableau contenant Int s) est du sucre syntaxique pour Array<T> .

En savoir plus sur les tableaux dans le langage de programmation Swift .

Tableaux vides

Les trois déclarations suivantes sont équivalentes:

// A mutable array of Strings, initially empty.

var arrayOfStrings: [String] = []      // type annotation + array literal
var arrayOfStrings = [String]()        // invoking the [String] initializer
var arrayOfStrings = Array<String>()   // without syntactic sugar

Littéraux de tableau

Un littéral de tableau est écrit avec des crochets entourant les éléments séparés par des virgules:

// Create an immutable array of type [Int] containing 2, 4, and 7
let arrayOfInts = [2, 4, 7]

Le compilateur peut généralement déduire le type d'un tableau basé sur les éléments du littéral, mais les annotations de type explicite peuvent remplacer le paramètre par défaut:

let arrayOfUInt8s: [UInt8] = [2, 4, 7]   // type annotation on the variable
let arrayOfUInt8s = [2, 4, 7] as [UInt8] // type annotation on the initializer expression
let arrayOfUInt8s = [2 as UInt8, 4, 7]   // explicit for one element, inferred for the others

Tableaux avec valeurs répétées

// An immutable array of type [String], containing ["Example", "Example", "Example"]
let arrayOfStrings = Array(repeating: "Example",count: 3)

Création de tableaux à partir d'autres séquences

let dictionary = ["foo" : 4, "bar" : 6]

// An immutable array of type [(String, Int)], containing [("bar", 6), ("foo", 4)]
let arrayOfKeyValuePairs = Array(dictionary)

Tableaux multidimensionnels

Dans Swift, un tableau multidimensionnel est créé en imbriquant des tableaux: un tableau à deux dimensions de Int est [[Int]] (ou Array<Array<Int>> ).

let array2x3 = [
    [1, 2, 3],
    [4, 5, 6]
]
// array2x3[0][1] is 2, and array2x3[1][2] is 6.

Pour créer un tableau multidimensionnel de valeurs répétées, utilisez les appels imbriqués de l'initialiseur de tableau:

var array3x4x5 = Array(repeating: Array(repeating: Array(repeating: 0,count: 5),count: 4),count: 3)

Accéder aux valeurs du tableau

Les exemples suivants utiliseront ce tableau pour démontrer l'accès aux valeurs

var exampleArray:[Int] = [1,2,3,4,5]
//exampleArray = [1, 2, 3, 4, 5]

Pour accéder à une valeur à un index connu, utilisez la syntaxe suivante:

let exampleOne = exampleArray[2]
//exampleOne = 3

Remarque: La valeur de l' index deux est la troisième valeur du Array . Array utilisent un index basé sur zéro, ce qui signifie que le premier élément du Array est à l'index 0.

let value0 = exampleArray[0]
let value1 = exampleArray[1]
let value2 = exampleArray[2]
let value3 = exampleArray[3]
let value4 = exampleArray[4]
//value0 = 1
//value1 = 2 
//value2 = 3
//value3 = 4
//value4 = 5

Accédez à un sous-ensemble d'un Array aide du filtre:

var filteredArray = exampleArray.filter({ $0 < 4 })
//filteredArray = [1, 2, 3]

Les filtres peuvent avoir des conditions complexes comme le filtrage des nombres pairs uniquement:

var evenArray = exampleArray.filter({ $0 % 2 == 0 })
//evenArray = [2, 4]

Il est également possible de retourner l'index d'une valeur donnée, en retournant nil si la valeur n'a pas été trouvée.

exampleArray.indexOf(3) // Optional(2)

Il existe des méthodes pour la valeur première, dernière, maximale ou minimale dans un Array . Ces méthodes renvoient nil si le Array est vide.

exampleArray.first // Optional(1)
exampleArray.last // Optional(5)
exampleArray.maxElement() // Optional(5)
exampleArray.minElement() // Optional(1)

Méthodes utiles

Détermine si un tableau est vide ou renvoie sa taille

var exampleArray = [1,2,3,4,5]
exampleArray.isEmpty //false
exampleArray.count //5

Inverser un tableau Remarque: Le résultat n'est pas appliqué au tableau sur lequel la méthode est appelée et doit être placé dans sa propre variable.

exampleArray = exampleArray.reverse()
//exampleArray = [9, 8, 7, 6, 5, 3, 2]

Modification de valeurs dans un tableau

Il y a plusieurs façons d'ajouter des valeurs à un tableau

var exampleArray = [1,2,3,4,5]
exampleArray.append(6)
//exampleArray = [1, 2, 3, 4, 5, 6]
var sixOnwards = [7,8,9,10]
exampleArray += sixOnwards
//exampleArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

et supprimer des valeurs d'un tableau

exampleArray.removeAtIndex(3)
//exampleArray = [1, 2, 3, 5, 6, 7, 8, 9, 10]
exampleArray.removeLast()
//exampleArray = [1, 2, 3, 5, 6, 7, 8, 9]
exampleArray.removeFirst()
//exampleArray = [2, 3, 5, 6, 7, 8, 9]

Tri d'un tableau

var array = [3, 2, 1]

Créer un nouveau tableau trié

Comme Array est conforme à SequenceType , nous pouvons générer un nouveau tableau des éléments triés en utilisant une méthode de tri intégrée.

let sorted = array.sort()  // [1, 2, 3]

let sorted = array.sorted()  // [1, 2, 3]

Trier un tableau existant en place

Comme Array est conforme à MutableCollectionType , nous pouvons trier ses éléments en place.

array.sortInPlace() // [1, 2, 3]

array.sort() // [1, 2, 3]

Remarque: Pour utiliser les méthodes ci-dessus, les éléments doivent être conformes au protocole Comparable .

Trier un tableau avec un ordre personnalisé

Vous pouvez également trier un tableau en utilisant une fermeture pour définir si un élément doit être ordonné avant un autre, ce qui ne se limite pas aux tableaux où les éléments doivent être Comparable . Par exemple, il n'est pas logique qu'un Landmark de Landmark soit Comparable , mais vous pouvez toujours trier un tableau de points de repère par hauteur ou par nom.

struct Landmark {
    let name : String
    let metersTall : Int
}

var landmarks = [Landmark(name: "Empire State Building", metersTall: 443),
                 Landmark(name: "Eifell Tower", metersTall: 300),
                 Landmark(name: "The Shard", metersTall: 310)]

// sort landmarks by height (ascending)
landmarks.sortInPlace {$0.metersTall < $1.metersTall}

print(landmarks) // [Landmark(name: "Eifell Tower", metersTall: 300), Landmark(name: "The Shard", metersTall: 310), Landmark(name: "Empire State Building", metersTall: 443)]

// create new array of landmarks sorted by name
let alphabeticalLandmarks = landmarks.sort {$0.name < $1.name}

print(alphabeticalLandmarks) // [Landmark(name: "Eifell Tower", metersTall: 300), Landmark(name: "Empire State Building", metersTall: 443), Landmark(name: "The Shard", metersTall: 310)]

// sort landmarks by height (ascending)
landmarks.sort {$0.metersTall < $1.metersTall}

// create new array of landmarks sorted by name
let alphabeticalLandmarks = landmarks.sorted {$0.name < $1.name}

Remarque: La comparaison de chaînes peut donner des résultats inattendus si les chaînes sont incohérentes. Voir Tri d'un tableau de chaînes .

Transformer les éléments d'un tableau avec map (_ :)

Comme Array est conforme à SequenceType , nous pouvons utiliser map(_:) pour transformer un tableau de A en un tableau de B utilisant une fermeture de type (A) throws -> B

Par exemple, nous pourrions l'utiliser pour transformer un tableau de Int s en un tableau de String comme suit:

let numbers = [1, 2, 3, 4, 5]
let words = numbers.map { String($0) }
print(words) // ["1", "2", "3", "4", "5"]

map(_:) va parcourir le tableau, en appliquant la fermeture donnée à chaque élément. Le résultat de cette fermeture sera utilisé pour remplir un nouveau tableau avec les éléments transformés.

Puisque String a un initialiseur qui reçoit un Int nous pouvons également utiliser cette syntaxe plus claire:

let words = numbers.map(String.init)

Une map(_:) transform n'a pas besoin de changer le type du tableau - par exemple, elle pourrait aussi être utilisée pour multiplier un tableau de Int s par deux:

let numbers = [1, 2, 3, 4, 5]
let numbersTimes2 = numbers.map {$0 * 2}
print(numbersTimes2) // [2, 4, 6, 8, 10]

Extraire des valeurs d'un type donné à partir d'un tableau avec flatMap (_ :)

Les things Array contiennent des valeurs de type Any .

let things: [Any] = [1, "Hello", 2, true, false, "World", 3]

Nous pouvons extraire les valeurs d'un type donné et créer un nouveau tableau de ce type spécifique. Disons que nous voulons extraire tous les Int(s) et les placer dans un tableau Int Array de manière sûre.

let numbers = things.flatMap { $0 as? Int }

Maintenant, les numbers sont définis comme [Int] . La fonction flatMap tous les éléments nil et le résultat ne contient donc que les valeurs suivantes:

[1, 2, 3]

Filtrage d'un tableau

Vous pouvez utiliser la méthode filter(_:) sur SequenceType pour créer un nouveau tableau contenant les éléments de la séquence qui satisfont un prédicat donné, qui peut être fourni en tant que fermeture .

Par exemple, filtrer les nombres pairs d'un [Int] :

let numbers = [22, 41, 23, 30]

let evenNumbers = numbers.filter { $0 % 2 == 0 }

print(evenNumbers)  // [22, 30]

Filtrer un [Person] , où son âge est inférieur à 30:

struct Person {
    var age : Int
}

let people = [Person(age: 22), Person(age: 41), Person(age: 23), Person(age: 30)]

let peopleYoungerThan30 = people.filter { $0.age < 30 }

print(peopleYoungerThan30) // [Person(age: 22), Person(age: 23)]

Filtrage de la transformation Nil d'une matrice avec flatMap (_ :)

Vous pouvez utiliser flatMap(_:) de manière similaire à map(_:) afin de créer un tableau en appliquant une transformation aux éléments d'une séquence.

extension SequenceType {
    public func flatMap<T>(@noescape transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]
}

La différence avec cette version de flatMap(_:) est qu’elle attend que la fermeture de la transformation renvoie une valeur optionnelle T? pour chacun des éléments. Il va ensuite déballer en toute sécurité chacune de ces valeurs optionnelles, en filtrant la valeur nil - ce qui donnera un tableau de [T] .

Par exemple, vous pouvez le faire afin de transformer un [String] en un [Int] utilisant l' initialiseur de String disponible d' Int , en filtrant tous les éléments qui ne peuvent pas être convertis:

let strings = ["1", "foo", "3", "4", "bar", "6"]

let numbersThatCanBeConverted = strings.flatMap { Int($0) }

print(numbersThatCanBeConverted) // [1, 3, 4, 6]

Vous pouvez également utiliser la flatMap(_:) à filtrer le nil afin de convertir simplement un tableau de flatMap(_:) optionnels en un tableau de données non optionnelles:

let optionalNumbers : [Int?] = [nil, 1, nil, 2, nil, 3]

let numbers = optionalNumbers.flatMap { $0 }

print(numbers) // [1, 2, 3]

Inscrire un tableau avec une plage

On peut extraire une série d'éléments consécutifs d'un tableau en utilisant une plage.

let words = ["Hey", "Hello", "Bonjour", "Welcome", "Hi", "Hola"]
let range = 2...4
let slice = words[range] // ["Bonjour", "Welcome", "Hi"]

L'indexation d'un tableau avec une plage renvoie un ArraySlice . C'est une sous-séquence du tableau.

Dans notre exemple, nous avons un tableau de chaînes, nous ArraySlice<String> donc ArraySlice<String> .

Bien qu'un ArraySlice soit conforme à CollectionType et puisse être utilisé avec un sort , un filter , etc., il ne sert pas au stockage à long terme mais à des calculs transitoires: il doit être reconverti en un tableau dès que vous avez fini de l'utiliser.

Pour cela, utilisez l'initialiseur Array() :

let result = Array(slice)

Pour résumer dans un exemple simple sans étapes intermédiaires:

let words = ["Hey", "Hello", "Bonjour", "Welcome", "Hi", "Hola"]
let selectedWords = Array(words[2...4]) // ["Bonjour", "Welcome", "Hi"]

Regroupement des valeurs de tableau

Si nous avons une structure comme celle-ci

struct Box {
    let name: String
    let thingsInside: Int
}

et un tableau de Box(es)

let boxes = [
    Box(name: "Box 0", thingsInside: 1),
    Box(name: "Box 1", thingsInside: 2),
    Box(name: "Box 2", thingsInside: 3),
    Box(name: "Box 3", thingsInside: 1),
    Box(name: "Box 4", thingsInside: 2),
    Box(name: "Box 5", thingsInside: 3),
    Box(name: "Box 6", thingsInside: 1)
]

nous pouvons regrouper les boîtes par la propriété thingsInside pour obtenir un Dictionary où la key est le nombre de choses et la valeur un tableau de boîtes.

let grouped = boxes.reduce([Int:[Box]]()) { (res, box) -> [Int:[Box]] in
    var res = res
    res[box.thingsInside] = (res[box.thingsInside] ?? []) + [box]
    return res
}

Maintenant regroupé est un [Int:[Box]] et a le contenu suivant

[
    2: [Box(name: "Box 1", thingsInside: 2), Box(name: "Box 4", thingsInside: 2)], 
    3: [Box(name: "Box 2", thingsInside: 3), Box(name: "Box 5", thingsInside: 3)],
    1: [Box(name: "Box 0", thingsInside: 1), Box(name: "Box 3", thingsInside: 1), Box(name: "Box 6", thingsInside: 1)]
]

Aplatir le résultat d'une transformation Array avec flatMap (_ :)

En plus d'être en mesure de créer un tableau de filtrage de nil à partir des éléments transformées d'une séquence, il existe également une version de flatMap(_:) qui prévoit la transformation de fermeture pour retourner une séquence S .

extension SequenceType {
    public func flatMap<S : SequenceType>(transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
}

Chaque séquence de la transformation sera concaténée, résultant en un tableau contenant les éléments combinés de chaque séquence - [S.Generator.Element] .

Combiner les caractères dans un tableau de chaînes

Par exemple, nous pouvons l'utiliser pour prendre un tableau de chaînes principales et combiner leurs caractères en un seul tableau:

let primes = ["2", "3", "5", "7", "11", "13", "17", "19"]
let allCharacters = primes.flatMap { $0.characters }
// => "["2", "3", "5", "7", "1", "1", "1", "3", "1", "7", "1", "9"]"

Briser l'exemple ci-dessus:

1. primes est un [String] (comme un tableau est une séquence, nous pouvons appeler flatMap(_:) ).
2. La fermeture de transformation prend l'un des éléments de primes , une String ( Array<String>.Generator.Element ).
3. La fermeture retourne alors une séquence de type String.CharacterView .
4. Le résultat est alors un tableau contenant les éléments combinés de toutes les séquences de chacun des appels de clôture de transformation - [String.CharacterView.Generator.Element] .

Aplatir un tableau multidimensionnel

Comme flatMap(_:) concaténera les séquences renvoyées par les appels de clôture de transformation, il peut être utilisé pour aplatir un tableau multidimensionnel, tel qu'un tableau 2D en un tableau 1D, un tableau 3D en un tableau 2D, etc.

Cela peut se faire simplement en retournant l'élément donné $0 (un tableau imbriqué) dans la fermeture:

// A 2D array of type [[Int]]
let array2D = [[1, 3], [4], [6, 8, 10], [11]]

// A 1D array of type [Int]
let flattenedArray = array2D.flatMap { $0 }

print(flattenedArray) // [1, 3, 4, 6, 8, 10, 11]

Trier un tableau de chaînes

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted()
print(sortedWords) // ["Ahola", "Bonjour", "Hello", "Salute"]

var mutableWords = ["Hello", "Bonjour", "Salute", "Ahola"]
mutableWords.sort()
print(mutableWords) // ["Ahola", "Bonjour", "Hello", "Salute"]

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted(isOrderedBefore: { $0 > $1 })
print(sortedWords) // ["Salute", "Hello", "Bonjour", "Ahola"]

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted() { $0 > $1 }
print(sortedWords) // ["Salute", "Hello", "Bonjour", "Ahola"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let unexpected = words.sorted()
print(unexpected) // ["Hello", "Salute", "ahola", "bonjour"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let sortedWords = words.sorted { $0.lowercased() < $1.lowercased() }
print(sortedWords) // ["ahola", "bonjour", "Hello", "Salute"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let sortedWords = words.sorted { $0.caseInsensitiveCompare($1) == .orderedAscending }
print(sortedWords) // ["ahola", "bonjour", "Hello", "Salute"]

let files = ["File-42.txt", "File-01.txt", "File-5.txt", "File-007.txt", "File-10.txt"]
let sortedFiles = files.sorted() { $0.compare($1, options: .numeric) == .orderedAscending }
print(sortedFiles) // ["File-01.txt", "File-5.txt", "File-007.txt", "File-10.txt", "File-42.txt"]

Aplatir paresseusement un tableau multidimensionnel avec flatten ()

Nous pouvons utiliser flatten() pour réduire paresseusement l'imbrication d'une séquence multidimensionnelle.

Par exemple, la mise à plat paresseuse d'un tableau 2D en un tableau 1D:

// A 2D array of type [[Int]]
let array2D = [[1, 3], [4], [6, 8, 10], [11]]

// A FlattenBidirectionalCollection<[[Int]]>
let lazilyFlattenedArray = array2D.flatten()

print(lazilyFlattenedArray.contains(4)) // true

Dans l'exemple ci-dessus, flatten() retournera un FlattenBidirectionalCollection , qui appliquera paresseusement l'aplatissement du tableau. La fonction contains(_:) ne nécessitera donc que l' array2D des deux premiers tableaux imbriqués de array2D , car il court-circuitera lors de la recherche de l'élément souhaité.

Combiner les éléments d'un tableau avec réduire (_: combiner :)

reduce(_:combine:) peut être utilisé pour combiner les éléments d'une séquence en une seule valeur. Il faut une valeur initiale pour le résultat, ainsi qu'une fermeture à appliquer à chaque élément - qui renverra la nouvelle valeur accumulée.

Par exemple, nous pouvons l'utiliser pour additionner un tableau de nombres:

let numbers = [2, 5, 7, 8, 10, 4]

let sum = numbers.reduce(0) {accumulator, element in
    return accumulator + element
}

print(sum) // 36

Nous passons 0 dans la valeur initiale, car c'est la valeur initiale logique pour une sommation. Si nous passons dans une valeur de N , la sum résultante serait N + 36 . La fermeture passée à reduce a deux arguments. accumulator est la valeur accumulée actuelle, à laquelle est affectée la valeur renvoyée par la fermeture à chaque itération. element est l'élément actuel de l'itération.

Comme dans cet exemple, nous passons une fermeture (Int, Int) -> Int à reduce , qui produit simplement l'ajout des deux entrées - nous pouvons en fait passer directement l'opérateur + , car les opérateurs sont des fonctions dans Swift:

let sum = numbers.reduce(0, combine: +)

Suppression d'un élément d'un tableau sans connaître son index

Généralement, si nous voulons supprimer un élément d'un tableau, nous devons connaître son index afin de pouvoir le supprimer facilement en utilisant la fonction remove(at:) .

Mais que faire si on ne connait pas l'index mais on connait la valeur de l'élément à supprimer!

Voici donc la simple extension à un tableau qui nous permettra de supprimer facilement un élément du tableau sans connaître son index:

Swift3

extension Array where Element: Equatable {

    mutating func remove(_ element: Element) {
        _ = index(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

par exemple

    var array = ["abc", "lmn", "pqr", "stu", "xyz"]
    array.remove("lmn")
    print("\(array)")    //["abc", "pqr", "stu", "xyz"]
    
    array.remove("nonexistent")
    print("\(array)")    //["abc", "pqr", "stu", "xyz"]
    //if provided element value is not present, then it will do nothing!

Aussi , si, par erreur, nous avons fait quelque chose comme ceci: array.remove(25) par exemple , nous avons fourni la valeur avec différents types de données, compilateur génère une erreur mentioning-
cannot convert value to expected argument type

Trouver l'élément minimum ou maximum d'un tableau

let numbers = [2, 6, 1, 25, 13, 7, 9]

let minimumNumber = numbers.minElement() // Optional(1)
let maximumNumber = numbers.maxElement() // Optional(25)

let minimumNumber = numbers.min() // Optional(1)
let maximumNumber = numbers.max() // Optional(25)

Les valeurs renvoyées par ces méthodes sont facultatives pour refléter le fait que le tableau pourrait être vide. Si tel est le cas, nil ne sera renvoyée.

Remarque: Les méthodes ci-dessus nécessitent que les éléments soient conformes au protocole Comparable .

Trouver l'élément minimum ou maximum avec un ordre personnalisé

Vous pouvez également utiliser les méthodes ci-dessus avec une fermeture personnalisée, en définissant si un élément doit être commandé avant un autre, ce qui vous permet de trouver l'élément minimum ou maximum dans un tableau où les éléments ne sont pas nécessairement Comparable .

Par exemple, avec un tableau de vecteurs:

struct Vector2 {
    let dx : Double
    let dy : Double
    
    var magnitude : Double {return sqrt(dx*dx+dy*dy)}
}

let vectors = [Vector2(dx: 3, dy: 2), Vector2(dx: 1, dy: 1), Vector2(dx: 2, dy: 2)]

// Vector2(dx: 1.0, dy: 1.0)
let lowestMagnitudeVec2 = vectors.minElement { $0.magnitude < $1.magnitude } 

// Vector2(dx: 3.0, dy: 2.0)
let highestMagnitudeVec2 = vectors.maxElement { $0.magnitude < $1.magnitude } 

let lowestMagnitudeVec2 = vectors.min { $0.magnitude < $1.magnitude }
let highestMagnitudeVec2 = vectors.max { $0.magnitude < $1.magnitude }

Accéder aux indices en toute sécurité

En ajoutant l'extension suivante aux tableaux, vous pouvez accéder aux indices sans savoir si l'index est compris dans les limites.

extension Array {
    subscript (safe index: Int) -> Element? {
        return indices ~= index ? self[index] : nil
    }
}

Exemple:

if let thirdValue = array[safe: 2] {
    print(thirdValue)
}

Comparaison de 2 tableaux avec zip

La fonction zip accepte 2 paramètres de type SequenceType et retourne une Zip2Sequence où chaque élément contient une valeur de la première séquence et une de la seconde.

Exemple

let nums = [1, 2, 3]
let animals = ["Dog", "Cat", "Tiger"]
let numsAndAnimals = zip(nums, animals)

nomsAndAnimals contient maintenant les valeurs suivantes

Ceci est utile lorsque vous souhaitez effectuer une sorte de comparaison entre le n-ième élément de chaque tableau.

Exemple

Étant donné 2 tableaux de Int(s)

let list0 = [0, 2, 4]
let list1 = [0, 4, 8]

vous voulez vérifier si chaque valeur dans list1 est le double de la valeur associée dans list0 .

let list1HasDoubleOfList0 = !zip(list0, list1).filter { $0 != (2 * $1)}.isEmpty