先说结论：
- swift：不被类包裹的的let 和 var，可以理解为超级全局变量；且非常好的地方在于：他并不是一运行App时就alloc和赋值，而是第一次使用全局变量时候才alloc和赋值，第二次使用就不新alloc了，有点类似lazy加载，而且alloc后永远不改变指针地址
- swift里的
NSString，默认是Strong。OC可以设置为strong 和 copy。而oc里strong 和 copy的区别，就在于NSMutableString.append的影响 - swift里的
String，是结构体，赋值时候是copy - swift里的
NSArray，默认是Strong，是引用的赋值。swift里的Array，默认是copy，值类型。但是Array有个copy on write优化。 - swift里的
Struct，是值的赋值，赋值的时候就产生了拷贝（两个struct的栈地址也不同）；swift的Dictionary[String,String]也是如此，赋值就拷贝 - 但是swift里的
Array在赋值的时候并没有立即产生拷贝，且两个array的栈地址也是一样的，只有当其中一个array发生事务操作的时候，才进行拷贝（如果array里的元素是NSObject，增删才是事务操作；如果array里元素是struct，修改item值就是事务） - 因此要注意：如果是Model是
struct，[Model] 要用 mainArray[indexPath.row].name = "new Name!" 不能取成var model = mainArray[indexPath.row]，因为这样就深拷贝了
先定义一个文件Common.swift
let STATUSBAR_HIGH = UIApplication.shared.statusBarFrame.size.height //非X是20 X是44
var kTopNavHeight = 44 + STATUSBAR_HIGH //非X是64 X是98 ，44是导航栏的高度
var Global = "abc"
然后ViewController.swift：
//先看一下全局变量的原始值
NSLog("org = %f", kTopNavHeight)
//原始值赋予test1
let test1:CGFloat = kTopNavHeight
NSLog("test1 = %f", test1)
//修改全局变量的原始值，看看test1会不会跟着变化
kTopNavHeight = kTopNavHeight+1000
NSLog("org1.1 = %f", kTopNavHeight)
NSLog("test1.1 = %f", test1)
//再赋值给新的test2，这样可以看出来kTopNavHeight重新alloc了没有
let test2:CGFloat = kTopNavHeight
NSLog("test2 = %f", test2)
打印日志：
2021-03-26 23:49:49.525818+0800 QSwift[20428:345180] org = 91.000000
2021-03-26 23:49:49.526088+0800 QSwift[20428:345180] test1 = 91.000000
2021-03-26 23:49:49.526247+0800 QSwift[20428:345180] org1.1 = 1091.000000
2021-03-26 23:49:49.526373+0800 QSwift[20428:345180] test1.1 = 91.000000
2021-03-26 23:49:49.526537+0800 QSwift[20428:345180] test2 = 1091.000000
很简单就能看出来了，如果var全局变量就是个普通的全局变量float，属于值类型，并且只初始化一次，对他做修改，就永远的修改了
那么如果var全局变量是String或者NSString类型的呢，我们先看一下OC的是什么情况:
@property(nonatomic,strong) NSString *b;
NSString *a = @"a";
self.b = a;
NSLog(@"b.1 = %@", self.b);
a = @"abc"; //a指向别的地方了，b还是原地不动，这是基础知识
NSLog(@"b.2 = %@", self.b);
2021-03-27 00:46:57.786943+0800 itopic[23859:383203] b.1 = a
2021-03-27 00:46:57.787379+0800 itopic[23859:383203] b.2 = a
NSMutableString *a = [[NSMutableString alloc]initWithString:@"a"];
self.b = a;
NSLog(@"b.1 = %@", self.b);
[a appendString:@"xyz"];
NSLog(@"b.3 = %@", self.b);
2021-03-27 00:51:13.534246+0800 itopic[24223:389631] b.1 = a
2021-03-27 00:51:13.534728+0800 itopic[24223:389631] b.3 = axyz
//注意：如果b是copy类型，就b.3 = a
再看看swift的String
var a :String = "a"
var b :String = a
NSLog("b1 = %@", b)
a.append("xyz")
NSLog("b3 = %@", b)
2021-03-26 23:59:31.640576+0800 QSwift[20800:351834] b1 = a
2021-03-26 23:59:31.640925+0800 QSwift[20800:351834] b3 = a
var a :NSMutableString = "a"
var b :NSString = a
NSLog("b1 = %@", b)
a.append("xyz")
NSLog("b3 = %@", b)
2021-03-27 00:03:20.609888+0800 QSwift[21046:355556] b1 = a
2021-03-27 00:03:20.610288+0800 QSwift[21046:355556] b3 = axyz
所以swift的String是结构体，赋值的时候就是copy。
swift的NSString和OC一样，默认是Strong。但是OC可以设置为copy，swift不清楚怎么设置为copy的
如果swift下是NSArray 和 Array对比呢
var a :NSMutableArray = ["a"]
var b :NSArray = a
NSLog("b.count = %d", b.count)
a.add("xyz")
NSLog("b.2.count = %d", b.count)
a = ["abc","def","xyz"] //这样a与b就分开了，两者毫无关联了
NSLog("b.3.count = %d", b.count)
2021-03-27 18:18:57.679867+0800 QSwift[35247:572549] b.count = 1
2021-03-27 18:18:57.680959+0800 QSwift[35247:572549] b.2.count = 2
2021-03-27 18:18:57.681628+0800 QSwift[35247:572549] b.3.count = 2
- 结论：swift中使用NSArray，就是OC中的Strong；意思就是：你add，我也跟着你add（堆地址是一样的），但是你变地址了（使用了=，我还是原来的堆的指针）
这一点跟flutter也是一样的：
newsList = [];
List<String> tempList = newsList;
List<String> tempList2 = List.from(newsList);
for(var i = 100 ; i >= 1; i--) {
newsList.add(i.toString());
}
print("tempList count = "+tempList.length.toString());
print("tempList2 count = "+tempList2.length.toString());
newsList = ["1"];
print("tempList count = "+tempList.length.toString());
print("newslit count = "+newsList.length.toString());
I/flutter (16442): tempList count = 100
I/flutter (16442): tempList2 count = 0
I/flutter (16442): tempList count = 100
I/flutter (16442): newslit count = 1
var a :Array = ["a"]
var b :Array = a
NSLog("b.count = %d", b.count)
a.append("xyz")
NSLog("b.2.count = %d", b.count)
a = ["abc","def","xyz"]
NSLog("b.3.count = %d", b.count)
2021-03-27 18:23:13.100743+0800 QSwift[35513:576751] b.count = 1
2021-03-27 18:23:13.103273+0800 QSwift[35513:576751] b.2.count = 1
2021-03-27 18:23:13.103677+0800 QSwift[35513:576751] b.3.count = 1
- 以上结论：swift中使用Array，就是OC中的copy
- 然后再看一下，Array是什么时候才进行的copy，是发生事务操作的时候才copy
class QEmotion {
}
Struct QStruct {
}
private var emotionArray: [QEmotion]?
private var copyedArray: [QEmotion]?
//为了测试，给emotionArray添加很多元素。最后emotionArray的占用内存为10M
func createEmotionArray() -> [QEmotion]? {
if emotionArray == nil {
emotionArray = [QEmotion]()
for index in 1...56000 {
emotionArray!.append(QEmotion(identifier: "", displayName: ""))
}
}
return emotionArray
}
func testEmotionClassArray() {
//Swift在复制Array时，同样对Array的性能有所考量，它使用了copy on write的方式。即如果你仅仅复制了Array而不对它修改时，真正的复制是不会发生的，两个数组仍旧引用同一个内存地址
//所以做完这一步 App占用内存也不会增加
copyedArray = emotionArray
//这时候打印两个Array的内存地址，都是相同的！
print("1--orgAddress = ",String.init(format: "%p", emotionArray!))
print("1--copyAddress = ",String.init(format: "%p", copyedArray!))
//就是这一步发生了复制，然后内存增加了2M，注意增量不是emotionArray的10M；因为他复制的是几万个int类型的指针，而不是实体类
copyedArray!.append(QEmotion(identifier: "", displayName: ""))
print("after append--copyAddress = ",String.init(format: "%p", copyedArray!))
let e = emotionArray![0]
e.identifier = "changed" //请注意，这里e是Class
let e2 = copyedArray![0]
print(e2.identifier) //输出copyedArray的第0个元素，打印的是“changed”；也跟着变了
//打印0元素 两个地址相同，说明了虽然有两份Array复制，但是两份Array里的int（元素地址）是一致的
print("orgc[0].address = ",String.init(format: "%p", e))
print("array2[0].address = ",String.init(format: "%p", e2))
//上面的这句请注意，如果Array里存是struct，那么当 eStruct.identifier = "changed" 的时候，copyedArray就会发生copy，再打印%p，copyedArray就会发生变化了
}
UIView *testObj = [[UIView alloc] init];
NSLog(@"testObj 指针指向的地址:%p 指针本身的地址:%p", testObj, &testObj);
//Dictionary [String,String] 就没这种保护机制了，复制时候就copy了：
userDictionary = [String : String]()
print("1--orgDictionaryAddress = ",String.init(format: "%p", address(&userDictionary!)))
userCopyedDictionary = userDictionary
print("1--orgCopyedDictionaryAddress = ",String.init(format: "%p", address(&userCopyedDictionary!)))
//打印出来的结果，两份Dictionary地址不一样
- 如果用copy NSArray = NSMutableArray，注意这时候仍然是值引用
// Mutable array [1, 2, 3]
let b = NSMutableArray(array: [1, 2, 3])
// Const array [1, 2, 3]
let copyB: NSArray = b
// [0, 1, 2, 3]
b.insert(0, at: 0)
// [0, 1, 2, 3]
copyB
从上面的代码可以看到，尽管我们在创建copyB时，使用了NSArray，表明我们不希望它的值被修改，由于这个赋值执行的是引用拷贝，因此，实际上它和b指向的是同一块内存空间。因此，当我们修改b的内容时，copyB也就间接受到了影响。
为了在拷贝NSArray对象时，执行值语义，我们必须使用它的copy方法复制所有的元素：
let b = NSMutableArray(array: [1, 2, 3])
let copyB: NSArray = b
let deepCopyB = b.copy() as! NSArray
b.insert(0, at: 0) // [0, 1, 2, 3]
copyB // [0, 1, 2, 3]
deepCopyB // [1, 2, 3]
userStruct = UserSimpleModel(userid: 1, name: "第一个人");
print("1--orgAddress = ",String.init(format: "%p", address(&userStruct!)))
copyedUserStruct = userStruct
print("1--copyAddress = ",String.init(format: "%p", address(©edUserStruct!)))
//打印结果：两个地址并不相同，说明Struct的赋值，立即就产生了拷贝
//打印栈上的地址，适用于struct
func address(_ o: UnsafeRawPointer) -> Int {
return Int(bitPattern: o)
}
//打印堆上的地址，适用于class
func addressHeap<T : AnyObject>(_ o: T) -> Int {
return unsafeBitCast(o, to: Int.self)
}
