Question

我有一些数组：

var arrayOne = [String]()
var arrayTwo = [String]()
var arrayThree = [String]()

然后我写了一个函数。我给出一个数字，它返回我的其中一个数组：

func get_array(aNumber:Int) -> NSArray {
   var arr = self.arrayOne //default
   if aNumber == 1 {
        arr = self.arrayOne
   } else if aNumber == 2 {
       arr = self.arrayTwo
   } else if aNumber == 3 {
       arr = self.arrayThree
   }
   return arr!
}

然后我做了：

var myArray = get_array(2)
myArray.append("hello")
NSLog("myArray: %@", myArray) // Ok, myArray was modified!!

NSLog("arrayTwo: %@", arrayTwo) // **Shit, arrayTwo was not modified!!** I was expecting myArray to be pointing to arrayTwo, so they are the same object

怎么办？

Answer 1

Swift数组是值类型。这意味着

let array2 = array1

生成array1的副本。因此，当您访问array2时，它不再是与array1相同的数组，它是具有相同内容的另一个对象。

这与作为参考类型的NSArray和NSMutableArray不同：当你这样做时

let nsarray2 = nsarray1

这次nsarray2是对nsarray1的引用，它们实际上是同一个对象。

Answer 2

在Swift Arrays中是值类型，因此如果您指定，返回或传递参数，它们将被复制。

为了使这项工作符合预期，你必须制作一个包装器（类）：

class ArrayWrapper<T> {
    var array: [T]
    init(_ array: [T] = []) {
        self.array = array
    }
}

var arrayOne = ArrayWrapper<String>()
var arrayTwo = ArrayWrapper<String>()
var arrayThree = ArrayWrapper<String>()

func get_array(aNumber:Int) -> ArrayWrapper<String> {
   var arr = self.arrayOne //default
   if aNumber == 1 {
        arr = self.arrayOne
   } else if aNumber == 2 {
       arr = self.arrayTwo
   } else if aNumber == 3 {
       arr = self.arrayThree
   }
   return arr
}

// in case of your function I would suggest to use switch instead:
func getArray(aNumber:Int) -> ArrayWrapper<String> {
   switch aNumber {
   case 1: return self.arrayOne
   case 2: return self.arrayTwo
   case 3: return self.arrayThree
   default: return self.arrayOne
   }
}

// so you modify the Array as following:
var myArray = get_array(2)
myArray.array.append("hello")

数组引用/值

2 个答案: