Swift Language
arrayer

Introduktion

Syntax

• Array <Element> // Typen för en matris med element av typen Element
• [Element] // Syntaktiskt socker för typen av en matris med element av typen Element
• [element0, element1, element2, ... elementN] // En matrisbokstav
• [Element] () // Skapar en ny tom matris av typen [Element]
• Array (count: repeatValue :) // Skapar en matris med count element, var och en initialiseras till repeatedValue
• Array (_ :) // Skapar en matris från en godtycklig sekvens

Anmärkningar

Value Semantics

Om du kopierar en matris kopieras alla objekt inuti den ursprungliga matrisen.

Ändring av den nya matrisen kommer inte att ändra den ursprungliga matrisen.

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

Kopierade matriser delar samma utrymme i minnet som originalet tills de ändras. Som ett resultat av detta uppstår en prestandahit när den kopierade matrisen ges sitt eget utrymme i minnet när det ändras för första gången.

Grunderna i Arrays

Array är en beställd samlingstyp i Swift-standardbiblioteket. Det ger O (1) slumpmässig åtkomst och dynamisk omfördelning. Array är en generisk typ , så den typ av värden som den innehåller är känd vid sammanställningstiden.

Eftersom Array är en värdetyp , definieras dess mutabilitet av om den är annoterad som en var (mutable) eller let (immutable).

Typen [Int] (betydelse: en matris som innehåller Int ) är syntaktiskt socker för Array<T> .

Läs mer om matriser i The Swift Programming Language .

Tomma matriser

Följande tre deklarationer är likvärdiga:

// 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 bokstäver

En matrisbokstav är skriven med fyrkantiga parenteser som omger kommaseparerade element:

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

Kompilatorn kan vanligtvis sluta sig till typen av en matris baserad på elementen i bokstäverna, men uttryckliga typanteckningar kan åsidosätta standard:

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

Matriser med upprepade värden

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

Skapa matriser från andra sekvenser

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

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

Multidimensionella matriser

I Swift skapas en flerdimensionell matris genom att häcka matriser: en tvådimensionell grupp av Int är [[Int]] (eller Array<Array<Int>> ).

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

För att skapa en flerdimensionell matris med upprepade värden använder du kapslade samtal i arrayinitieraren:

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

Öppna arrayvärden

Följande exempel använder denna matris för att demonstrera åtkomstvärden

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

För att komma åt ett värde på ett känt index använder du följande syntax:

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

Obs: Värdet vid index två är det tredje värdet i Array . Array s använder ett nollbaserat index vilket betyder att det första elementet i Array är på 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

Öppna en delmängd av en Array med filter:

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

Filter kan ha komplexa förhållanden som att filtrera endast jämna siffror:

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

Det är också möjligt att returnera indexet för ett givet värde, returnera nil om värdet inte hittades.

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

Det finns metoder för det första, sista, högsta eller lägsta värdet i en Array . Dessa metoder kommer att returnera nil om Array är tom.

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

Användbara metoder

Bestäm om en matris är tom eller returnera storleken

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

Omvänd en array Obs! Resultatet utförs inte på den matris som metoden kallas på och måste läggas in i sin egen variabel.

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

Ändra värden i en matris

Det finns flera sätt att lägga till värden i en matris

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]

och ta bort värden från en matris

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]

Sortera en matris

var array = [3, 2, 1]

Skapa en ny sorterad matris

Eftersom Array överensstämmer med SequenceType kan vi generera en ny matris med de sorterade elementen med en inbyggd sorteringsmetod.

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

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

Sortera en befintlig matris på plats

Eftersom Array överensstämmer med MutableCollectionType , kan vi sortera dess element på plats.

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

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

Obs: För att använda ovanstående metoder måste elementen överensstämma med det Comparable protokollet.

Sortera en matris med en anpassad beställning

Du kan också sortera en matris med hjälp av en stängning för att definiera om ett element ska beställas före ett annat - vilket inte är begränsat till matriser där elementen måste vara Comparable . Till exempel är det inte vettigt att ett Landmark är Comparable - men du kan fortfarande sortera en rad landmärken efter höjd eller namn.

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}

Obs: Jämförelse av strängar kan ge oväntade resultat om strängarna är inkonsekventa, se Sortera ett array av strängar .

Transformera elementen i en matris med karta (_ :)

Eftersom Array överensstämmer med SequenceType , kan vi använda map(_:) att förvandla en matris med A till en matris av B hjälp av en stängning av typ (A) throws -> B

Vi kan till exempel använda den för att omvandla en rad Int till en rad String som så:

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

map(_:) kommer att iterera genom matrisen och tillämpa den givna stängningen på varje element. Resultatet av den nedläggningen kommer att användas för att fylla en ny grupp med de transformerade elementen.

Eftersom String har en initialiserare som får en Int vi också använda den tydligare syntaxen:

let words = numbers.map(String.init)

En map(_:) -omvandling behöver inte ändra arrayens typ - till exempel kan den också användas för att multiplicera en matris med Int s med två:

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

Extrahera värden av en viss typ från en matris med flatMap (_ :)

Den things Array innehåller värdet Any slag.

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

Vi kan extrahera värden av en viss typ och skapa en ny matris av den specifika typen. Låt oss säga att vi vill extrahera alla Int(s) och lägga dem i ett Int Array på ett säkert sätt.

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

Nu definieras numbers som [Int] . flatMap funktionen kasserar alla nil och resultatet innehåller därför endast följande värden:

[1, 2, 3]

Filtrera en matris

Du kan använda filter(_:) på SequenceType för att skapa en ny matris som innehåller elementen i sekvensen som uppfyller ett givet predikat, som kan tillhandahållas som en avslutning .

Till exempel filtrering av jämna siffror från en [Int] :

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

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

print(evenNumbers)  // [22, 30]

Filtrera en [Person] , där deras ålder är mindre än 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)]

Filtrera noll från en Array-transformation med flatMap (_ :)

Du kan använda flatMap(_:) på liknande sätt som map(_:) för att skapa en matris genom att tillämpa en transform på en sekvens element.

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

Skillnaden med den här versionen av flatMap(_:) är att den förväntar sig att omvandla stängning returnera en tillval värde T? för var och en av elementen. Den kommer då säkert att packa upp vart och ett av dessa valfria värden, filtrera bort nil - vilket resulterar i en matris med [T] .

Du kan till exempel göra detta för att förvandla en [String] till en [Int] med Int : s tillgängliga String initialisator , filtrera bort alla element som inte kan konverteras:

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

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

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

Du kan också använda flatMap(_:) : s förmåga att filtrera bort nil för att helt enkelt konvertera en matris med tillval till en matris med icke-alternativ:

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

let numbers = optionalNumbers.flatMap { $0 }

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

Prenumerera på en matris med ett intervall

Man kan extrahera en serie på varandra följande element från en array med hjälp av ett intervall.

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

Att prenumerera på en matris med ett ArraySlice returnerar en ArraySlice . Det är en följd av Array.

I vårt exempel har vi ett Array of Strings, så vi får tillbaka ArraySlice<String> .

Även om en ArraySlice överensstämmer med CollectionType och kan användas med sort , filter osv, är syftet inte för långsiktig lagring utan för kortvariga beräkningar: det bör konverteras tillbaka till en Array så snart du är klar med att arbeta med den.

För detta använder du Array() -initieraren:

let result = Array(slice)

För att sammanfatta i ett enkelt exempel utan mellansteg:

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

Gruppera matrisvärden

Om vi har en struktur som den här

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

och en matris med 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)
]

vi kan gruppera rutorna thingsInside egenskapen thingsInside ting för att få en Dictionary där key är antalet saker och värdet är en rad rutor.

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

Nu grupperas en [Int:[Box]] och har följande innehåll

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

Platta ut resultatet av en Array-transformation med flatMap (_ :)

Såväl som att kunna skapa en array genom att filtrera bort nil från de transformerade delar av en sekvens, finns det också en version av flatMap(_:) som förväntar transformationslutningen att returnera en sekvens S .

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

Varje sekvens från transformationen kommer att sammanlänkas, vilket resulterar i en matris som innehåller de kombinerade elementen i varje sekvens - [S.Generator.Element] .

Kombinera karaktärerna i en rad strängar

Till exempel kan vi använda den för att ta en rad primära strängar och kombinera deras karaktärer i en enda grupp:

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

Dela ned ovanstående exempel:

1. primes är en [String] (Eftersom en matris är en sekvens kan vi kalla flatMap(_:) på den).
2. Transformationsstängningen tar in ett av elementen i primes , en String ( Array<String>.Generator.Element ).
3. Stängningen returnerar sedan en sekvens av typen String.CharacterView .
4. Resultatet är sedan en matris som innehåller de kombinerade elementen i alla sekvenser från var och en av transformationsstängningsanropen - [String.CharacterView.Generator.Element] .

Att platta ut en flerdimensionell matris

Eftersom flatMap(_:) kommer att sammanfoga sekvenserna som returneras från flatMap(_:) med omvandlingsstängning, kan det användas för att platta en flerdimensionell matris - till exempel en 2D-grupp i en 1D-grupp, en 3D-grupp till en 2D-grupp etc.

Detta kan helt enkelt göras genom att returnera det givna elementet $0 (en kapslad matris) i stängningen:

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

Sortera en rad strängar

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

Lazily plattning av en flerdimensionell matris med platta ()

Vi kan använda flatten() för att lata minska häckningen av en flerdimensionell sekvens.

Till exempel lata plattning av en 2D-grupp i en 1D-grupp:

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

I exemplet ovan kommer flatten() att returnera en FlattenBidirectionalCollection , som lättare tillämpar utplattningen av matrisen. Därför contains(_:) kommer endast att kräva att de två första kapslade matriserna av array2D plattas ut - eftersom det kommer att kortsluta när man hittar önskat element.

Kombinera en matris element med reducera (_: kombinera :)

reduce(_:combine:) kan användas för att kombinera elementen i en sekvens till ett enda värde. Det krävs ett initialvärde för resultatet, liksom en stängning som gäller för varje element - vilket kommer att returnera det nya ackumulerade värdet.

Vi kan till exempel använda den för att summera en mängd siffror:

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

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

print(sum) // 36

Vi överför 0 till startvärdet, eftersom det är det logiska initialvärdet för en summering. Om vi fick ett värde på N , skulle den resulterande sum vara N + 36 . Den nedläggning som antogs för att reduce har två argument. accumulator är det aktuella ackumulerade värdet, som tilldelas det värde som stängningen returnerar vid varje iteration. element är det aktuella elementet i iterationen.

Som i det här exemplet passerar vi en (Int, Int) -> Int stängning för att reduce , vilket helt enkelt matar ut tillägget av de två ingångarna - vi kan faktiskt skicka in + operatören direkt, eftersom operatörer är funktioner i Swift:

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

Ta bort element från en matris utan att veta om det är index

I allmänhet, om vi vill ta bort ett element från en matris, måste vi veta att det är index så att vi enkelt kan ta bort det med funktionen remove(at:) .

Men vad händer om vi inte känner till indexet men vi vet värdet på elementet som ska tas bort!

Så här är den enkla tillägget till en matris som gör att vi enkelt kan ta bort ett element från matrisen utan att veta om det är index:

Swift3

extension Array where Element: Equatable {

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

t.ex

    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!

Om vi, av misstag, gjorde något liknande: array.remove(25) dvs vi tillhandahöll värde med olika datatyp, kommer kompilatorn att kasta ett fel med att nämna-
cannot convert value to expected argument type

Hitta det minsta eller maximala elementet i en array

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 returnerade värdena från dessa metoder är valfria för att återspegla det faktum att matrisen kan vara tom - om det är så kommer nil att returneras.

Obs: Ovanstående metoder kräver att elementen överensstämmer med det Comparable protokollet.

Hitta minimi- eller maxelementet med en anpassad beställning

Du kan också använda ovanstående metoder med en anpassad stängning , definiera om ett element ska beställas före ett annat, så att du kan hitta det minsta eller maximala elementet i en matris där elementen inte nödvändigtvis är Comparable .

Till exempel med en rad vektorer:

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 }

Åtkomst till index på ett säkert sätt

Genom att lägga till följande tillägg till array kan du nå index utan att veta om indexet är inom gränserna.

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

exempel:

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

Jämförelse av två matriser med dragkedja

zip funktionen accepterar 2 parametrar av typen SequenceType och returnerar en Zip2Sequence där varje element innehåller ett värde från den första sekvensen och ett från den andra sekvensen.

Exempel

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

nomsAndAnimals innehåller nu följande värden

Detta är användbart när du vill utföra en slags jämförelse mellan det n: e elementet i varje array.

Exempel

Får 2 Arrays of Int(s)

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

du vill kontrollera om varje värde i list1 är det dubbla av det relaterade värdet i list0 .

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