iOS-传值方式

传值方式：
1、属性传值 方法传值
2、代理传值
3、单例传值
4、通知传值 NSNotificationCenter
5、Block
6、NSUserDefaults
7、数据库
8、NSFileManager
9、全局变量
http://www.360doc.com/content/14/0410/21/11029609_367858753.shtml

1、属性传值：

//B页面定义了一个naviTitle属性
（@property (nonatomic,copy) NSString *naviTitle;），
//在A页面中直接通过属性赋值将A页面中的值传到B页面。
DetailViewController *viewB = [[DetailViewController alloc] init];
//属性传值，直接属性赋值
viewB.naviTitle =tf.text;

方法传值

可以直接将b.m方法与初始化方法合并。 a.m触发点击事件并跳转时，直接通过初始化将值保存。

-(id)initWithValue:(NSString *)value
{
    if (self = [super initWithNibName:nil bundle:nil]) {
        self.firstValue = value;
    }
    return self;
}

2、代理传值 Delegate (委托)

代理是一种设计模式，可用于页面间反向传值。返回给上个页面。
当一个对象无法直接获取到另一个对象的指针，又希望对那个对象进行一些操作时，可以使用代理模式。
代理模式让某个类持有另一个类的指针
让程序低耦合。
单对单的：指的是在发出消息时收到消息的那一方的个数。通知是一旦发出，多个对象接收到消息。而代理是发出消息后只能某个特定对象获取到消息。
A页面push到B页面，如果B页面的信息想回传（回调）到A页面，用代理传值，其中B定义协议和声明代理，A确认并实现代理，A作为B的代理

A:
A.h

A.m
//代理传值: detailViewController.delegate =self;
//让其自身作为代理人 //设置代理实例  

//实现代理方法
-(void)changeTitle:(NSString *)aStr
{ 。。。。。 }

B:
B.h
//定义协议
@protocol ChangeDelegate 
@optional
-(void)changeTitle:(NSString *)aStr;//协议方法
@required
- (void)hhh;
@end

//定义代理
//id_delegate;
//遵循协议的一个代理变量定义 
@property(nonatomic, weak)id delegate;

@end

B.m
// 判断代理对象是否实现这个方法，没有实现会导致崩溃
if (self.delegate  && [self.delegate respondsToSelector:@selector(changeTitle:)]) {
    [self.delegate changeTitle:textField.text];
//将textField.text参数传给changeTitle方法,让代理也就是A页面去实现这个方法
}

为什么我们设置代理属性都使用weak呢？
我们定义的指针默认都是__strong类型的，而属性本质上也是一个成员变量和set、get方法构成的，strong类型的指针会造成强引用，必定会影响一个对象的生命周期，这也就会形成循环引用。
weak会自动将指针指向nil，而assign则不会。

这种传值主要用于A进入B，然后B输入值后传回给A。
常见于修改个人信息，点击进入修改界面，修改完之后回到显示界面，显示修改后的结果。

SixViewController *six = [[SixViewController alloc]init];
     six.delegate = self;//把自己设置为对方的代理
     [self.navigationController pushViewController:six animated:YES];

 [self.delegate changeValue:self.DMTextField.text];
//对方要做事，让自己去做，就改了自己这边的值
[self.navigationController popViewControllerAnimated:YES];

3、单例传值（实现共享）

（比如我们经常会把一个变量放在AppDelegate里面作为全局变量来访问， 其中AppDelegate就是一个单例类）

+ (id)sharedManager {
    static MyManager *sharedMyManager = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedMyManager = [[self alloc] init];
    });
    return sharedMyManager;
}

static MyClass *class = nil;
@implementation MyClass
+(MyClass *)sharedMyClass{
    @synchronized(self){  //为了确保多线程情况下，仍然确保实体的唯一性
        if (!class) {
            [[self alloc] init]; //该方法会调用 allocWithZone
        }
    }
    return class;
}

+(id)allocWithZone:(NSZone *)zone{
    @synchronized(self){
        if (!class) {
            class = [super allocWithZone:zone]; //确保使用同一块内存地址
            return class;
        }
    }
    return nil;
}
- (id)copyWithZone:(NSZone *)zone;{
    return self; //确保copy对象也是唯一
}

@end

创建对象的时候，alloc表示申请内存，init表示初始化，程序在alloc时，会在allocWithZone这个方法申请内存，我们只要在这个方法中调用sharedManager返回单例即可。这样就不会申请多次内存了。拷贝对象以此类推，同理所得，要重写copyWithZone。这样就保证了这个类只被实例化了一次。

4、通知传值

谁要监听值的变化，谁就注册通知 ，通知的接受者必须存在这一先决条件

B:
方法一：
[[NSNotificationCenter defaultCenter] postNotificationName:@"CHANGE_TITLE" object:nil userInfo:dic];
方法二：
//创建通知
NSNotification *notification =[NSNotification notificationWithName:@"tongzhi" object:nil userInfo:dic];
//通过通知中心发送通知
    [[NSNotificationCenter defaultCenter] postNotification:notification];

A:
//注册通知监听者，将通知发送的信息接收
[[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(change:)
                                                     name:@"CHANGE_TITLE"
                                                   object:nil];
-(void)change:(NSNotification *)aNoti
{......}

//移除通知
[[NSNotificationCenter defaultCenter] removeObserver:self name:@"CHANGE_TITLE" object:nil];

//添加一个广播，用于注册当用户按下home键时，归档数据到闪存中  
    UIApplication *app = [UIApplication sharedApplication];  
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(saveAppDataWhenApplicationWillResignActive) name:UIApplicationWillResignActiveNotification object:app];  

http://blog.sina.com.cn/s/blog_6317728d0102v779.html

5、Block

类似js的单层回调
Block 两个作用：
一个在处理异步问题的时候，例如HTTP请求，有点像javascript的回调，在得到回复的时候更新主线程，而不会占用主线程，比Delegate逻辑好看多了。
另一个当你要返回多个值又懒得创建一个类的时候…

几种形式的Block：
//无返回值
    void (^block1) (void);
    block1 = ^{
        NSLog(@"bock demo");
    };
    block1();
    
//int返回类型
    int (^block2) (void);
    block2  = ^(void)
    {
        int a  = 1 ,b =1;
        int c = a+b;
        return  c;
    };
    
//有返回 有参数
    int (^block3)(int, int)= ^(int a, int b)
    {
        int c = a +b;
        return c;
        
    };
    NSLog(@"bock=%d",block3(1,2));
    
//有返回值，有参数并且可以修改block之外变量的block
    static int sum = 10;// __block and static关键字 或者 __block int sum = 10
    int (^block4) (int) =^(int a)
    {
        sum=11;
        int c = sum+a;  //此时sum就是可以修改的了，若没加static或__block关键字则不能修改block之外变量
        return c;
    };
    NSLog(@"block4= %d",block4(4));

static ： 有限的作用域，内存只被分配一次。

__block关键字的使用：
在Block的{}体内，是不可以对外面的变量进行更改的。但加上__block就能在Block的{}体内修改外部变量了。
block都是一些简短代码片段的封装，适用作工作单元，通常用来做并发任务、遍历、以及回调。

（1）在类中，定义一个Block变量，就像定义一个函数；
就像函数一样，只有在调用的时候才会执行block体内的代码。
（2）Block可以定义在方法内部，也可以定义在方法外部；
（3）只有调用Block时候，才会执行其{}体内的代码；

http://my.oschina.net/leejan97/blog/268536

Block传值：

闭包特性，传函数过去。
对方之行到这个函数的时候，修改值，就把数值传过来。

    EightViewController *eight = [[EightViewController alloc]initWithBlock:^(UIColor *color, NSString *name) {
        self.view.backgroundColor = color;
        self.DMlabel.text = name;
    }];
    [self.navigationController pushViewController:eight animated:YES];

    NSArray *array = [NSArray arrayWithObjects:[UIColor yellowColor],[UIColor cyanColor],[UIColor greenColor],[UIColor brownColor], nil];
    self.myBlock([array objectAtIndex:rand() % 4],_DMTextField.text);
    [self.navigationController popViewControllerAnimated:YES];

6、NSUserDefaults

7、数据库

8、NSFileManager

9、全局变量

什么时候用通知，代理和KVO?

代理：一般控件用的比较多，其实也可以用block实现，如果实现的接口比较多的话，建议用代理，如UITableview。
通知：这东西是全局的，而且是同步的，如果你要全局发送消息，并且做的事情时间不长，不会阻塞线程的话，建议使用。
kvo: kvo是建立在kvc的基础之上的，它通过 key path 观察对象的值，当值发生变化的时候会收到通知。比如，你需要监听UITableview的contentoffset那么当，tableview滑动的时候，就会不停的收到contentoffset point值。你要监听某一对象的值的时候，建议使用。

全局变量：

1、使用"extern"关键词
extern来说可以理解为扩展吧是这样的是从一个类扩展到另一个类中的
比如：在一个类中定义NSString* meString=@"123"; 在另一个类中extern NSString* meString;然后就可以使用meString进行操作了(直接使用或者重新赋值)。

2、静态变量 static
static关键字声明的变量必须放在implementation外面，或者方法中。
如果不为它赋值默认为0，它只在程序开机初始化一次。
警告: static 写在.h中 interface外面编译是没有错误的，但是编译器会报警告，这样的写法是不被编辑器认可的。
错误：static 写在.h中 interface里面会直接报错，显然这样的语法是不被认可的。
在Objective-C 的语法中声明后的static静态变量在其他类中是不能通过类名直接访问的，它的作用域只能是在声明的这个.m文件中 。
不过可以调用这个类的方法间接的修改这个静态变量的值。
不加static，是可能被释放掉的，那还怎么通过单例来持续共享数据？
http://www.apkbus.com/android-593-1.html

3、使用singleton pattern 使用单例实现

4、定义在APPDelegate中
（比如我们经常会把一个变量放在AppDelegate里面作为全局变量来访问， 其中AppDelegate就是一个单例类）
AppDelegate *myDelegate = [[UIApplication sharedApplication] delegate];
myDelegte.myName = @"123 ";

https://blog.csdn.net/Seal_Shile/article/details/52781876