Swift Language
Arrays

Einführung

Syntax

• Array <Element> // Der Typ eines Arrays mit Elementen des Typs Element
• [Element] // Syntaktischer Zucker für den Typ eines Arrays mit Elementen des Typs Element
• [element0, element1, element2, ... elementN] // Ein Array-Literal
• [Element] () // Erstellt ein neues leeres Array vom Typ [Element]
• Array (Anzahl: Wiederholter :) // Erzeugt ein Array von count die jeweils initialisiert repeatedValue
• Array (_ :) // Erzeugt ein Array aus einer beliebigen Sequenz

Bemerkungen

Wertsemantik

Beim Kopieren eines Arrays werden alle Elemente innerhalb des ursprünglichen Arrays kopiert.

Das Ändern des neuen Arrays ändert das ursprüngliche Array nicht.

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

Kopierte Arrays haben denselben Speicherplatz wie das Original, bis sie geändert werden. Dies führt zu einem Performance-Hit, wenn das kopierte Array bei der ersten Änderung seinen eigenen Speicherplatz erhält.

Grundlagen von Arrays

Array ist ein geordneter Collection-Typ in der Swift-Standardbibliothek. Es bietet O (1) Direktzugriff und dynamische Neuzuweisung. Array ist ein generischer Typ , daher ist der Typ der Werte, die es enthält, zur Kompilierzeit bekannt.

Als Array a Werttyp , wird ihre Veränderlichkeit definiert durch ob es als kommentierter wird var (veränderbaren) oder let (unveränderlich).

Der Typ [Int] (Bedeutung: ein Array, das Int s enthält) ist syntaktischer Zucker für Array<T> .

Weitere Informationen zu Arrays finden Sie in The Swift Programming Language .

Leere Arrays

Die folgenden drei Erklärungen sind gleichwertig:

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

Array-Literale

Ein Array-Literal wird mit eckigen Klammern um kommagetrennte Elemente geschrieben:

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

Der Compiler kann normalerweise den Typ eines Arrays basierend auf den Elementen im Literal ableiten, explizite Typanmerkungen können jedoch den Standardwert überschreiben:

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 mit wiederholten Werten

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

Erstellen von Arrays aus anderen Sequenzen

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

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

Mehrdimensionale Arrays

In Swift wird ein mehrdimensionales Array durch Verschachteln von Arrays erstellt: Ein zweidimensionales Array mit Int ist [[Int]] (oder Array<Array<Int>> ).

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

Verwenden Sie zum Erstellen eines mehrdimensionalen Arrays wiederholter Werte verschachtelte Aufrufe des Array-Initialisierers:

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

Zugriff auf Array-Werte

In den folgenden Beispielen wird dieses Array verwendet, um den Zugriff auf Werte zu veranschaulichen

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

Um auf einen Wert an einem bekannten Index zuzugreifen, verwenden Sie die folgende Syntax:

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

Hinweis: Der Wert bei Index zwei ist der dritte Wert im Array . Array s verwenden einen auf Null basierenden Index , dh das erste Element im Array befindet sich am 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

Array mit einem Filter auf eine Teilmenge eines Array :

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

Filter können komplexe Bedingungen haben, wie das Filtern nur gerader Zahlen:

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

Es ist auch möglich, den Index eines bestimmten Werts zurückzugeben. Wenn der Wert nicht gefunden wurde, wird nil .

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

Es gibt Methoden für den ersten, letzten, maximalen oder minimalen Wert in einem Array . Diese Methoden geben nil wenn das Array leer ist.

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

Nützliche Methoden

Bestimmen Sie, ob ein Array leer ist oder seine Größe zurückgibt

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

Array umkehren Hinweis: Das Ergebnis wird nicht für das Array ausgeführt, für das die Methode aufgerufen wird, und muss in eine eigene Variable geschrieben werden.

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

Werte in einem Array ändern

Es gibt mehrere Möglichkeiten, Werte an ein Array anzuhängen

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]

und entfernen Sie Werte aus einem Array

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]

Ein Array sortieren

var array = [3, 2, 1]

Erstellen eines neuen sortierten Arrays

Da Array mit SequenceType übereinstimmt, können wir ein neues Array der sortierten Elemente mithilfe einer integrierten Sortiermethode generieren.

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

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

Vorhandenes Array an Ort und Stelle sortieren

Da Array mit MutableCollectionType , können wir seine Elemente an Ort und Stelle sortieren.

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

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

Hinweis: Um die obigen Methoden verwenden zu können, müssen die Elemente dem Comparable Protokoll entsprechen.

Sortieren eines Arrays mit einer benutzerdefinierten Reihenfolge

Sie können auch eine Anordnung unter Verwendung einer Art Verschluss zu definieren , ob ein Element , bevor ein anderer bestellt werden sollte - die nicht auf Arrays beschränkt ist , wo die Elemente sein müssen Comparable . Beispielsweise ist es nicht sinnvoll, dass eine Landmark Comparable Sie können jedoch ein Array von Landmarken nach Höhe oder Namen sortieren.

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}

Hinweis: Der Zeichenfolgenvergleich kann zu unerwarteten Ergebnissen führen, wenn die Zeichenfolgen inkonsistent sind. Weitere Informationen finden Sie unter Sortieren eines Zeichenfolgenarrays .

Elemente eines Arrays mit Map umwandeln (_ :)

Da Array mit SequenceType übereinstimmt, können Sie map(_:) um ein Array von A in ein Array von B zu transformieren, indem Sie einen Abschluss vom Typ (A) throws -> B

Zum Beispiel könnten wir damit ein Array von Int s in ein Array von String s transformieren:

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

map(_:) durchläuft das Array und wendet den angegebenen Abschluss auf jedes Element an. Das Ergebnis dieser Schließung wird verwendet, um ein neues Array mit den transformierten Elementen zu füllen.

Da String über einen Initialisierer verfügt, der ein Int , können wir auch diese klarere Syntax verwenden:

let words = numbers.map(String.init)

Eine map(_:) -Transformation muss den Typ des Arrays nicht ändern. Es könnte beispielsweise auch verwendet werden, um ein Array von Int s mit zwei zu multiplizieren:

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

Werte eines bestimmten Typs aus einem Array mit flatMap (_ :) extrahieren

Das things Array enthält Werte des Typs Any .

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

Wir können Werte eines bestimmten Typs extrahieren und ein neues Array dieses bestimmten Typs erstellen. Angenommen, wir möchten alle Int(s) extrahieren und auf sichere Weise in ein Int Array einfügen.

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

numbers sind jetzt als [Int] . Die Funktion flatMap verwirft alle nil Elemente und das Ergebnis enthält daher nur die folgenden Werte:

[1, 2, 3]

Filtern eines Arrays

Sie können die Verwendung filter(_:) Methode auf SequenceType , um ein neues Array mit den Elementen der Sequenz zu erzeugen , die eine gegebene Prädikat erfüllen, die als zur Verfügung gestellt werden kann Verschluß .

So filtern Sie gerade Zahlen aus einem [Int] :

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

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

print(evenNumbers)  // [22, 30]

Filtern einer [Person] , deren Alter weniger als 30 beträgt:

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

Mit flatMap (_ :) nichts aus einer Array-Transformation herausfiltern

Sie können flatMap(_:) auf ähnliche Weise zur map(_:) verwenden, um ein Array zu erstellen, indem Sie eine Transformation auf die Elemente einer Sequenz anwenden.

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

Der Unterschied zu dieser Version von flatMap(_:) besteht darin, dass erwartet wird, dass der Abschluss der Transformation einen optionalen Wert T? für jedes der Elemente. Es wird dann jeden dieser optionalen Werte sicher auspacken, wobei nil was zu einem Array von [T] .

Zum Beispiel können Sie dies, um einen zu transformieren [String] in ein [Int] mit Int ‚s failable String initializer , Ausfiltern alle Elemente , die nicht konvertiert werden können:

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

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

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

Sie können auch die Fähigkeit von flatMap(_:) , um nil herauszufiltern, um einfach ein Array von Optionals in ein Array von Nicht-Optionals zu konvertieren:

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

let numbers = optionalNumbers.flatMap { $0 }

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

Subskription eines Arrays mit einem Bereich

Man kann eine Reihe aufeinanderfolgender Elemente aus einem Array mit einem Range extrahieren.

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

Durch die Subskription eines Arrays mit einem Bereich wird ein ArraySlice . Es ist eine Folge des Arrays.

In unserem Beispiel haben wir ein Array von Strings, daher erhalten wir ArraySlice<String> .

Obwohl ein ArraySlice CollectionType konform ist und mit sort , filter usw. verwendet werden kann, dient es nicht zur Langzeitspeicherung, sondern für vorübergehende Berechnungen: Es sollte nach der Bearbeitung wieder in ein Array konvertiert werden.

Verwenden Sie dazu den Initialisierer Array() :

let result = Array(slice)

Um ein einfaches Beispiel ohne Zwischenschritte zusammenzufassen:

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

Gruppieren von Array-Werten

Wenn wir eine Struktur wie diese haben

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

und ein Array von 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)
]

Wir können die Boxen nach der Eigenschaft thingsInside , um ein Dictionary in dem der key die Anzahl der Dinge und der Wert ein Array von Boxen ist.

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

Jetzt gruppiert ist ein [Int:[Box]] und hat den folgenden Inhalt

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

Reduzieren des Ergebnisses einer Array-Umwandlung mit flatMap (_ :)

Als auch in der Lage , eine Anordnung zu schaffen , durch Ausfiltern nil aus den transformierten Elementen einer Sequenz, gibt es auch eine Version von flatMap(_:) , dass die Transformation erwartet Verschluss eine Sequenz zurückzukehren S .

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

Jede Sequenz aus der Transformation wird verkettet, was zu einem Array führt, das die kombinierten Elemente jeder Sequenz enthält - [S.Generator.Element] .

Kombinieren der Zeichen in einem String-Array

Wir können es beispielsweise verwenden, um ein Array von Prim-Strings zu nehmen und ihre Zeichen in einem einzigen Array zu kombinieren:

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

Das obige Beispiel zerlegen:

1. primes ist ein [String] (Da ein Array eine Sequenz ist, können wir flatMap(_:) ) aufrufen.
2. Der Transformationsabschluss übernimmt eines der Elemente der primes , einen String ( Array<String>.Generator.Element ).
3. Der Abschluss gibt dann eine Sequenz des Typs String.CharacterView .
4. Das Ergebnis ist dann ein Array mit den kombinierten Elementen aller Sequenzen aus jedem der Aufrufe zum Umwandlungsabschluss - [String.CharacterView.Generator.Element] .

Reduzieren eines mehrdimensionalen Arrays

Da flatMap(_:) die von den Umwandlungsaufrufen zurückgegebenen Sequenzen verkettet, kann es verwendet werden, um ein mehrdimensionales Array zu flatMap(_:) beispielsweise ein 2D-Array in ein 1D-Array, ein 3D-Array in ein 2D-Array usw.

Dies kann einfach durch Rückgabe des angegebenen Elements $0 (verschachteltes Array) in der Schließung erfolgen:

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

Ein Array von Strings sortieren

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

Faules Abflachen eines mehrdimensionalen Arrays mit Abflachung ()

Wir verwenden flatten() , um lazily die Verschachtelung eines multidimensionalen Sequenz zu reduzieren.

Zum Beispiel das langsame Abflachen eines 2D-Arrays in ein 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

Im obigen Beispiel gibt flatten() eine FlattenBidirectionalCollection , die das Abflachen des Arrays FlattenBidirectionalCollection übernimmt. contains(_:) erfordert daher nur eine array2D der ersten beiden verschachtelten Arrays von array2D , da bei der Suche nach dem gewünschten Element ein Kurzschluss array2D .

Elemente eines Arrays mit verkleinern (_: kombinieren :) kombinieren

reduce(_:combine:) kann verwendet werden, um die Elemente einer Sequenz zu einem einzigen Wert zusammenzufassen. Für das Ergebnis ist ein Anfangswert sowie ein Abschluss für jedes Element erforderlich, der den neuen angesammelten Wert zurückgibt.

Wir können es zum Beispiel verwenden, um ein Zahlenfeld zu summieren:

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

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

print(sum) // 36

Wir übergeben 0 in den Anfangswert, da dies der logische Anfangswert für eine Summation ist. Wenn wir einen Wert von N , wäre die resultierende sum N + 36 . Die zu reduce Schließung hat zwei Argumente. accumulator ist der aktuelle akkumulierte Wert, dem der Wert zugewiesen wird, den der Abschluss bei jeder Iteration zurückgibt. element ist das aktuelle Element in der Iteration.

Wie in diesem Beispiel übergeben wir eine (Int, Int) -> Int Schließung, reduce zu reduce , was einfach die Addition der beiden Eingaben ausgeben soll - wir können tatsächlich den Operator + , da Operatoren Funktionen in Swift sind:

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

Element aus einem Array entfernen, ohne dessen Index zu kennen

Wenn Sie ein Element aus einem Array entfernen möchten, müssen wir im Allgemeinen dessen Index kennen, um es leicht mit der Funktion remove(at:) können.

Was aber, wenn wir den Index nicht kennen, aber den Wert des zu entfernenden Elements kennen!

Hier ist also die einfache Erweiterung eines Arrays, die es uns ermöglicht, ein Element leicht aus dem Array zu entfernen, ohne dessen Index zu kennen:

Swift3

extension Array where Element: Equatable {

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

z.B

    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!

Auch wenn wir aus Versehen etwas wie das array.remove(25) : array.remove(25) dh wir haben Werte mit einem anderen Datentyp angegeben, der Compiler gibt einen Fehler aus
cannot convert value to expected argument type

Ermitteln des minimalen oder maximalen Elements eines Arrays

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)

Die von diesen Methoden zurückgegebenen Werte sind optional , um die Tatsache widerzuspiegeln, dass das Array leer sein könnte. Ist dies der Fall, wird nil zurückgegeben.

Hinweis: Bei den oben genannten Methoden müssen die Elemente dem Comparable Protokoll entsprechen.

Finden des minimalen oder maximalen Elements mit einer benutzerdefinierten Reihenfolge

Sie können die oben genannten Methoden auch mit einem benutzerdefinierten Abschluss verwenden , um festzulegen, ob ein Element vor einem anderen angeordnet werden soll. Dadurch können Sie das Minimum- oder Maximum-Element in einem Array ermitteln, bei dem die Elemente nicht unbedingt Comparable .

Zum Beispiel mit einem Array von Vektoren:

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 }

Sicherer Zugriff auf Indizes

Durch Hinzufügen der folgenden Erweiterung zu einem Array kann auf Indizes zugegriffen werden, ohne zu wissen, ob sich der Index innerhalb der Grenzen befindet.

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

Beispiel:

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

Vergleich von 2 Arrays mit Reißverschluss

Die zip Funktion akzeptiert 2 Parameter vom Typ SequenceType und gibt eine Zip2Sequence wobei jedes Element einen Wert aus der ersten und einen aus der zweiten Sequenz enthält.

Beispiel

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

nomsAndAnimals enthält jetzt die folgenden Werte

Dies ist nützlich, wenn Sie eine Art Vergleich zwischen dem n-ten Element jedes Arrays durchführen möchten.

Beispiel

2 Arrays von Int(s)

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

Sie möchten prüfen, ob jeder Wert in list1 das Doppelte des zugehörigen Werts in list0 .

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