swift的let和var全局变量是copy还是每次都alloc，并与OC对比

先说结论：

• 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 tempList = newsList;
    List 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就会发生变化了
    }

      //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(_ o: T) -> Int {
        return unsafeBitCast(o, to: Int.self)
    }