OC的常见知识点01-六虎

一，OC方针实质(底层完成)

1.OC方针底层完成

OC里有两大基类，NSObject类和 NSProxy类，咱们熟知的绝大部分类都是承继自NSObject类。经过Clang语句能够将OC代码转换成C/C++代码

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp

会发现，OC方针的底层完成是一个结构体，结构体里有一个Class类型的isa指针，Class便是一个objc_class类型的结构体指针，objc_class又承继自objc_object结构体，而objc_object内部只要一个isa指针

如下:

struct NSObject_IMPL {
     Class isa; 
};
typedef struct objc_class *Class;
struct objc_class : objc_object {
  // Class ISA;
  Class superclass;
  cache_t cache;       
  class_data_bits_t bits;  
  class_rw_t *data() {
    return bits.data();
  }
}
struct objc_object {
  Class _Nonnull isa OBJC_ISA_AVAILABILITY;
};
所以objc_class结构体能够转化为如下:
struct objc_class {
  Class isa;
  Class superclass;
  cache_t cache;
  class_data_bits_t bits; 
  class_rw_t *data() {
    return bits.data();
  }
}

所以OC方针底层完成结构体里存放的信息有：

isa指针，是承继自objc_object的特点
superclass表示当时类的父类
cache 是办法缓存表。
bits是class_data_bits_t类型的特点,用来存放类的详细信息。(办法，特点，协议等等)

2. 两张表class_rw_t和class_ro_t的差异

在结构体class_rw_t中存放着

办法列表methods
特点列表properties
协议列表protocols。
一个class_ro_t类型的只读变量ro

class_ro_t中存放着类最原始的办法列表，特点列表等等，这些在编译期就现已生成了，并且它是只读的，在运转期无法修正。而class_rw_t不仅包括了编译器生成的办法列表、特点列表，还包括了运转时动态生成的办法和特点。它是可读可写的。

struct class_rw_t {
    // Be warned that Symbolication knows the layout of this structure.
    uint32_t flags;
    uint32_t version;
    const class_ro_t *ro;        //只读的特点ro
    method_array_t methods;      //办法列表
    property_array_t properties; //特点列表
    protocol_array_t protocols;  //协议列表
    Class firstSubclass;
    Class nextSiblingClass;
}
struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize;  //当时instance方针占用内存的巨细
    const uint8_t * ivarLayout;
    const char * name;              //类名
    method_list_t * baseMethodList; //根底的办法列表
    protocol_list_t * baseProtocols;//根底协议列表
    const ivar_list_t * ivars;      //成员变量列表
    const uint8_t * weakIvarLayout;
    property_list_t *baseProperties;//根本特点列表
}

3. 获取方针内存巨细的办法

sizeof

1，sizeof是一个操作符，不是函数。 2，咱们在用sizeof计算内存巨细时，一般传入的是数据类型，在编译阶段就能确认巨细而不是在运转时确认 3，sizeof最终得到的结果是该数据类型占用空间的巨细

例如，sizeof(int)为4，sizeof(long)为8 一个isa指针占用8个字节
class_getInstanceSize

是runtime供给的API,实质是获取类的实例方针中成员变量所占用的内存巨细，选用8字节对齐办法
malloc_size 体系给方针实践分配的内存巨细。选用16字节对齐办法。所以有的时分，实践分配的和实践占用的内存巨细并不持平。

经过源码可知：
关于一个方针来说，其真正的对齐办法是 8字节对齐，8字节对齐现已满足满足方针的需求了
apple体系为了避免一切的容错，选用的是16字节对齐的内存，首要是由于选用8字节对齐时，两个方针的内存会紧挨着，显得比较紧凑，而16字节比较宽松，利于苹果今后的扩展。 /post/694957…

4. OC方针的分类

1，

分为三大类:实例方针(instance)、类方针(class)、元类方针(meta class)

2，

实例方针存储的信息:

isa指针（指向它的类方针）
其他的成员变量的详细值

类方针存储的信息:

isa指针（指向它的mata-class方针）
superClass（指向它的父类的class方针）
特点信息（properties），存放着特点的名称，特点的类型等等，这些信息在内存中只需要存放一份
方针办法信息（methods）
协议信息（protocols）
成员变量描绘信息等等（ivars）

元类方针存储的信息:

isa指针（指向基类方针mata-class）
superClass（指向父类方针的mata-class）
类办法信息（class method)

经典图来啦。。

6. alloc、init、new源码剖析

1，alloc剖析:

经过对alloc源码的剖析，能够得知alloc的首要意图便是拓荒内存，并且拓荒的内存需要运用16字节对齐算法，现在拓荒的内存的巨细根本上都是16的整数倍
拓荒内存的核心进程有3步：计算 -- 请求 -- 相关

1)计算所需内存巨细 cls->instanceSize
2)请求内存，回来指向内存地址的指针 calloc
3)类与isa相相关 obj->initInstanceIsa

2，init剖析:

init是一个构造办法，首要用于给用户供给构造办法进口，初始化一些数据的，回来的是传入的self自身

3，new剖析:

初始化除了init，还能够运用new，两者实质上并没有什么差异，经过源码能够得知，new函数中直接调用了callAlloc函数（即alloc中剖析的函数），且调用了init函数，所以能够得出new 其实就等价于 [alloc init]的定论

5. 知道NSProxy吗？

/post/684790…

二，runtime原理

了解两个概念

1，编译时: 源代码翻译成机器代码能识别的进程，首要是对代码进行根本的检查错误，比方语法剖析等，假如有语法错误，则编译报错，是一个静态的进程

2，运转时: 代码成功跑起来后，被装载到内存里的进程，假如出错，则程序会溃散，是一个动态的进程

根底概念

Runtime被称为运转时。

1，OC是一门动态性比较强的语言，允许许多操作推迟到程序运转时再进行。

2，OC的动态性便是由runtime来支撑和完成的，runtime是由C和汇编完成的一套API, 封装了许多动态性相关的函数，平时编写的OC代码，底层都是转成了runtime API进行调用

在许多语言，比方 C ，调用一个办法其实便是跳到内存中的某一点并开端履行一段代码。没有任何动态的特性，由于这在编译时就抉择好了。而在 Objective-C 中，[object foo] 语法并不会当即履行 foo 这个办法的代码。它是在运转时给 object 发送一条叫 foo 的音讯。这个音讯，也许会由 object 来处理，也许会被转发给另一个方针，或许不予理睬假装没收到这个音讯。多条不同的音讯也能够对应同一个办法完成。这些都是在程序运转的时分抉择的。

OC办法的实质

OC方针的实质 是一个包括isa指针和其他信息的结构体
OC办法调用的实质 是objc_msgSend音讯发送
办法调用又涉及到办法在类中的查找流程，objc_msgSend可分为快速查找和慢速查找

音讯发送之快速查找

即缓存查找流程，走CacheLookup，也便是所谓的sel-imp快速查找流程

struct objc_object {
    Class _Nonnull isa __attribute__((deprecated)); //8字节
}
struct objc_class : objc_object {
    // Class ISA; //8字节
    Class superclass; //Class 类型 8字节
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags
    //....办法部分省掉，未贴出
}

1，isa首地址平移16字节(如上，由于在objc_class中，isa首地址占8字节，superclass占8字节，所以cache距离首地址16字节)，获取cache，cache(实质也是结构体类型，占8字节，即占64位)中高16位存mask,低48位存buckets，即p11 = cache

2，从cache中别离取出buckets和mask，并由mask依据哈希算法计算出存储sel-imp的bucket下标index

3，依据所得的哈希下标index和buckets首地址，取出哈希下标对应的bucket

4，依据获取的bucket,取出其中的imp存入p17，即p17 = imp, 取出sel存入p9，即p9 = sel

5，递归循环，比较获取的bucket中的sel与objc_msgSend的第二个参数的_cmd是否持平，假如持平，则直接跳转至CacheHit,即缓存射中，回来imp；假如不持平，1）假如一直都查找不到，会跳转至__objc_msgSend_uncached,即进入慢速查找流程。2）

弥补个小常识: 二进制位左移和右移左移(<<)是将一个二进制位的操作数按指定移动的位数向左移动，移出位被丢掉，右边移出的空位一概补0。右移(>>)是将一个二进制位的操作数按指定移动的位数向右移动，移出位被丢掉，左边移出的空位一概补0，或许补符号位，这由不同的机器而定。在运用补码作为机器数的机器中，正数的符号位为0，负数的符号位为1。

到此，咱们对objc_msgSend(reciver,_cmd)到找到imp做一个简单总结：

class位移16位得到cache_t;
cache_t与上mask掩码得到mask地址，
cache_t与上bucket掩码得到bucket地址；
mask与上sel得到sel-imp下标index，
经过bucket地址内存平移，能够得到第index方位的bucket;
bucket里边有sel、imp;然后拿bucket里的sel和msg_msgSend的_cmd参数进行比较是否持平；
假如持平就履行cacheHit,cacheHit里边做的便是拿到sel对应的imp，然后进行imp^Class，得到真正的imp地址，最终调用imp函数。
假如不持平，就拿到bucket进行- – （减减）平移，找到下一个bucket进行比较，假如找到了就进入7，否则就持续缓存查找。假如一直找不到，就进入__objc_msgSend_uncached慢速查找函数。
慢速查找流程：lookUpImpOrForward二分法查找imp，找到了就写入缓存；
当时类找遍了没有，就进入递归循环：

再从父类开端，快速查找、慢速查找。仍是没找到，就从父类的父类开端循环这一步;
递归结束条件是class为空，然后给imp一个默认值。

音讯发送之慢速查找

再次从缓存查找一次
假如缓存仍是没找到，去类方针的办法表里查找办法，假如找到，就保存到缓存，并履行这个办法。
假如类方针办法表里也没找到，就先去父类的缓存表里找，假如缓存表也没找到，就取找父类的办法表，假如找到，相同缓存办法到缓存，假如仍是没找到，持续往上一层父类查找。
以此类推，直到找到基类，即NSObject类的办法表。
到了基类仍是没找到，那么就先判别自己是不是元类，不是元类的话调用resolveInstanceMethod办法；是元类的话，先调用resolveClassMethod办法，假如也没找到就调用resolveInstanceMethod办法，去元类的方针办法中查找，由于类办法在元类中是实例办法。
假如resolveInstanceMethod办法或许resolveClassMethod办法也没被调用，开启转发流程。
先调用forwardingTargetForSelector，假如这个办法回来nil，持续调用methodSignatureForSelector，假如回来不为空持续调用forwardInvocation；假如仍是为空，调用doesNotRecognizeSelector，则闪退报错

Runtime之音讯转发

Runtime的详细应用

1).运用相关方针AssociatedObject给分类增加特点

//相关方针 
void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy) 
//获取相关的方针 
id objc_getAssociatedObject(id object, const void *key) 
//移除相关的方针 
void objc_removeAssociatedObjects(id object)
eg.
1)分类里增加特点
@interface LLPerson (Test)
@property (nonatomic, copy) NSString *className;
@end
2)重写get/set办法
@implementation LLPerson (Test)
- (void)setClassName:(NSString *)className {
  objc_setAssociatedObject(self, @selector(className), className, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
- (NSString *)className {
  return objc_getAssociatedObject(self, _cmd);
}
@end

留意

相关方针并不是存储在被相关方针自身内存中
相关方针存储在大局的统一的一个AssociationsManager中
设置相关方针为nil，就适当所以移除相关方针
当object方针被开释，相关方针的值也会对应的从内存中移除（内存办理主动做了处理）

2).运用音讯转发机制解决办法找不到的反常问题(动态办法抉择->办法转发)

/*** a,动态办法解析 **/
//a1,假如是类办法，应完成 +(BOOL)resolveClassMethod:(SEL)sel)
+ (BOOL)resolveInstanceMethod:(SEL)sel {
  if (sel == @selector(test)) {
    Method method = class_getInstanceMethod(self, NSSelectorFromString(@"test2"));
    if (method_getImplementation(method)) {
            //增加办法
      class_addMethod(self, sel, method_getImplementation(method), method_getTypeEncoding(method));
      return YES;
    }
  }
  return [super resolveInstanceMethod:sel];
}
/*** b,音讯快速转发 **/
//b1,假如上面的办法resolveInstanceMethod没完成，或许即使完成，但没增加新的办法以及其完成，不论回来YES仍是NO,都会调用下面forwardingTargetForSelector:办法
//b2,假如是类办法，记住是完成+(id)forwardingTargetForSelector:(SEL)aSelector
- (id)forwardingTargetForSelector:(SEL)aSelector {
  if (aSelector == @selector(test)) {
    return [[LLStudent alloc] init];//会去调用LLStudent的方针办法test
  }
  return [super forwardingTargetForSelector:aSelector];
}
/*** c,音讯慢速转发 **/
//c1,假如上面的forwardingTargetForSelector也没完成，或许完成了，但回来nil,就会走到下面两个办法，进行音讯慢速转发
//c2,假如是类办法，记住是完成对应的+办法
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
  if (aSelector == @selector(test)) {
    return [NSMethodSignature signatureWithObjCTypes:"v@:"];
  }
  return [super methodSignatureForSelector:aSelector];
}
- (void)forwardInvocation:(NSInvocation *)anInvocation {
    //会去调用LLStudent的方针办法test
  [anInvocation invokeWithTarget:[[LLStudent alloc] init]];
}

假如上面-methodSignatureForSelector:回来nil ，Runtime则会宣布 -doesNotRecognizeSelector: 音讯，程序这时也就挂掉了。假如回来了一个函数签名，Runtime就会创立一个NSInvocation 方针并发送 -forwardInvocation:音讯给方针方针。

3).交换办法完成

+ (void)load {
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    Class class = [self class];
    SEL originalSelector = @selector(personTestInstance);
    SEL swizzledSelector = @selector(personTestInstance1);
    Method originalMethod = class_getInstanceMethod(class, originalSelector);
    Method swizzledMethod = class_getInstanceMethod(class, swizzledSelector);
        //增加办法：旧办法的SEL--新办法的完成IMP--新办法的encoding
    BOOL didAddMethod = class_addMethod(class, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
    if (didAddMethod) {
           //假如增加成功，则替换办法：新办法的SEL--旧办法的完成IMP--旧办法的encoding
      class_replaceMethod(class, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
    } else {
            //否则，交换办法
      method_exchangeImplementations(originalMethod, swizzledMethod);
    }
  });
}

4).KVO的完成

- (void)viewDidLoad {
    [super viewDidLoad];    
    _person = [Person alloc];
    [_person addObserver:self forKeyPath:@"nickName" options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld context:nil];
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    _person.nickName = @"嘻嘻";
}
// 呼应办法
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context{
    NSLog(@"%@ - %@ - %@",keyPath,object,change);
}
// 移除调查者
- (void)dealloc{
    [_person removeObserver:self forKeyPath:@"nickName"];
}

即键值调查。供给了一种当其它方针特点(留意是只针对特点，成员变量没用)被修正的时分能通知当时方针的机制。在MVC大行其道的Cocoa中，KVO机制很合适完成model和controller类之间的通讯。

KVO的完成依赖于 Objective-C 强大的 Runtime，当调查某方针 A 时，KVO 机制动态创立一个方针A当时类的子类，并为这个新的子类重写了被调查特点 keyPath 的 setter 办法。setter 办法随后担任通知调查方针特点的改变状况。

Apple 运用了 isa-swizzling 来完成 KVO 。
当调查方针A时，KVO机制动态创立一个新的名为：NSKVONotifying_A的中心类，该类是A类的子类，方针A的 isa,由原有类更改为指向中心类
中心类重写了被调查特点的setter 办法、class、dealloc、_isKVO办法
dealloc 办法中，移除 KVO 调查者之后，实例方针 isa指向由中心类改为原有类
中心类在移除调查者后也并不会被毁掉

5).完成NSCoding的主动归档宽和档用途:数据耐久化原理描绘：用runtime供给的函数遍历Model自身一切特点，并对特点进行encode和decode操作。核心办法：在Model的基类中重写办法：

- (id)initWithCoder:(NSCoder *)aDecoder {
  if (self = [super init]) {
    unsigned int outCount;
    Ivar * ivars = class_copyIvarList([self class], &outCount);
    for (int i = 0; i < outCount; i ++) {
      Ivar ivar = ivars[i];
      NSString * key = [NSString stringWithUTF8String:ivar_getName(ivar)];
      [self setValue:[aDecoder decodeObjectForKey:key] forKey:key];
    }
  }
  return self;
}
- (void)encodeWithCoder:(NSCoder *)aCoder {
  unsigned int outCount;
  Ivar * ivars = class_copyIvarList([self class], &outCount);
  for (int i = 0; i < outCount; i ++) {
    Ivar ivar = ivars[i];
    NSString * key = [NSString stringWithUTF8String:ivar_getName(ivar)];
    [aCoder encodeObject:[self valueForKey:key] forKey:key];
  }
}

6).完成字典转模型(项目里用到的YYKit里的YYModel)、修正textfield占位文字颜色等(遍历类的一切成员变量进行动态修正)

三，分类category

// 界说在objc-runtime-new.h文件中
  struct category_t {
    const char *name; // 比方给Student增加分类，name便是Student的类名
    classref_t cls;
    struct method_list_t *instanceMethods; // 分类的实例办法列表
    struct method_list_t *classMethods; // 分类的类办法列表
    struct protocol_list_t *protocols; // 分类的协议列表
    struct property_list_t *instanceProperties; // 分类的实例特点列表
    struct property_list_t *_classProperties; // 分类的类特点列表
  };

好处： 1，减少单个文件的体积 2，能够把不同的功用组织到不同的category里 3，按需加载想要的category等等

底层原理:

1，Category编译之后的底层结构其实是一个category_t类型的结构体，里边存储着分类的方针办法，类办法，特点，协议等信息

2，在编译阶段分类的相关信息和现有类的相关信息是分开的，比及运转阶段，体系就会经过runtime加载现有类的一切category数据，把一切category的办法，特点，协议数据别离兼并到一个数组中，然后将兼并后的数据插入到现有类数据的前面。

3，(以新增办法为例),兼并后分类的办法在前面(不同分类的相同办法，最终参与编译的那个分类的办法列表在最前面)，本类的办法列表在最终面。所以当分类中有和本类同名的办法时，调用的实践上是分类中的办法。从这个现象来看，好像是本类的办法被分类中同名的办法覆盖了，实践上并不是，仅仅调用办法时最早查找到了分类的办法所以就履行分类的办法。

4，分类能够增加特点，但不能增加成员变量，界说成员变量的话编译器会直接报错。

1）从category_t结构体里存储的信息就能够看出，并没有界说存储成员变量的列表 2）假如咱们在Person的分类中界说一个特点@property (nonatomic , strong) NSString *name;，编译器只会帮咱们声明- (void)setName:(NSString *)name;和- (NSString *)name;这两个办法，而不会完成这两个办法，也不会界说成员变量。所以此刻假如咱们在外面给一个实例方针设置name特点值peron.name = @"Jack"，编译器并不会报错，由于setter办法是有声明的，可是一旦程序运转，就会抛出unrecognized selector的反常，由于setter办法没有完成。

5，类扩展Extension和分类Category的完成是一样的吗？不一样。类扩展仅仅将.h文件中的声明放到.m中作为私有来运用，编译时就现已兼并到该类中了。分类中的声明都是揭露的，并且是运用runtime机制在程序运转时将分类里的数据兼并到类中

6, +load办法和 +initialize办法差异

initialize是经过objc_msgSend进行调用的，而load是找到函数地址直接调用的
假如子类没有完成initialize，会调用父类的initialize
- 所以父类的initialize或许会被调用屡次，榜首次是体系经过音讯发送机制调用的父类initialize，后边屡次的调用都是由于子类没有完成initialize，而经过superclass找到父类再次调用的
假如分类完成了initialize，就覆盖类自身的initialize调用

四，Block底层原理

办法一,typedef声明

typedef void(^LLBlockA)(void);
typedef int(^LLBlockB)(int i,int j);
@property (nonatomic, copy) LLBlockA block;
@property (nonatomic, copy) LLBlockB blockB;
self.blockB = ^int(int i, int j) {
    NSLog(@"test1:age--%ld",self.age);
    return i+j;
};
 NSLog(@"block1-------%d",self.blockB(10, 35));

办法二

- (void)testBlockA {
  void(^blockA)(void) = ^ {
    NSLog(@"testBlockA");
  };
  //无参无回来值，大局block <__NSGlobalBlock__: 0x100004278>
  NSLog(@"blockA--%@",blockA);
}
- (void)testBlockB {
  int a = 10;
  void(^blockB)(void) = ^ {
    NSLog(@"testBlockB--%d",a);
  };
  //访问了外部变量，堆区block <__NSMallocBlock__: 0x10722ceb0>
  NSLog(@"blockB--%@",blockB);
}
- (void)testBlockC {
  int a = 10;
  void(^__weak blockC)(void) = ^ {
    NSLog(@"testBlockC--%d",a);
  };
  //运用了__weak修饰，变成了栈区block <__NSStackBlock__: 0x7ff7bfeff1e8>
  NSLog(@"blockC--%@",blockC);
}

1，block类型

大局block __NSGlobalBlock__，block直接存储在大局区,无参无回来值
堆区block __NSMallocBlock__ ，假如此刻的block是强引证，并且访问了外部变量
栈区block __NSStackBlock__ ，假如此刻的block是弱引证，运用了__weak修饰，并且访问了外部变量

2，block循环引证

正常开释：是指A持有B的引证，当A调用dealloc办法，给B发送release信号，B收到release信号，假如此刻B的retainCount（即引证计数）为0时，则调用B的dealloc办法
循环引证：A、B彼此持有，所以导致A无法调用dealloc办法给B发送release信号，而B也无法接纳到release信号。所以A、B此刻都无法开释

//代码一
[UIView animateWithDuration:0.5 animations:^{
    NSLog(@"%@",self.name);
} completion:nil];
//代码二
NSString *name = @"zhangsan";
self.block = ^(void){
    NSLog(@"%@",self.name);
};
 self.block();

以上代码会产生循环引证吗？答案是代码一不会，代码二会。

代码一虽然也运用了外部变量，可是self并没有持有animation的block，仅仅只要animation持有self，所以不构成彼此持有

代码二 self持有了block, block完成体里又运用了self的特点，经过编译后底层代码得知，block持有了self，那么self和block就彼此持有,就会产生循环引证

3，解决循环引证

五，事情传递及呼应链机制

1. 呼应者(UIResponder)

iOS里并不是一切方针都能接纳和处理事情，在UIKit中咱们运用呼应者方针(Responder)接纳和处理事情。一个呼应者方针一般是UIResponder类的实例或许承继UIResponder类，例如 UIView，UIViewController，UIApplication，AppDelagate等都承继自UIResponder，意味咱们日常运用的控件简直都是呼应者。

2. 事情(UIEvent)

事情分为许多种，比方UITouch接触事情、UIPress、加快计、远程操控事情等，UIResponder都能够处理这些事情，本篇仅讨论UITouch接触事情，即手指接触屏幕产生的UITouch方针。

在 UITouch 内，存储了大量接触相关的数据，当手指在屏幕上移动时，所对应的 UITouch 数据也会更新，例如：这个接触是在哪个 window 或许哪个 view 内产生的？当时接触点的坐标是？前一个接触点的坐标是？当时接触事情的状况是？这些都存储在 UITouch 里边。

3. 事情传递链

当接触产生后，从后向前，从里向外，UIApplication 会触发 sendEvent办法将一个封装好的 UIEvent 传给 UIWindow，也便是当时展现的 UIWindow，通常状况接下来会传给当时展现的 UIViewController，接下来传给 UIViewController 的根视图，顺次往前将接触事情传递下去。即

a. ---> UIApplication -> UIWindow -> UIViewController -> UIViewController的view -> 子view -> ... 或许

b. ---> UIApplication -> UIWindow -> UIWindow的rootView -> 子view -> ...

留意: 不止UIView能够呼应事情，只要是UIResponse的子类，都能够呼应和传递事情

4. 确认榜首呼应者

UIKit供给了射中测验(hit-test)来确认接触事情的榜首呼应者。如下图

留意事项:

1). 在进程1里，以下3种状况出现任意的一种，都无法接纳事情

view.isHidden = true
view.isUserInteractionEnabled = false
view.alpha <= 0.01

2). 检查接触点坐标是否在当时视图内部运用了- (BOOL)pointInside:(CGPoint)point withEvent:(nullable UIEvent *)event办法，可被重写

3). 假如当时视图有若干个子视图，要依据FILO原则，后增加的先遍历

以下为hitTest的内部判别逻辑

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
    //3种状况无法接纳事情
    if (self.userInteractionEnabled == NO || self.hidden == YES || self.alpha <= 0.01) {
        return nil;
    }
    if ([self pointInside:point withEvent:event] == NO) {
        //接触点不在当时视图内部
        return nil;
    }
    NSInteger count = self.subviews.count;
    //FILO 后增加的先遍历
    for (NSInteger i = count -1; i >= 0; i--) {
        UIView *subview = self.subviews[i];
        //坐标转换————把 接触点 在当时视图上的坐标方位转换为在子视图上的坐标方位
        CGPoint subviewP = [self convertPoint:point toView:subview];
        //或许 CGPoint subviewP = [subview convertPoint:point fromView:self];
        //寻觅子视图中的榜首呼应者视图
        UIView *resultView = [subview hitTest:subviewP withEvent:event];
        //接触点是否在子视图内部，在就回来子视图
        if (resultView) {
            return resultView;
        }
    }
    //当时视图的一切子视图都不符合要求，而接触点又在该视图自身内部，所以回来当时视图
    return self;
}

因此hitTest的效果有两个：

一是用来询问事情在当时视图中的呼应者，回来的是最终呼应这个的事情的呼应者方针；

二是事情传递的一个桥梁；

举个栗子如下:

整个射中测验的走向是这样的： A✅ --> D❎ --> B✅ --> C❎ >>>> B,所以B是接触事情榜首呼应者

5. 事情呼应链

确认了榜首呼应者之后，整个呼应链也随着确认下来了。所谓呼应链是由呼应者组成的一个链表，链表的头是榜首呼应者，链表的每个结点的下一个结点都是该结点的 next 特点。

以上呼应链便是：B -> A ->UIViewController的根视图 -> UIViewController方针 -> UIWindow方针 -> UIApplication方针 -> App Delegate. 或许 B -> A -> UIWindow方针 -> UIApplication方针 -> App Delegate

事情依照呼应链顺次呼应，触发touchesBegan等办法。若榜首呼应者在这个办法中不处理这个事情，则会传递给呼应链中的下一个呼应者触发该办法处理，若下一个也不处理，则以此类推传递下去。若到最终还没有人呼应，则会被丢掉（比方一个误触）。

总结：

接触屏暗地事情的传递能够分为以下几个进程：

1). 经过「射中测验」来找到「榜首呼应者」

2). 由「榜首呼应者」来确认「呼应链」

3). 事情沿「呼应链」呼应

4). 若「呼应链」上的呼应者不处理该事情，则传递给下一个呼应者，若下一个也不处理，则以此类推传递下去。若到最终还没有人呼应，则该事情会被丢掉

还有多线程，内存办理，性能优化，离屏渲染等常识收拾未完待续…

OC的常见知识点01

一，OC方针实质(底层完成)

二，runtime原理

根底概念

OC办法的实质

音讯发送之快速查找

音讯发送之慢速查找

三，分类category

四，Block底层原理

五，事情传递及呼应链机制

作者信息

推广

OC的常见知识点01

一，OC方针实质(底层完成)

二，runtime原理

根底概念

OC办法的实质

音讯发送之快速查找

音讯发送之慢速查找

三，分类category

四，Block底层原理

五，事情传递及呼应链机制

相关文章

测试平台系列(92) HTTP请求支持文件上传相关接口

Flutter 开发出现的那些 Bugs 和解决方案「持续更新… 」

移植micropython的最小工程到lpc5500微控制器（2） – 调整内存分配

说说苹果 App Store 将下架长期不更新的App一事

作者信息

推广