Agregar un elemento a una matriz en Swift

Supongamos que tengo una matriz, por ejemplo:

var myArray = ["Steve", "Bill", "Linus", "Bret"]

Y luego quiero empujar / agregar un elemento al final de dicha matriz, para obtener:

["Steve", "Bill", "Linus", "Bret", "Tim"]

¿Qué método debo usar?

¿Y qué pasa con el caso en el que quiero agregar un elemento al frente de la matriz? ¿Hay un tiempo constante sin cambio?

A partir de Swift 3/4/5 , esto se hace de la siguiente manera.

Para agregar un nuevo elemento al final de una matriz.

anArray.append("This String")

Para agregar una matriz diferente al final de su matriz.

anArray += ["Moar", "Strings"]
anArray.append(contentsOf: ["Moar", "Strings"])

Para insertar un nuevo elemento en su matriz.

anArray.insert("This String", at: 0)

Para insertar el contenido de una matriz diferente en su matriz.

anArray.insert(contentsOf: ["Moar", "Strings"], at: 0)

Se puede encontrar más información en el capítulo "Tipos de colección" de " El lenguaje de programación Swift ", que comienza en la página 110.

También puede pasar una variable y / u objeto si lo desea.

var str1:String = "John"
var str2:String = "Bob"

var myArray = ["Steve", "Bill", "Linus", "Bret"]

//add to the end of the array with append
myArray.append(str1)
myArray.append(str2)

Para agregarlos al frente:

//use 'insert' instead of append
myArray.insert(str1, atIndex:0)
myArray.insert(str2, atIndex:0)

//Swift 3
myArray.insert(str1, at: 0)
myArray.insert(str2, at: 0)

Como ya han dicho otros, ya no puede usar '+ =' a partir de xCode 6.1

Para agregar al final, use el +=operador:

myArray += ["Craig"]
myArray += ["Jony", "Eddy"]

Ese operador es generalmente equivalente al append(contentsOf:)método. (Y en versiones Swift realmente antiguas, podría agregar elementos individuales, no solo otras colecciones del mismo tipo de elemento).

También hay insert(_:at:)para insertar en cualquier índice.

Si, por ejemplo, desea una función conveniente para insertar al principio, puede agregarla a la Arrayclase con una extensión .

Utilice los operadores + = y +:

extension Array {

}

func += <V> (inout left: [V], right: V) {
    left.append(right)
}

func + <V>(left: Array<V>, right: V) -> Array<V>
{
    var map = Array<V>()
    for (v) in left {
        map.append(v)
    }

    map.append(right)

    return map
}

luego use:

var list = [AnyObject]()
list += "hello" 
list += ["hello", "world!"]
var list2 = list + "anything"

Aquí hay una pequeña extensión si desea insertar al comienzo de la matriz sin perder el elemento en la primera posición

extension Array{
    mutating func appendAtBeginning(newItem : Element){
        let copy = self
        self = []
        self.append(newItem)
        self.appendContentsOf(copy)
    }
}

En Swift 4.1 y Xcode 9.4.1

Podemos agregar objetos a Array básicamente de dos maneras

let stringOne = "One"
let strigTwo = "Two"
let stringThree = "Three"
var array:[String] = []//If your array is string type

Tipo 1)

//To append elements at the end
array.append(stringOne)
array.append(stringThree)

Tipo 2)

//To add elements at specific index
array.insert(strigTwo, at: 1)

Si quieres agregar dos matrices

var array1 = [1,2,3,4,5]
let array2 = [6,7,8,9]

let array3 = array1+array2
print(array3)
array1.append(contentsOf: array2)
print(array1)

De la página 143 del lenguaje de programación Swift:

Puede agregar un nuevo elemento al final de una matriz llamando al método append de la matriz

Alternativamente, agregue un nuevo elemento al final de una matriz con el operador de asignación de suma (+ =)

Extracto de: Apple Inc. "El lenguaje de programación Swift". iBooks https://itun.es/us/jEUH0.l

Para agregar a las soluciones que sugierenappend , es útil saber que esta es una operación amortizada de tiempo constante en muchos casos:

Complejidad: O (1) amortizado a menos que el almacenamiento del self se comparta con otra matriz en vivo; O (contar) si self no envuelve un NSArray con puente; de lo contrario, la eficiencia no se especifica.

Estoy buscando un consoperador similar para Swift. Debería devolver una nueva matriz inmutable con el elemento agregado al final, en tiempo constante, sin cambiar la matriz original. Todavía no he encontrado una función estándar que haga esto. ¡Intentaré recordar informarme si encuentro uno!

Podrías usar

Myarray.insert("Data #\(index)", atIndex: index)

Si desea agregar un objeto único, puede expandir Array struct

extension Array where Element: Equatable {
    mutating func appendUniqueObject(object: Generator.Element) {
        if contains(object) == false {
            append(object)
        }
    }
}

Si la matriz es NSArray, puede usar la addingfunción para agregar cualquier objeto al final de la matriz, de esta manera:

Swift 4.2

var myArray: NSArray = []
let firstElement: String = "First element"
let secondElement: String = "Second element"

// Process to add the elements to the array
myArray.adding(firstElement)
myArray.adding(secondElement)

Resultado :

print(myArray) 
// ["First element", "Second element"]

Esa es una manera muy simple, saludos!

En Swift 4.2: puedes usar

myArray.append("Tim") //To add "Tim" into array

o

myArray.insert("Tim", at: 0) //Change 0 with specific location 

Ejemplo: estudiantes = ["Ben", "Ivy", "Jordell"]

1) Para agregar elementos individuales al final de una matriz, use el apéndice (_ :)

students.append(\ "Maxime" )

2) Agregue varios elementos al mismo tiempo pasando otra matriz o una secuencia de cualquier tipo al método append (contentsOf :)

students.append(contentsOf: ["Shakia" , "William"])

3) Para agregar nuevos elementos en el medio de una matriz utilizando el método insert (_: at :) para elementos individuales

students.insert("Liam" , at:2 )

4) Uso de insert (contentsOf: at :) para insertar múltiples elementos de otra colección o matriz literal

students.insert(['Tim','TIM' at: 2 )