面试题总结

1. iOS开发中的加密方式

iOS加密相关算法框架：CommonCrypto。

对称加密： DES、3DES、AES

加密和解密使用同一个密钥。

加密解密过程：明文->密钥加密->密文，密文->密钥解密->明文。

优点：算法公开、计算量少、加密速度快、加密效率高、适合大批量数据加密；

缺点：双方使用相同的密钥，密钥传输的过程不安全，易被破解，因此为了保密其密钥需要经常更换。

AES：AES又称高级加密标准，是下一代的加密算法标准，支持128、192、256位密钥的加密，加密和解密的密钥都是同一个。iOS一般使用ECB模式，16字节128位密钥。
AES算法主要包括三个方面：轮变化、圈数和密钥扩展。
优点：高性能、高效率、灵活易用、安全级别高。
缺点：加密与解密的密钥相同，所以前后端利用AES进行加密的话，如何安全保存密钥就成了一个问题。

DES：数据加密标准，DES算法的入口参数有三个：Key、Data、Mode。
其中Key为7个字节共56位，是DES算法的工作密钥；Data为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密、解密。
缺点：与AES相比，安全性较低。

3DES：3DES是DES加密算法的一种模式，它使用3条64位的密钥对数据进行三次加密。是DES向AES过渡的加密算法，是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法。

非对称加密：RSA加密

非对称加密算法需要成对出现的两个密钥，公开密钥(publickey) 和私有密钥(privatekey) 。

加密解密过程：对于一个私钥，有且只有一个与之对应的公钥。生成者负责生成私钥和公钥，并保存私钥，公开公钥。
公钥加密，私钥解密；或者私钥数字签名，公钥验证。公钥和私钥是成对的，它们互相解密。

特点：

1). 对信息保密，防止中间人攻击：将明文通过接收人的公钥加密，传输给接收人，因为只有接收人拥有对应的私钥，别人不可能拥有或者不可能通过公钥推算出私钥，所以传输过程中无法被中间人截获。只有拥有私钥的接收人才能阅读。此方法通常用于交换对称密钥。
2). 身份验证和防止篡改：权限狗用自己的私钥加密一段授权明文，并将授权明文和加密后的密文，以及公钥一并发送出来，接收方只需要通过公钥将密文解密后与授权明文对比是否一致，就可以判断明文在中途是否被篡改过。此方法用于数字签名。

优点：加密强度小，加密时间长，常用于数字签名和加密密钥、安全性非常高、解决了对称加密保存密钥的安全问题。

缺点：加密解密速度远慢于对称加密，不适合大批量数据加密。

哈希算法加密：MD5加密、.SHA加密、HMAC加密

哈希算法加密是通过哈希算法对数据加密，加密后的结果不可逆，即加密后不能再解密。

特点：不可逆、算法公开、相同数据加密结果一致。

作用：信息摘要，信息“指纹”，用来做数据识别的。如：用户密码加密、文件校验、数字签名、鉴权协议。

MD5加密：对不同的数据加密的结果都是定长的32位字符。

.SHA加密：安全哈希算法，主要适用于数字签名标准(DSS)里面定义的数字签名算法(DSA)。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。当然除了SHA1还有SHA256以及SHA512等。

HMAC加密：给定一个密钥，对明文加密，做两次“散列”，得到的结果还是32位字符串。

Base64加密：

一种编码方式，严格意义上来说不算加密算法。其作用就是将二进制数据编码成文本，方便网络传输。

用 base64 编码之后，数据长度会变大，增加了大约 1/3，但是好处是编码后的数据可以直接在邮件和网页中显示；

虽然 base64 可以作为加密，但是 base64 能够逆运算，非常不安全！

base64 编码有个非常显著的特点，末尾有个 ‘=’ 号。

原理：
1). 将所有字符转化为ASCII码；
2). 将ASCII码转化为8位二进制；
3). 将二进制三位一组不足补0，共24位，再拆分成6位一组共四组；
4). 统一在6位二进制前补两个0到八位；
5). 将补0后的二进制转为十进制；
6). 最后从Base64编码表获取十进制对应的Base64编码。

2. App安全，数字签名，App签名，重签名

因为应用实际上是一个加壳的ipa文件，但是有可能被砸壳甚至越狱手机下载的ipa包直接就是脱壳的，可以直接反编译，所以不要在plist文件、项目中的静态文件中存储关键的信息。所以敏感信息对称加密存储或者就存储到keychain里。而且加密密钥也要定期更换。

数字签名是通过HASH算法和RSA加密来实现的。
我们将明文数据加上通过RSA加密的数据HASH值一起传输给对方，对方可以解密拿出HASH值来进行验证。这个通过RSA加密HASH值数据，我们称之为数字签名。

App签名

在Mac开发机器上生成一对公钥和私钥，这里称为公钥L，私钥L(L：Local)。

苹果自己有固定的一对公钥和私钥，私钥在苹果后台，公钥在每个iOS设备上。这里称为公钥A，私钥A(A：Apple)。

把开发机器上的公钥L传到苹果后台，用苹果后台的私钥A去签名公钥L。得到一个包含公钥L以及其签名数据证书。

在苹果后台申请AppID，配置好设备ID列表和APP可使用的权限，再加上第③步的证书，组成的数据用私钥A签名，把数据和签名一起组成一个Provisioning Profile描述文件，下载到本地Mac开发机器。

在开发时，编译完一个APP后，用本地的私钥L对这个APP进行签名，同时把第④步得到的Provisioning Profile描述文件打包进APP里，文件名为embedded.mobileprovision，把 APP安装到手机上。

在安装时，iOS系统取得证书，通过系统内置的公钥A，去验证embedded.mobileprovision的数字签名是否正确，里面的证书签名也会再验一遍。

确保了embedded.mobileprovision里的数据都是苹果授权的以后，就可以取出里面的数据，做各种验证，包括用公钥 L 验证APP签名，验证设备 ID 是否在 ID 列表上，AppID 是否对应得上，权限开关是否跟 APP 里的 Entitlements 对应等。

3. OC数据类型

① 基本数据类型

C语言基本数据类型（如short、int、float等）在OC中都不是对象，只是一定字节的内存空间用于存储数值，他们都不具备对象的特性，没有属性方法可以被调用。

OC中的基本数据类型：

NSInteger(相当于long型整数)、

NSUInteger(相当于unsigned long型整数)、

CGFloat(在64位系统相当于double，32位系统相当于float)等。

他们并不是类，只是用typedef对基本数据类型进行了重定义，他们依然只是基本数据类型。

枚举类型：其本质是无符号整数。

BOOL类型：是宏定义，OC底层是使用signed char来代表BOOL。

② 指针数据类型

指针数据类型包括：类class、id。

类class：NSString、NSSet、NSArray、NSMutableArray、NSDictionary、NSMutableDictionary、NSValue、NSNumber(继承NSValue)等，都是class，创建后便是对象，继承NSObject。
OC中提供了NSValue、NSNumber来封装C语言的基本类型，这样我们就可以让他们具有面向对象的特征了。

id：id是指向Objective-C对象的指针，等价于C语言中的void*，可以映射任何对象指针指向他，或者映射它指向其他的对象。常见的id类型就是类的delegate属性。

集合NSSet和数组NSArray区别：

都是存储不同的对象的地址；

但是NSArray是有序的集合，NSSet是无序的集合，它们俩可以互相转换。

NSSet会自动删除重复元素。

集合是一种哈希表，运用散列算法，查找集合中的元素比数组速度更快，但是它没有顺序。

③ 构造类型

构造类型包括：结构体、联合体

结构体：struct，将多个基本数据类型的变量组合成一个整体。结构体中访问内部成员用点运算符访问。

联合体(共用体)：union，有些类似结构体struct的一种数据结构，联合体(union)和结构体(struct)同样可以包含很多种数据类型和变量。

结构体和联合体的区别：

结构体(struct)中所有变量是“共存”的，同一时刻每个成员都有值，其sizeof为所以成员的和。
优点：是“有容乃大”，全面；
缺点：是struct内存空间的分配是粗放的，不管用不用，全分配，会造成内存浪费。

联合体(union)中各变量是“互斥”的，同一时刻只有一个成员有值，其sizeof为最长成员的sizeof。
优点：是内存使用更为精细灵活，也节省了内存空间。
缺点：就是不够“包容”，修改其中一个成员时会覆盖原来的成员值；

4. property和属性修饰符

@property的本质是 ivar(实例变量) + setter + getter.

我们每次增加一个属性时内部都做了什么：
1.系统都会在 ivar_list 中添加一个成员变量的描述；
2.在 method_list 中增加 setter 与 getter 方法的描述；
3.在属性列表中增加一个属性的描述；
4.然后计算该属性在对象中的偏移量；
5.给出 setter 与 getter 方法对应的实现，在 setter 方法中从偏移量的位置开始赋值，在 getter 方法中从偏移量开始取值，为了能够读取正确字节数，系统对象偏移量的指针类型进行了类型强转。

修饰符：
MRC下：assign、retain、copy、readwrite、readonly、nonatomic、atomic等。
ARC下：assign、strong、weak、copy、readwrite、readonly、nonatomic、atomic、nonnull、nullable、null_resettable、_Null_unspecified等。

assign：用于基本数据类型，不更改引用计数。如果修饰对象(对象在堆需手动释放内存，基本数据类型在栈系统自动释放内存)，会导致对象释放后指针不置为nil 出现野指针。
retain：和strong一样，释放旧对象，传入的新对象引用计数+1；在MRC中和release成对出现。
strong：在ARC中使用，告诉系统把这个对象保留在堆上，直到没有指针指向，并且ARC下不需要担心引用计数问题，系统会自动释放。
weak：在被强引用之前，尽可能的保留，不改变引用计数；weak引用是弱引用，你并没有持有它；它本质上是分配一个不被持有的属性，当引用者被销毁(dealloc)时，weak引用的指针会自动被置为nil。可以避免循环引用。
copy：一般用来修饰不可变类型属性字段，如：NSString、NSArray、NSDictionary等。用copy修饰可以防止本对象属性受外界影响，在NSMutableString赋值给NSString时，修改前者会导致后者的值跟着变化。还有block也经常使用 copy 修饰符，但是其实在ARC中编译器会自动对block进行copy操作，和strong的效果是一样的。但是在MRC中方法内部的block是在栈区，使用copy可以把它放到堆区。
readwrite：可以读、写；编译器会自动生成setter/getter方法。
readonly：只读；会告诉编译器不用自动生成setter方法。属性不能被赋值。
nonatomic：非原子性访问。用nonatomic意味着可以多线程访问变量，会导致读写线程不安全。但是会提高执行性能。
atomic：原子性访问。编译器会自动生成互斥锁，对 setter 和 getter 方法进行加锁来保证属性的赋值和取值原子性操作是线程安全的，但不包括可变属性的操作和访问。比如我们对数组进行操作，给数组添加对象或者移除对象，是不在atomic的负责范围之内的，所以给被atomic修饰的数组添加对象或者移除对象是没办法保证线程安全的。原子性访问的缺点是会消耗性能导致执行效率慢。
nonnull：设置属性或方法参数不能为空，专门用来修饰指针的，不能用于基本数据类型。
nullable：设置属性或方法参数可以为空。
null_resettable：设置属性，get方法不能返回为空，set方法可以赋值为空。
_Null_unspecified：设置属性或方法参数不确定是否为空。
后四个属性应该主要就是为了提高开发规范，提示使用的人应该传什么样的值，如果违反了对规范值的要求，就会有警告。

weak修饰的对象释放则自动被置为nil的实现原理：
Runtime维护了一个weak表，存储指向某个对象的所有weak指针。weak表其实是一个hash（哈希）表，Key是所指对象的地址，Value是weak指针的地址数组（这个地址的值是所指对象的地址）。

weak 的实现原理可以概括一下三步：
1、初始化时：runtime会调用objc_initWeak函数，初始化一个新的weak指针指向对象的地址。
2、添加引用时：objc_initWeak函数会调用 objc_storeWeak() 函数， objc_storeWeak() 的作用是更新指针指向，创建对应的弱引用表。
3、释放时，调用clearDeallocating函数。clearDeallocating函数首先根据对象地址获取所有weak指针地址的数组，然后遍历这个数组把其中的数据设为nil，最后把这个entry从weak表中删除，最后清理对象的记录。

4. 一个 autorealese 对象在什么时刻释放？

分两种情况：手动干预释放时机、系统自动释放。
手动干预释放时机：手动指定 autoreleasepool 的 autorelease 对象，在当前作用域大括号结束时释放。
系统自动释放：不手动指定 autoreleasepool 的 autorelease 对象，出了作用域之后，会被添加到最近一次创建的自动释放池中，并会在当前的 runloop 迭代结束时释放。而它能够释放的原因是系统在每个 runloop 迭代中都加入了自动释放池 Push 和 Pop。一个典型的例子是在一个类方法中创建一个对象并作为返回值，这时就需要将该对象放置到对应的 autoreleasepool 中。

5. 成员变量`ivar`和属性`property`的区别，以及不同关键字的作用

成员变量：成员变量的默认修饰符是@protected、不会自动生成set和get方法，需要手动实现、不能使用点语法调用，因为没有set和get方法，只能使用->。
属性：属性会默认生成带下划线的成员变量和setter/getter方法、可以用点语法调用，实际调用的是set和get方法。
注意：分类中添加的属性是不会自动生成 setter/getter方法的，必须要手动添加。
实例变量：class类进行实例化出来的对象为实例对象

关键字作用：

访问范围关键字
@public：声明公共实例变量，在任何地方都能直接访问对象的成员变量。
@private：声明私有实例变量，只能在当前类的对象方法中直接访问，子类要访问需要调用父类的get/set方法。
@protected：可以在当前类及其子类对象方法中直接访问(系统默认)。
@package：在同一个包下就可以直接访问，比如说在同一个框架。

@关键字

@property：声明属性，自动生成一个以下划线开头的成员变量_propertyName(默认用@private修饰)、属性setter、getter方法的声明、属性setter、getter方法的实现。注意：在协议@protocol中只会生成getter和setter方法的声明，所以不仅需要手动实现getter和setter方法还需要手动定义变量。
@sythesize：修改@property自动生成的_propertyName成员变量名，@synthesize propertyName = newName；。
@dynamic：告诉编译器：属性的 setter 与 getter 方法由用户自己实现，不自动生成。谨慎使用：如果对属性赋值取值可以编译成功，但运行会造成程序崩溃，这就是常说的动态绑定。
@interface：声明类
@implementation：类的实现
@selecter：创建一个SEL，类成员指针
@protocol：声明协议
@autoreleasepool：ARC中的自动释放池
@end：类结束

6. 类簇

类簇是Foundation框架中广泛使用的设计模式。类簇在公共抽象超类下对多个私有的具体子类进行分组。以这种方式对类进行分组简化了面向对象框架的公共可见体系结构，而不会降低其功能丰富度。类簇是基于抽象工厂设计模式的。

常见的类簇有 NSString、NSArray、NSDictionary等。
以数组为例：不管创建的是可变还是不可变的数组，在alloc之后得到的类都是 __NSPlaceholderArray。而当我们 init 一个不可变的空数组之后，得到的是__NSArray0；如果有且只有一个元素，那就是 __NSSingleObjectArrayI；有多个元素的，叫做 __NSArrayI；init 出来一个可变数组的话，都是 __NSArrayM。

优点：

可以将抽象基类背后的复杂细节隐藏起来。

程序员不会需要记住各种创建对象的具体类实现，简化了开发成本，提高了开发效率。

便于进行封装和组件化。

减少了 if-else 这样缺乏扩展性的代码。

增加新功能支持不影响其他代码。
缺点：

已有的类簇非常不好扩展。

我们运用类簇的场景：

出现 bug 时，可以通过崩溃报告中的类簇关键字，快速定位 bug 位置。

在实现一些固定且并不需要经常修改的事物时，可以高效的选择类簇去实现。例：

针对不同版本，不同机型往往需要不同的设置，这时可以选择使用类簇。

app 的设置页面这种并不需要经常修改的页面，可以使用类簇去创建大量重复的布局代码。

7. 设计模式

创建型模式：

单例模式：在整个应用程序中，共享一份资源。保证在程序运行过程中，一个类只有一个实例，而且该实例只提供一个全局访问点供外界访问，从而方便控制实例个数，节约系统资源。
优点是：提供了对唯一实例的受控访问、可扩展、避免频繁创建销毁对象影响性能。
缺点是：延长了声明周期，一直存在占用内存。如果两个单例循环依赖会造成死锁，所以尽量不去产生单例间的依赖关系。

工厂方法模式：通过类继承创建抽象产品，创建一种产品，子类化创建者并重载工厂方法以创建新产品。

抽象工厂模式：通过对象组合创建抽象产品，可以创建多系列产品，必须修改父类的接口才能支持新的产品。

结构型模式：

代理模式：代理用来处理事件的监听和参数传递。@required修饰必须实现这个协议方法方法，@optional修饰是可选实现。使用方法时最好先判断方法是否实现respondsToSelector:，避免找不到方法而崩溃。
delegate和block、Notification对比优缺点：delegate和block是一对一通信、block比delegate更加简洁清晰，但是如果通信事件较多时delegate运行成本较低且不易造成循环引用；通知适合一对多通信，代码清晰简单，但问题查找溯源会比较困难，并且注册通知要注意在合适的时间移除，避免对野指针发送消息引起崩溃（注意：iOS9之后已经做了弱引用处理不需要移除了，之前版本使用不安全引用__unsafe_unretained是为了兼容旧版本）。

类簇：见上边 5. 类簇

装饰模式：在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。如：分类。

享元模式：使用共享物件，减少同一类对象的大量创建。如：UITableviewCell复用。

行为型模式：

观察者模式：其本质上是一种发布-订阅模型，用来消除具有不同行为的对象之间的耦合，通过这一模式，不同对象可以协同工作。如：KVO。

命令模式：是一种将方法调用封装为对象的设计模式，在iOS中具体实现为NSInvocation。下边为NSInvocation的实现代码。

- (void)viewDidLoad {
    NSMethodSignature *signature = [ViewController instanceMethodSignatureForSelector:@selector(sendMessageWithPhone:WithName:)]; // 方法签名：用来获得方法的返回类型和参数类型
    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
    invocation.target = self; // 目标：接收消息的对象
    invocation.selector = @selector(sendMessageWithPhone:WithName:); // 选择器：被发送的消息, 方法必须和签名中的方法一致。
    
    NSString *phone = @"13512345678";
    // 注意：设置参数的索引时不能从0开始，因为0已经被self占用，1已经被_cmd占用
    [invocation setArgument:&phone atIndex:2]; // 参数：可以添加任意数量的参数。
    NSString *name = @"Dezi";
    [invocation setArgument:&name atIndex:3];
    /*
     注：调用invocation的invoke方法，就代表需要执行NSInvocation对象中指定对象的指定方法，并且传递指定的参数
     */
    [invocation invoke];
}
- (void)sendMessageWithPhone:(NSString*)phone WithName:(NSString*)name {
    NSLog(@"电话号=%@, 姓名=%@",phone, name);
}
// 电话号=13512345678, 姓名Dezi

MVC和MVVM算是架构。

8. 架构设计

**MVC：

M 是数据模型Model，负责处理数据，以及数据改变时发出通知(Notification、KVO)，Model和View不能直接进行通信，这样会违背MVC设计模式；

V 是视图View，用来展示界面，和用户进行交互，为了解耦合一般不会直接持有或者操作数据层中的数据模型(可以通过action-target、delegate、block等方式解耦)；

C 是控制器Controller用来调节Model和View之间的交互，可以直接与Model还有View进行通信，操作Model进行数据更新，刷新View。

优点：View、Model低耦合、高复用、容易维护。
缺点：Controller的代码过于臃肿，如果View与Model直接交互会导致View和Model之间的耦合性比较大、网络逻辑会加重Controller的臃肿。

MVVM：Model - View - ViewModel

MVVM衍生于MVC，是MVC的一种演进，促进了UI代码和业务逻辑的分离，抽取Controller中的展示逻辑放到ViewModel里边。

M：数据模型Model。

V：就是View和Controller联系到一起，视为是一个组件View。View和Controller都不能直接引用模型Model，可以引用视图模型ViewModel。ViewController 尽量不涉及业务逻辑，让 ViewModel 去做这些事情。ViewController 只是一个中间人，负责接收 View 的事件、调用 ViewModel 的方法、响应 ViewModel 的变化。

VM：ViewModel负责封装业务逻辑、网络处理和数据缓存。使用ViewModel会轻微的增加代码量，但是总体上减少了代码的复杂性。ViewModel之间可以有依赖。

注意事项：

View引用ViewModel，但反过来不行，因为如果VM跟V产生了耦合，不方便复用。即不要在viewModel中引入#import UIKit.h，任何视图本身的引用都不应该放在viewModel中 (注意：基本要求，必须满足)。

ViewModel可以引用Model，但反过来不行。

优点：
低耦合、可复用、数据流向清晰、而且兼容MVC，便于代码的移植、并且ViewModel可以拆出来独立开发、方便测试。
缺点：
类会增多、ViewModel会越来越庞大、调用复杂度增加、双向绑定数据会导致问题调试变得困难。
总结：

MVVM其实是MVC的变种。MVVM只是帮MVC中的Controller瘦身，把一些逻辑代码和网络请求分离出去。不让Controller处理更多的东西，不会变得臃肿，MVVM和MVC可以根据实际需求进行灵活选择。

MVVM 在使用当中，通常还会利用双向绑定技术，使得Model 变化时，ViewModel会自动更新，而ViewModel变化时，View 也会自动变化。OC中可以用RAC(ReactiveCocoa)函数响应式框架来实现响应式编程。

9. ReactiveCocoa的使用及优缺点

ReactiveCocoa简称RAC，是函数响应式编程框架，因为它具有函数式编程和响应式编程的特性。

由于该框架的编程思想，使得它具有相当魅惑人心的功能，它能实现传统设计模式和事件监听所能实现的功能，比如KVO、通知、block回调、action、协议等等，它的全面性并不是它最为优越的特色，RAC最值得炫耀的是它提供了统一的消息传递机制，这种机制使得它的代码更加的简洁，同一功能代码块更少，这正是符合了我们编程的思想：高聚合、低耦合，它非常适合MVVM设计模式的开发。

不过它也并不能完全取代传统的编码方式，在多人开发和代码维护方面，RAC还是有着一些让人头痛的问题。

优点：使用灵活方便、代码简洁、逻辑清晰
缺点：维护成本较高、问题溯源困难

使用：
RAC的统一消息传递机制，其所以动作都离不开信号(sigal)。
1). 信号的创建、发送、接收

// 创建  此时为冷信号，并不会被触发
RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {  
    // 发送信号  
    [subscriber sendNext:@"oh my god"];  
    // 回收资源。注意：手动创建一个signal一定要记得回收资源，不然程序会崩溃
    return [RACDisposable disposableWithBlock:^{  
        NSLog(@"信号发送完成");  
    }];  
}];  
// 订阅信号后才会变为热信号，可以被触发
[signal subscribeNext:^(id x) {  
    NSLog(@"singalContent:%@", x);  
}];

2). RAC的ControlEvents
这个方法可以简单的实现监听操作，并且逻辑在其后的block中处理，而且也能添加手势并进行监听。

[[self.textField rac_signalForControlEvents:UIControlEventEditingDidBegin] subscribeNext:^(id x) {  
    NSLog(@"%@", x);  
}];  

UITapGestureRecognizer *tap = [UITapGestureRecognizer new];  
[[tap rac_gestureSignal] subscribeNext:^(id x) {  
    NSLog(@"three:%@", x);  
}];  
[self.view addGestureRecognizer:tap];

3). RAC的KVO

[[self.textField rac_valuesAndChangesForKeyPath:@"text" options:NSKeyValueObservingOptionNew observer:self] subscribeNext:^(id x) {  
    NSLog(@"%@", x);  
}];

4). RAC的通知

[[[NSNotificationCenter defaultCenter] rac_addObserverForName:UIKeyboardDidShowNotification object:nil] subscribeNext:^(id x) {  
    NSLog(@"键盘弹起");  
}];

5). RAC的协议

- (void)viewDidLoad {  
    [super viewDidLoad];  
    // 代理  
    self.textField.delegate = self;  
    [[self rac_signalForSelector:@selector(textFieldDidBeginEditing:) fromProtocol:@protocol(UITextFieldDelegate)] subscribeNext:^(id x) {  
        NSLog(@"打印点击信息:%@", x);  
    }];  
}  
- (void)textFieldDidBeginEditing:(UITextField *)textField {  
    NSLog(@"开始编辑了");  
}

6). RAC遍历数组和字典
相当于枚举遍历，但是效率相比更高

NSArray *arr = @[@"1", @"2", @"3", @"4", @"5"];  
[arr.rac_sequence.signal subscribeNext:^(id x) {  
    NSLog(@"arr : %@", x);  
}];  
NSDictionary *dic = @{@"name":@"yangBo", @"age":@"19"};  
[dic.rac_sequence.signal subscribeNext:^(id x) {  
    NSLog(@"dic : %@", x);  
}];

7). RAC信号处理（map、filter、combine）
① 对信号不做处理

[[self.textField rac_textSignal] subscribeNext:^(id x) {  
    NSLog(@"doNothing:%@", x);  
}];

② 对信号进行过滤（filter）
可以对信号进行条件判断是否处理。

[[[self.textField rac_textSignal] filter:^BOOL(NSString* value) {
    if (value.length > 3) {
        return YES;
    }
    return NO;
}] subscribeNext:^(id x) {
    NSLog(@"filter:%@", x);
}];

③ 对信号进行映射（map）
映射也可以理解为转换，第一个block返回的是id类型，如果返回"map now"，就相当于信号转换，第二个block打印的值就是你return的值"map now"。

[[[self.textField rac_textSignal] map:^id(NSString* value) {
    if (value.length > 3) {
        return @"map now";
    }
    return value;
}] subscribeNext:^(id x) {
    NSLog(@"map:%@", x);
}];

④ 信号的联合（combine）

// 创建需要联合的信号
RACSignal *firstCombineSignal = [self.textField rac_textSignal];
RACSignal *secondeCombineSignal = [tap rac_gestureSignal];
// 信号联合处理返回self.label的背景色
RAC(self.label, backgroundColor) = [RACSignal combineLatest:@[firstCombineSignal, secondeCombineSignal] reduce:^id(NSString *text, UITapGestureRecognizer * tap){
    // 这里进行信号逻辑判断和处理
    if (text.length == 3 && tap.state == UIGestureRecognizerStateEnded) {
        return [UIColor redColor];
    }
    return [UIColor cyanColor];
}];

⑤ 信号关联

RAC(self.label, text) = [self.textField rac_textSignal];

10. 类的继承，类能否多继承，协议能不能做继承

OC的类不支持多继承只支持单继承。

协议可以实现多继承，遵循多个协议即可。

消息的转发也可以实现多继承，但并不建议，维护成本高。

继承和类别在实现中有何区别？

category 可以在不获悉、不改变原来代码的情况下往里面添加并且只能添加方法不能删除修改。如果类别和原来类中的方法产生名称冲突，则类别将覆盖原来的方法，因为类别具有更高的优先级。类别不会影响到其他类与原有类的关系。

类别主要有3个作用：
(1)将类的实现分散到多个不同文件或多个不同框架中。
(2)创建对私有方法的前向引用。
(3)向对象添加非正式协议。

继承可以增加，修改或者删除方法，并且可以增加属性。

11. 分类(category)和类扩展(extension)的区别

1). 分类实现原理

Category编译之后的底层结构是struct category_t，里面存储着分类的对象方法、类方法、属性、协议信息。在程序运行的时候，runtime会将Category的数据，合并到类信息中（类对象、元类对象中）。

2). Category和Extension的区别是什么？

类扩展可以为类添加私有变量和私有方法，在类的源文件中书写，不能被子类继承，类扩展在编译的时候，它的数据就已经包含在类信息中。
分类可以为类添加方法并且可以被子类继承，因为分类是运行时才会将数据合并到类信息中。但是分类不能直接添加属性，需要借助运行时关联对象。

3). 分类为啥不能添加成员变量?

struct _category_t {
    const char *name;
    struct _class_t *cls;
    const struct _method_list_t *instance_methods;
    const struct _method_list_t *class_methods;
    const struct _protocol_list_t *protocols;
    const struct _prop_list_t *properties;
};

从结构体可以知道，有属性列表，所以分类可以声明属性，但是分类只会生成该属性对应的get和set的声明，没有去实现该方法。
结构体没有成员变量列表，所以不能声明成员变量。

12. 如何实现week

weak：该属性定义了一种非拥有关系。为属性设置新值时，设置方法既不持有新值，也不释放旧值。

weak实现原理：

当一个对象被weak指针指向时，这个weak指针会以对象为key，存储到sideTable类的weak_table散列表上对应的一个weak指针数组里面。

当一个对象的dealloc方法被调用时，Runtime会以obj为key，从sideTable的weak_table散列表中，找出对应的weak指针列表，然后将里面的weak指针逐个置为nil。

key是weak指向的对象内存地址，value是所有指向该对象的weak指针表。

13. 字典注意事项：setvalue和setobject的区别

setObject:ForKey：是NSMutableDictionary特有的。

setValue:ForKey：是KVC的主要方法。

setobject中的key和value可以为nil以外的任何对象。

setValue中的key只能为字符串，value可以为nil也可以为空对象[NSNull null]以及全部对象

14. 多线程和锁

进程：是资源分配的基本单位，它是程序执行时的一个实例，在程序运行时创建。
线程：是程序执行的最小单位，是进程的一个执行流，一个进程由多个线程组成。
多线程：
一个进程中并发执行多个线程，叫做多线程。在一个时间片内，CPU只能处理一个线程中的一个任务，对于一个单核CPU来说，在不同的时间片来执行不同线程中的任务，就形成了多个任务在同时执行的“假象”。

多线程的几种方式：

pthread：即POSIX Thread，缩写称为pthread，是线程的POSIX标准，是一套通用的多线程API，可以在Unix/Linux/Windows等平台跨平台使用。iOS中基本不使用。

NSThread：苹果封装的面向对象的线程类，可以直接操作线程，比起GCD，NSThread效率更高，由程序员自行创建，当线程中的任务执行完毕后，线程会自动退出，程序员也可手动管理线程的生命周期。使用频率较低。

GCD：全称Grand Central Dispatch，由C语言实现，是苹果为多核并行运算提出的解决方案，CGD会自动利用更多的CPU内核，自动管理线程的生命周期，程序员只需要告诉GCD需要执行的任务，无需编写任何管理线程的代码。GCD也是iOS使用频率最高的多线程技术。

NSOperation：基于GCD封装的面向对象的多线程技术，常配合NSOperationQueue使用，使用频率较高。

GCD和NSOperation区别

GCD仅仅支持先进先出FIFO队列，不支持异步操作之间的依赖关系设置。而NSOperation中的队列可以被重新设置优先级，从而实现不同操作的执行顺序调整。

NSOperation支持KVO，可以观察任务的执行状态。

GCD更接近底层，GCD在追求性能的底层操作来说，是速度最快的。

从异步操作之间的事务性，顺序行，依赖关系。GCD需要自己写更多的代码来实现，而NSOperation已经内建了这些支持。

如果异步操作的过程需要更多的被交互和UI呈现出来，NSOperation更好。底层代码中，任务之间不太互相依赖，而需要更高的并发能力，GCD则更有优势。

线程池原理

使用线程执行任务的时候，需要到线程池中去取线程进行任务分配。

首先判断线程池大小是否小于核心线程池大小，如果小于的话，创建新的线程执行任务；

如果当前小城池大小大于了核心线程池大小，然后开始判断工作队列是否已满，如果没满，将任务提交到工作队列。

如果工作队列已满，判断线程池的线程是否都在工作，如果有空闲线程没有在工作，就交给它去执行任务。

如果线程池中的线程都在工作，那么就交给饱和策略去执行。

饱和策略分为下面四种：

AbortPolicy 直接抛出RejectedExecutionExeception 异常来阻止系统正常运行；

CallerRunsPolicy 将任务回退到调用者；

DisOldestPolicy 丢掉等待最久的任务‘；

DisCardPolicy 直接丢弃任务。

线程间通讯
直接同步或者异步向任务队列添加任务。
通过NSPort端口的形式进行发送消息，实现不同的线程间的通信。使用的时候注意需要将NSPort加入的线程的RunLoop中去。

直接消息传递：通过performSelector的一系列方法，可以实现由某一线程指定在另外的线程上执行任务。因为任务的执行上下文是目标线程，这种方式发送的消息将会自动的被序列化。

全局变量、共享内存块和对象：在两个线程之间传递信息的另一种简单方法是使用全局变量，共享对象或共享内存块。尽管共享变量既快速又简单，但是它们比直接消息传递更脆弱。必须使用锁或其他同步机制仔细保护共享变量，以确保代码的正确性。否则可能会导致竞争状况，数据损坏或崩溃。

条件执行：条件是一种同步工具，可用于控制线程何时执行代码的特定部分。您可以将条件视为关守，让线程仅在满足指定条件时运行。

Runloop sources：一个自定义的Runloop source配置可以让一个线程上收到特定的应用程序消息。由于Runloop source是事件驱动的，因此在无事可做时，线程会自动进入睡眠状态，从而提高了线程的效率。

Ports and sockets：基于端口的通信是在两个线程之间进行通信的一种更为复杂的方法，但它也是一种非常可靠的技术。更重要的是，端口和套接字可用于与外部实体（例如其他进程和服务）进行通信。为了提高效率，使用Runloop source来实现端口，因此当端口上没有数据等待时，线程将进入睡眠状态。

消息队列：传统的多处理服务定义了先进先出（FIFO）队列抽象，用于管理传入和传出数据。尽管消息队列既简单又方便，但是它们不如其他一些通信技术高效。

Cocoa 分布式对象：分布式对象是一种 Cocoa 技术，可提供基于端口的通信的高级实现。尽管可以将这种技术用于线程间通信，但是强烈建议不要这样做，因为它会产生大量开销。分布式对象更适合与其他进程进行通信，尽管在这些进程之间进行事务的开销也很高。

线程安全就是在同一时刻，对同一个数据操作的线程只有一个。这时就用到了锁。

锁：是保证线程安全的同步工具。每一个线程在访问数据资源之前，要先获取(acquire)锁，然后在访问结束之后释放(release)锁。如果锁已经被占用，其它要获取锁的线程会等待，直到锁重新可用。

iOS中的锁分为互斥锁、自旋锁、信号量这三种。
互斥锁：就是在多线程编程中，防止两条线程同时对同一公共资源(比如全局变量)进行读写。

@synchronized：是递归锁

调用synchronzied的每个对象，runtime都会为其分配一个递归锁并存储在哈希表中。

如果在synchronzied内部对象被释放或为nil，会执行类似objc_sync_nil的空方法。

注意不要像synchronzied传入nil , 这将会从代码中移走线程安全。

NSLock：遵循 NSLocking 协议，lock方法是加锁，unlock是解锁，tryLock是尝试加锁，如果失败的话返回 NO，lockBeforeDate: 是在指定Date之前尝试加锁，如果在指定时间之前都不能加锁，则返回NO。注意不能多次调用lock方法，会造成死锁。

自旋锁：线程会反复检查锁变量是否可用，线程在这一过程中保持执行，是一种忙等待，一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁，自旋锁避免了进程上下文的调度开销，因此对于线程只会阻塞很短时间的场合是有效的。atomic就是通过个set和get方法添加一个自旋锁。

信号量： dispatch_semaphore
使用：
1). 通过dispatch_semaphore_create(value)创建一个信号量，初始为1。

Runloop sources：一个自定义的Runloop source配置可以让一个线程上收到特定的应用程序消息。由于Runloop source是事件驱动的，因此在无事可做时，线程会自动进入睡眠状态，从而提高了线程的效率。
> - Ports and sockets：基于端口的通信是在两个线程之间进行通信的一种更为复杂的方法，但它也是一种非常可靠的技术。更重要的是，端口和套接字可用于与外部实体（例如其他进程和服务）进行通信。为了提高效率，使用Runloop source来实现端口，因此当端口上没有数据等待时，线程将进入睡眠状态。
> - 消息队列：传统的多处理服务定义了先进先出（FIFO）队列抽象，用于管理传入和传出数据。尽管消息队列既简单又方便，但是它们不如其他一些通信技术高效。
> - Cocoa 分布式对象：分布式对象是一种 Cocoa 技术，可提供基于端口的通信的高级实现。尽管可以将这种技术用于线程间通信，但是强烈建议不要这样做，因为它会产生大量开销。分布式对象更适合与其他进程进行通信，尽管在这些进程之间进行事务的开销也很高。

> 线程安全就是在同一时刻，对同一个数据操作的线程只有一个。这时就用到了锁。
> - 锁：是保证线程安全的同步工具。每一个线程在访问数据资源之前，要先获取(acquire)锁，然后在访问结束之后释放(release)锁。如果锁已经被占用，其它要获取锁的线程会等待，直到锁重新可用。
>> - iOS中的锁分为互斥锁、自旋锁、信号量这三种。
>> 互斥锁：就是在多线程编程中，防止两条线程同时对同一公共资源(比如全局变量)进行读写。
>>
>> @synchronized：是递归锁
>> - 调用synchronzied的每个对象，runtime都会为其分配一个递归锁并存储在哈希表中。
>> - 如果在synchronzied内部对象被释放或为nil，会执行类似objc_sync_nil的空方法。
>> - 注意不要像synchronzied传入nil , 这将会从代码中移走线程安全。
>>
>> NSLock：遵循 NSLocking 协议，lock方法是加锁，unlock是解锁，tryLock是尝试加锁，如果失败的话返回 NO，lockBeforeDate: 是在指定Date之前尝试加锁，如果在指定时间之前都不能加锁，则返回NO。注意不能多次调用lock方法，会造成死锁。
>>
>> 自旋锁：线程会反复检查锁变量是否可用，线程在这一过程中保持执行，是一种忙等待，一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁，自旋锁避免了进程上下文的调度开销，因此对于线程只会阻塞很短时间的场合是有效的。atomic就是通过个set和get方法添加一个自旋锁。
>>
>> 信号量： dispatch_semaphore
>> 使用：
1). 通过dispatch_semaphore_create(value)创建一个信号量，初始为1。
2). 等待信号量dispatch_semaphore_wait，可以理解为lock加锁，会使信号量-1。
3). 发送信号量dispatch_semaphore_signal，可以理解为 unlock解锁，会使 signal 信号量+1。
互斥锁是 dispatch_semaphore在取值0/1时的特例。信号量可以有更多的取值空间，用来实现更加复杂的同步，而不仅仅是线程间互斥。

15. 通知，能不能跨线程

不能跨线程，在哪个线程发送的通知，就会在哪个线程接收。所以需要手动切换到主线程更新UI。

测试过程：发出通知的线程决定接收通知处理代码线程
主线程发通知 — 子线程监听通知：接收通知代码在主线程处理
子线程发通知 — 主线程监听通知：接收通知代码在子线程处理

16. 网络TCP协议，三次握手

网络相关面试题

TCP是传输控制协议，具有面向连接、可靠传输、点到点通信、全双工服务等特点，TCP侧重可靠传输。
UDP是用户数据报协议，具有非连接的、不可靠的、点到多点的通信等特点，UDP侧重快速传输。

TCP/IP协议：TCP/IP不是一个协议，而是一个协议簇的统称。通常使用的网络是在TCP/IP协议簇的基础上运行的。应用层的HTTP、DNS、FTP，传输层的TCP(传输控制协议)、UDP(用户数据报协议)，网络层的IP等等都属于它内部的一个子集。

TCP报文重点字段：
序号：Seq序号，占32位，用来标识从TCP源端向目的端发送的字节流，发起方发送数据时对此进行标记。
确认序号：Ack序号，占32位，只有ACK标志位为1时，确认序号字段才有效，Ack=Seq+1。
标志位：共6个，即URG、ACK、PSH、RST、SYN、FIN等，具体含义如下：
（A）URG：紧急指针（urgent pointer）有效。
（B）ACK：确认序号有效。
（C）PSH：接收方应该尽快将这个报文交给应用层。
（D）RST：重置连接。
（E）SYN：发起一个新连接。
（F）FIN：释放一个连接。

TCP是面向连接的协议，建立连接需要经过三次握手：
1.首先客户端将标志位SYN置为1，然后随机产生一个序号seq=J，将数据包发送给服务端，客户端进入SYN_SENT状态，等待服务端确认。
2.服务器收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，确认序号ack=J+1，随机产生一个序号seq=K，并将该数据包发送给服务端确认连接请求，服务端进入SYN_RCVD状态。
3.客户端收到确认后，检查确认序号ack是否为J+1，标志位ACK是否为1，确认正确后将标志位ACK=1和确认序号ack=K+1数据包发送给服务端，服务端检查标志位ACK为1、确认序号ack=K+1成功后，客户端和服务端进入ESTABLISHED(建立连接)状态，完成三次握手，两端可以进行数据传输。

TCP断开连接需要经过四次挥手：
1.首先客户端向服务端发送释放连接的标志位 FIN，客户端进入FIN_WAIT_1状态，等待服务端确认。
2.服务端收到标志位FIN后发送确认标志位ACK给客户端，确认序号为收到序号+1(与SYN相同，一个FIN占用一个序号)，服务端进入CLOSE_WAIT状态。
3.服务端发送自己的释放连接的标志位 FIN。服务端进入LAST_ACK状态。
4.客户端收到标志位FIN后进入TIME_WAIT状态，然后发送一个确认标志位ACK给服务端，确认序号为收到序号+1，服务端进入CLOSED状态，完成四次挥手。

客户端进入TIME_WAIT状态而不是直接进入CLOSED状态是因为：我们必须要假想网络是不可靠的，你无法保证你最后发送的ACK报文一定会被对方收到，因此对方处于LAST_ACK状态下的SOCKET可能会因为超时未收到ACK报文，而重发FIN报文，所以这个TIME_WAIT状态的作用就是用来重发可能丢失的ACK报文。

为什么不能用两次握手进行连接？
因为三次握手是为了双方都知道彼此已做好准备，如果改成两次握手，会发生死锁。假设客户端给服务端发送连接请求，服务端收到后发送确认连接给客户端，如果两次握手的话此时服务端会认为已经建立了连接，可以发送数据了，但是如果确认连接数据丢失，客户端还不知道已经建立了连接，会一直等待确认连接序号，导致数据传输超时，服务端重复发送同样的数据，造成死锁。

为什么是四次挥手而不是三次？
因为TCP是全双工连接，关闭连接需要双向确认关闭才算是真正的关闭，否则未关闭一方仍可以继续发送数据。

17. HTTPS的加密原理

HTTPS是身披SSL外壳的HTTP，是一种通过计算机网络进行安全通信的传输协议，经由HTTP进行通信，利用SSL/TLS建立安全信道，加密数据包。

客户端向服务端发送请求https://baidu.com，然后连接到server的443端口

服务端本身是要有一套数字证书的，这套证书其实就是一对公钥和私钥
服务端必须要有一套数字证书，可以自己制作，也可以向组织申请。区别就是自己颁发的证书需要客户端验证通过，才可以继续访问，而使用受信任的公司申请的证书则不会弹出提示页面，这套证书其实就是一对公钥和私钥。

服务端把证书(公钥)传送给客户端
这个证书其实就是公钥，只是包含了很多信息，如证书的颁发机构，过期时间、服务端的公钥，第三方证书认证机构(CA)的签名，服务端的域名信息等内容。

客户端解析证书，验证无误后用证书加密一个随机生成的值(秘钥)
这部分工作是由客户端的TLS来完成的，首先会验证公钥是否有效，比如颁发机构，过期时间等等，如果发现异常，则会弹出一个警告框，提示证书存在问题。如果证书没有问题，那么就生成一个随机值（秘钥）。然后用证书对该随机值进行加密。

客户端传送加密后的秘钥给服务端
这部分传送的是用证书加密后的秘钥，目的就是让服务端得到这个秘钥，以后客户端和服务端的通信就可以通过这个随机值来进行加密解密了。

服务端用私钥解密随机值，然后通过该值对称加密信息
服务端用私钥解密秘钥，得到了客户端传过来的私钥，然后把内容通过该值进行对称加密。

再传输加密后的信息给客户端
这部分信息是服务端用私钥加密后的信息，可以在客户端被还原。

因为是对称加密，客户端可以解密信息
客户端用之前生成的私钥解密服务端传过来的信息，于是获取了解密后的内容。

HTTP和HTTPS的区别？

https协议需要到ca申请证书，一般免费证书很少，需要交费。

http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议。

http和https使用的是完全不同的连接方式用的端口也不一样，前者是80，后者是443。

http的连接很简单，是无状态的。

HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，要比http协议安全

18. WebSocket与TCP Socket的区别

Socket是抽象层，并不是一个协议，是为了方便使用TCP或UDP而抽象出来的一层，是位于应用层和传输层(TCP/UDP)之间的一组接口。

WebSocket和HTTP一样，都是应用层协议，是基于TCP 连接实现的双向通信协议，替代HTTP轮询的一种技术方案。是全双工通信协议，HTTP是单向的，注意WebSocket和Socket是完全不同的两个概念。

WebSocket建立连接时通过HTTP传输，但是建立之后，在真正传输时候是不需要HTTP协议的。

相对于传统 HTTP 每次请求-应答都需要客户端与服务端建立连接的模式，WebSocket 是类似 Socket 的 TCP 长连接的通讯模式，一旦 WebSocket 连接建立后，后续数据都以帧序列的形式传输。在客户端断开 WebSocket 连接或 Server 端断掉连接前，不需要客户端和服务端重新发起连接请求。在海量并发及客户端与服务器交互负载流量大的情况下，极大的节省了网络带宽资源的消耗，有明显的性能优势，且客户端发送和接受消息是在同一个持久连接上发起，实时性优势明显。

WebSocket连接过程 —— 握手过程
1.浏览器、服务器建立TCP连接，三次握手。这是通信的基础，传输控制层，若失败后续都不执行。
2.TCP连接成功后，浏览器通过HTTP协议向服务器传送WebSocket支持的版本号等信息。（开始前的HTTP握手）
3.服务器收到客户端的握手请求后，同样采用HTTP协议回馈数据。
4.当收到了连接成功的消息后，通过TCP通道进行传输通信。

Socket.IO 是一个为浏览器（客户端）和服务器之间提供实时，双向和基于事件的通信软件库。
Socket.IO 是把数据传输抽离成 Engine.IO，内部对轮询（Polling）和 WebSocket 等进行了封装，抹平一些细节和平台兼容的问题，提供统一的 API。
注意 Socket.IO 不是 WebSocket 的实现，只是在必要时使用 WebSocket 传输数据，并在此基础上会加一些 MetaData。这就是为什么 WebSocket 的客户端/服务器无法和 Socket.IO 的服务器/客户端进行通信。

19. 事件传递和响应机制

在iOS中只有继承了UIResponder的对象才能接受并处理事件。

事件传递：事件的传递是从上到下（父控件到子控件）

产生触摸事件A后，触摸事件会被添加到由UIApplication管理的事件队列中(首先接收到事件的是UIApplication)。

UIApplication会从事件队列中取出最前面的事件(此处假设为触摸事件A)，将事件对象由上往下传递(UIApplication->keyWindow->父控件->子控件)，查找最合适的控件处理事件

只要事件传递给控件，就会调用自身的hitTest:withEvent:方法，寻找能够响应事件最合适的view(其内部会调用pointInside:withEvent:判断触摸点是否在自己身上)。

响应机制：从下到上（顺着响应者链条向上传递：子控件到父控件)
当事件传递到某个控件，但是最终hitTest:withEvent:没有找到第一响应者，那么该事件会沿着响应者链向上回溯，如果UIWindow实例和UIApplication实例都不能处理该事件，则该事件会被丢弃。

响应者链条：在iOS程序中视图的摆放是有前后关系的，一个控件可以放到另一个控件上面或下面，那么用户点击某个控件时是触发上面的控件还是下面的控件呢，这种先后关系构成一个链条就叫响应者链。也可以说，响应者链是由多个响应者对象连接起来的链条。

如果父控件不能接受触摸事件，那么子控件就不可能接收到触摸事件

UIView有三种情况不能接收事件：

不接收用户交互：userInteractionEnabled = NO

隐藏：hidden = YES

透明：alpha<0.01

子视图在父视图之外区域点击是否有效？

无效(父视图的clipsToBounds=NO，这样超过父视图bound区域的子视图内容也会显示)，因为父视图的pointInside:withEvent:方法会返回NO，就不会向下遍历子视图了。**

但是可以通过重写pointInside:withEvent:来处理。

20. runloop

runloop：通过系统内部维护的循环进行事件/消息管理的一个对象。runloop实际上就是一个do...while循环，有任务时开始，无任务时休眠。
其本质是通过mach_msg()函数接收、发送消息。

RunLoop 与线程的关系：

RunLoop的作用就是来管理线程的，当线程的RunLoop开启后，线程就会在执行完任务后，处于休眠状态，随时等待接受新的任务，不会退出。

只有主线程的RunLoop是默认开启的，其他线程的RunLoop需要手动开启。所以当程序开启后，主线程会一直运行，不会退出。

runloop 事件循环机制内部流程

RunLoop主要涉及五个类：
CFRunLoop：RunLoop对象、
CFRunLoopMode：五种RunLoop运行模式、
CFRunLoopSource：输入源/事件源，包括Source0 和 Source1、
CFRunLoopTimer：定时源，就是NSTimer、
CFRunLoopObserver：观察者，用来监听RunLoop。

CFRunLoop：RunLoop对象

CFRunLoopMode：RunLoop运行模式，有五种：

kCFRunLoopDefaultMode：默认的运行模式，通常主线程是在这个 Mode 下运行的。

UITrackingRunLoopMode：界面跟踪 Mode，用于 ScrollView 追踪触摸滑动，保证界面滑动时不受其他 Mode 影响。

UIInitializationRunLoopMode：在刚启动 App 时第进入的第一个 Mode，启动完成后就不再使用。

GSEventReceiveRunLoopMode：接受系统事件的内部 Mode，通常用不到。

kCFRunLoopCommonModes：是一个伪模式，可以在标记为CommonModes的模式下运行，RunLoop会自动将_commonModeItems里的 Source、Observer、Timer 同步到具有此标记的Mode里。

CFRunLoopSource：输入源/事件源，包括Source0 和 Source1两种：

Source1：基于mach_Port，处理来自系统内核或其它进程的事件，比如点击手机屏幕。

Source0：非基于Port的处理事件，也就是应用层事件，需要手动标记为待处理和手动唤醒RunLoop。

简单举例：一个APP在前台静止，用户点击APP界面，屏幕表面的事件会先包装成Event告诉source1(mach_port)，source1唤醒RunLoop将事件Event分发给source0，由source0来处理。

CFRunLoopTimer：定时源，就是NSTimer。在预设的时间点唤醒RunLoop执行回调。因为它是基于RunLoop的，因此它不是实时的（就是NSTimer 是不准确的。因为RunLoop只负责分发源的消息。如果线程当前正在处理繁重的任务，就有可能导致Timer本次延时，或者少执行一次）。

CFRunLoopObserver：观察者，用来监听以下时间点：CFRunLoopActivity

kCFRunLoopEntry：RunLoop准备启动

kCFRunLoopBeforeTimers：RunLoop将要处理一些Timer相关事件

kCFRunLoopBeforeSources：RunLoop将要处理一些Source事件

kCFRunLoopBeforeWaiting：RunLoop将要进行休眠状态,即将由用户态切换到内核态

kCFRunLoopAfterWaiting：RunLoop被唤醒，即从内核态切换到用户态后

kCFRunLoopExit：RunLoop退出

kCFRunLoopAllActivities：监听所有状态

各数据结构之间的联系：

Runloop和线程是一对一的关系

Runloop和RunloopMode是一对多的关系

RunloopMode和RunloopSource是一对多的关系

RunloopMode和RunloopTimer是一对多的关系

RunloopMode和RunloopObserver是一对多的关系

为什么 main 函数能够保持一直存在且不退出？
在 main 函数内部会调用 UIApplicationMain 这样一个函数，而在UIApplicationMain内部会启动主线程的 runloop，可以做到有消息处理时，能够迅速从内核态到用户态的切换，立刻唤醒处理，而没有消息处理时通过用户态到内核态的切换进入等待状态，避免资源占用。因此 main 函数能够一直存在且不退出。

21. runtime

什么是runtime？
runtime 一套c、c++、汇编编写的API，为OC提供运行时功能。能够将数据类型的确定由编译期推迟到运行时。

问1：方法的本质，问2：runtime的消息机制
方法的本质其实就是发送消息。

发送消息主要流程：

快速查找：objc_msgSend查找cache_t缓存消息

慢速查找：递归自己和父类查找方法lookUpImpOrForward

查找不到消息，进行动态方法解析：resolveInstanceMethod

消息快速转发：forwardingTargetForSelector

消息慢速转发：消息签名methodSignatureForSelector和分发forwardInvocation

最终仍未找到消息：程序crash，报经典错误信息unrecognized selector sent to instance xxx

SEL是什么？IMP是什么？两者有什么联系？

SEL是方法编号，即方法名称，在dyld加载镜像时，通过read_image方法加载到内存的表中了。

IMP是函数实现指针，找IMP就是找函数的过程

两者的关系：sel相当于书本的目录标题，imp就是书本的页码。查找具体的函数就是想看这本书里面具体篇章的内容：

1). 我们首先知道想看什么，也就是title -> sel
2). 然后根据目录对应的页码 -> imp
3). 打开具体的内容 -> 方法的具体实现

runtime应用：

方法的交换：具体应用拦截系统自带的方法调用（Method Swizzling黑魔法）

实现给分类增加属性

实现字典的模型和自动转换

JSPatch替换已有的OC方法实行等

aspect 切面编程

能否向编译后得到的类中增加实例变量？能否向运行时创建的类中添加实例变量？为什么？

不能向编译后得到的类中增加实例变量。

可以向运行时创建的类中添加实例变量。

因为编译后的类已经注册在 runtime 中，类结构体中的 objc_ivar_list实例变量的链表和 instance_size 实例变量的内存大小已经确定，同时runtime会调用 class_setIvarLayout或class_setWeakIvarLayout来处理 strong、weak引用，所以不能向存在的类中添加实例变量。
运行时创建的类是可以添加实例变量，调用class_addIvar函数。但是得在调用objc_allocateClassPair之后，objc_registerClassPair之前，原因同上。

Category中添加属性和成员变量的区别

Category它的主要作用是在不改变原有类的前提下，动态地给这个类添加一些方法。

分类的结构体指针中，没有属性列表，只有方法列表。原则上它只能添加方法，不能添加属性(成员变量)，但是可以借助运行时关联对象objc_setAssociatedObject(self, @selector(name), name, OBJC_ASSOCIATION_COPY_NONATOMIC);、objc_getAssociatedObject(self,@selector(name));。

分类中的可以写@property，但不会生成setter/getter方法声明和实现，也不会生成私有的成员变量，会编译通过，但是引用变量会报错。

如果分类中有和原有类同名的方法，会优先调用分类中的方法，就是说会忽略原有类的方法，同名方法调用的优先级为分类 > 本类 > 父类，因为方法是放在方法栈中，遵循先进后出原则；

22. isa指针

isa是一个Class类型的指针，其源码结构为isa_t联合体，在类中以Class对象存在，指向类的地址，大小为8字节(64位)。

每个实例对象都有isa的指针指向对象的类。Class里也有个isa的指针指向meteClass(元类)。元类保存了类方法的列表。当类方法被调用时，先会从本身查找类方法的实现，如果没有，元类会向他父类查找该方法。元类（meteClass）也是类，它也是对象，也有isa指针。

isa的指向：对象的isa指向类，类的isa指向元类(meta class)，元类isa指向根元类，根元类的isa指向本身，形成了一个封闭的内循环。isa可以帮助一个对象找到它的方法。

isa指向图中类的继承关系：DZTeacher -> DZPerson -> NSObject -> nil。这里需要注意的是根元类的父类是NSObject，NSObject的父类是nil。

23. block

什么是Block
Block是将函数及其执行上下文封装起来的对象。

什么是Block调用
Block调用即是函数的调用。

Block的几种形式(类型)
Block有三种形式，包括：

全局Block(_NSConcreteGlobalBlock)：当我们声明一个block时，如果这个block没有捕获外部的变量，那么这个block就位于全局区(已初始化数据(.data)区)。

栈Block(_NSConcreteStackBlock)：

1). ARC环境下，当我们声明并且定义了一个block，系统默认使用__strong修饰符，如果该Block捕获了外部变量，实质上是从__NSStackBlock__转变到__NSMallocBlock__的过程，只不过是系统帮我们完成了copy操作，将栈区的block迁移到堆区，延长了Block的生命周期。对于栈block而言，变量作用域结束，空间被回收。
2). ARC的环境下，如果我们在声明一个block的时候，使用了__weak或者__unsafe__unretained的修饰符，那么系统就不会做copy的操作，也就不会将其迁移到堆区。

堆Block(_NSConcreteMallocBlock)：

1). 在MRC环境下，我们需要手动调用copy方法才可以将block迁移到堆区
2). 而在ARC环境下，__strong修饰的（默认）block只要捕获了外部变量就会位于堆区，NSMallocBlock支持retain、release，会对其引用计数＋1或 -1。

1). 不使用外部变量的block是全局block。
2). 使用外部变量并且未进行copy操作的block是栈block。
3). 对栈block进行copy操作，就是堆block。对堆Block进行copy，将会增加引用计数。对全局block进行copy，仍是全局block。

在什么场景下使用__block修饰符呢？
1). 对截获变量进行赋值操作需要添加__block修饰符（赋值 != 使用）。
2). 对局部变量（基本数据类型和对象类型）进行赋值需要__block修饰符。
其内部其实是对该__block对象进行拷贝，所以通过__block可以修改被截获变量的值且不会和外部变量互相影响。
3). 对静态局部变量、全局变量、静态全局变量不需要__block修饰符。

block 的截获变量特性？
基本数据类型的局部变量 Block 可以截获其值。
对于对象类型的局部变量连同所有权修饰符一起截获。
局部静态变量以指针的形式进行截获。
全局变量和静态全局变量，block 是不截获的。

weak打破Block循环引用原理
block内部操作的是weakSelf的指针地址，它和self是两个不同的指针地址，即没有直接持有self，所以可以weakSelf可以打破self的循环引用关系self -> block -> weakSelf。