Swift: passa array por referência?

Quero passar meu Swift Array account.chatspara chatsViewController.chatsreferência (para que, quando eu adicionar um bate-papo account.chats, chatsViewController.chatsainda aponte para account.chats). Ou seja, não quero que o Swift separe as duas matrizes quando a duração das account.chatsalterações for alterada.

As estruturas no Swift são passadas por valor, mas você pode usar o inoutmodificador para modificar sua matriz (veja as respostas abaixo). As aulas são passadas por referência. Arraye Dictionaryno Swift são implementados como estruturas.

Para o operador de parâmetro de função, usamos:

let (é o operador padrão, portanto, podemos omitir let ) para tornar um parâmetro constante (significa que não podemos modificar nem mesmo a cópia local);

var para torná-lo variável (podemos modificá-lo localmente, mas isso não afetará a variável externa que foi passada para a função); e

inout para torná-lo um parâmetro in-out. Na entrada significa na verdade passar variável por referência, não por valor. E requer não apenas aceitar valor por referência, mas também passá-lo por referência; assim, passe-o com & - em foo(&myVar)vez de apenasfoo(myVar)

Então faça assim:

var arr = [1, 2, 3]

func addItem(inout localArr: [Int]) {
    localArr.append(4)
}

addItem(&arr)    
println(arr) // it will print [1, 2, 3, 4]

Para ser exato, não é apenas uma referência, mas um alias real para a variável externa; portanto, você pode fazer esse truque com qualquer tipo de variável, por exemplo, com número inteiro (você pode atribuir um novo valor a ela), embora possa não ser um boa prática e pode ser confuso modificar os tipos de dados primitivos como este.

Defina você mesmo BoxedArray<T>que implementa a Arrayinterface, mas delega todas as funções para uma propriedade armazenada. Assim sendo

class BoxedArray<T> : MutableCollection, Reflectable, ... {
  var array : Array<T>

  // ...

  subscript (index: Int) -> T { 
    get { return array[index] }
    set(newValue) { array[index] = newValue }
  }
}

Use o local BoxedArrayem que você usaria um Array. A atribuição de a BoxedArrayserá por referência, é uma classe e, portanto, as alterações na propriedade armazenada, através da Arrayinterface, serão visíveis para todas as referências.

Para as versões Swift 3-4 (XCode 8-9), use

var arr = [1, 2, 3]

func addItem(_ localArr: inout [Int]) {
    localArr.append(4)
}

addItem(&arr)
print(arr)

Algo como

var a : Int[] = []
func test(inout b : Int[]) {
    b += [1,2,3,4,5]
}
test(&a)
println(a)

???

Uma outra opção é fazer com que o consumidor da matriz peça ao proprietário conforme necessário. Por exemplo, algo como:

class Account {
    var chats : [String]!
    var chatsViewController : ChatsViewController!

    func InitViewController() {
        chatsViewController.getChats = { return self.chats }
    }

}

class ChatsViewController {
    var getChats: (() -> ([String]))!

    func doSomethingWithChats() {
        let chats = getChats()
        // use it as needed
    }
}

Você pode modificar a matriz o quanto quiser dentro da classe Account. Observe que isso não ajuda se você também deseja modificar a matriz da classe do controlador de exibição.

Usar inouté uma solução, mas não me parece muito rápida, pois matrizes são tipos de valor. Estilisticamente, eu pessoalmente prefiro retornar uma cópia mutada:

func doSomething(to arr: [Int]) -> [Int] {
    var arr = arr
    arr.append(3) // or likely some more complex operation
    return arr
}

var ids = [1, 2]
ids = doSomething(to: ids)
print(ids) // [1,2,3]

use a NSMutableArrayou a NSArray, que são classes

Dessa forma, você não precisa implantar nenhum raspador e pode usar a construção em ponte

open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration