Swift Language
arrays

Invoering

Syntaxis

• Array <Element> // Het type van een array met elementen van het type Element
• [Element] // Syntactische suiker voor het type array met elementen van het type Element
• [element0, element1, element2, ... elementN] // Een letterlijk array
• [Element] () // Maakt een nieuwe lege array van het type [Element]
• Array (count: herhaalde waarde :) // Maakt een reeks count , elk geïnitialiseerd naar repeatedValue
• Array (_ :) // Maakt een array op basis van een willekeurige volgorde

Opmerkingen

Waarde semantiek

Als u een array kopieert, worden alle items in de oorspronkelijke array gekopieerd.

Als u de nieuwe array wijzigt, wordt de oorspronkelijke array niet gewijzigd .

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

Gekopieerde arrays delen dezelfde ruimte in het geheugen als het origineel totdat ze worden gewijzigd. Als gevolg hiervan is er een prestatiehit wanneer de gekopieerde array zijn eigen geheugenruimte krijgt wanneer deze voor de eerste keer wordt gewijzigd.

Basisprincipes van arrays

Array is een geordend verzameltype in de standaardbibliotheek van Swift. Het biedt O (1) willekeurige toegang en dynamische herverdeling. Array is een generiek type , dus het type waarden dat het bevat, is bekend tijdens het compileren.

Aangezien Array een waardetype is , wordt de veranderlijkheid ervan bepaald door of deze is geannoteerd als een var (mutable) of let (onveranderlijk).

Het type [Int] (wat betekent: een array met Int s) is syntactische suiker voor Array<T> .

Lees meer over arrays in The Swift Programming Language .

Lege arrays

De volgende drie verklaringen zijn gelijkwaardig:

// 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

Matrix letterlijk

Een letterlijk array wordt geschreven met vierkante haken rond door komma's gescheiden elementen:

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

De compiler kan meestal het type van een array afleiden op basis van de elementen in het letterlijke, maar expliciete type-annotaties kunnen de standaardwaarde overschrijven:

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

Arrays met herhaalde waarden

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

Arrays maken van andere reeksen

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

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

Multi-dimensionale arrays

In Swift wordt een multidimensionale array gemaakt door arrays te nesten: een tweedimensionale array van Int is [[Int]] (of Array<Array<Int>> ).

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

Gebruik een geneste aanroep van de array-initialisatie om een multidimensionale array met herhaalde waarden te maken:

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

Toegang tot matrixwaarden

In de volgende voorbeelden wordt deze array gebruikt om toegangswaarden aan te tonen

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

Gebruik de volgende syntaxis om toegang te krijgen tot een waarde met een bekende index:

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

Opmerking: de waarde op index twee is de derde waarde in de Array . Array gebruiken een op nul gebaseerde index, wat betekent dat het eerste element in de Array op index 0 staat.

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

Toegang tot een subset van een Array met behulp van filter:

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

Filters kunnen complexe omstandigheden hebben, zoals alleen even nummers filteren:

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

Het is ook mogelijk om de index van een bepaalde waarde te retourneren, waarbij nil geretourneerd als de waarde niet is gevonden.

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

Er zijn methoden voor de eerste, laatste, maximale of minimale waarde in een Array . Deze methoden retourneren nil als de Array leeg is.

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

Handige methoden

Bepaal of een array leeg is of de grootte retourneert

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

Een array omkeren Opmerking: het resultaat wordt niet uitgevoerd op de array waarop de methode wordt aangeroepen en moet in een eigen variabele worden geplaatst.

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

Waarden in een array wijzigen

Er zijn meerdere manieren om waarden aan een array toe te voegen

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]

en waarden uit een array verwijderen

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]

Een array sorteren

var array = [3, 2, 1]

Een nieuwe gesorteerde array maken

Omdat Array voldoet aan SequenceType , kunnen we een nieuwe reeks van de gesorteerde elementen genereren met behulp van een ingebouwde sorteermethode.

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

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

Een bestaande array op zijn plaats sorteren

Omdat Array voldoet aan MutableCollectionType , kunnen we de elementen op hun plaats sorteren.

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

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

Opmerking: om de bovenstaande methoden te kunnen gebruiken, moeten de elementen voldoen aan het Comparable protocol.

Een array sorteren met een aangepaste volgorde

U kunt ook een array sorteren met een sluiting om te bepalen of het ene element vóór het andere moet worden geordend - wat niet is beperkt tot arrays waarbij de elementen Comparable moeten zijn. Het is bijvoorbeeld niet logisch dat een Landmark Comparable , maar u kunt nog steeds een reeks oriëntatiepunten sorteren op hoogte of naam.

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}

Opmerking: Stringvergelijking kan onverwachte resultaten opleveren als de strings inconsistent zijn, zie Een array met strings sorteren .

De elementen van een array transformeren met kaart (_ :)

Omdat Array voldoet aan SequenceType , kunnen we map(_:) gebruiken om een array van A in een array van B met een afsluiting van type (A) throws -> B

We kunnen het bijvoorbeeld gebruiken om een reeks Int 's om te zetten in een reeks String s als volgt:

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

map(_:) doorloopt de array en past de gegeven sluiting toe op elk element. Het resultaat van die sluiting zal worden gebruikt om een nieuwe array met de getransformeerde elementen te vullen.

Omdat String een initialisator heeft die een Int ontvangt, kunnen we deze duidelijkere syntaxis ook gebruiken:

let words = numbers.map(String.init)

Een map(_:) transformatie hoeft het type van de array niet te veranderen - het kan bijvoorbeeld ook worden gebruikt om een array van Int s met twee te vermenigvuldigen:

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

Waarden van een bepaald type extraheren uit een array met flatMap (_ :)

De things Array bevat waarden van Any type.

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

We kunnen waarden van een bepaald type extraheren en een nieuwe array van dat specifieke type maken. Laten we zeggen dat we alle Int(s) willen extraheren en op een veilige manier in een Int Array willen plaatsen.

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

Nu wordt numbers gedefinieerd als [Int] . De flatMap functie leggen alle nil elementen en het resultaat bevat dus alleen de volgende waarden:

[1, 2, 3]

Een array filteren

U kunt de filter(_:) -methode op SequenceType gebruiken om een nieuwe array te maken met de elementen van de reeks die voldoen aan een bepaald predicaat, die als afsluiting kan worden verstrekt.

Bijvoorbeeld, het filteren van even getallen uit een [Int] :

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

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

print(evenNumbers)  // [22, 30]

Een [Person] filteren met een leeftijd jonger dan 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)]

Nul filteren uit een array-transformatie met flatMap (_ :)

U kunt gebruik maken flatMap(_:) in een soortgelijke wijze als map(_:) om een array te maken door het toepassen van een transformatie naar elementen een opeenvolging's.

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

Het verschil met deze versie van flatMap(_:) is dat verwacht wordt dat de transformatie- sluiting een optionele waarde T? retourneert T? voor elk van de elementen. Het zal dan veilig elk van deze optionele waarden uitpakken en nil filteren - wat resulteert in een reeks van [T] .

U kunt dit bijvoorbeeld doen om een [String] te transformeren in een [Int] met behulp van de beschikbare String initialisatie van Int , waarbij alle elementen worden gefilterd die niet kunnen worden geconverteerd:

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

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

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

Je kunt ook de mogelijkheid van flatMap(_:) om nil uit te filteren om een reeks optionele opties eenvoudig om te zetten in een reeks niet-optionele opties:

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

let numbers = optionalNumbers.flatMap { $0 }

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

Een array met een bereik onderschrijven

Men kan een reeks opeenvolgende elementen uit een array extraheren met behulp van een bereik.

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

Abonneren op een array met een bereik retourneert een ArraySlice . Het is een deelreeks van de array.

In ons voorbeeld hebben we een Array of Strings, dus we krijgen ArraySlice<String> .

Hoewel een ArraySlice voldoet aan CollectionType en kan worden gebruikt met sort , filter , enz., Is het doel niet voor langdurige opslag, maar voor tijdelijke berekeningen: het moet worden teruggezet in een Array zodra je klaar bent met ermee te werken.

Gebruik hiervoor de initialisatie Array() :

let result = Array(slice)

Samenvattend in een eenvoudig voorbeeld zonder tussenstappen:

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

Arraywaarden groeperen

Als we zo'n structuur hebben

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

en een reeks 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)
]

we kunnen de vakken thingsInside eigenschap thingsInside om een Dictionary te krijgen waarbij de key het aantal dingen is en de waarde een reeks vakken is.

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

Nu gegroepeerd is een [Int:[Box]] en heeft de volgende inhoud

[
    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)]
]

Het resultaat van een array-transformatie afvlakken met flatMap (_ :)

Naast de mogelijkheid om een array te creëren door het uitfilteren van nil uit de getransformeerde elementen of een sequentie, is er ook een versie van flatMap(_:) dat verwacht dat de transformatie afsluiting een volgorde terugkeren S .

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

Elke reeks van de transformatie wordt aaneengeschakeld, wat resulteert in een array met de gecombineerde elementen van elke reeks - [S.Generator.Element] .

De tekens combineren in een reeks tekenreeksen

We kunnen het bijvoorbeeld gebruiken om een reeks priemreeksen te nemen en hun karakters in een enkele reeks te combineren:

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"]"

Het bovenstaande voorbeeld opsplitsen:

1. primes is een [String] (aangezien een array een reeks is, kunnen we flatMap(_:) erop aanroepen).
2. De transformatie-afsluiting neemt een van de elementen van primes , een String ( Array<String>.Generator.Element ).
3. De sluiting retourneert vervolgens een reeks van het type String.CharacterView .
4. Het resultaat is dan een array met de gecombineerde elementen van alle sequenties van elk van de sluitingsaanroepen van de transformatie - [String.CharacterView.Generator.Element] .

Een multidimensionale array afvlakken

Omdat flatMap(_:) de sequenties samengevoegd die worden geretourneerd door de afsluitingsoproepen van de transformatie, kan het worden gebruikt om een multidimensionale array af te vlakken - zoals een 2D-array in een 1D-array, een 3D-array in een 2D-array enz.

Dit kan eenvoudig worden gedaan door het gegeven element $0 (een geneste array) terug te geven in de afsluiting:

// 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]

Een reeks strings sorteren

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"]

Een multidimensionale array lui afvlakken met flatten ()

We kunnen flatten() gebruiken om het nestelen van een multidimensionale reeks lui te verminderen.

Bijvoorbeeld, lui een 2D-array afvlakken tot een 1D-array:

// 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

In het bovenstaande voorbeeld retourneert flatten() een FlattenBidirectionalCollection , die de afvlakking van de array lui toepast. Daarom contains(_:) alleen de eerste twee geneste arrays van array2D moeten worden afgevlakt - omdat het kortsluiting veroorzaakt bij het vinden van het gewenste element.

Elementen van een array combineren met verkleinen (_: combineren :)

reduce(_:combine:) kan worden gebruikt om de elementen van een reeks te combineren in een enkele waarde. Er is een initiële waarde voor het resultaat nodig, evenals een afsluiting voor elk element - die de nieuwe geaccumuleerde waarde retourneert.

We kunnen het bijvoorbeeld gebruiken om een reeks getallen op te tellen:

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

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

print(sum) // 36

We geven 0 aan de beginwaarde, want dat is de logische beginwaarde voor een sommatie. Als we een waarde van N doorgeven, zou de resulterende sum N + 36 . De sluiting om te reduce heeft twee argumenten. accumulator is de huidige geaccumuleerde waarde, waaraan de waarde wordt toegekend die de sluiting bij elke iteratie retourneert. element is het huidige element in de iteratie.

Zoals in dit voorbeeld geven we een (Int, Int) -> Int sluiting om te reduce , die eenvoudigweg de toevoeging van de twee ingangen uitvoert - we kunnen de operator + rechtstreeks doorgeven, omdat operators functies zijn in Swift:

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

Element uit een array verwijderen zonder de index te kennen

Over het algemeen moeten we, als we een element uit een array willen verwijderen, de index ervan kennen, zodat we het gemakkelijk kunnen verwijderen met de functie remove(at:) .

Maar wat als we de index niet kennen, maar we weten de waarde van het element dat moet worden verwijderd!

Dus hier is de eenvoudige uitbreiding van een array waarmee we een element eenvoudig uit de array kunnen verwijderen zonder de index te kennen:

Swift3

extension Array where Element: Equatable {

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

bv

    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!

Als we per ongeluk zoiets als dit hebben gedaan: array.remove(25) wil zeggen dat we waarde hebben gegeven met een ander gegevenstype, geeft de compiler een foutmelding met de melding-
cannot convert value to expected argument type

Het minimale of maximale element van een array vinden

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)

De geretourneerde waarden van deze methoden zijn optioneel om aan te geven dat de array mogelijk leeg is. Als dit het geval is, wordt nil geretourneerd.

Opmerking: Voor de bovenstaande methoden moeten de elementen voldoen aan het Comparable protocol.

Het minimale of maximale element vinden met een aangepaste volgorde

U kunt ook de bovenstaande methoden gebruiken met een aangepaste afsluiting , die bepaalt of het ene element vóór het andere moet worden besteld, zodat u het minimum- of maximumelement kunt vinden in een array waar de elementen niet noodzakelijkerwijs Comparable .

Bijvoorbeeld met een reeks vectoren:

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 }

Toegang tot indices veilig

Door de volgende extensie toe te voegen aan array-indices, kunt u toegang krijgen zonder te weten of de index binnen de grenzen valt.

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

voorbeeld:

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

Vergelijking van 2 arrays met rits

De zip functie accepteert 2 parameters van het type SequenceType en retourneert een Zip2Sequence waarbij elk element een waarde uit de eerste reeks en een uit de tweede reeks bevat.

Voorbeeld

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

nomsAndAnimals bevat nu de volgende waarden

Dit is handig als u een soort vergelijking wilt maken tussen het n-de element van elke array.

Voorbeeld

Gegeven 2 Arrays of Int(s)

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

u wilt controleren of elke waarde in list1 het dubbele is van de gerelateerde waarde in list0 .

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