assign
assign:只对属性进行简单的赋值，不更改所赋的值的引用计数，适用于NSInteger等基础类型，以及short、float、double、结构体等C数据结构。
copy
copy：调用setter方法对成员变量赋值时，会将被赋值的对象赋值一个副本，再将该副本赋值给成员变量。copy会将原成员变量的引用对象的引用计数减1.
retain
retain: 把某对象赋值给该属性时，该属性原来所引用的对象的引用计数器-1，被赋值的对象的引用计数器+1；
strong
VC中有一个TextField
@property (nonatomic, assign) IBOutlet UITextField *nameField;
1>我们在文本框输入：alex；
此时nameField的text属性的NSString对象指针指向文本框的内容，此时：
image.png
2>执行以下代码：
NSString *name = self.nameField.text;
一个对象可以拥有多个拥有者，name属性也是这个NSString对象的拥有者，也就是两个指针指向同一个对象。
image.png
3>接下来改变nameField的内容：Niki，此时namefield的text属性指向新的NSString对象，而原来的NSString对象仍然还有一个持有者name，所以仍会在内存中。
image.png
4>当那么变量赋新值时，原先alex 的NSString对象就不再拥有任何所有者，retain计数降为0，对象被释放。
name= @"Jake";
image.png
weak
weak 指针指向一个对象，但是不是对象的所有者。
__weak NSString *name = self.nameField.text;
image.png
name和self.textField.text 都指向alex 同一个NSString对象，但是name不是对象的拥有者。
2>当文本框的内容发生变化时，原先的alex对象没有拥有者，此时被释放，而此时的name被置为nil，是空指针。
image.png
assign 和 weak
两者都是弱引用，assign适用于普通类型。
后者比前者对一个功能，weak的引用对象被释放的时候将该属性置为nil，而assign依然会指向原来的位置，此时就成了野指针。在oc中给nil对象发送消息不会crash，但是给一个对象发送不能解析的消息就会crash，weak比assign安全一些。
retain和strong
两者都是强引用。
修饰block属性时适用copy，不使用copy，block是存放在栈连里面的，他的生命周期会随着函数的结束而出栈的，copy之后会放在堆里面。
strong在修饰block的时候就相当于copy，而retain修饰block的时候就相当于assign，这样block会出现提前被释放掉的危险。
strong和copy
了解：
浅Copy：可以理解为指针的复制，只是多了一个指向这块内存的指针，共用一块内存。
深Copy:理解为内存的复制，两块内存是完全不同的，也就是两个对象指针分别指向不同的内存，互不干涉。
@property (nonatomic, strong)NSString * stringStrong; //strong修饰的字符串对象
@property (nonatomic, copy)NSString * stringCopy; //copy修饰的字符串对象
接着创建两个不可变字符串(NSString)
//新创建两个NSString对象
NSString * strong1 = @"I am Strong!";
NSString * copy1 = @"I am Copy!";
将两个属性分别进行赋值
//初始化两个字符串
self.stringStrong = strong1;
self.stringCopy = copy1;
分别打印一下四个变量的内存地址:
NSLog(@"strong1 = %p",strong1);
NSLog(@"stringStrong = %p",self.stringStrong);
NSLog(@"copy1 = %p",copy1);
NSLog(@"stringCopy = %p",self.stringCopy);
结果如下:可以看出，此时无论是strong修饰的字符串还是copy修饰的字符串，都进行了浅Copy.
如果创建两个不可变字符串对象(NSMutableString)
//新创建两个NSMutableString对象
NSMutableString * mutableStrong = [NSMutableString stringWithString:@"StrongMutable"];
NSMutableString * mutableCopy = [NSMutableString stringWithString:@"CopyMutable"];
分别对属性再次进行赋值
self.stringStrong = mutableStrong;
self.stringCopy = mutableCopy;
分别打印一下四个变量的地址:结果如下:这时就发现了,用strong修饰的字符串依旧进行了浅Copy,而由copy修饰的字符串进行了深Copy,所以mutableStrong与stringStrong指向了同一块内存，而mutableCopy和stringCopy指向的是完全两块不同的内存。
作用：
首先是对不可变字符串进行操作:
//新创建两个NSString对象
NSString * strong1 = @"I am Strong!";
NSString * copy1 = @"I am Copy!";
//初始化两个字符串
self.stringStrong = strong1;
self.stringCopy = copy1;
//两个NSString进行操作
[strong1 stringByAppendingString:@"11111"];
[copy1 stringByAppendingString:@"22222"];
分别对在字符串后面进行拼接，当然这个拼接对原字符串没有任何的影响，因为不可变自字符串调用的方法都是有返回值的，原来的值是不会发生变化的.打印如下，对结果没有任何的影响:
StrongOrCopy strong1 = I am Strong!
StrongOrCopy stringStrong = I am Strong!
StrongOrCopy copy1 = I am Copy!
StrongOrCopy stringCopy = I am Copy!
然后是对可变字符串进行操作:
//新创建两个NSMutableString对象
NSMutableString * mutableStrong = [NSMutableString stringWithString:@"StrongMutable"];
NSMutableString * mutableCopy = [NSMutableString stringWithString:@"CopyMutable"];
//初始化两个字符串
self.stringStrong = mutableStrong;
self.stringCopy = mutableCopy;
//两个MutableString进行操作
[mutableStrong appendString:@"Strong!"];
[mutableCopy appendString:@"Copy!"];
再来看一下结果:对mutableStrong进行的操作，由于用strong修饰的stringStrong没有进行深Copy，导致共用了一块内存，当mutableStrong对内存进行了操作的时候，实际上对stringStrong也进行了操作; 相反，用copy修饰的stringCopy进行了深Copy，也就是说stringCopy与mutableCopy用了两块完全不同的内存，所以不管mutableCopy进行了怎么样的变化，原来的stringCopy都不会发生变化.这就在日常中避免了出现一些不可预计的错误。
stringStrong = StrongMutableStrong!
mutableStrong = StrongMutableStrong!
stringCopy = CopyMutable
mutableCopy = CopyMutableCopy!
在不可变对象之间进行转换，strong与copy作用是一样的。
但是如果在不可变与可变之间进行操作，比较推荐copy,这也就是为什么很多地方用copy，而不是strong修饰NSString,NSArray等存在可变不可变之分的类对象了，避免出现意外的数据操作.
网友评论