参考截图：
1、聊天页面

2、会话列表

Fastlane是一套使用Ruby写的自动化工具集，旨在简化Android和iOS的部署过程，自动化你的工作流。它可以简化一些乏味、单调、重复的工作，像截图、代码签名以及发布App

Github

官网

文档

我认为我们在选择一些三方开源库或是工具的前提是：可以满足我们当下的需求并且提供好的扩展性， 无疑对我而言Fastlane做到了。我当前项目的需求主要是下面几方面：

1.一行命令实现打包工作，不需要时时等待操作下一步，节省打包的时间去做其他的事。

2.避免频繁修改配置导致可能出现的Release/Debug环境错误，如果没有检查机制，那将是灾难，即使有检查机制，我们也不得不重新打包，浪费了一次打包时间。毕竟人始终没有程序可靠，可以告别便利贴了。

3.通过配置自动上传到蒲公英,fir.im内测平台进行测试分发，也可以直接上传到TestFlight，iTunes Connect

4.证书的同步更新，管理，在新电脑能够迅速具备项目打包环境。

如果你也有上述需求，那我相信Fastlane是一个好的选择。

多说无益，开始上手

[20:48:55]: Please enter your Apple ID developer credentials

[20:48:55]: Apple ID Username:

desc "打包到pgy"
lane :test do |options|
gym(
  clean:true, #打包前clean项目
  export_method: "ad-hoc", #导出方式
  scheme:"shangshaban", #scheme
  configuration: "Debug",#环境
  output_directory:"./app",#ipa的存放目录
  output_name:get_build_number()#输出ipa的文件名为当前的build号
  )
#蒲公英的配置 替换为自己的api_key和user_key
pgyer(api_key: "xxxxxxx", user_key: "xxxxxx",update_description: options[:desc])
end

fastlane test desc:测试打包

一.OC对象的内存管理机制?

在iOS中，使用引用计数来管理OC对象的内存

一个新创建的OC对象引用计数默认是1，当引用计数减为0，OC对象就会销毁，释放其占用的内存空间
调用retain会让OC对象的引用计数+1，调用release会让OC对象的引用计数-1
内存管理的经验总结

当调用alloc、new、copy、mutableCopy方法返回了一个对象，在不需要这个对象时，要调用release或者autorelease来释放它
想拥有某个对象，就让它的引用计数+1；不想再拥有某个对象，就让它的引用计数-1
可以通过以下私有函数来查看自动释放池的情况

extern void _objc_autoreleasePoolPrint(void);

二.内存区域分布

在iOS开发过程中，为了合理的分配有限的内存空间，将内存区域分为五个区，由低地址向高地址分类分别是：代码区、常量区、全局静态区、堆、栈。

代码段 -- 程序编译产生的二进制的数据
常量区 -- 存储常量数据，通常程序结束后由系统自动释放
全局静态区 -- 全局区又可分为未初始化全局区：.bss段和初始化全局区：data段。全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域，在程序结束后有系统释放。
堆（heap) -- 程序运行过程中,动态分配的内存
栈（stack） -- 存放局部变量，临时变量

三.堆区和栈取的区别

按管理方式分

对于栈来讲，是由系统编译器自动管理，不需要程序员手动管理
对于堆来讲，释放工作由程序员手动管理，不及时回收容易产生内存泄露
按分配方式分

堆是动态分配和回收内存的，没有静态分配的堆
栈有两种分配方式：静态分配和动态分配
静态分配是系统编译器完成的，比如局部变量的分配
动态分配是有alloc函数进行分配的，但是栈的动态分配和堆是不同的，它的动 态分配也由系统编译器进行释放，不需要程序员手动管理

四.怎么保证多人开发进行内存泄露的检查

1.使用Analyze进行代码的静态分析
2.使用leaks 进行内存泄漏检测
3.使用一些三方工具(DoraemonKit/WithMLeaksFinder)

五.内存泄漏可能会出现的几种原因？

第一种可能：第三方框架不当使用；
第二种可能：block循环引用；
第三种可能：delegate循环引用；
第四种可能：NSTimer循环引用
第五种可能：非OC对象内存处理
第六种可能：地图类处理
第七种可能：大次数循环内存暴涨

六.什么是Tagged Pointer?

1.从64bit开始，iOS引入了Tagged Pointer技术，用于优化NSNumber、NSDate、NSString等小对象的存储
在没有使用Tagged Pointer之前， NSNumber等对象需要动态分配内存、维护引用计数等，NSNumber指针存储的是堆中NSNumber对象的地址值
2.使用Tagged Pointer之后，NSNumber指针里面存储的数据变成了：Tag + Data，也就是将数据直接存储在了指针中
3.当指针不够存储数据时，才会使用动态分配内存的方式来存储数据

七.copy和mutableCopy区别

八.AutoreleasePoolPage的结构?以及如何 push 和 pop 的

AutoreleasePool(自动释放池)其实并没有自身的结构,他是基于多个AutoreleasePoolPage(一个C++类)以双向链表组合起来的结构; 可以通过 push操作添加对象,pod 操作弹出对象,以及通过 release 操作释放对象;

调用push方法会将一个POOL_BOUNDARY入栈，并且返回其存放的内存地址

调用pop方法时传入一个POOL_BOUNDARY的内存地址，会从最后一个入栈的对象开始发送release消息，直到遇到这个POOL_BOUNDARY

id *next指向了下一个能存放autorelease对象地址的区域

九.Autoreleasepool 与 Runloop 的关系

主线程默认为我们开启 Runloop，Runloop 会自动帮我们创建Autoreleasepool，并进行Push、Pop 等操作来进行内存管理
iOS在主线程的Runloop中注册了2个Observer

第1个Observer监听了kCFRunLoopEntry事件，会调用objc_autoreleasePoolPush()
第2个Observer 监听了kCFRunLoopBeforeWaiting事件，会调用objc_autoreleasePoolPop()、objc_autoreleasePoolPush()监听了kCFRunLoopBeforeExit事件，会调用objc_autoreleasePoolPop()

十.什么是多线程?

多线程是指实现多个线程并发执行的技术,进而提升整体处理性能。

同一时间,CPU 只能处理一条线程,多线程并发执行,其实是 CPU 快速的在多条线程之间调度(切换)如果 CPU 调度线程的时间足够快, 就造成了多线程并发执行的假象

主线程的栈区 空间大小为1M,非常非常宝贵

子线程的栈区 空间大小为512K内存空间

优势
充分发挥多核处理器的优势，将不同线程任务分配给不同的处理器，真正进入“并行计算”状态

弊端
新线程会消耗内存控件和cpu时间，线程太多会降低系统运行性能。

十一.iOS的多线程方案有哪几种？

十二,讲一下GCD

GCD(Grand Central Dispatch), 又叫做大中央调度, 它对线程操作进行了封装,加入了很多新的特性,内部进行了效率优化,提供了简洁的C语言接口, 使用更加高效,也是苹果推荐的使用方式.

GCD 的队列

1.并发队列（Concurrent Dispatch Queue）
可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
并发功能只有在异步（dispatch_async）函数下才有效

2.串行队列（Serial Dispatch Queue）
让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）,按照FIFO顺序执行.

同步和异步任务

GCD多线程经常会使用 dispatch_sync和dispatch_async函数向指定队列添加任务,分别是同步和异步

同步指阻塞当前线程,既要等待添加的耗时任务块Block完成后,函数才能返回,后面的代码才能继续执行

异步指将任务添加到队列后,函数立即返回,后面的代码不用等待添加的任务完成后即可执行,异步提交无法确定任务执行顺序

相关常用函数使用:

1.dispatch_after使用 (通过该函数可以让提交的任务在指定时间后开始执行,也就是延迟执行;)

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"10秒后开始执行")
    });

2.dispatch_group_t (组调度)的使用 (组调度可以实现等待一组操都作完成后执行后续任务.)

dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    //请求1
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    //请求2
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    //请求3
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    //界面刷新
    NSLog(@"任务均完成，刷新界面");
});

3.dispatch_semaphore (信号量)如何使用?

用于控制最大并发数     可以防止资源抢夺

与他相关的共有三个函数，分别是:

dispatch_semaphore_create，  // 创建最大并发数
dispatch_semaphore_wait。    // -1 开始执行 (0则等待)
dispatch_semaphore_signal，  // +1

4.dispatch_barrier_(a)sync使用?

一个dispatch barrier 允许在一个并发队列中创建一个同步点。当在并发队列中遇到一个barrier, 他会延迟执行barrier的block,等待所有在barrier之前提交的blocks执行结束。 这时，barrier block自己开始执行。 之后， 队列继续正常的执行操作。

十三.什么是NSOperation?

1.NSOperation是基于GCD的上封装,将线程封装成要执行的操作,不需要管理线程的生命周期和同步,比GCD可控性更强

例如:
可以加入操作依赖控制执行顺序,设置操作队列最大并发数,取消操作等

2.NSOperation如何实现操作依赖

通过任务间添加依赖，可以为任务设置执行的先后顺序。接下来通过一个案例来展示设置依赖的效果。

NSOperationQueue *queue=[[NSOperationQueue alloc] init];
//创建操作
NSBlockOperation *operation1=[NSBlockOperation blockOperationWithBlock:^(){
    NSLog(@"执行第1次操作，线程：%@",[NSThread currentThread]);
}];
NSBlockOperation *operation2=[NSBlockOperation blockOperationWithBlock:^(){
    NSLog(@"执行第2次操作，线程：%@",[NSThread currentThread]);
}];
NSBlockOperation *operation3=[NSBlockOperation blockOperationWithBlock:^(){
    NSLog(@"执行第3次操作，线程：%@",[NSThread currentThread]);
}];
//添加依赖
[operation1 addDependency:operation2];
[operation2 addDependency:operation3];
//将操作添加到队列中去
[queue addOperation:operation1];
[queue addOperation:operation2];
[queue addOperation:operation3];

十四.在项目什么时候选择使用 GCD，什么时候选 择 NSOperation

项目中使用 NSOperation 的优点是 NSOperation 是对线程的高度抽象，在项目中使 用它，会使项目的程序结构更好，子类化 NSOperation 的设计思路，是具有面向对 象的优点(复用、封装)，使得实现是多线程支持，而接口简单，建议在复杂项目中 使用。

项目中使用 GCD 的优点是 GCD 本身非常简单、易用，对于不复杂的多线程操 作，会节省代码量，而 Block 参数的使用，会是代码更为易读，建议在简单项目中 使用。

区别，以及各自的优势

GCD是纯C语⾔言的API，NSOperationQueue是基于GCD的OC版本封装

GCD只⽀支持FIFO的队列列，NSOperationQueue可以很⽅方便便地调整执⾏行行顺 序、设 置最⼤大并发数量量

NSOperationQueue可以在轻松在Operation间设置依赖关系，⽽而GCD 需要写很 多的代码才能实现

NSOperationQueue⽀支持KVO，可以监测operation是否正在执⾏行行 (isExecuted)、 是否结束(isFinished)，是否取消(isCanceld)

GCD的执⾏行行速度⽐比NSOperationQueue快 任务之间不不太互相依赖:GCD 任务之间 有依赖\或者要监听任务的执⾏行行情况:NSOperationQueue

十五.线程安全的处理手段有哪些,线程锁都有哪些?

1.加锁

2.同步执行

线程锁 (我们在使用多线程的时候多个线程可能会访问同一块资源，这样就很容易引发数据错乱和数据安全等问题，这时候就需要我们保证每次只有一个线程访问这一块资源，锁 应运而生。)

1.OSSpinLock (自旋锁)

注:苹果爸爸已经在iOS10.0以后废弃了这种锁机制,使用os_unfair_lock 替换,顾名思义能够保证不同优先级的线程申请锁的时候不会发生优先级反转问题.

2.os_unfair_lock(自旋锁)

3.dispatch_semaphore (信号量)

4.pthread_mutex(互斥锁)

5.NSLock(互斥锁、对象锁)

6.NSCondition(条件锁、对象锁)

7.NSConditionLock(条件锁、对象锁)

8.NSRecursiveLock(递归锁、对象锁)

9.@synchronized(条件锁)

10.pthread_mutex(recursive)(递归锁) 

注.递归锁可以被同一线程多次请求，而不会引起死锁。即在同一线程中在未解锁之前还可以上锁, 执行锁中的代码。这主要是用在循环或递归操作中

性能图

十六.HTTPS连接过程简述

1.客户端向服务端发起 https 请求

2.服务器(需要申请 ca 证书),返回证书(包含公钥)给客户端

3.客户端使用根证书验证 服务器证书的有效性,进行身份确认

4.客户端生成对称密钥,通过公钥进行密码,发送给服务器

5.服务器使用私钥进行 解密,获取对称密钥

6.双方使用对称加密的数据进行通信

十七.http 与https区别

HTTPS和HTTP的区别主要为以下四点：

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

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

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

4.http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全

十八.什么是DNS?DNS劫持问题?

域名系统(DomainNameSystem，缩写：DNS）是[互联网]的一项服务。它作为将域名和IP地址相互映射的一个分布式数据库，能够使人更方便地访问[互联网]

DNS劫持又称(域名劫持), 是指在劫持的网络范围内拦截域名解析的请求，分析请求的域名，把审查范围以外的请求放行，否则返回假的IP地址或者什么都不做使请求失去响应，其效果就是对特定的网络不能访问或访问的是假网址。

解决办法: 使用HTTPDNS

十九.网络七层是什么?

OSI模型有7层结构，每层都可以有几个子层。 OSI的7层从上到下分别是 7 应用层 6 表示层 5 会话层 4 传输层 3 网络层 2 数据链路层 1 物理层 ；其中高层（即7、6、5、4层）定义了应用程序的功能，下面3层（即3、2、1层）主要面向通过网络的端到端的数据流。

1.应用层
网络服务与最终用户的一个接口。
协议有：HTTP FTP TFTP SMTP SNMP DNS TELNET HTTPS POP3 DHCP

2.表示层
数据的表示、安全、压缩。（在五层模型里面已经合并到了应用层）
格式有，JPEG、ASCll、DECOIC、加密格式等

3 .会话层
建立、管理、终止会话。（在五层模型里面已经合并到了应用层）
对应主机进程，指本地主机与远程主机正在进行的会话

4.传输层
定义传输数据的协议端口号，以及流控和差错校验。
协议有：TCP UDP，数据包一旦离开网卡即进入网络传输层

5.网络层
进行逻辑地址寻址，实现不同网络之间的路径选择。
协议有：ICMP IGMP IP（IPV4 IPV6） ARP RARP

6.数据链路层
建立逻辑连接、进行硬件地址寻址、差错校验 [2] 等功能。（由底层网络定义协议）
将比特组合成字节进而组合成帧，用MAC地址访问介质，错误发现但不能纠正。

7.物理层
建立、维护、断开物理连接。（由底层网络定义协议）

二十.项目中网络层如何做安全处理

1.尽量使用https

2.不要传输明文密码

3.Post并不比Get安全

4.不要使用301跳转

5.http请求都带上MAC

6.http请求使用临时密钥

7.AES使用CBC模式

ios加固，ios代码混淆，ios代码混淆工具，iOS源码混淆产品是一款纯离线的源码加密工具，主要用于保护iOS项目中的核心代码，避免因逆向工程或破解，造成核心技术被泄漏、代码执行流程被分析等安全问题。该加密工具和普通编译器相似，基于项目源代码可将Objective-C、Swift、C、C++代码编译成二进制代码，不同之处在于，加密工具在编译时，能够对代码采取混淆、字符串加密等安全措施。从而避免攻击者通过IDA Pro等逆向工具反编译二进制代码，分析业务代码执行流程，进一步篡改或窃取核心技术。

概述

本文主要介绍iOS源码混淆产品之Xcode插件的使用方式，阅读者需具备iOS开发经验，否则使用可能存在困难。

安装插件

v13.0.2-20190703及其之前的版本为替换clang编译器的模式，之后版本为切换Xcode -> Toolchains的模式，后者可以在Xcode中快速切换编译器。

Xcode插件通过执行python install.py 命令安装编译器，使用完成后执行 python uninstal.py 即可卸载编译器。如下图：

（备注：如果有多个Xcode版本，请修改configuration.txt文件中Xcode默认的路径。）

执行安装会提示输入密码，输入电脑开机密码即可，Xcode插件安装成功后会有Install Success提示，如下图：

引入头文件

将include目录下的KiwiOBF.h头文件拷贝到iOS项目中，并在需的地方进行引用即可。

添加KIWIOBF标签

对需要进行混淆保护的函数，添加KIWIOBF标签，以告知编译器该函数需要进行混淆编译。如下图：

设置参数

全编译器有默认混淆参数，如不能满足需求，可以自定义配置参数
加密参数说明

iOS项目的混淆参数在 Other C Flags,Other C++ Flags,Other Swift Flags中设置，如下图：

卸载插件

Xcode插件：执行 python uninstall.py 即可卸载编译器。

友情告知地址，ios代码混淆，ios加固：https://www.kiwisec.com/product/compiler-ios.html

转自：https://www.jianshu.com/p/7fdb4544c916

一.列举出延迟调用的几种方法?

1.performSelector方法 

[self performSelector:@selector(Delay) withObject:nil afterDelay:3.0f];

2.NSTimer定时器  

[NSTimer scheduledTimerWithTimeInterval:3.0f target:self selector:@selector(Delay) userInfo:nil repeats:NO];

3.sleepForTimeInterval

[NSThread sleepForTimeInterval:3.0f];

4.GCD方式

dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC));
    dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
        [self Delay];
    });
- (void)Delay {
 NSLog(@"执行"); 
}

二.NSCache 和NSDictionary 区别?

NSCache可以提供自动删减缓存功能，而且保证线程安全，与字典不同，不会拷贝键。
NSCache可以设置缓存上限，限制对象个数和总缓存开销。定义了删除缓存对象的时机。这个机制只对NSCache起到指导作用，不会一定执行。
NSPurgeableData搭配NSCache使用，可以自动清除数据。
只有那种“重新计算很费劲”的数据才值得放入缓存。

三.NSArray 和 NSSet区别

NSSet和NSArray功能性质一样，用于存储对象，属于集合。
NSSet属于 “无序集合”，在内存中存储方式是不连续
NSArray是 “有序集合” 它内存中存储位置是连续的。
NSSet，NSArray都是类，只能添加对象，如果需要加入基本数据类型（int，float，BOOL，double等），需要将数据封装成NSNumber类型。
由于NSSet是用hash实现的所以就造就了它查询速度比较快，但是我们不能把某某对象存在第几个元素后面之类的有关下标的操作。

四.什么是分类?

分类: 在不修改原有类代码的情况下,可以给类添加方法
Categroy 给类扩展方法,或者关联属性, Categroy底层结构也是一个结构体:内部存储这结构体的名字,那个类的分类,以及对象和类方法列表,协议,属性信息
通过Runtime加载某个类的所有Category数据
把所有Category的方法、属性、协议数据，合并到一个大数组中后面参与编译的Category数据，会在数组的前面
将合并后的分类数据（方法、属性、协议），插入到类原来数据的前面

五.为什么说OC是一门动态语言？

动态语言:是指程序在运行时可以改变其结构，新的函数可以被引进,已有的函数可以被删除等在结构上的变化
动态类型语言: 就是类型的检查是在运行时做的。
OC的动态特性可从三方面:

动态类型（Dynamic typing）:最终判定该类的实例类型是在运行期间
动态绑定（Dynamic binding）：在运行时确定调用的方法
动态加载（Dynamic loading）：在运行期间加载需要的资源或可执行代码

六.什么是动态绑定?

动态绑定 将调用方法的确定也推迟到运行时。OC可以先跳过编译，到运行的时候才动态地添加函数调用，在运行时才决定要调用什么方法，需要传什么参数进去，这就是动态绑定。
在编译时，方法的 调用并不和代码绑定在一起，只有在消实发送出来之后，才确定被调用的代码。通过动态类型和动态绑定技术，

七.什么是谓词?

谓词(NSPredicate)是OC针对数据集合的一种逻辑帅选条件,类似一个过滤器,简单实实用代码如下:

Person * p1 = [Person personWithName:@"alex" Age:20];
Person * p2 = [Person personWithName:@"alex1" Age:30];
Person * p3 = [Person personWithName:@"alex2" Age:10];
Person * p4 = [Person personWithName:@"alex3" Age:40];
Person * p5 = [Person personWithName:@"alex4" Age:80];

NSArray * persons = @[p1, p2, p3, p4, p5];
//定义谓词对象,谓词对象中包含了过滤条件
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"age < 30"];
//使用谓词条件过滤数组中的元素,过滤之后返回查询的结果
NSArray *array = [persons filteredArrayUsingPredicate:predicate];

八.什么是类工厂方法?

类工厂方法就是用来快速创建对象的类方法, 他可以直接返回一个初始化好的对象,具备以下特征:

一定是类方法
返回值需要是 id/instancetype 类型
规范的方法名说说明类工厂方法返回的是一个什么对象,一般以类名首字母小写开始;
比如系统 UIButton 的buttonWithType 就是一个类工厂方法:

// 类工厂方法
+ (instancetype)buttonWithType:(UIButtonType)buttonType;
// 使用
+ UIButton * button = [UIButton buttonWithType:UIButtonTypeCustom];

九.简要说明const,宏,static,extern区分以及使用?

1.const

const常量修饰符,经常使用的字符串常量，一般是抽成宏，但是苹果不推荐我们抽成宏，推荐我们使用const常量。

- const 作用：限制类型
- 使用const修饰基本变量, 两种写法效果一致 , b都是只读变量
  const int b = 5; 
  int const b = 5;   
- 使用const修饰指针变量的变量 
  第一种: const int *p = &a 和 int const *q = &a; 效果一致,*p 的值不能改,p 的指向可以改; 
  第二种: int * const p = &a;  表示 p 的指向不能改,*p 的值可以改
  第三种: 
  const int * const p = &a; *p 值和 p 的指向都不能改

  const 在*左边, 指向可变, 值不可变
  const 在*的右边, 指向不可变, 值可变
  const 在*的两边, 都不可变

2.宏

* 基本概念：宏是一种批量处理的称谓。一般说来，宏是一种规则或模式，或称语法替换 ，用于说明某一特定输入（通常是字符串）如何根据预定义的规则转换成对应的输出（通常也是字符串)。这种替换在预编译时进行，称作宏展开。编译器会在编译前扫描代码，如果遇到我们已经定义好的宏那么就会进行代码替换，宏只会在内存中copy一份，然后全局替换，宏一般分为对象宏和函数宏。 宏的弊端：如果代码中大量的使用宏会使预编译时间变长。

const与宏的区别？

* 编译检查 宏没有编译检查，const有编译检查；
* 宏的好处 定义函数，方法 const不可以；
* 宏的坏处 大量使用宏，会导致预编译时间过长

3.static

* 修饰局部变量: 被static修饰局部变量，延长生命周期，跟整个应用程序有关，程序结束才会销毁,被 static 修饰局部变量，只会分配一次内存
* 修饰全局变量: 被static修饰全局变量，作用域会修改，也就是只能在当前文件下使用

4.extern

声明外部全局变量(只能用于声明，不能用于定义)

常用用法（.h结合extern联合使用）
如果在.h文件中声明了extern全局变量，那么在同一个类中的.m文件对全局变量的赋值必须是：数据类型+变量名（与声明一致）=XXXX结构。并且在调用的时候，必须导入.h文件。代码如下：

.h
@interface ExternModel : NSObject
extern NSString *lhString;
@end 
.m     
@implementation ExternModel
NSString *lhString=@"hello";
@end

调用的时候：例如：在viewController.m中调用，则可以引入：ExternModel.h，否则无法识别全局变量。当然也可以通过不导入头文件的方式进行调用（通过extern调用）。

十.id类型, nil , Nil ,NULL和NSNULL的区别?

id类型: 是一个独特的数据类型，可以转换为任何数据类型，id类型的变量可以存放任何数据类型的对象，在内部处理上，这种类型被定义为指向对象的指针，实际上是一个指向这种对象的实例变量的指针; id 声明的对象具有运行时特性，既可以指向任意类型的对象
nil 是一个实例对象值;如果我们要把一个对象设置为空的时候,就用nil
Nil 是一个类对象的值,如果我们要把一个class的对象设置为空的时候,就用Nil
NULL 指向基本数据类型的空指针(C语言的变量的指针为空)
NSNull 是一个对象,它用在不能使用nil的场合

十一.C和 OC 如何混编&&Swift 和OC 如何调用?

1.xcode可以识别一下几种扩展名文件:

.m文件,可以编写 OC语言 和 C 语言代码
.cpp: 只能识别C++ 或者C语言(C++兼容C)
.mm: 主要用于混编 C++和OC代码,可以同时识别OC,C,C++代码

2.Swift 调用 OC代码

需要创建一个 Target-BriBridging-Header.h 的桥文件,在乔文件导入需要调用的OC代码头文件即可

3.OC 调用 Swift代码
直接导入 Target-Swift.h文件即可, Swift如果需要被OC调用,需要使用@objc 对方法或者属性进行修饰

十二.OC与 JS交互方式有哪些?

1.通过拦截URL

- (BOOL)webView:(UIWebView *)webView shouldStartLoadWithRequest:(NSURLRequest *)request navigationType:(UIWebViewNavigationType)navigationType {
    NSString *url = request.URL.absoluteString;
    if ([url rangeOfString:@"需要跳转源生界面的URL判断"].location != NSNotFound) {
        //跳转原生界面
        return NO;
    }
    return YES;
}

2.使用MessageHandler(WKWebView)

当JS端想传一些数据给iOS.那它们会调用下方方法来发送.
window.webkit.messageHandlers.<方法名>.postMessage(<数据>)上方代码在JS端写会报错,导致网页后面业务不执行.可使用try-catch执行.
那么在OC中的处理方法如下.它是WKScriptMessageHandler的代理方法.name和上方JS中的方法名相对应.

- (void)addScriptMessageHandler:(id )scriptMessageHandler name:(NSString *)name;

3.JavaScriptCore (UIWebView)
使用三方库WebViewJavascriptBridge,可提供 js 调OC,以及OC掉JS

1. 设置 webViewBridge
_bridge = [WKWebViewJavascriptBridge bridgeForWebView:self.webView];
    [_bridge setWebViewDelegate:self];
2. 注册handler方法,需要和 前段协商好 方法名字,是供 JS调用Native 使用的。
    [_bridge registerHandler:@"scanClick" handler:^(id data, WVJBResponseCallback responseCallback) {
        // OC调用
        NSString *scanResult = @"http://www.baidu.com";
        // js 回调传参
        responseCallback(scanResult);
    }];
3. OC掉用JS
  [_bridge callHandler:@"testJSFunction" data:@"一个字符串" responseCallback:^(id responseData) {
        NSLog(@"调用完JS后的回调：%@",responseData);
    }];

4.OC调用JS代码

// 直接运行 使用 
NSString *jsStr = @"执行的JS代码";
[webView stringByEvaluatingJavaScriptFromString:jsStr];

// 使用JavaScriptCore框架
#import   
- (void)webViewDidFinishLoad:(UIWebView *)webView {
    //获取webview中的JS内容
    JSContext *context = [webView valueForKeyPath:@"documentView.webView.mainFrame.javaScriptContext"];
    NSString *runJS = @"执行的JS代码";
    //准备执行的JS代码
    [context evaluateScript:runJS];
}

十三.编译过程做了哪些事情

Objective,Swift都是编译语言。编译语言在执行的时候，必须先通过编译器生成机器码，机器码可以直接在CPU上执行，所以执行效率较高。Objective,Swift二者的编译都是依赖于Clang + LLVM. OC和Swift因为原理上大同小异，知道一个即可！
1.iOS编译 不管是OC还是Swift，都是采用Clang作为编译器前端,LLVM(Low level vritual machine)作为编译器后端。
2.编译器前端 :编译器前端的任务是进行：语法分析，语义分析，生成中间代码(intermediate representation )。在这个过程中，会进行类型检查，如果发现错误或者警告会标注出来在哪一行
3.编译器后端 :编译器后端会进行机器无关的代码优化，生成机器语言，并且进行机器相关的代码优化。LVVM优化器会进行BitCode的生成，链接期优化等等,LLVM机器码生成器会针对不同的架构，比如arm64等生成不同的机器码。

十四.Category的实现原理&&使用场合&&Class Extension的区别

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

使用场合:

在不修改原有类代码的情况下,为类添对象方法或者类方法
或者为类关联新的属性
分解庞大的类文件

添加实例方法
添加类方法
添加协议
添加属性
关联成员变量

区别

Class Extension在编译的时候，它的数据就已经包含在类信息中
Category是在运行时，才会将数据合并到类信息中。

十五.Category能否添加成员变量？如果可以，如何给Category添加成员变量？

不能直接给Category添加成员变量，但是可以间接实现Category有成员变量的效果
Category是发生在运行时,编译完毕,类的内存布局已经确定,无法添加成员变量(Category的底层数据结构也没有成员变量的结构)
可以通过 runtime 动态的关联属性

十六.Category中有load方法吗？load方法是什么时候调用的？load 方法能继承吗？

有load方法
load方法在runtime加载类、分类的时候调用
load方法可以继承，但是一般情况下不会主动去调用load方法，都是让系统自动调用

十七.initialize方法如何调用,以及调用时机

当类第一次收到消息的时候会调用类的initialize方法
是通过 runtime 的消息机制 objc_msgSend(obj,@selector()) 进行调用的
优先调用分类的 initialize, 如果没有分类会调用 子类的,如果子类未实现则调用 父类的

十八.load、initialize方法的区别什么？它们在category中的调用的顺序？以及出现继承时他们之间的调用过程？

load 是类加载到内存时候调用, 优先父类->子类->分类
initialize 是类第一次收到消息时候调用,优先分类->子类->父类
同级别和编译顺序有关系
load 方法是在 main 函数之前调用的

十九.什么是Runtime？平时项目中有用过么？

Objective-C runtime是一个运行时库，它为Objective-C语言的动态特性提供支持，我们所写的OC代码在运行时都转成了runtime相关的代码，类转换成C语言对应的结构体，方法转化为C语言对应的函数，发消息转成了C语言对应的函数调用。通过了解runtime以及源码,可以更加深入的了解OC其特性和原理

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

OC的动态性就是由Runtime来支撑和实现的，Runtime是一套C语言的API，封装了很多动态性相关的函数

平时编写的OC代码，底层都是转换成了Runtime API进行调用

具体应用

利用关联对象（AssociatedObject）给分类添加属性
遍历类的所有成员变量（修改textfield的占位文字颜色、字典转模型、自动归档解档）
交换方法实现（交换系统的方法）
利用消息转发机制解决方法找不到的异常问题

二十.讲一下 OC 的消息机制

1.OC中的方法调用其实都是转成了objc_msgSend函数的调用，给receiver（方法调用者）发送了一条消息（selector方法名）
2.objc_msgSend底层有3大阶段   消息发送（当前类、父类中查找）、动态方法解析、消息转发

消息发送流程

当我们的一个 receiver(实例对象)收到消息的时候, 会通过 isa 指针找到 他的类对象, 然后在类对象方法列表中查找 对应的方法实现,如果 未找到,则会通过 superClass 指针找到其父类的类对象, 找到则返回,未找打则会一级一级往上查到,最终到NSObject 对象, 如果还是未找到就会进行动态方法解析
类方法调用同上,只不过 isa 指针找到元类对象;

动态方法解析机制&&消息转发机制流程

当我们发送消息未找到方法实现,就会进入第二步,动态方法解析: 代码实现如下

//  动态方法绑定- 实例法法调用
+ (BOOL)resolveInstanceMethod:(SEL)sel{
    if (sel == @selector(run)) {
        Method method = class_getInstanceMethod(self, @selector(test));
        class_addMethod(self, sel, method_getImplementation(method), method_getTypeEncoding(method));
        return YES;
    }
    return [super resolveInstanceMethod:sel];
}
// 类方法调用
+(BOOL) resolveClassMethod:(SEL)sel....

未找到动态方法绑定,就会进行消息转发阶段

// 快速消息转发- 指定消息处理对象
- (id)forwardingTargetForSelector:(SEL)aSelector{
    if (aSelector == @selector(run)) {
        return [Student new];
    }
    return  [super forwardingTargetForSelector:aSelector];
} 

// 标准消息转发-消息签名
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    if(aSelector == @selector(run))
    {
        return [NSMethodSignature signatureWithObjCTypes:"v@:"];
    }
    return [super methodSignatureForSelector:aSelector];
}
- (void)forwardInvocation:(NSInvocation *)anInvocation{
   //内部逻辑自己处理 
}

答案摘自作者：iOS猿_员

原贴链接：https://www.jianshu.com/p/4aaf45c11082

1. 定义
   

   TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议。面向连接意味着两个使用TCP的进程（一个客户和一个服务器）在交换数据之前必须先建立好连接，然后才能开始传输数据。建立连接时采用客户服务器模式，其中主动发起连接建立的进程叫做客户（Client），被动等待连接建立的进程叫做服务器（Server）。

2. 端对端
   

   TCP提供全双工的数据传输服务，这意味着建立了TCP连接的主机双方可以同时发送和接收数据。这样，接收方收到发送方消息后的确认可以在反方向的数据流中进行捎带。“端到端”的TCP通信意味着TCP连接发生在两个进程之间，一个进程发送数据，只有一个接收方，因此TCP不支持广播和组播。

3. 面向字节
   

   TCP连接面向字节流，字节流意味着用户数据没有边界，例如，发送进程在TCP连接上发送了2个512字节的数据，接收方接收到的可能是2个512字节的数据，也可能是1个1024字节的数据。因此，接收方若要正确检测数据的边界，必须由发送方和接收方共同约定，并且在用户进程中按这些约定来实现。

4. 位于传输层
   TCP接收到数据包后，将信息送到更高层的应用程序，如FTP的服务程序和客户程序。应用程序处理后，再轮流将信息送回传输层，传输层再将它们向下传送到网际层，最后到接收方。
   

二、UDP

UDP与TCP位于同一层，但与TCP不同

• UDP协议提供的是一种无连接的、不可靠的传输层协议，只提供有限的差错检验功能。

• 它在IP层上附加了简单的多路复用功能，提供端到端的数据传输服务。

• 设计UDP的目的是为了以最小的开销在可靠的或者是对数据可靠性要求不高的环境中进行通信，

• 由于无连接，UDP支持广播和组播，这在多媒体应用中是非常有用的。

三、IP协议

1. 定义
   

   IP（网际）协议是TCP/IP模型的核心，也是网络层最重要的协议。

2. 功能
   

   网际层接收来自网络接口层的数据包，并将数据包发送到传输层；相反，也将传输层的数据包传送到网络接口层。
   IP协议主要包括无连接数据报传送，数据报路由器选择以及差错处理等功能。

3. 局限及对策
   

   由于网络拥挤、网络故障等问题可能导致数据报无法顺利通过传输层。IP协议具有有限的报错功能，不能有效处理数据报延迟，不按顺序到达和数据报出错，所以IP协议需要与另外的协议配套使用，包括地址解析协议ARP、逆地址解析协议RARP、因特网控制报文协议ICMP、因特网组管理协议IGMP等。
   IP数据包中含有源地址（发送它的主机地址）和目的地址（接收它的主机地址）。

4. 意义
   

   IP协议对于网络通信而言有着重要的意义。由于网络中的所有计算机都安装了IP软件，使得许许多多的局域网构成了庞大而严密的通信系统，才形成了如今的Internet。其实，Internet并非一个真实存在的网络，而是一个虚拟网络，只不过是利用IP协议把世界上所有愿意接入Internet的计算机局域网络连接起来，使之能够相互通信。
   
   链接：https://www.jianshu.com/p/b8b2220a8bd0

在APP的开发中，我们难免会遇到这种情况，一层层的打开下一级控制，这时，我们再想回到原始控制器时，一级级返回不太现实，所以我们需要一种方法，来一次性返回首页

从App的rootViewController开始，找到所有presentedController，然后逆序dismiss这些Controller，最后pop to rootViewController就可以了。

- (void)backToHomePage
{
    UIWindow *window = [(AppDelegate *)[UIApplication sharedApplication].delegate window];
    UIViewController *presentedController = nil;
    
    UIViewController *rootController = [window rootViewController];
    if ([rootController isKindOfClass:[UITabBarController class]]) {
        rootController = [(UITabBarController *)rootController selectedViewController];
    }
    presentedController = rootController;
    //找到所有presented的controller，包括UIViewController和UINavigationController
    NSMutableArray *presentedControllerArray = [[NSMutableArray alloc] init];
    while (presentedController.presentedViewController) {
        [presentedControllerArray addObject:presentedController.presentedViewController];
        presentedController = presentedController.presentedViewController;
    }
    if (presentedControllerArray.count > 0) {
        //把所有presented的controller都dismiss掉
        [self dismissControllers:presentedControllerArray topIndex:presentedControllerArray.count - 1 completion:^{
            [self popToRootViewControllerFrom:rootController];
        }];
    } else {
        [self popToRootViewControllerFrom:rootController];
    }
}

- (void)dismissControllers:(NSArray *)presentedControllerArray topIndex:(NSInteger)index completion:(void(^)(void))completion
{
    if (index < 0) {
        completion();
    } else {
        [presentedControllerArray[index] dismissViewControllerAnimated:NO completion:^{
            [self dismissControllers:presentedControllerArray topIndex:index - 1 completion:completion];
        }];
    }
}

- (void)popToRootViewControllerFrom:(UIViewController *)fromViewController
{
    //pop to root
    if ([fromViewController isKindOfClass:[UINavigationController class]]) {
        [(UINavigationController *)fromViewController popToRootViewControllerAnimated:YES];
    }
    if (fromViewController.navigationController) {
        [fromViewController.navigationController popToRootViewControllerAnimated:YES];
    }
}

参考这个思路可以做一些其他非常规页面跳转，跳转到我们想要跳转的指定界面去

原文链接：https://blog.csdn.net/yinyignfenlei/article/details/86167245

一、简介

1. 我们可以利用 category 把类的实现分开在几个不同的文件中，这样可以减少单个文件的体积。可以把不同的功能组织到不同的 category 里使功能单一化。可以由多个开发者共同完成一个类，只需各自创建该类的 category 即可。可以按需加载想要的 category，比如 SDWebImage 中 UIImageView+WebCache 和 UIButton+WebCache，根据不同需求加载不同的 category。

二、Extension 和 Category 对比

• extension 是在编译器决定的，它就是类的一部分，在编译期和头文件里的 @interface 和 实现文件里的 @implementation形成一个完整的类，它伴随类的的产生而产生，随着类的消亡而消亡。extension 一般用来隐藏类的私有信息，必须有类的源码才可以为一个类添加 extension。所以无法为系统的类添加 extension。


• category 是在运行期决定的，category 是无法添加实例变量的，extension 是可以添加的。

三、Category 的本质

3.1 Category的基本使用

我们首先来看以下 category的基本使用：

// Person+Eat.h



#import "Person.h"



@interface Person (Eat) 



- (void)eatBread;



+ (void)eatFruit;



@property (nonatomic, assign) int count;



@end



// Person+Eat.m



#import "Person+Eat.h"



@implementation Person (Eat)



- (void)eatBread {

    NSLog(@"eatBread");

}



+ (void)eatFruit {

    NSLog(@"eatFruit");

}



@end

复制代码

• 创建了一个 Person 的分类，专门实现吃这个功能


• 这个分类遵守了2个协议，分别为 NSCopying 和 NSCoding


• 声明了2个方法，一个实例方法，一个类方法


• 定义一个 count 属性

3.2 编译期的 Category

我们通过 clang 编译器来观察一下在编译期这些代码的本质是什么？

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

复制代码

编译之后，我们可以发现 category 的本质是结构体 category_t，无论我们创建了多少个 category 最终都会生成 category_t 这个结构体，并且 category 中的方法、属性、协议都是存储在这个结构体里的。也就是说在编译期，分类中成员是不会和类合并在一起的。

struct category_t {

    const char *name;

    classref_t cls;

    struct method_list_t *instanceMethods;

    struct method_list_t *classMethods;

    struct protocol_list_t *protocols;

    struct property_list_t *instanceProperties;

};

复制代码

• name：类的名字


• cls：类


• instanceMethods ：category 中所有给类添加的实例方法的列表


• classMethods：category 中所有给类添加的类方法的列表


• protocols：category 中实现的所有协议的列表


• instanceProperties：category 中添加的所有属性

从 category 的定义中可以看到我们可以 添加实例方法，添加类方法，可以实现协议，可以添加属性。

不可以添加实例变量

我们继续研究下面的编译后的代码：

static struct /*_method_list_t*/ {

	unsigned int entsize;  // sizeof(struct _objc_method)

	unsigned int method_count;

	struct _objc_method method_list[1];

} _OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {

	sizeof(_objc_method),

	1,

	{{(struct objc_selector *)"eatBread", "v16@0:8", (void *)_I_Person_Eat_eatBread}}

};



static struct /*_method_list_t*/ {

	unsigned int entsize;  // sizeof(struct _objc_method)

	unsigned int method_count;

	struct _objc_method method_list[1];

} _OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {

	sizeof(_objc_method),

	1,

	{{(struct objc_selector *)"eatFruit", "v16@0:8", (void *)_C_Person_Eat_eatFruit}}

};



static struct /*_protocol_list_t*/ {

	long protocol_count;  // Note, this is 32/64 bit

	struct _protocol_t *super_protocols[2];

} _OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {

	2,

	&_OBJC_PROTOCOL_NSCopying,

	&_OBJC_PROTOCOL_NSCoding

};



static struct /*_prop_list_t*/ {

	unsigned int entsize;  // sizeof(struct _prop_t)

	unsigned int count_of_properties;

	struct _prop_t prop_list[1];

} _OBJC_$_PROP_LIST_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {

	sizeof(_prop_t),

	1,

	{{"count","Ti,N"}}

};



static struct _category_t _OBJC_$_CATEGORY_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = 

{

	"Person",

	0, // &OBJC_CLASS_$_Person,

	(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat,

	(const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat,

	(const struct _protocol_list_t *)&_OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat,

	(const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Person_$_Eat,

};

复制代码

• 首先看一下 _OBJC_$_CATEGORY_Person_$_Eat 结构体变量中的值，就是分别对应 category_t 的成员，第1个成员就是类名，因为我们声明了实例方法，类方法，遵守了协议，定义了属性，所以我们的结构体变量中这些都会有值。


• _OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat 结构体表示实例方法列表，里面包含了 eatBread 实例方法


• _OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat 结构体包含了 eatFruit 类方法


• _OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat 结构体包含了 NSCoping 和 NSCoding 协议


• _OBJC_$_PROP_LIST_Person_$_Eat 结构体包含了 count 属性

3.3 运行期的 Category

在研究完编译时期的 category 后，我们进而研究运行时期的 category

在 objc-runtime-new.mm 的源码中，我们可以最终找到如何将 category 中的方法列表，属性列表，协议列表添加到类中。

static void

attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,

                 int flags)

{

    if (slowpath(PrintReplacedMethods)) {

        printReplacements(cls, cats_list, cats_count);

    }

    if (slowpath(PrintConnecting)) {

        _objc_inform("CLASS: attaching %d categories to%s class '%s'%s",

                     cats_count, (flags & ATTACH_EXISTING) ? " existing" : "",

                     cls->nameForLogging(), (flags & ATTACH_METACLASS) ? " (meta)" : "");

    }



    /*

     * Only a few classes have more than 64 categories during launch.

     * This uses a little stack, and avoids malloc.

     *

     * Categories must be added in the proper order, which is back

     * to front. To do that with the chunking, we iterate cats_list

     * from front to back, build up the local buffers backwards,

     * and call attachLists on the chunks. attachLists prepends the

     * lists, so the final result is in the expected order.

     */

    constexpr uint32_t ATTACH_BUFSIZ = 64;

    method_list_t   *mlists[ATTACH_BUFSIZ];

    property_list_t *proplists[ATTACH_BUFSIZ];

    protocol_list_t *protolists[ATTACH_BUFSIZ];



    uint32_t mcount = 0;

    uint32_t propcount = 0;

    uint32_t protocount = 0;

    bool fromBundle = NO;

    bool isMeta = (flags & ATTACH_METACLASS);

    auto rwe = cls->data()->extAllocIfNeeded();



    for (uint32_t i = 0; i < cats_count; i++) {

        auto& entry = cats_list[i];



        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);

        if ( ) {

            if (mcount == ATTACH_BUFSIZ) {

                prepareMethodLists(cls, mlists, mcount, NO, fromBundle);

                rwe->methods.attachLists(mlists, mcount);

                mcount = 0;

            }

            mlists[ATTACH_BUFSIZ - ++mcount] = mlist;

            fromBundle |= entry.hi->isBundle();

        }



        property_list_t *proplist =

            entry.cat->propertiesForMeta(isMeta, entry.hi);

        if (proplist) {

            if (propcount == ATTACH_BUFSIZ) {

                rwe->properties.attachLists(proplists, propcount);

                propcount = 0;

            }

            proplists[ATTACH_BUFSIZ - ++propcount] = proplist;

        }



        protocol_list_t *protolist = entry.cat->protocolsForMeta(isMeta);

        if (protolist) {

            if (protocount == ATTACH_BUFSIZ) {

                rwe->protocols.attachLists(protolists, protocount);

                protocount = 0;

            }

            protolists[ATTACH_BUFSIZ - ++protocount] = protolist;

        }

    }



    if (mcount > 0) {

        prepareMethodLists(cls, mlists + ATTACH_BUFSIZ - mcount, mcount, NO, fromBundle);

        rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);

        if (flags & ATTACH_EXISTING) flushCaches(cls);

    }



    rwe->properties.attachLists(proplists + ATTACH_BUFSIZ - propcount, propcount);



    rwe->protocols.attachLists(protolists + ATTACH_BUFSIZ - protocount, protocount);

}

复制代码

• rwe->methods.attachLists(mlists, mcount);


• rwe->protocols.attachLists(protolists, protocount);


• rwe->properties.attachLists(proplists, propcount);

以上三个函数就是把 category 中的方法、属性和协议列表添加到类中的函数。

继续查看 attchLists 函数的实现：

void attachLists(List* const * addedLists, uint32_t addedCount) {

    if (addedCount == 0) return;



    if (hasArray()) {

        // many lists -> many lists

        uint32_t oldCount = array()->count;

        uint32_t newCount = oldCount + addedCount;

        setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));

        array()->count = newCount;

        memmove(array()->lists + addedCount, array()->lists, 

                oldCount * sizeof(array()->lists[0]));

        memcpy(array()->lists, addedLists, 

               addedCount * sizeof(array()->lists[0]));

    }

    else if (!list  &&  addedCount == 1) {

        // 0 lists -> 1 list

        list = addedLists[0];

    } 

    else {

        // 1 list -> many lists

        List* oldList = list;

        uint32_t oldCount = oldList ? 1 : 0;

        uint32_t newCount = oldCount + addedCount;

        setArray((array_t *)malloc(array_t::byteSize(newCount)));

        array()->count = newCount;

        if (oldList) array()->lists[addedCount] = oldList;

        memcpy(array()->lists, addedLists, 

               addedCount * sizeof(array()->lists[0]));

    }

}

复制代码

• 在这段源码中，主要关注2个函数 memmove 和 memcpy。


• memmove 函数的作用是移动内存，将之前的内存向后移动，将原来的方法列表往后移


• memcpy 函数的作用是内存的拷贝，将 category 中的方法列表复制到上一步移出来的位置。

从上述源码中，可以发现 category 的方法并没有替换原来类已有的方法，如果 category 和原来类中都有某个同名方法，只不过 category 中的方法被放到了新方法列表的前面，在运行时查找方法的时候是按照顺序查找的，一旦找到该方法，就不会向下继续查找了，产生了 category 会覆盖原类方法的假象。

所以我们在 category 定义方法的时候都要加上前缀，以避免意外的重名把类本身的方法”覆盖“掉。

• 如果多个 category 中存在同名的方法，运行时最终调用哪个方法是由编译器决定的，最后一个参与编译的方法将会先被调用。

链接：https://juejin.cn/post/6950833332422705165

一.App启动过慢，你可能想到的因素有哪些？

1.解析Info.plist  

 加载相关信息，例如如闪屏 沙箱建立、权限检查

2.Mach-O加载 

如果是胖二进制文件，寻找合适当前CPU类别的部分
加载所有依赖的Mach-O文件（递归调用Mach-O加载的方法）
定位内部、外部指针引用，例如字符串、函数等
执行声明为attribute((constructor))的C函数
加载类扩展（Category）中的方法

3.程序执行

调用main()
调用UIApplicationMain()
调用applicationWillFinishLaunching

影响启动性能的因素

main()函数之前耗时的影响因素
动态库加载越多，启动越慢。
ObjC类越多，启动越慢
C的constructor函数越多，启动越慢
C++静态对象越多，启动越慢
ObjC的+load越多，启动越慢
main()函数之后耗时的影响因素
执行main()函数的耗时
执行applicationWillFinishLaunching的耗时
rootViewController及其childViewController的加载、view及其subviews的加载

优化

纯代码方式而不是storyboard加载首页UI。
对didFinishLaunching里的函数考虑能否挖掘可以延迟加载或者懒加载，需要与各个业务方pm和rd共同check 对于一些已经下线的业务，删减冗余代码。
对于一些与UI展示无关的业务，如微博认证过期检查、图片最大缓存空间设置等做延迟加载。
对实现了+load()方法的类进行分析，尽量将load里的代码延后调用。
上面统计数据显示展示feed的导航控制器页面(NewsListViewController)比较耗时，对于viewDidLoad以及viewWillAppear方法中尽量去尝试少做，晚做，不做。

二.单例的利弊

优点：
1：一个类只被实例化一次，提供了对唯一实例的受控访问。
2：节省系统资源
3：允许可变数目的实例。

缺点：
1：一个类只有一个对象，可能造成责任过重，在一定程度上违背了“单一职责原则”。
2：由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
3：滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

三.TCP和UDP的区别于联系

TCP为传输控制层协议，为面向连接、可靠的、点到点的通信；
UDP为用户数据报协议，非连接的不可靠的点到多点的通信；
TCP侧重可靠传输，UDP侧重快速传输

四.TCP连接的三次握手

第一次握手：客户端发送 syn 包(syn=j)到服务器，并进入 SYN_SEND 状态，等待服务器确认；

第二次握手：服务器收到 syn 包，必须确认客户的 SYN（ack=j+1），同时自己也发送一个 SYN 包（syn=k），即 SYN+ACK 包，此时服务器进入 SYN_RECV 状态；

第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入 ESTABLISHED 状态，完成三次握手。

握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。理想状态下，TCP 连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP 连接都将被一直保持下去。断开连接时服务器和客户端均可以主动发起断开 TCP 连接的请求，断开过程需要经过“四次握手”（过程就不细写了，就是服务器和客户端交互，最终确定断开）

五.假如Controller太臃肿，如何优化?

1.将网络请求抽象到单独的类中

方便在基类中处理公共逻辑；
方便在基类中处理缓存逻辑，以及其它一些公共逻辑；
方便做对象的持久化。

2.将界面的封装抽象到专门的类中
构造专门的 UIView 的子类，来负责这些控件的拼装。这是最彻底和优雅的方式，不过稍微麻烦一些的是，你需要把这些控件的事件回调先接管，再都一一暴露回 Controller。

3.构造 ViewModel
借鉴MVVM。具体做法就是将 ViewController 给 View 传递数据这个过程，抽象成构造 ViewModel 的过程

4.专门构造存储类
专门来处理本地数据的存取。

5.整合常量

六.对程序性能的优化你有什么建议?

1.使用复用机制

2.尽可能设置 View 为不透明

3.避免臃肿的 XIB 文件

4.不要阻塞主线程

5.图片尺寸匹配 UIImageView

6.选择合适的容器

7.启用 GZIP 数据压缩

8.View 的复用和懒加载机制

9、缓存

服务器的响应信息（response）。图片。计算值。比如：UITableView 的 row heights。

10.关于图形绘制

11.处理 Memory Warnings

在 AppDelegate 中实现 - [AppDelegate applicationDidReceiveMemoryWarning:] 代理方法。
在 UIViewController 中重载 didReceiveMemoryWarning 方法。
监听 UIApplicationDidReceiveMemoryWarningNotification 通知。

12.复用高开销的对象

13.减少离屏渲染(设置圆角和阴影的时候可以选用绘制的方法)

14.优化 UITableView

通过正确的设置 reuseIdentifier 来重用 Cell。
尽量减少不必要的透明 View。
尽量避免渐变效果、图片拉伸和离屏渲染。
当不同的行的高度不一样时，尽量缓存它们的高度值。
如果 Cell 展示的内容来自网络，确保用异步加载的方式来获取数据，并且缓存服务器的 response。
使用 shadowPath 来设置阴影效果。
尽量减少 subview 的数量，对于 subview 较多并且样式多变的 Cell，可以考虑用异步绘制或重写 drawRect。
尽量优化 - [UITableView tableView:cellForRowAtIndexPath:] 方法中的处理逻辑，如果确实要做一些处理，可以考虑做一次，缓存结果。
选择合适的数据结构来承载数据，不同的数据结构对不同操作的开销是存在差异的。
对于 rowHeight、sectionFooterHeight、sectionHeaderHeight 尽量使用常量。

15.选择合适的数据存储方式

在 iOS 中可以用来进行数据持有化的方案包括：
NSUserDefaults。只适合用来存小数据。
XML、JSON、Plist 等文件。JSON 和 XML 文件的差异在「选择正确的数据格式」已经说过了。
使用 NSCoding 来存档。NSCoding 同样是对文件进行读写，所以它也会面临必须加载整个文件才能继续的问题。
使用 SQLite 数据库。可以配合 FMDB 使用。数据的相对文件来说还是好处很多的，比如可以按需取数据、不用暴力查找等等。
使用 CoreData。也是数据库技术，跟 SQLite 的性能差异比较小。但是 CoreData 是一个对象图谱模型，显得更面向对象；SQLite 就是常规的 DBMS。

16.减少应用启动时间

快速启动应用对于用户来说可以留下很好的印象。尤其是第一次使用时。
保证应用快速启动的指导原则：
尽量将启动过程中的处理分拆成各个异步处理流，比如：网络请求、数据库访问、数据解析等等。
避免臃肿的 XIB 文件，因为它们会在你的主线程中进行加载。重申：Storyboard 没这个问题，放心使用。
注意：在测试程序启动性能的时候，最好用与 Xcode 断开连接的设备进行测试。因为 watchdog 在使用 Xcode 进行调试的时候是不会启动的。

17.使用 Autorelease Pool （内存释放池）

18.imageNamed 和 imageWithContentsOfFile

七.使用drawRect有什么影响？

drawRect方法依赖Core Graphics框架来进行自定义的绘制

缺点：它处理touch事件时每次按钮被点击后，都会用setNeedsDisplay进行强制重绘；而且不止一次，每次单点事件触发两次执行。这样的话从性能的角度来说，对CPU和内存来说都是欠佳的。特别是如果在我们的界面上有多个这样的UIButton实例，那就会很糟糕了

这个方法的调用机制也是非常特别. 当你调用 setNeedsDisplay 方法时, UIKit 将会把当前图层标记为dirty,但还是会显示原来的内容,直到下一次的视图渲染周期,才会将标记为 dirty 的图层重新建立Core Graphics上下文,然后将内存中的数据恢复出来, 再使用 CGContextRef 进行绘制

八.基于CTMediator的组件化方案，有哪些核心组成？

假如主APP调用某业务A，那么需要以下组成部分：

CTMediator类，该类提供了函数 - (id)performTarget:(NSString *)targetName action:(NSString *)actionName params:(NSDictionary *)params shouldCacheTarget:(BOOL)shouldCacheTarget;
这个函数可以根据targetName生成对象，根据actionName构造selector，然后可以利用performSelector:withObject:方法，在目标上执行动作。

业务A的实现代码，另外要加一个专门的类，用于执行Target Action
类的名字的格式：Target_%@，这里就是Target_A。
这个类里面的方法，名字都以Action_开头，需要传参数时，都统一以NSDictionary*的形式传入。
CTMediator类会创建Target类的对象，并在对象上执行方法。

业务A的CTMediator扩展
扩展里声明了所有A业务的对外接口，参数明确，这样外部调用者可以很容易理解如何调用接口。
在扩展的实现里，对Target, Action需要通过硬编码进行指定。由于扩展的负责方和业务的负责方是相同的，所以这个不是问题。

九.为什么CTMediator方案优于基于Router的方案？

Router的缺点：

在组件化的实施过程中，注册URL并不是充分必要条件。组件是不需要向组件管理器注册URL的，注册了URL之后，会造成不必要的内存常驻。注册URL的目的其实是一个服务发现的过程，在iOS领域中，服务发现的方式是不需要通过主动注册的，使用runtime就可以了。另外，注册部分的代码的维护是一个相对麻烦的事情，每一次支持新调用时，都要去维护一次注册列表。如果有调用被弃用了，是经常会忘记删项目的。runtime由于不存在注册过程，那就也不会产生维护的操作，维护成本就降低了。 由于通过runtime做到了服务的自动发现，拓展调用接口的任务就仅在于各自的模块，任何一次新接口添加，新业务添加，都不必去主工程做操作，十分透明。

在iOS领域里，一定是组件化的中间件为openURL提供服务，而不是openURL方式为组件化提供服务。如果在给App实施组件化方案的过程中是基于openURL的方案的话，有一个致命缺陷：非常规对象(不能被字符串化到URL中的对象，例如UIImage)无法参与本地组件间调度。

在本地调用中使用URL的方式其实是不必要的，如果业务工程师在本地间调度时需要给出URL，那么就不可避免要提供params，在调用时要提供哪些params是业务工程师很容易懵逼的地方。

为了支持传递非常规参数，蘑菇街的方案采用了protocol，这个会侵入业务。由于业务中的某个对象需要被调用，因此必须要符合某个可被调用的protocol，然而这个protocol又不存在于当前业务领域，于是当前业务就不得不依赖public Protocol。这对于将来的业务迁移是有非常大的影响的

CTMediator的优点：

调用时，区分了本地应用调用和远程应用调用。本地应用调用为远程应用调用提供服务。

组件仅通过Action暴露可调用接口，模块与模块之间的接口被固化在了Target-Action这一层，避免了实施组件化的改造过程中，对Business的侵入，同时也提高了组件化接口的可维护性。

方便传递各种类型的参数。

十.内存的使用和优化的注意事项

重用问题：如UITableViewCells、UICollectionViewCells、UITableViewHeaderFooterViews设置正确的reuseIdentifier，充分重用；

尽量把views设置为不透明：当opque为NO的时候，图层的半透明取决于图片和其本身合成的图层为结果，可提高性能；

不要使用太复杂的XIB/Storyboard：载入时就会将XIB/storyboard需要的所有资源，包括图片全部载入内存，即使未来很久才会使用。那些相比纯代码写的延迟加载，性能及内存就差了很多；

选择正确的数据结构：学会选择对业务场景最合适的数组结构是写出高效代码的基础。比如，数组: 有序的一组值。使用索引来查询很快，使用值查询很慢，插入/删除很慢。字典: 存储键值对，用键来查找比较快。集合: 无序的一组值，用值来查找很快，插入/删除很快。
gzip/zip压缩：当从服务端下载相关附件时，可以通过gzip/zip压缩后再下载，使得内存更小，下载速度也更快。

延迟加载：对于不应该使用的数据，使用延迟加载方式。对于不需要马上显示的视图，使用延迟加载方式。比如，网络请求失败时显示的提示界面，可能一直都不会使用到，因此应该使用延迟加载。

数据缓存：对于cell的行高要缓存起来，使得reload数据时，效率也极高。而对于那些网络数据，不需要每次都请求的，应该缓存起来，可以写入数据库，也可以通过plist文件存储。

处理内存警告：一般在基类统一处理内存警告，将相关不用资源立即释放掉
重用大开销对象：一些objects的初始化很慢，比如NSDateFormatter和NSCalendar，但又不可避免地需要使用它们。通常是作为属性存储起来，防止反复创建。

避免反复处理数据：许多应用需要从服务器加载功能所需的常为JSON或者XML格式的数据。在服务器端和客户端使用相同的数据结构很重要;

使用Autorelease Pool：在某些循环创建临时变量处理数据时，自动释放池以保证能及时释放内存;

正确选择图片加载方式：UIImage加载方式

摘自作者：iOS猿_员
原贴链接：https://www.jianshu.com/p/4b4bd4e3feff

一.    Runloop和线程的关系?

1.一一对应的关系,主线程的runloop已经创建,默认开启,子线程的runloop需要手动创建

2.runloop在第一次获取时创建,在线程结束时销毁.

runloop 的运行逻辑就是 do-while 循环下运用观察者模式（或者说是消息发送），根据7种状态的变化，处理事件输入源和定时器。如下图

runloop的应用:

1.NSTimer在子线程开启一个定时器;控制定时器在特定模式下执行

2.imageView的显示

3.performSelector

4.常驻线程(让一个子线程不进入消亡状态,等待其他线程发来消息,处理其他事件)

5.自动释放池

二.自动释放池什么时候释放?

第一次创建:启动runloop时候

最后一次销毁:runloop退出的时候

其他时候的创建和销毁:当runloop即将睡眠时销毁之前的释放池,重建一个新的

三.什么时候使用weak关键字,和assign的区别?

1.arc中有可能出现循环引用的地方,比如delegate属性

2.自定义IBOutlet空间属性一般也是使用weak

区别:weak表明一种非持有关系,必须用于oc对象;assign用于基本数据类型

weak修饰的指针默认是nil,如果用assign修饰对象,在对象被销毁时,会产生野指针,容易发生崩溃

四.objc中向一个nil对象发送消息将会发生什么?

在oc中向nil发送消息是完全有效的,只是在运行时不会有任何作用,如果一个方法返回值是一个对象,那么发送给nil的消息将返回0(nil),如果向一个nil对象发送消息,首先寻找对象的isa指针时就是0地址返回了,所以不会出现任何错误.

五.runtime如何实现weak变量的自动置nil

runtime对注册的类,会进行布局,对于weak对象会放入一个hash表中,用weak指向的对象内存地址作为key,当此对象的引用计数为0的时候会dealloc,假如weak指向的对象内存地址是a,那么就会以a为键,在这个weak表中搜索,找到所有以a为键的weak对象,从而设置为nil

六.runtime如何通过selector找到对应的IMP地址?

每一个类对象都有一个方法列表,方法列表中记录着方法名称.方法实现.参数类型,其实selector本质就是方法名称,通过这个方法名称就可以在方法列表中找到对应的方法实现

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

1.不能向编译后得到的类中增加实例变量,可以向运行时创建的类中添加实例变量

原因: (1)因为编译后的类已经注册在runtime中,类结构中的objc_ivar_list 实例变量的链表和instance_size实例变量的内存大小已经确定,同事runtime会调用class_setIvarLayout 或者class_setWeakIvarLayout来处理strong weak引用,所以不能向存在的类中添加实例变量

(2)运行时创建的的类可以添加实例变量,调用class_addIvar函数,但是得在调用objc_allocateClassPair之后,objc_registerClassPair之前,原因同上

八.kvo的实现原理?

当你观察一个对象时,一个新的类会被动态创建,这个类继承自该对象的原本的类,并重写了被观察属性的setter方法,重写setter方法会负责在调用原setter方法之前和之后,通知所有观察对象:值得更改,最后通过isa混写,把这个对象的isa指针(isa指针告诉runtime系统这个对象的类是什么)指向这个新创建的子类,对象就神奇的变成了新创建子类的实例

实现原理如下图:

九.谈谈你对kvc的理解

kvc可以通过key直接访问对象属性,或者给对象的属性赋值,这样可以在运行时动态访问或者改变对象的属性值

当调用setValue:属性值forKey:@"name"的代码时,底层执行机制如下:

1.程序优先调用set:属性值方法,代码通过setter方法完成设置,注意,这里的是指成员变量名,首字母大小写要符合kvc的命名规则

2.如果没有找到setName:方法,kvc机制会检查+(Bool)accessInstanceVariablesDiretly方法,有没有返回yes,默认是返回yes,如果重写了该方法切返回NO的话,那么这一步会直接执行setValue:forUnderfindKey:方法, 如果返回Yes,那么kvc机制会搜索该类里面有没有名为的成员变量,不论该变量是在类接口处定义,还是在类实现处定义,也无论用什么样的访问修饰符只要存在以命名的变量,kvc都可以对该变量赋值

3.如果该类即没有set方法,也没有成员变量,kvc机制会搜索_is的成员变量

4.和上面一样,如果该类即没有set:方法,也没有_和_is成员变量,kvc机制会继续搜索和is的成员变量,再给它赋值

5.如果以上列出的方法和成员变量都不存在,系统将执行setValue:forUnderfindKey:方法,默认是抛出异常.

十.Notification和KVO的区别

1.KVO提供一种机制,当指定的被观察对象属性被修改后,kvo会自动通知响应的观察者

2.通知:是一种广播机制,在事件发生的时候,通过通知中心对象,一个对象能够为所关心这个事件发生的对象发送消息,两者都是观察者模式,不同在于kvo是被观察者直接发送消息给观察者,是对象间的直接交互.通知则是两者都和通知中心对象交互,对象之间不知道彼此

3.本质区别,底层原理不一样,kvo基于runtime,通知则有个通知中心来进行通知

十一.如果让你设计一个通知中心,设计思路

1.创建通知中心单例类,并在里面有一个保存全局NSDictionary

2.对于注册通知的类,将注册通知名作为key,执行的方法和类,以及一些参数作为一个数组为值

3.发送通知可以调用通知中心,通过字典key(通知名)找到对应的类和方法进行调用传值

十二.atomic和nonatomic区别,以及作用?

atomic与nonatom的主要区别就是系统自动生成的getter/setter方法不一样 ,atomic系统自动生成的getter/setter方法会进行加锁操作,nonatomic系统自动生成的getter/setter方法不会进行加锁操作

atomic不是线程安全的

系统生成的getter/setter方法会进行加锁操作,注意:这个锁仅仅保证了getter和setter存取方法的线程安全.因为getter/setter方法有加锁的缘故,故在别的线程来读写这个属性之前,会先执行完当前操作

atomic可以保证多线程访问时候,对象是未被其他线程销毁(比如:如果当一个线程正在get或set时,又有另一个线程同时在进行release操作,可能会直接crash)

十三.说一下静态库和动态库之间的区别

静态库：以.a 和 .framework为文件后缀名。链接时会被完整的复制到可执行文件中，被多次使用就有多份拷贝。

动态库：以.tbd(之前叫.dylib) 和 .framework 为文件后缀名。链接时不复制，程序运行时由系统动态加载到内存，系统只加载一次，多个程序共用（如系统的UIKit.framework等），节省内存 

静态库.a 和 framework区别.a 主要是二进制文件,不包含资源,需要自己添加头文件.framework 可以包含头文件+资源信息

十四.遇到过BAD_ACCESS的错误吗？你是怎样调试的？

BAD_ACCESS 报错属于内存访问错误，会导致程序崩溃，错误的原因是访问了野指针(悬挂指针)。

常规操作如下:

设置全局断点快速定位问题代码所在行。

开启僵尸对象诊断
Analyze分析
重写object的respondsToSelector方法，现实出现EXEC_BAD_ACCESS前访问的最后一个object。
Xcode 7 已经集成了BAD_ACCESS捕获功能：Address Sanitizer。 用法如下：在配置中勾选✅Enable Address Sanitizer

十五.说一下iOS 中的APNS,远程推送原理?

Apple push Notification Service,简称 APNS,是苹果的远程消息推送,原理如下:
iOS 系统向APNS服务器请求手机端的deviceToken
App 接收到手机端的 deviceToken,然后传给 App 对应的服务器.
App 服务端需要发送推送消息时, 需要先通过 APNS 服务器
然后根据对应的 deviceToken 发送给对应的手机

十六.UITableView的优化

1.重用cell

2.缓存行高(在请求到数据的时候提前计算好行高,用字典缓存好高度)

3.加载网络图片,使用异步加载,并缓存,下载的图片根据显示大小切成合适大小的图,查看大图时再显示大图,服务端最好处理好大图和小图,延时加载,当滚动很快时避免频繁请求,可通过runloop设置defultMode状态下渲染请求

4.局部刷新,减少全局刷新

5.渲染,尽量不要使用透明图层,将cell的opaque值设为Yes,背景色和子View不要使用透明色,减少阴影渐变,圆角等

6.少用addSubview给cell动态添加子View,初始化时直接设置好,通过hidden控制显示隐藏,布局在初始化直接布局好,避免cell的重新布局

7.按需加载cell,滚动很快时,只加载范围内的cell,如果目标行与当前行相差超过指定行数,只在目标滚动范围的前后定制n行加载,按需加载,提高流畅性方法如下

8.遇到复杂界面,需要异步绘制,给自定义的cell添加draw方法,在方法中利用GCD异步绘制,或者直接重写drawRect方法,此外,绘制cell不建议使用UIView,建议使用CALayer,UIView的绘制是建立在CoreGraphic上的,使用的是cpu,CALayer使用的是core Animation,CPU.GPU通吃.由系统决定使用哪一个,view的绘制使用的自下向上的一层层的绘制,然后渲染layer处理的是Texure,利用GPU的Texure Cache和独立的浮点数计算单元加速纹理的处理,GPU不喜欢透明,所以绘图一定要弄成不透明,对于圆角和阴影截一个伪透明的小图绘制上去,在layer回调里一定只做绘图,不做计算

cell被重用时,内部绘制的内容并不会自动清除,因此需要调用setNeedsDisplay或者setNeedsDisplayLayInRect:方法

十七.离屏渲染

下面的情况或操作会引发离屏渲染:

1.为图层设置遮罩(layer.mask)
2.将图层的layer.masksToBounds/view.clipsToBounds属性设置为ture
3.将图层layer,allowsGroupOpacity属性设置为Yes和layer.opacity小于1.0
4.给图层设置阴影(layer.shadow)
5.为图层设置layer.shouldRasterize=Yes(光栅化)
6.具有layer.cornerRadius,layer.edgeAntialiasingMask,layer.allowsEdgeAntialiasing的图层(圆角,抗锯齿)
7.使用CGContext在drawRect:方法中绘制大部分情况会导致离屏渲染,甚至是一个空的实现

优化方案

圆角优化:使用CAShapeLayer和UIBezierPath设置圆角;直接中间覆盖一张为圆形的透明图片
shadow优化:使用shadowPath指定layer阴影效果路径,优化性能
使用异步进行layer渲染(Facebook开源异步绘制框架AsncDisplayKit)
设置layer的opaque值为Yes,减少复杂图层合成
尽量使用不包含透明(alpha)通道的图片资源
尽量设置layer的大小为整型值

十八.UIView和CALayer区别

1.UIView可以响应事件，CALayer不可以,UIView继承自UIResponder,在UIResponder中定义了处理各种事件的事件传递接口。而CALayer直接继承NSObject,并没有相应的处理事件接口。
2.一个CALayer的frame是由它的anchorPoint（锚点）,position，bounds，和transform共同决定，而一个view的frame只是简单的返回layer的frame，同样view的center和bounds也是返回layer的一些属性
3..UIView主要是对显示内容的管理，而CALayer主要是侧重显示内容的绘制。UIView是CALayer的CALayerDelegate。
4.每一个view内部都有一个CALayer在背后提供内容的绘制和显示，并且UIView的尺寸样式都由内部的CALayer提供，两者都有树状层级结构，layer内部有subLayers,view内部有subviews。
5.两者最明显的区别是view可以接受并处理事件，而Layer不可以。View是Layer的代理Delegate。

十九.iOS应用程序生命周期

ios程序启动原理(过程):如下:

二十.view视图生命周期

前言

     今天一直在网上找如何在UITableViewCell嵌套WKWebView，问题还挺多了，最后还是在stackoverflow找到了解决方案，废话不多说，直接看解决方案。

正文

一.先来看看我们平时接触的NSObject

• NSObject *objc = [[NSObject alloc]init]的本质
  
  在内存中，这行代码就把objc转在底层实现中转成了一个结构体，其底层C++编译成结构体为：

struct NSObject_IMPL {

    Class isa;

};

在64位机中，一个isa占8个字节，在32位机中，一个isa占4个字节（当然苹果后面的机型都是64位的，这里我们着重讲解64位机）

• 我们先来看看这个创建好的objc占多少个字节

int main(int argc, char * argv[]) {

    

    @autoreleasepool {

        // Setup code that might create autoreleased objects goes here.

        //定义一个objc

        NSObject *objc = [[NSObject alloc]init];

        //打印内存

        NSLog(@"tu-%zd",class_getInstanceSize([NSObject class]));

        NSLog(@"tu-%zd",malloc_size((__bridge const void *)(objc)));

    }

    

}

其打印结果为:

objc打印结果

• 
  为什么一个是8一个是16

• • 我们先来认识一下class_getInstanceSize、malloc_size的区别
    
    1.class_getInstanceSize：是一个函数（调用时需要开辟额外的内存空间），程序运行时才获取，计算的是类的大小（至少需要的大小）即实例对象的大小->结构体内存对齐
    
    2.创建的对象【至少】需要的内存大小不考虑malloc函数的话，内存对齐一般是以【8】对齐
    
    3.#import <objc/runtime.h>使用这个函数时倒入runtime运行时

  
  
  • 
    

    malloc_size：堆空间【实际】分配给对象的内存大小 -系统内存对齐

    
    
    
    
    1. 在Mac、iOS中的malloc函数分配的内存大小总是【16】的倍数 即指针指向的内存大小
       
    
    
    2. import <malloc/malloc.h>使用时倒入这个框架
    
    
    
    
  
  
  
  


• sizeof：是一个运算符，获取的是类型的大小（int、size_t、结构体、指针变量等），这些数值在程序编译时就转成常数，程序运行时是直接获取的
• 看到上面对两个函数的认识，应该知道为什么输出的一个是8，一个是16了吧，当内存申请<16时，在底层分配的时候，系统会默认最低16个字节，系统给objc16个字节，而objc用到的是8个字节（没添加任何成员变量之前）

二.内存对齐

• 在上面的基础上我们新建一个类Student继承NSObject，那么对于student的底层C++编译实现就变成了：

struct Student {

    struct NSObject_IMPL NSOBJECT_IVARS;

};

也就是说，继承关系，子类直接将父类的isa引用进来

• 对于class_getInstanceSize（也就是类本质的内存对其）
  
  1.在student中创建成员变量：

@interface Student : NSObject

{

    @public

    int _age;

    int _no;

    int _tc;

}

@end

其底层C++编译结构体就变成了

struct Student {

    struct NSObject_IMPL NSOBJECT_IVARS;

    int _age;

    int _no;

    int _tc;

};

• 打印结果：

 //定义一个objc

        Student *objc = [[Student alloc]init];

        //打印内存

        NSLog(@"tu-%zd",class_getInstanceSize([Student class]));

        NSLog(@"tu-%zd",malloc_size((__bridge const void *)(objc)));

2020-09-08 12:35:27.158568+0800 OC底层[1549:79836] tu-24

2020-09-08 12:35:27.159046+0800 OC底层[1549:79836] tu-32

• 先来说说24的由来

由于创建对象的时候，内存是以8对齐，上面我们讲到一个对象里面包含了一个isa占8个字节，对于student来说它有四个成员变量，isa，age，no，tc，共占8+4+4+4=20字节，但是由于内存以8对齐的原因，我们看到的输出是24，

所以class_getInstanceSize在计算实例大小的时候就是24，其白色区域表示空出了四个字节

再来看看32的由来
上面我们说到malloc_size指的是实际堆分配的空间，它以16字节对齐

可以看到，空白的区域为空出了12个字节，总共为32个字节

三.添加属性

• 添加属性

@interface Student : NSObject

{

    @public

    int _age;

    int _no;

    int _tc;



}

@property (nonatomic, strong) NSString *name;

@property (nonatomic, strong) NSArray *array;

@end

其在底层C++编译就变成了

struct Student {

    struct NSObject_IMPL NSOBJECT_IVARS;

    int _age;

    int _no;

    int _tc;

    NSString _name;

    NSArray _array;

};

默认的会将属性生成的_name添加进结构体中，计算相应的大小

总结:所以在实际计算类的占用空间大小的时候，根据添加的成员变量就可以计算出一个实例占用的内存大小（即计算出结构体的大小24，然后告诉系统，系统调用calloc分配内存的时候按照16对齐原则分配）

崩溃提示：Terminating app due to uncaught exception 'NSGenericException', reason: '*** Collection <CALayerArray: 0x14df0bd0> was mutated while being enumerated.'



当程序出现这个提示的时候，是因为你一边便利数组，又同时修改这个数组里面的内容，导致崩溃，网上的方法如下：

NSMutableArray * arrayTemp = xxx;

NSArray * array = [NSArray arrayWithArray: arrayTemp];

for (NSDictionary * dic in array) {

if (condition){

[arrayTemp removeObject:dic];

}

}

这种方法就是在定义一个一模一样的数组，便利数组A然后操作数组B

今天终于找到了一个更快接的删除数组里面的内容以及修改数组里面的内容的方法：

NSMutableArray *tempArray = [[NSMutableArray alloc]initWithObjects:@"12",@"23",@"34",@"45",@"56", nil];

[tempArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {

if ([obj isEqualToString:@"34"]) {

*stop = YES;

if (*stop == YES) {

[tempArray replaceObjectAtIndex:idx withObject:@"3333333"];

}

}

if (*stop) {

NSLog(@"array is %@",tempArray);

}

}];



利用block来操作，根据查阅资料，发现block便利比for便利快20%左右，这个的原理是这样的：

找到符合的条件之后，暂停遍历，然后修改数组的内容

转自：https://www.cnblogs.com/rglmuselily/p/6249015.html

• 一.isa指针

• 上篇文章我们提到了实例对象，类对象和元类对象的存储结构里面都包含了一个isa指针，今天我们来看看它的作用，以及实例对象类对象元类对象之间的关联

• 
  

• 实例对象的isa指针

  
  
  • 当实例对象（instance）调用对象方法的时候，实例对象的isa指针指向类对象（class），在类对象中，查找对象方法并调用
  
  


• 
  

  类对象的isa指针

  
  

  • 类对象（class）的isa指针指向元类对象（meta-class），当调用类方法时，类对象的isa指针指向元类对象，并在元类里面找到类方法并调用

    二.类对象的supercl

    • 先两个类，一个Person继承自NSObject，一个类继承自Person
    /// Person继承自NSObject
    

    @interface Person : NSObject
    
    -(void)perMethod;
    
    +(void)perEat;
    
    @end
    
    @implementation Person
    
    -(void)perMethod{
    
    }
    
    +(void)perEat{ 
    
    }
    
    
    
    @end
    
    
    
    /// student继承自Person
    
    @interface Student : Person
    
    -(void)StudentMethod;
    
    +(void)StudentEat;
    
    @end
    
    @implementation Student
    
    
    
    -(void)StudentMethod{  
    
    }
    
    +(void)StudentEat{
    
    }
    
    
    
    

    
    

    
    
    • 当实例对象调用自身的对象方法时，它在自身的class对象中找到StudentMethod方法

    •         Student *student = [[Student alloc]init];
      
              [student StudentMethod]
      
      

      
      

      
      
      • 当实例对象调用父类的方法的时候
      
      

      
      

              Student *student = [[Student alloc]init];
      
              [student perMethod];当子类调用父类的实例方法的时候，子类的class类对象的superclass指针指向父类，直至基类（NSObject）找到方法并执行（注意，这里指的是实例方法，也就是减号方法）
      三.元类对象的superclass 指针
      当子类调用父类的类方法的时候，子类的superclass指向父类，并查找到相应的类方法，调用
      

    • [Student perEat];

    • 
      

    • 总的来说，isa，superclass的的关系可以用一副经典的图来表示

      
      

    • instance的isa指向class

      class的isa指向meta-class

      meta-class的isa指向基类的meta-class

      class的superclass指向父类的class

    • 
      
    • 
      
    • 作者：枫紫_6174
      原贴链接：https://www.jianshu.com/p/26f37fb21151
      

• 上一篇文章我们讲到了load方法，今天我们来看看initialize

新建项目，新建类（和上一篇文章所建的类相同，方便大家理解，具体的类相关关系可以看上一篇文章我的介绍）类结构图如下

将原来的load方法换成initialize

说明：NSLog(@"---")是由于我建的是命令行工程，不写这个，貌似不能显示控制台，Xcode版本是12，当然你们的要显示控制台，直接去掉这行代码

从输出结果可以看到没有任何关于initialize的打印，程序直接退出

• 2.initialize的打印

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

    }

    return 0;

}

运行结果：

2020-12-04 14:59:17.417072+0800 TCCateogry[1616:79391] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

从上面的输出结果我们可以看到，TCPerson (TCtest2) +initialize打印

load是直接函数指针直接调用，类，分类，继承等等

[TCPerson alloc]就是相当于该类发送消息，但是它只会调用类，分类的其中一个（取决于编译顺序，从输出结果可以看出，initialize走的是objc_msgSend，而load直接通过函数指针直接调用，所以initialize通过isa方法查找调用.

多次向TCPerson发送消息的输出结果

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

    }

    return 0;

}

输出结果：

2020-12-04 15:11:12.246442+0800 TCCateogry[1659:85317] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

initialize只会调用一次

我们再来看看继承关系中，initialize的调用

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCStudent alloc];

      

    }

    return 0;

}

输出结果：

2020-12-04 15:14:58.705423+0800 TCCateogry[1705:87507] TCPerson (TCtest2) +initialize

2020-12-04 15:14:58.705750+0800 TCCateogry[1705:87507] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

从输出结果来看，子类调用initialize之前，会先调用父类的initialize，再调用自己的initialize，当然无论父类调用initialize，还是子类调用initialize，如果有多个分类（这里指的是父类调用父类的分类，子类调用子类的分类），调用initialize取决于分类的编译顺序（调用后编译分类中的initialize，类似于压栈，先进后出），值得注意的是，无论父类子类的initialize，都只调用一次

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];

        [TCPerson alloc];

        [TCStudent alloc];

        [TCStudent alloc];

    }

    return 0;

}

输出结果：

020-12-04 15:23:27.168243+0800 TCCateogry[1731:91248] TCPerson (TCtest2) +initialize

2020-12-04 15:23:27.168601+0800 TCCateogry[1731:91248] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

如果子类（子类的分类也不实现）不实现initialize，则父类的initialize就调用多次

#import "TCStudent.h"



@implementation TCStudent

//+ (void)initialize{

//    NSLog(@"TCStudent +initialize");

//}

@end

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];   

        [TCStudent alloc];

    }

    return 0;

}

2020-12-04 15:37:09.055459+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

2020-12-04 15:37:09.055775+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

#import "TCStudent.h"



@implementation TCStudent

+ (void)initialize{

    NSLog(@"TCStudent +initialize");

}

@end

#import "TCStudent+TCStudentTest1.h"



@implementation TCStudent (TCStudentTest1)

+ (void)initialize{

    NSLog(@"TCStudent (TCStudentTest1) +initialize");

}

@end#import "TCStudent+TCStudentTest2.h"



@implementation TCStudent (TCStudentTest2)

+ (void)initialize{

    NSLog(@"TCStudent (TCStudentTest2) +initialize");

}

@end

2020-12-04 15:41:21.863260+0800 TCCateogry[1868:100750] TCPerson (TCtest2) +initialize

2020-12-04 15:41:21.863568+0800 TCCateogry[1868:100750] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0