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底层原理

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

相关文章

奇思妙想：在Compose中跳转Fragment

学习Python中的 Lambda函数

Flutter学习 – Bloc – 06 列表刷新与加载

🔥 小册上新 | Web 动画之旅

作者信息