Adicionar um elemento a uma matriz no Swift

Suponha que eu tenha uma matriz, por exemplo:

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

E depois eu quero empurrar / acrescentar um elemento ao final do referido array, para obter:

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

Que método devo usar?

E o caso em que eu quero adicionar um elemento à frente da matriz? Existe um tempo constante sem mudança?

A partir do Swift 3/4/5 , isso é feito da seguinte maneira.

Para adicionar um novo elemento ao final de uma matriz.

anArray.append("This String")

Para acrescentar uma matriz diferente ao final da matriz.

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

Para inserir um novo elemento em sua matriz.

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

Para inserir o conteúdo de uma matriz diferente em sua matriz.

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

Mais informações podem ser encontradas no capítulo "Tipos de coleções" de " A linguagem de programação Swift ", começando na página 110.

Você também pode passar uma variável e / ou objeto, se quiser.

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 adicioná-los à 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 outros já declararam, você não pode mais usar '+ =' a partir do xCode 6.1

Para adicionar ao final, use o +=operador:

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

Esse operador geralmente é equivalente ao append(contentsOf:)método. (E nas versões Swift realmente antigas, era possível acrescentar elementos únicos, não apenas outras coleções do mesmo tipo.)

Também há insert(_:at:)para inserir em qualquer índice.

Se, por exemplo, você quiser uma função de conveniência para inserir no início, adicione-a à Arrayclasse com uma extensão .

Use os operadores + = e +:

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
}

então use:

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

Aqui está uma pequena extensão se você deseja inserir no início da matriz sem perder o item na primeira posição

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

No Swift 4.1 e no Xcode 9.4.1

Podemos adicionar objetos ao Array basicamente de duas maneiras

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)

Se você deseja adicionar duas matrizes

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)

Na página 143 da linguagem de programação Swift:

Você pode adicionar um novo item ao final de uma matriz chamando o método de adição da matriz

Como alternativa, adicione um novo item ao final de uma matriz com o operador de atribuição de adição (+ =)

Trecho de: Apple Inc. “A linguagem de programação Swift”. iBooks. https://itun.es/us/jEUH0.l

Para adicionar às soluções sugeridasappend , é útil saber que essa é uma operação de tempo constante amortizada em muitos casos:

Complexidade: Amortizado O (1), a menos que o armazenamento do self seja compartilhado com outro array ativo; O (count) se self não quebra um NSArray em ponte; caso contrário, a eficiência não é especificada.

Estou procurando um consoperador semelhante para Swift. Ele deve retornar uma nova matriz imutável com o elemento pregado no final, em tempo constante, sem alterar a matriz original. Ainda não encontrei uma função padrão que faça isso. Vou tentar lembrar de informar se encontrar um!

Você poderia usar

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

Se você deseja acrescentar um objeto exclusivo, pode expandir a estrutura da matriz

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

Se a matriz for NSArray, você poderá usar a addingfunção para adicionar qualquer objeto no final da matriz, assim:

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

Essa é uma maneira muito simples, cumprimentos!

No Swift 4.2: você pode usar

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

ou

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

Exemplo: alunos = ["Ben", "Ivy", "Jordell"]

1) Para adicionar elementos únicos ao final de uma matriz, use o apêndice (_ :)

students.append(\ "Maxime" )

2) Adicione vários elementos ao mesmo tempo passando outra matriz ou sequência de qualquer tipo para o método append (contentsOf :)

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

3) Para adicionar novos elementos no meio de uma matriz usando o método insert (_: at :) para elementos únicos

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

4) Usando insert (contentsOf: at :) para inserir vários elementos de outra coleção ou matriz literal

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