Swift Language
Arrays

Introducción

Sintaxis

• Array <Element> // El tipo de una matriz con elementos de tipo Elemento
• [Elemento] // Azúcar sintáctico para el tipo de una matriz con elementos de tipo Elemento
• [element0, element1, element2, ... elementN] // Un literal de matriz
• [Elemento] () // Crea una nueva matriz vacía de tipo [Elemento]
• Array (count: repeatValue :) // Crea una matriz de elementos de count , cada uno inicializado en repeatedValue
• Array (_ :) // Crea un array a partir de una secuencia arbitraria

Observaciones

Semántica de valor

Copiar una matriz copiará todos los elementos dentro de la matriz original.

Cambiar la nueva matriz no cambiará la matriz original.

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

Las matrices copiadas compartirán el mismo espacio en la memoria que el original hasta que se cambien. Como resultado de esto, se produce un impacto en el rendimiento cuando la matriz copiada recibe su propio espacio en la memoria cuando se modifica por primera vez.

Conceptos básicos de matrices

Array es un tipo de colección ordenada en la biblioteca estándar de Swift. Proporciona O (1) acceso aleatorio y reasignación dinámica. La matriz es un tipo genérico , por lo que el tipo de valores que contiene se conocen en tiempo de compilación.

Dado que Array es un tipo de valor , su mutabilidad se define por su anotación como var (mutable) o let (immutable).

El tipo [Int] (que significa: una matriz que contiene Int s) es azúcar sintáctica para Array<T> .

Lee más sobre matrices en el lenguaje de programación Swift .

Arreglos vacíos

Las siguientes tres declaraciones son equivalentes:

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

Literales array

Un literal de matriz se escribe con corchetes que rodean los elementos separados por comas:

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

El compilador generalmente puede inferir el tipo de una matriz basada en los elementos en el literal, pero las anotaciones de tipo explícitas pueden invalidar el valor predeterminado:

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

Arreglos con valores repetidos.

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

Creando arrays desde otras secuencias.

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

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

Matrices multidimensionales

En Swift, se crea una matriz multidimensional anidando matrices: una matriz bidimensional de Int es [[Int]] (o Array<Array<Int>> ).

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

Para crear una matriz multidimensional de valores repetidos, use llamadas anidadas del inicializador de matriz:

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

Acceso a valores de matriz

Los siguientes ejemplos utilizarán esta matriz para demostrar el acceso a los valores.

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

Para acceder a un valor en un índice conocido use la siguiente sintaxis:

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

Nota: El valor en el índice dos es el tercer valor en la Array . Array usa un índice basado en cero, lo que significa que el primer elemento de la Array está en el índice 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

Acceda a un subconjunto de un Array utilizando el filtro:

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

Los filtros pueden tener condiciones complejas como filtrar solo números pares:

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

También es posible devolver el índice de un valor dado, devolviendo nil si no se encontró el valor.

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

Hay métodos para el primer, último, máximo o mínimo valor en una Array . Estos métodos devolverán nil si la Array está vacía.

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

Metodos utiles

Determine si una matriz está vacía o devuelve su tamaño

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

Invertir una matriz Nota: el resultado no se realiza en la matriz en la que se invoca el método y se debe colocar en su propia variable.

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

Modificar valores en una matriz

Hay varias formas de agregar valores a una matriz

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]

y eliminar los valores de una matriz

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]

Ordenar una matriz

var array = [3, 2, 1]

Creando una nueva matriz ordenada

Dado que Array ajusta a SequenceType , podemos generar una nueva matriz de los elementos ordenados utilizando un método de clasificación integrado.

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

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

Ordenar una matriz existente en su lugar

Como Array ajusta a MutableCollectionType , podemos ordenar sus elementos en su lugar.

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

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

Nota: Para utilizar los métodos anteriores, los elementos deben cumplir con el protocolo Comparable .

Ordenar una matriz con un orden personalizado

También puede ordenar una matriz utilizando un cierre para definir si un elemento debe ordenarse antes que otro, lo cual no está restringido a matrices donde los elementos deben ser Comparable . Por ejemplo, no tiene sentido que un Landmark de Landmark sea Comparable , pero aún puede ordenar un conjunto de puntos de referencia por altura o nombre.

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}

Nota: la comparación de cadenas puede producir resultados inesperados si las cadenas son inconsistentes, vea Ordenar una matriz de cadenas .

Transformando los elementos de un Array con mapa (_ :)

Como la Array ajusta al tipo de SequenceType , podemos usar map(_:) para transformar una matriz de A en una matriz de B utilizando un cierre de tipo (A) throws -> B

Por ejemplo, podríamos usarlo para transformar una matriz de Int s en una matriz de String s así:

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

map(_:) recorrerá la matriz, aplicando el cierre dado a cada elemento. El resultado de ese cierre se utilizará para poblar una nueva matriz con los elementos transformados.

Como String tiene un inicializador que recibe un Int , también podemos usar esta sintaxis más clara:

let words = numbers.map(String.init)

Una transformación de map(_:) no necesita cambiar el tipo de la matriz; por ejemplo, también podría usarse para multiplicar una matriz de Int s por dos:

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

Extraer valores de un tipo dado de un Array con flatMap (_ :)

Las things Array contiene valores de Any tipo.

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

Podemos extraer valores de un tipo dado y crear una nueva matriz de ese tipo específico. Digamos que queremos extraer todos los Int(s) y colocarlos en un Int Array de forma segura.

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

Ahora los numbers se definen como [Int] . La función flatMap descarta todos los elementos nil y el resultado contiene solo los siguientes valores:

[1, 2, 3]

Filtrando una matriz

Puede usar el método de filter(_:) en SequenceType para crear una nueva matriz que contenga los elementos de la secuencia que satisfagan un predicado dado, que se puede proporcionar como un cierre .

Por ejemplo, filtrando números pares de un [Int] :

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

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

print(evenNumbers)  // [22, 30]

Filtrando una [Person] , donde su edad es menor de 30 años:

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

Filtrado nil de una transformación de Array con flatMap (_ :)

Puede usar flatMap(_:) de una manera similar para map(_:) para crear una matriz aplicando una transformación a los elementos de una secuencia.

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

La diferencia con esta versión de flatMap(_:) es que espera que el cierre de transformación devuelva un valor Opcional T? Para cada uno de los elementos. Luego desenvolverá de forma segura cada uno de estos valores opcionales, filtrando nil , dando como resultado una matriz de [T] .

Por ejemplo, puede hacer esto para transformar un [String] en un [Int] usando String inicializador de String failable de Int , filtrando cualquier elemento que no pueda convertirse:

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

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

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

También puede usar la flatMap(_:) para filtrar nil a fin de simplemente convertir una matriz de opcionales en una matriz de no opcionales:

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

let numbers = optionalNumbers.flatMap { $0 }

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

Suscribiendo una matriz con un rango

Uno puede extraer una serie de elementos consecutivos de un Array usando un Rango.

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

La suscripción de una matriz con un rango devuelve un ArraySlice . Es una subsecuencia del Array.

En nuestro ejemplo, tenemos un Array of Strings, así que volvemos a ArraySlice<String> .

Aunque un ArraySlice se ajusta al CollectionType y se puede usar con sort , filter , etc., su propósito no es para el almacenamiento a largo plazo sino para los cálculos transitorios: debe volver a convertirse en un Array tan pronto como haya terminado de trabajar con él.

Para esto, use el inicializador Array() :

let result = Array(slice)

Para resumir en un ejemplo simple sin pasos intermedios:

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

Agrupar valores de matriz

Si tenemos una estructura como esta

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

y una matriz 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)
]

podemos agrupar los cuadros por la propiedad thingsInside para obtener un Dictionary donde la key es el número de cosas y el valor es una matriz de cuadros.

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

Ahora agrupado es un [Int:[Box]] y tiene el siguiente contenido

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

Aplanar el resultado de una transformación de Array con flatMap (_ :)

Además de poder crear una matriz al filtrar nil de los elementos transformados de una secuencia, también hay una versión de flatMap(_:) que espera que el cierre de la transformación devuelva una secuencia S

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

Cada secuencia de la transformación se concatenará, dando como resultado una matriz que contiene los elementos combinados de cada secuencia - [S.Generator.Element] .

Combinando los caracteres en una serie de cadenas.

Por ejemplo, podemos usarlo para tomar una matriz de cadenas principales y combinar sus caracteres en una sola matriz:

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

Desglosando el ejemplo anterior:

1. primes es una [String] (Como una matriz es una secuencia, podemos llamar a flatMap(_:) en ella).
2. El cierre de la transformación toma uno de los elementos de los primes , una String ( Array<String>.Generator.Element ).
3. El cierre luego devuelve una secuencia de tipo String.CharacterView .
4. El resultado es una matriz que contiene los elementos combinados de todas las secuencias de cada una de las llamadas de cierre de transformación: [String.CharacterView.Generator.Element] .

Aplanando una matriz multidimensional

Como flatMap(_:) concatenará las secuencias devueltas de las llamadas de cierre de transformación, puede utilizarse para aplanar una matriz multidimensional, como una matriz 2D en una matriz 1D, una matriz 3D en una matriz 2D, etc.

Esto se puede hacer simplemente devolviendo el elemento dado $0 (una matriz anidada) en el cierre:

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

Ordenar una matriz de cuerdas

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

Lácilmente aplanando una matriz multidimensional con aplanar ()

Podemos usar flatten() para reducir perezosamente el anidamiento de una secuencia multidimensional.

Por ejemplo, laxitud aplanar una matriz 2D en una matriz 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

En el ejemplo anterior, flatten() devolverá una FlattenBidirectionalCollection , que aplicará perezosamente el aplanamiento de la matriz. Por lo tanto, contains(_:) solo requerirá que las dos primeras matrices anidadas de array2D , ya que se producirá un cortocircuito al encontrar el elemento deseado.

Combinando los elementos de un Array con reduce (_: combine :)

reduce(_:combine:) se puede utilizar para combinar los elementos de una secuencia en un solo valor. Se requiere un valor inicial para el resultado, así como un cierre para aplicar a cada elemento, que devolverá el nuevo valor acumulado.

Por ejemplo, podemos usarlo para sumar una matriz de números:

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

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

print(sum) // 36

Pasamos 0 al valor inicial, ya que ese es el valor inicial lógico para una suma. Si pasamos en un valor de N , la sum resultante sería N + 36 . El cierre aprobado para reduce tiene dos argumentos. accumulator es el valor acumulado actual, al cual se le asigna el valor que el cierre devuelve en cada iteración. element es el elemento actual en la iteración.

Como en este ejemplo, estamos pasando un cierre (Int, Int) -> Int para reduce , que simplemente está generando la adición de las dos entradas; de hecho, podemos pasar el operador + directamente, ya que los operadores son funciones en Swift:

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

Eliminar elemento de una matriz sin saber su índice

Generalmente, si queremos eliminar un elemento de una matriz, necesitamos saber su índice para poder eliminarlo fácilmente usando la función remove(at:) .

¡Pero qué pasa si no conocemos el índice, pero sabemos el valor del elemento que se eliminará!

Así que aquí está la extensión simple a una matriz que nos permitirá eliminar un elemento de la matriz fácilmente sin saber su índice:

Swift3

extension Array where Element: Equatable {

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

p.ej

    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!

También si, por error, hicimos algo como esto: array.remove(25) es decir, proporcionamos valor con diferentes tipos de datos, el compilador arrojará un error mencionando:
cannot convert value to expected argument type

Encontrar el elemento mínimo o máximo de un 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)

Los valores devueltos de estos métodos son opcionales para reflejar el hecho de que la matriz podría estar vacía; si lo está, se devolverá nil .

Nota: Los métodos anteriores requieren que los elementos se ajusten al protocolo Comparable .

Encontrar el elemento mínimo o máximo con un pedido personalizado.

También puede usar los métodos anteriores con un cierre personalizado, definiendo si un elemento debe ordenarse antes que otro, lo que le permite encontrar el elemento mínimo o máximo en una matriz donde los elementos no son necesariamente Comparable .

Por ejemplo, con una matriz de vectores:

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 }

Acceder a los índices de forma segura.

Al agregar la siguiente extensión a la matriz, se puede acceder a los índices sin saber si el índice está dentro de los límites.

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

ejemplo:

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

Comparando 2 matrices con zip

La función zip acepta 2 parámetros de tipo SequenceType y devuelve una Zip2Sequence donde cada elemento contiene un valor de la primera secuencia y uno de la segunda secuencia.

Ejemplo

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

nomsAndAnimals ahora contiene los siguientes valores

Esto es útil cuando desea realizar algún tipo de comparación entre el elemento n-th de cada Array.

Ejemplo

Dados 2 matrices de Int(s)

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

desea verificar si cada valor en la list1 es el doble del valor relacionado en la list0 .

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