4 |
5 | 
6 | 
7 | 
8 | 
9 | 
10 |
11 |
[JSPatch作者博客中的技能栈-图](./images/iOS/iOSDev-bang.png)| 73 | |iOS开发相关shell脚本|[组件自动化更新&&组件校验脚本](https://github.com/DevDragonLi/DevelopBaseNote#shell)
[多项目批量更新检出脚本](https://github.com/DevDragonLi/DevelopBaseNote#shell)| 74 | |iOSDevNote|[**东半球效率最高的iOS组件通信中间件**](https://github.com/DevDragonLi/ProtocolServiceKit)
[**iOS UI界面热重载神器InjectionTool**:支持懒加载](https://github.com/Todaycoding/InjectionTool)
[**DarkMode适配组件**](https://github.com/DevDragonLi/LFLDarkModeKit)
[iOS项目完全解耦**Debug菜单中心组件**](https://github.com/DevDragonLi/iOSDebugKit)
[**iOS开发架构分享文稿**](./iOSNote/iOS_architecture.pdf)
[**掘金客户端体积瘦身**](./iOSNote/iOSAppThin.md)
[**iOSDevCodeRepo**](https://github.com/DevDragonLi/iOSDevDemo)
[Core Animation框架结构及性能调优11张大图详解](https://github.com/DevDragonLi/Core-AnimationPerformanceOptimization)
[iOS_StaticLibrary](./iOSNote/iOS_StaticLibrary.md)
[iOS经典Crash分析与总结- QQ`MelonTeam`](https://github.com/DevDragonLi/iOSDevDemo)
[iOS核心动画高级技巧阅读笔记(**性能调优**,**高效绘制**,**图像IO**,**图层性能**)](./iOSNote/iOSCoreAnimationNote.md)
[单元测试概述](./iOSNote/UnitTesting.md)| 75 | |CocoaPods |[**cocoapods Install [已适配M1]**](./iOSNote/CocoaPods/cocoapods.md)
[**cocoapods-plugins：插件汇总**](./iOSNote/CocoaPods/cocoapods-plugins.md)
[开源组件之开发流程](./iOSNote/CocoaPods/cocoapods-pod.md)
[管理库的使用技巧](./iOSNote/CocoaPods/cocoapods-pod.md)
[公司内部组件化开发参考基础文档](./iOSNote/CocoaPods/cocoapods-PodFile&spec.md)
[私有库参考Demo](https://github.com/DevDragonLi/iOSDevDemo/tree/master/1-DevDemo/PodPrivate_demo)
[Podspec语法说明及PodFile使用汇总](./iOSNote/CocoaPods/cocoapods-PodFile&spec.md)| 76 | |开源框架|**[WiFi显示图片高清图;蜂窝显示图片缩略图解析](./iOSNote/Analyze/SDWebImage/网络网络状态不同加载图片.md)**
**[MJRefresh源码解析](./iOSNote/Analyze/MJRefresh/MJRefresh.md)**| 77 | 78 | ## 赞赏一下旺仔(收集整理不易，且赞且珍惜) 79 | 80 | 81 |
82 |
83 |
84 | ## 欢迎提交 PR / issue
85 |
86 | > **Dragonli_52171@163.com**
87 |
88 |
89 | 
90 |
--------------------------------------------------------------------------------
/interview-iOS/07深圳iOS面试分享2018年4月.md:
--------------------------------------------------------------------------------
1 | # 深圳iOS面试分享2018年4月
2 |
3 | > 作者：Xcode_boy&&juejin.im/post/5adaed6a518825673123c757
4 |
5 | - [请在1000万个整型数据中以最快的速度找出其中最大的1000个数？](#请在1000万个整型数据中以最快的速度找出其中最大的1000个数)
6 | - [循环链表题：一个有序循的整形环链表断开了，请插入一个整形数，使得链表仍然是有序的。](#循环链表题一个有序循的整形环链表断开了请插入一个整形数使得链表仍然是有序的)
7 | - [Block中可以修改全局变量，全局静态变量，局部静态变量吗？](#block中可以修改全局变量全局静态变量局部静态变量吗)
8 | - [NSString代码输出考察 ?](#nsstring代码输出考察)
9 | - [SDWebImage实现原理是什么？
10 | 它是如何解决tableView的复用时出现图片错乱问题的呢？](#sdwebimage实现原理是什么-它是如何解决tableview的复用时出现图片错乱问题的呢)
11 | - [Swift问题](#swift问题)
12 | - [struct 和 class 的区别？](#struct-和-class-的区别)
13 | - [class与staitc关键字的区别？](#class与staitc关键字的区别)
14 |
15 | ## 算法题
16 |
17 | ### 请在1000万个整型数据中以最快的速度找出其中最大的1000个数？
18 |
19 |
28 |
29 | ### 循环链表题：一个有序循的整形环链表断开了，请插入一个整形数，使得链表仍然是有序的。
30 |
31 | 参考内容
20 | 21 | > 这是一个经常被问到的问题，百度网上解法也很多。这里仅提供基本思路，供参考： 22 | 23 | - 把1000万的整型平均分到合适n个文件中，分别对每一份文件找出前1000个最大的数，最后对每份文件前1000数据用常规算法合并即可。 24 | - 那么，如何从每一份文件中找出前1000个最大的数呢？ 25 | - **先取文件中前1000个数放到数组中，并排好序（假设升序），之后从文件中读取下一个数与数组第一个数比较，如果比数组中第一个数大，则替换数组第一个数，并重新排序，之后再取下一个数进行下轮比较即可。** 26 | 27 |
32 |
36 | #include
37 | typedef struct node{
38 | int data;
39 | struct node *next;
40 | }linklist;
41 |
42 | linklist *createList(){
43 | linklist *head,*p,*q;
44 | int x;
45 | scanf("%d",&x);
46 | p=(linklist *)malloc(sizeof(linklist));
47 | p->data=x;
48 | head=p;
49 | scanf("%d",&x);
50 | while (x!=-1){
51 | q=(linklist *)malloc(sizeof(linklist));
52 | q->data=x;
53 | p->next=q;
54 | p=q;
55 | scanf("%d",&x);
56 | }
57 | p->next=NULL;
58 | return head;
59 | }
60 |
61 | linklist *insertList(int n,linklist *head){
62 | linklist *p,*q,*s;
63 | s=(linklist *)malloc(sizeof(linklist));
64 | s->data=n;s->next=NULL;
65 | if (head==NULL) return p;
66 | p=q=head;
67 | while (q!=NULL && q->data < n){
68 | p=q;q=q->next;
69 | }
70 | if (p==head){
71 | s->next=p;head=s;//在头部插入
72 | }
73 | else{
74 | s->next=q;p->next=s;
75 | }
76 | return head;
77 | }
78 | void printList(linklist *head){
79 | linklist *t;
80 | t=head;
81 | if (t==NULL)
82 | printf("这是一个空列表\n");
83 | while (t!=NULL){
84 | printf("%d ",t->data);
85 | t=t->next;
86 | }
87 | printf("\n");
88 | }
89 | int main()
90 | {
91 | linklist *head;
92 | int n;
93 | printf("请输入一组递增数，以-1结束\n");
94 | head=createList();
95 | printList(head);
96 | printf("请输入要插入的数\n");
97 | scanf("%d",&n);
98 | head=insertList(n,head);
99 | printList(head);
100 |
101 | system("pause");
102 | return 0;
103 | }
104 |
105 | ```
106 |
107 |
108 | ### Block中可以修改全局变量，全局静态变量，局部静态变量吗？
109 |
110 | C语言实现参考内容
33 | 34 | ``` 35 | #include
111 |
122 |
123 | ### NSString代码输出考察 会输出什么？
124 |
125 | ```objc
126 |
127 | @property (nonatomic, strong) NSString *strongString;
128 | @property (nonatomic, weak) NSString *weakString;
129 |
130 | strongString = [NSString stringWithFormat:@"%@",@"string1"];
131 | weakString = strongString;
132 | strongString = nil;
133 |
134 | NSLog(@"%@", weakString);
135 |
136 | ```
137 |
138 | 参考内容
112 | 113 | > 修饰符所有权一同捕获 114 | 115 | - 参考链接 [深入研究Block捕获外部变量和__block实现原理](https://www.jianshu.com/p/ee9756f3d5f6) 116 | - 全局变量和静态全局变量的值改变，以及它们被Block捕获进去，因为是全局的，作用域很广 117 | - 静态变量和自动变量，被Block从外面捕获进来，成为__main_block_impl_0这个结构体的成员变量 118 | - 自动变量是以值传递方式传递到Block的构造函数里面去的。Block只捕获Block中会用到的变量。由于只捕获了自动变量的值，并非内存地址，所以Block内部不能改变自动变量的值。 119 | - Block捕获的外部变量可以**改变值的是静态变量，静态全局变量，全局变量** 120 | 121 |
139 |
147 |
148 | ### SDWebImage实现原理是什么？ 它是如何解决tableView的复用时出现图片错乱问题的呢？
149 | 参考内容
140 | 141 | - NSString的问题，这个跟retainCount没什么太大的关系 142 | - **首先，stringWithFormat方法创建的字符串是autorelease的，本身就会延迟释放，直接跟log的话肯定不会输出null，如果你写个button做触发，放在方法外作log的话，才会打印出null** 143 | - 在64位环境下，苹果对NSString做了优化，细节不说，具体表现是，当非字面值常量的数字，英文字母字符串的长度小于等于 9 的时候会自动成为 NSTaggedPointerString 类型，如果有中文或其他特殊符号存在的话则会直接成为__NSCFString 类型。而NSTaggedPointerString是个常量释放不掉的. 144 | - 最后，如果是使用@""或者initWithString:@""的方式创建的字符串，会被转换成__NSCFConstantString,也是个常量，释放不掉不会输出null 145 | 146 |
150 |
162 |
163 | ## Swift问题
164 |
165 | ### struct 和 class 的区别？
166 |
167 | 参考内容
151 | 152 | - 解决tableView复用错乱问题：每次都会调UIImageView+WebCache文件中的 [self sd_cancelCurrentImageLoad]; 153 | - [原理解释参考](https://www.jianshu.com/p/13c0cdc7987e) 154 | - SDWebImageDownloader 155 | - 图片的下载操作放在一个NSOperationQueue并发操作队列中，队列默认最大并发数是6 156 | - 每个图片对应一些回调（下载进度，完成回调等），回调信息会存在downloader的URLCallbacks（一个字典，key是url地址，value是图片下载回调数组）中，URLCallbacks可能被多个线程访问，所以downloader把下载任务放在一个barrierQueue中，并设置屏障保证同一时间只有一个线程访问URLCallbacks。，在创建回调URLCallbacks的block中创建了一个NSOperation并添加到NSOperationQueue中 157 | - 下载的核心是利用NSURLSession加载数据，每个图片的下载都有一个operation操作来完成，并将这些操作放到一个操作队列中，这样可以实现图片的并发下载。 158 | - 内存缓存的处理由NSCache对象实现，NSCache类似一个集合的容器，它存储key-value对，类似于nsdictionary类，我们通常使用缓存来临时存储短时间使用但创建昂贵的对象，重用这些对象可以优化新能，同时这些对象对于程序来说不是紧要的，如果内存紧张就会自动释放。 159 | - 先在内存中放置一份缓存，如果需要缓存到磁盘，将磁盘缓存操作作为一个task放到串行队列中处理，会先检查图片格式是jpeg还是png，将其转换为响应的图片数据，最后吧数据写入磁盘中（文件名是对key值做MD5后的串）。 160 | 161 |
168 |
177 |
178 |
179 | ### class与staitc关键字的区别？
180 | 参考内容
169 | 170 | - 类可以继承，结构体不可以 171 | 172 | - 可以让一个类的实例来反初始化，释放存储空间，结构体做不到 173 | 174 | - 类的对象是引用类型，而结构体是值类型。所以类的赋值是传递引用 ，结构体则是传值。 175 | 176 |
181 |
191 |
192 |
193 | ### 觉得整理的蛮不错，可以赞赏一下旺仔(收集整理不易，且赞且珍惜)
194 |
195 |
196 | 参考内容
182 | 183 | - static 可以在类、结构体、或者枚举中使用。而 class 只能在类中使用。 184 | - static 可以修饰存储属性，static 修饰的存储属性称为静态变量(常量)。而 class 不能修饰存储属性。 185 | - static 修饰的计算属性不能被重写。而 class 修饰的可以被重写。 186 | - static 修饰的静态方法不能被重写。而 class 修饰的类方法可以被重写。 187 | - class 修饰的计算属性被重写时，可以使用 static 让其变为静态属性。 188 | - class 修饰的类方法被重写时，可以使用 static 让方法变为静态方法。 189 | 190 |
21 |
83 |
84 | - 业务上的问题，为什么用highcharts这个库
85 | - 这个面试问题是根据你的项目经验提出的，所以具体问题具体分析。
86 |
87 | - webview的优化，webview为什么会加载白屏
88 | 参考内容
22 | - 判等流程 23 | 24 | - 实现一个新的 isEqualTo__ClassName__ 方法，进行实际意义上的值的比较。 25 | - 重载 isEqual: 方法进行类和对象的本体性检查，如果失败则回退到上面提到的值比较方法。 26 | - 重载 hash 方法，在下一个部分会详细介绍 27 | 28 | - 对于面向对象编程来说，对象相等性检查的主要用例，就是确定一个对象是不是一个集合的成员。为了加快这个过程，子类当中需要实现 hash 方法: 29 | 30 | - 对象相等具有 交换性 （[a isEqual:b] ⇒ [b isEqual:a]) 31 | - 如果两个对象相等，它们的 hash 值也一定是相等的 ([a isEqual:b] ⇒ [a hash] == [b hash]) 32 | - 反过来则不然，两个对象的散列值相等不一定意味着它们就是相等的 ([a hash] == [b hash] ¬⇒ [a isEqual:b]) 33 | 34 | ``` 35 | //NSObject 使用 isEqual: 这个方法来测试和其他对象的相等性。在它的基类实现中，相等性检查本质上就是对本体性的检查。 36 | //两个 NSObject 如果指向了同一个内存地址，那它们就被认为是相同的。 37 | @implementation NSObject (Approximate) 38 | - (BOOL)isEqual:(id)object { 39 | return self == object; 40 | } 41 | @end 42 | // 一个完整例子 43 | @interface Person 44 | @property NSString *name; 45 | @property NSDate *birthday; 46 | 47 | - (BOOL)isEqualToPerson:(Person *)person; 48 | @end 49 | 50 | @implementation Person 51 | 52 | - (BOOL)isEqualToPerson:(Person *)person { 53 | if (!person) { 54 | return NO; 55 | } 56 | 57 | BOOL haveEqualNames = (!self.name && !person.name) || [self.name isEqualToString:person.name]; 58 | BOOL haveEqualBirthdays = (!self.birthday && !person.birthday) || [self.birthday isEqualToDate:person.birthday]; 59 | 60 | return haveEqualNames && haveEqualBirthdays; 61 | } 62 | 63 | 64 | - (BOOL)isEqual:(id)object { 65 | if (self == object) { 66 | return YES; 67 | } 68 | 69 | if (![object isKindOfClass:[Person class]]) { 70 | return NO; 71 | } 72 | 73 | return [self isEqualToPerson:(Person *)object]; 74 | } 75 | 76 | //对于好奇心旺盛和不畏钻研的同学来说，Mike Ash 的这篇博文解释了如何通过移位操作和旋转可能重复的部分值来进一步优化 hash 函数的实现。 77 | - (NSUInteger)hash { 78 | return [self.name hash] ^ [self.birthday hash]; 79 | } 80 | 81 | ``` 82 |
89 |
104 |
105 | - 项目遇到哪些比较困难的问题
106 | - 曲线卡顿问题
107 | - 全局切换工厂问题
108 |
109 | - app 启动优化
110 | 参考内容
90 | 91 | - webview加载H5页面过程 92 | - 初始化 webview -> 请求页面 -> 下载数据 -> 解析HTML -> 请求 js/css 资源 -> dom 渲染 -> 解析 JS 执行 -> JS 请求数据 -> 解析渲染 -> 下载渲染图片 93 | - 优化 94 | - 前端优化 95 | - 合并资源，减少http请求数 96 | - 加快请求速度：预解析DNS，减少域名数，并行加载，CDN 分发 97 | - 客户端优化 98 | - 离线包方案：把一个个功能模块的所有相关页面和资源打包下发 99 | - 提前初始化 webview，提供一个全局的webview。添加webview 池重用池，可以用两个或多个 webview 重复使用 100 | - 预加载数据 101 | - 总结：缓存/预加载/并行，缓存一切网络请求，尽量在用户打开之前就加载好所有内容，能并行做的事不串行做。 102 | 103 |
111 |
127 |
128 | - TableView卡顿
129 | - 要说明ios卡顿&掉帧的原理
130 | - 然后针对CPU和GPU渲染超时的解决方案
131 |
132 | - 查找两个view的共同父视图
133 | 参考内容
112 | 113 | - App总启动时间 = pre-main耗时 + main耗时，可以通过添加环境变量：DYLD_PRINT_STATISTICS 114 | 115 | - 启动流程 116 | - pre-main：系统dylib(动态链接库)和自身App可执行文件的加载 117 | - main: main方法执行之后到AppDelegate类中的didFinishLaunchingWithOptions方法执行结束前这段时间，主要是构建第一个界面，并完成渲染展示 118 | - pre-main优化 119 | - 减少类的数量，删除无用代码（未被调用的静态变量、类和方法,抽象重复代码 120 | +load方法中做的事情延迟到+initialize中，或者在+load中做的事情不宜花费过多时间 121 | - 减少不必要的framework，或者优化已有的framework 122 | - main阶段优化 123 | - didFinishLaunchingWithOptions,日志、统计，某个功能的预加载,第三方SDK初始化，可以采用懒加载，或者分阶段启动 124 | - 首页启动渲染的页面优化，对于viewDidLoad以及viewWillAppear方法中尽量去尝试少做，晚做，不做，或者采用异步的方式去做。不使用xib或者storyboard，直接使用代码 125 | 126 |
134 | *)findSuperViews:(UIView *)view
174 | {
175 | UIView * temp = view.superview;
176 |
177 | NSMutableArray * result = [NSMutableArray array];
178 |
179 | while (temp) {
180 |
181 | [result addObject:temp];
182 |
183 | temp = temp.superview;
184 | }
185 |
186 | return result;
187 | }
188 |
189 | ```
190 |
191 |
192 | - 用过设计模式介绍下
193 | 参考内容
135 | 136 | > 注意这是要手敲代码的！！！ 137 | 138 | > 思考：如果是只需要查找最近的公共父视图呢？ 139 | 140 | ```objc 141 | 142 | - (void)findCommonSuperViews:(UIView *)view1 view2:(UIView *)view2 143 | { 144 | NSArray * superViews1 = [self findSuperViews:view1]; 145 | 146 | NSArray * superViews2 = [self findSuperViews:view2]; 147 | 148 | NSMutableArray * resultArray = [NSMutableArray array]; 149 | 150 | int i = 0; 151 | 152 | while (i < MIN(superViews1.count, superViews2.count)) { 153 | 154 | UIView *super1 = superViews1[superViews1.count - i - 1]; 155 | 156 | UIView *super2 = superViews2[superViews2.count - i - 1]; 157 | 158 | if (super1 == super2) { 159 | 160 | [resultArray addObject:super1]; 161 | 162 | i++; 163 | 164 | }else{ 165 | 166 | break; 167 | } 168 | } 169 | 170 | NSLog(@"resultArray:%@",resultArray); 171 | 172 | } 173 | - (NSArray
194 |
210 |
211 | ## 链接
212 |
213 | - [面试题系列目录](../README.md)
214 | - **上一份**: [第22份：2020年3月份快手X3岗面试题](22快手X3岗面试题2020年3月.md)
215 | - **下一份**: [第24份：阿里iOS五轮面经2019年10月](24阿里iOS五轮面经2019年10月.md)
216 |
217 |
218 |
219 | ## 赞赏一下旺仔(收集整理不易，且赞且珍惜)
220 |
221 |
222 | 参考内容
195 | 196 | > 六大原则：单一职责/开闭/接口隔离/依赖倒置/里氏替换/迪米特原则 197 | 198 | - 单例模式:保证一个类仅有一个实例，并提供一个访问它的全局访问点。 199 | - 优点： 1. 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。2. 避免对资源的多重占用（比如写文件操作）。 200 | - 缺点： 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。 201 | 202 | - 工厂模式:定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。 203 | - 优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。 204 | - 缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。 205 | - 观察者模式：系统的KVO 206 | - 桥接模式：业务解耦 207 | - 适配器：一个类需要适应变化的需求，对象适配器和类适配器 208 | - 命令模式：YTKNetwork 采用此模式 209 |
224 |
225 |
226 |
--------------------------------------------------------------------------------
/interview-iOS/25小米百度bigo滴滴快手等iOS面试题2020年上.md:
--------------------------------------------------------------------------------
1 | # 小米百度bigo 滴滴 快手等iOS 面试题2020年上
2 |
3 | > xiaozhuanlan.com/topic/7628534019
4 | > 第25份面试题
5 |
6 | #### 面试过程
7 |
8 | - 在疫情期间都是远程面试，下边先介绍一下疫情期间面试的一些公司的面试情况。同时拿到了其中几家的 offer。下边介绍的面试题只还原了其中印象比较深的部分，会存在不足的情况，并不代表面试的全部。
9 |
10 | ## 小米
11 |
12 | ### 一面 （已更新参考答案）
13 |
14 | * 介绍有哪些设计原则，并让比较详细的说了其中开闭原则在项目中的应用。
15 | * [六大设计原则](./23抖音面试题2020年3月.md)
16 | * 开闭原则在项目中的应用：一个软件实体应当对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。（分类）
17 | * 介绍设计模式，然后其中主要问了我抽象工厂和适配器两种模式。
18 | * [常见设计模式](./23抖音面试题2020年3月.md)
19 | * 介绍 runloop 相关的知识和在实际开发中的使用情况
20 | * [Runloop相关问题解答参考面试题第六份](./06iOS基础问题系列2017年.md)
21 | * [应用示例：卡顿监控](19新浪公司iOS面试题2019年6月.md),亦可以优化列表大图加载等场景。
22 |
23 | #### 要求详细的描述事件响应链
24 |
25 |
26 |
56 |
57 | ### 二面（已更新参考答案）
58 |
59 | > 介绍过往的项目经验，因为曾经的项目和所面试的部门岗位需求匹配度较高，所以这块的时间占比较多。
60 |
61 | * 【回文算法】判断一个字符串是不是对称的字符串，比如 abba 或者 aba 这样的就是对称的。
62 |
63 | 参考内容
27 | 28 | ``` 29 | //判断点击的位置是不是在视图内 30 | - (BOOL)pointInside:(CGPoint)point withEvent:(nullable UIEvent *)event; 31 | //返回点击的视图 32 | - (nullable UIView *)hitTest:(CGPoint)point withEvent:(nullable UIEvent *)event; 33 | 34 | ``` 35 | ##### 事件的传递 36 | 37 | - 加入到一个由UIApplication管理的事件队列中（队列的特点是FIFO，即先进先出，先产生的事件先处理才符合常理，所以把事件添加到队列中） 38 | 39 | - UIApplication会发送事件给应用程序的主窗口UIWindow。 40 | 41 | - 主窗口UIWindow会调用hitTest:withEvent:方法在视图(UIView)层次结构中找到一个最合适的UIView来处理触摸事件（也就是把事件传递给那个最适合的UIView） 42 | 43 | ##### 工作流程 44 | 45 | * 首先调用当前视图的pointInside:withEvent:方法判断触摸点是否在当前视图内 46 | 47 | * 若pointInside:withEvent:方法返回NO，说明触摸点不在当前视图内，则当前视图的hitTest:withEvent:返回nil 48 | 49 | * 若pointInside:withEvent:方法返回YES，说明触摸点在当前视图内，则遍历当前视图的所有子视图(subviews)，调用子视图的hitTest:withEvent:方法重复前面的步骤，子视图的遍历顺序是从top到bottom，即从subviews数组的末尾向前遍历，直到有子视图的hitTest:withEvent:方法返回非空对象或者全部子视图遍历完毕。 50 | 51 | * 若第一次有子视图的hitTest:withEvent:方法返回非空对象,则当前视图的hitTest:withEvent:方法就返回此对象，处理结束 52 | 53 | * 若所有子视图的hitTest:withEvent:方法都返回nil，则当前视图的hitTest:withEvent:方法返回当前视图自身(self) 54 | 55 |
64 |
79 |
80 | * block 的实现原理
81 |
82 | 参考内容
65 | 66 | ``` 67 | bool check_string(char *s){ 68 | int len = strlen(s); 69 | int i = 0; 70 | int j = len-1; 71 | while(i < j){ 72 | if(s[i] != s[j])return false; 73 | } 74 | retrun true; 75 | } 76 | 77 | ``` 78 |
83 |
102 | * 比较详细的介绍 https 的过程。
103 | * 过往开发中做过哪些优化向的工作，问的也比较详细。
104 | * 如何检测项目中的卡顿问题（比如假死）
105 | * [应用示例：卡顿监控](19新浪公司iOS面试题2019年6月.md)
106 | * 比较详细的介绍消息转发流程和事件响应链
107 | * [消息转发流程](./08字节跳动面试题：2018年4月.md)
108 | * 事件响应链参考一面链接
109 | * GCD 的底层线程调度原理
110 | * 介绍 hash 算法的原理
111 |
112 | ### 三面
113 |
114 | * 一个二叉树逐层打印的算法题
115 | * [😁leetcode](https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/)
116 | * 介绍自己的过往的项目经验，会结合项目问一些架构向的思考
117 | * 如果现在做一个新的网络层框架，有哪些需要考量的点
118 | * 参考知名网络框架，或者绘制UML图。
119 |
120 | ## 百度
121 |
122 | > 百度只有一面，因为面得是百度的商业化部门，对于细节的要求非常严格。个人感觉自己的表现确实不是很好。
123 |
124 | * 判断一个字符串是不是 ipv6 地址（要求尽全力的考虑所有异常的情况）
125 | * [同是百度面试题，类似参考](./11天猫蚂蚁金服百度面试题2018年4月.md)
126 | * PS:当时面试官明确告诉我，这个面试题做不好，面试是直接结束的。
127 |
128 | * 介绍界面卡顿的优化有哪些可以优化的点。
129 | 参考内容
84 | 85 | * block本质一个对象，主要分为 Imp 结构体 和 Desc 结构体 86 | * [block全部，静态，局部变量相关](./07深圳iOS面试分享2018年4月.md) 87 | 88 | ``` 89 | struct __main_block_impl_0 { 90 | struct __block_impl impl; 91 | struct __main_block_desc_0* Desc; 92 | __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) { 93 | impl.isa = &_NSConcreteStackBlock; 94 | impl.Flags = flags; 95 | impl.FuncPtr = fp; 96 | Desc = desc; 97 | } 98 | }; 99 | 100 | ``` 101 |
130 |
134 | * 介绍 UIResponder 的继承链。然后说事件响应链。
135 | * 参考上文小米面试题解答。
136 |
137 | ## Bigo
138 |
139 | > 感觉面试的这些公司，Bigo 对于基础的考察最全面。
140 |
141 | ### 一面
142 |
143 | * (算法)找出一个页面中漏出部分面积最大的试图，重合的部分按照最上层的面积算漏出，会有时间复杂度的要求。
144 | * 简单地介绍的过往的项目经验
145 | * 控件的点击事件和添加在上边的手势谁先响应，并说明原因
146 | * 谈 CoreAnimation 和 CoreGraphic 的区别
147 | * 说 @synchronized 锁的实现原理，并说明其中可能存在的问题。同时介绍了 iOS 开发中常见的锁。
148 | * 介绍编译的过程和原理
149 | * 谈对于 bitcode 的理解和作用。
150 | * 详细的介绍了 Https 的过程。
151 |
152 | ### 二面
153 |
154 | * 介绍属性常用修饰符，介绍 assign 和 weak 之间的区别。这块会延伸到内存管理相关，比如引用计数的方式。
155 | * 聊对于 GCD 的理解，和 GCD 底层是如何进行线程调度的。聊 GCD 中常见方法的使用 （group ，信号量
156 | * ，barrier 等）
157 | * 详细的介绍了 KVC 和 KVO 的原理。
158 | * 介绍消息转发过程
159 | * 介绍对于 Runloop 并介绍知道的应用场景。再具体场景中会有追问。
160 | * 介绍项目优化的经验，这一块会聊的比较细。
161 | * 介绍对于静态库和动态库的理解。
162 | * 在 webview 使用过程中存在的问题和解决方案。
163 |
164 | ### 三面
165 |
166 | * 介绍了过往 RN 的使用经验和对于 Flutter 的理解。
167 | * 谈对于组件化的理解和市面上常见的组件化方案
168 | * 问了一些 APM 向上的问题。
169 | * 谈个人对于项目架构选择的理解。自己如何进行架构的选择（主要对于 MVVM，MVC等，后文有个人对于这一块的理解）
170 | * 谈个人规划
171 |
172 | ## 滴滴
173 |
174 | ### 一面
175 |
176 | > 滴滴的一面分为两部分。
177 |
178 | * 第一部分：过往项目经验，会对自己的过往项目经验，结合自己的描述，面试官问你介绍到的项目中涉及到问题，然后会据此引申出一些问题，这一部分占比比较大。
179 | * 第二部分是基础知识面
180 | * 谈属性修饰符，如果 assign 修饰对象可能存在的问题和原因。
181 | * 比较的深入的聊了内存管理的内容，包含引用计数和 weak 修饰的对象的内存管理的过程。问的会比较深入。
182 | * 讲 runloop 的过往使用经验。
183 | * 介绍自己比较熟悉的三方库的实现原理
184 |
185 | ## 二面
186 |
187 | * 对于锁的理解（自旋锁和互斥锁），以及 iOS 开发中常见的锁。同时要求介绍个人在开发过程中在哪些场景下用到过锁。
188 | * 在实际开发中遇到过哪些多线程问题以及如何进行解决的。
189 | * 为什么不能在异步线程中更新页面，介绍原因。
190 | * 对于内存泄漏的了解，以及介绍知道的解决方案。
191 | * 一些优化向上的问题，主要是根据自己介绍的优化进行较为深入的追问。
192 | * 一个坦克从一个空间的起点到终点，中间在某些位置上有阻隔的情况下，判断从起点到终点是否有可行路径的算法题。
193 |
194 | ### 三面
195 |
196 | * 比较详细的介绍之前的项目经验和主要负责的内容
197 | * 介绍过往项目中最有挑战的事情，并会据此深入的聊。
198 | * 介绍了一些架构向的理解
199 | * 谈个人规划
200 |
201 | ## 快手
202 | > 快手的一面是跨部门面试，二面是本部门面，所以一二面面试题会有一些重复，只写了一次。
203 |
204 | ### 一面
205 |
206 | * 介绍过往的项目经验
207 | * 两个不算难的算法题（具体的忘记了...）
208 | * 聊了 assign 修饰对象可能存在的问题
209 | * 聊过往项目中的优化经验
210 | * 介绍消息转发流程
211 |
212 | ### 二面
213 |
214 | * 比较详细的聊到的 block，深入的讲了其中的实现原理，并介绍不同变量的引用方式。
215 | * 介绍开发中常见的循环引用，并说明其中的原因和解决的方案和原理。
216 | * 介绍 Runloop 并讲应用场景。
217 | * 二叉树翻转
218 |
219 | ### 三面
220 |
221 | * 一道多线程实际场景下的问题，要求远程写出实现方案的代码
222 | * 聊对于 MVVM，MVC 和 MVP 的理解。
223 | * 介绍过往项目中 RN 的使用经验和遇到的问题。
224 | * 讲如何将一张内存极大的图片可以像地图一样的加载出来（只说实现思路）
225 | * 聊对于组件化的理解，对于市面上的组件化方案的理解，优劣分析等。
226 |
227 |
228 | ## 其他
229 | * 除了上边介绍的公司外，还面了平安，51 talk，58 同城，好未来，美篇。
230 | * 因为绝大部分面试内容和上边的基本上只是重复，只对差异性的面试题进行了总结。
231 | * 对图像编解码的了解
232 | * 在子线程中是如何进行内存管理的JSBridge 是如何实现的,以及和原生的调用关系。
233 | * 问到了一些 AFNetworking 和 SDWebImage 相关的实际开发中的问题。
234 |
235 | ### 觉得整理的蛮不错，可以赞赏一下旺仔(收集整理不易，且赞且珍惜)
236 |
237 |
238 | 参考内容
131 | * 复用cell，缓存 Cell 高度，减少一些复杂的 layout，文字计算等，可进行缓存处理； 132 | * 异步渲染内容到图片&&图片解码放到子线程处理 133 |
21 |
27 |
28 | ### KVO/KVC的优缺点？
29 |
30 | 参考内容
22 | 23 | - KVC : 键值编码，是Key Value Coding 的简称，cocoa的标准组成部分，是一种可以直接通过字符串的名字(Key)来访问类属性的机制，而不是通过调用Setter方法、Getter方法进行访问 24 | - KVO：（Key Value Observer）键值观察者，是观察者设计模式的一种具体实现 25 | 26 |
31 |
53 |
54 | ### Swfit和Objective-C的联系及Swift对比Objective-C有什么优势？
55 | 参考内容
32 | 33 | #### KVC： 34 | 35 | - 优点：没有property的变量（私有）也能通过KVC进行设置，或者简化代码（多级属性） 36 | - 缺点：如果key只写错，编写的时候不会报错，但是运行的时候会报错 37 | 38 | #### KVO优点： 39 | 40 | * 能够提供一种简单的方法实现两个对象的同步； 41 | * 能够对内部对象的状态改变作出响应，而且不需要改变内部对象的实现； 42 | * 能够提供被观察者属性的最新值和之前的值； 43 | * 使用key Path来观察属性，因此可以观察嵌套对象； 44 | * 完成了对观察对象的抽象，因为不需要额外的代码来允许观察者被观察。 45 | 46 | #### KVO缺点： 47 | 48 | * KVO只能检测类中的属性，并且属性名都是通过NSString来查找，编译器不会补全（编译时不会出现警告），容易写错； 49 | * 对属性重构，将导致观察代码不可用； 50 | * 复杂的 “if” 语句要求对象正在观察多个值，是因为所有的观察代码通过一个方法来指向； 51 | 52 |
56 |
73 |
74 | ### 举例说明Swfit里面有哪些是Objective-C中没有的？
75 |
76 | 参考内容
57 | 58 | > 联系: 59 | 60 | - Swift与Objective-C共用同一套运行时环境 61 | - 同一个工程，可以同时使用Swift和Objective-C 62 | - Objective-C出现过的绝大多数概念，比如引用记数、ARC、属性、协议、接口、初始化、扩展类、命名参数、匿名函数等，在Swift中继续有效（可能只是换了个术语) 63 | 64 | >优势 65 | 66 | - Swift容易阅读，语法和文件结构简易化。 67 | - Swift更易于维护，文件分离后结构更清晰。 68 | - Swift更加安全，它是类型安全的语言。 69 | - Swift代码更少，简洁的语法，可以省去大量冗余代码 70 | - Swift速度更快，运算性能更高。 71 | 72 |
77 |
103 |
104 | ### 如何对iOS设备进行性能测试？
105 |
106 | - Instruments 是应用程序用来动态跟踪和分析 Mac OS X 和 iOS 代码的实用工具。这是一个灵活而强大的工具,它让你可以跟踪一个或多个进程,并检查收集的数据
107 |
108 | - Profile-> Instruments ->Time Profiler
109 |
110 | ### 集成三方框架有哪些方法？
111 | - 手动集成(不推荐)
112 | - cocoapods集成
113 | - carthage (iOS8+)
114 | - other（参考pb）
115 |
116 | ### 如何解决TableView卡的问题？
117 | 参考内容
78 | 79 | 1).swift独有的范围运算符：a…b 表示 [a,b] 如3…5 就是范围取3，4，5 80 | 81 | 2).swift独有的元组类型 82 | 83 | var point = (x:15,y:20.2) 84 | 就是元组名是 point ，里面有两个元素x和y。 有点类似于结构体. 85 | 86 | 3).函数的默认参数值 87 | 88 | func addStudent (name:string,age:Int = 20) –>string{} 89 | 设置了默认的年龄为20 所以再调用时只需要写个名字 90 | addStudent("DragonLi") 91 | 要注意的是，使用了默认参数值， 系统会自动生成一个外部参数名。 92 | 想改名字也就要写外部参数名了 即 addStudent(“zss”,age:18) 93 | 94 | 4).swift中使用let定义常量,var定义变量 95 | 96 | 使用常量,更加安全,不能够被修改,在需要对对象进行修改的时候 只能用var修饰. 97 | 98 | 5).if let 、 guard let 的用法 99 | 100 | 缩减代码量，安全处理数据逻辑。 101 | 102 |
118 |
137 |
138 | ### 一个动画怎么实现？
139 | > [CoreAnimation（核心动画）](https://github.com/DevDragonLi/Core-AnimationPerformanceOptimization)
140 |
141 | ### iOS中常用的数据存储方式有哪些？
142 |
143 | - [相似问题链接](./01一份"有点难"的iOS面试题MrPeak2016年.md#链接)
144 |
145 | 参考内容
119 | 120 | * 缓存行高 121 | * 尽量用轻量级的对象，比如用不到事件处理的地方，可以考虑使用 CALayer 取代 UIView 122 | * 不要频繁地调用 UIView 的相关属性，比如 frame、bounds、transform 等属性，尽量减少不必要的修改 123 | * 尽量提前计算好布局，在有需要时一次性调整对应的属性，不要多次修改属性 124 | * Autolayout 会比直接设置 frame 消耗更多的 CPU 资源 125 | * 图片的 size 最好刚好跟 UIImageView 的 size 保持一致 126 | * 控制一下线程的最大并发数量 127 | * 尽量把耗时的操作放到子线程 128 | * 文本处理（尺寸计算、绘制） 129 | * 图片处理（解码、绘制） 130 | 131 | * 尽量避免短时间内大量图片的显示，尽可能将多张图片合成一张进行显示 132 | * 尽量减少视图数量和层次 133 | * 减少透明的视图（alpha<1），不透明的就设置 opaque 为 YES 134 | * 尽量避免出现离屏渲染 135 | 136 |
146 |
164 |
165 | ### runloop和线程有什么关系？
166 | 参考内容
147 | 148 | - 综合 149 | - 所有的本地持久化数据存储的本质都是写文件，而且只能存到沙盒中。 150 | - 沙盒机制是苹果的一项安全机制，本质就是系统给每个应用分配了一个文件夹来存储数据，而且每个应用只能访问分配给自己的那个文件夹，其他应用的文件夹是不能访问的。 151 | - 数据存储的核心都是写文件。主要有四种持久化方式：属性列表，对象序列化，SQLite 数据库, CoreData 152 | 153 | - 属性列表：应用于少量数据存储，比如登陆的用户信息，应用程序配置信息等。只有NSString ，NSArray，NSDictory，NSData，可以WriteToFile；存储的依旧是plist文件，plist文件可以存储的7种数据类型：array，dictory，string，bool，data，date，number。 154 | 155 | - 详细 156 | - 对象序列化：最终也是存为属性列表文件，如果程序中，需要存储的时候，直接存储对象比较方便，例如有一个设置类，我们可以把设置类的对象直接存储，就没必要再把里面的每一个属性单独存到文件中。对象序列化是将一个实现了NSCoding协议的对象，通过序列化（NSKeydArchiver）的形式，将对象中的属性抽取出来，转化成二进制流，也就是NSData，NSData可以选择write to file 或者存储到NSUserdefault中。 必须实现的两个方法 encodeWithCoder，initWithCoder。对象序列化的本质就是 对象NSData。 157 | 158 | - SQLite： 适合大量，重复，有规律的数据存储。而且频繁的读取，删除，过滤数据，这种适合使用数据库 (iOS 使用第三方FMDB) 159 | 160 | - CoreData： Sqlite叫做关系型数据库，CoreData 是一中OR-Mapping的思想 ，O代表对象Object，R代表relationship，Mapping代表映射，直译过来就是对象关系映射，其实就是把对象的属性和表中的字段自动映射，简化程序员的负担，以面向对象的方式操作数据库。ORMapping是一种思想，CoreData实现了这种思想，在Java中，hibernate 也是对ORMapping的一种实现，只是利用java实现的。 161 | - CoreData 本质还是数据库，只不过使用起来更加面向对象，不关注二维的表结构，而是只需要关注对象，纯面向对象的数据操作方式。我们直接使用数据库的时候，如果向数据库中插入数据，一般是把一个对象的属性和数据库中某个表的字段一一对应，然后把对象的属性存储到具体的表字段中.取一条数据的时候，把表中的一行数据取出，同样需要再封装到对象的属性中，这样的方式有点繁琐，不面向对象。CoreData解决的问题就是不需要这个中间的转换过程，看起来是直接把对象存储进去，并且取出来，不关心表的存在，实际内部帮你做好了映射关系。 162 | 163 |
167 |
182 |
183 | ### runloop的mode作用是什么？
184 | 参考内容
168 | 169 | - runloop和线程是一一对应关系 170 | - key：thread ，value ：loop 171 | - 一般来讲，一个线程一次只能执行一个任务，执行完成后线程就会退出。 172 | - 保持程序的持续运行(ios程序为什么能一直活着不会死) 173 | - 处理app中的各种事件（比如触摸事件、定时器事件【NSTimer】、selector事件【选择器·performSelector···】） 174 | - 节省CPU资源，提高程序性能，有事情就做事情，没事情就休息 175 | 176 | - 重要性 177 | - 如果没有Runloop,那么程序一启动就会退出，什么事情都做不了。 178 | - 如果有了Runloop，那么相当于在内部有一个事件循环，能够保证程序的持续运行 179 | - main函数中的Runloop a 在UIApplication函数内部就启动了一个Runloop 该函数返回一个int类型的值 b 这个默认启动的Runloop是跟主线程相关联的 180 | 181 |
185 |
191 |
192 | ### 你一般是如何调试Bug的？
193 | 参考内容
186 | 187 | - 实际编码可用为3种(系统占用2种独有) 188 | - example ,定时器,等处理需要采取不同的 mode 189 | 190 |
194 |
201 |
202 | ### 描述一个ViewController的生命周期
203 | 参考内容
195 | 196 | - 在运行过程中，如果出现EXC_BAD_ACCESS 异常，往往提示的信息很少或者没有提示，启用NSZombieEnabled后在控制台能打印出更多的提示信息，便于debug,请注意，僵尸模式下的调试工作只能在模拟器中实现，我们无法在物理设备上完成这一诊断流程. 197 | - 异常断点，一般程序crash时Xcode一般会定位到main函数中，得不到详细的crash信息，打上异常断点后就极大可能定位到程序的crash处，利于debug。 198 | - 一般来说，在创建工程的时候，应该在Build Settings启用Analyze During 'Build'，这样每次编译时都会自动静态分析。这样的话，写完一小段代码之后，就马上知道是否存在内存泄露或其他bug问题，并且可以修bugs。 199 | - 如果你想在运行的时候查看APP是否存在内存泄露，你可以使用Xcode上instruments工具上的Leaks模块进行内存分析。但是有些内存泄露是很难检查出来，有时只有通过手动覆盖dealloc方法，看它最终有没有调用。 200 |
204 |
218 |
219 |
220 | ### 觉得整理的蛮不错，可以赞赏一下旺仔(收集整理不易，且赞且珍惜)
221 |
222 |
223 | 参考内容
205 | 206 | * 当我们调用UIViewControlller的view时， 207 | * 系统首先判断当前的 UIViewControlller是否存在view，如果存在直接返回view， 208 | * 如果不存在的话，会调用loadview方法， 209 | * 然后判断loadview方法是否是自定义方法， 210 | * 如果是自定义方法，就执行自定义方法， 211 | * 如果不是自定义方法，判断当时视图控制器是否有xib、stroyboard。 212 | * 如果有xib、stroyboard 就加载xib、stroyboard。 213 | * 如果没有创建一个空白的view。 214 | * 调用viewDidLoad方法。 215 | * 最后返回view 216 | 217 |
16 |
26 |
27 | ## ReactiveCocoa(RAC)如何防止UIButton短时间内多次重复点击，大概思路?
28 |
29 | > 需要有RAC使用经验才可问此题
30 |
31 | 参考内容
17 | 18 | - 用MD5验证文件的完整性！(仅仅通过代码来判断当前次的请求发送结束或者收到数据结束不可以的) 19 | - 当客户端上传一个文件的时候，在请求body里面添加该文件的MD5值来告诉服务器，服务器接受文件完毕以后通过校验收到的文件的MD5值与请求body里面的MD5值来最终确定本次上传是否成功 20 | - 当客户端下载一个文件的时候，在响应头里面收到了服务器附带的该文件的MD5值，文件下载结束以后，通过获取下载后文件的MD5值与本次请求服务器返回的响应头中的MD5值做一个比较，来最终判断本次下载是否成功 21 | - MD5，是一个将任意长度的数据字符串转化成短的固定长度的值的单向操作。任意两个字符串不应有相同的散列值 22 | - MD5校验可以应用在多个领域，比如说机密资料的检验，下载文件的检验，明文密码的加密等。MD5校验原理举例：如客户往我们数据中心同步一个文件，该文件使用MD5校验，那么客户在发送文件的同时会再发一个存有校验码的文件，我们拿到该文件后做MD5运算，得到的计算结果与客户发送的校验码相比较，如果一致则认为客户发送的文件没有出错，否则认为文件出错需要重新发送。 23 | 24 | 25 |
32 |
39 |
40 | ## 倒计时如何实现 ？
41 | 参考内容
33 | 34 | - 建立一个`flag`或者使用 `filter` 35 | 36 | - 事件完成 flag重置，否则一直skip或者filter (某个RAC群友抛砖引玉) 37 | 38 |
42 |
92 |
93 | ## 熟悉CocoaPods么？能大概讲一下工作原理么？
94 |
95 | 参考内容
43 | 44 | - NSTimer ,精度不一定准确 45 | - GCD 46 | - DisplayLink 47 | - RAC 48 | 49 | 50 | ```objc 51 | -(void)startTime{ 52 | __block int timeout=30; //倒计时时间 53 | dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 54 | dispatch_source_t _timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0,queue); 55 | dispatch_source_set_timer(_timer,dispatch_walltime(NULL, 0),1.0*NSEC_PER_SEC, 0); //每秒执行 56 | dispatch_source_set_event_handler(_timer, ^{ 57 | if(timeout<=0){ //倒计时结束，关闭 58 | dispatch_source_cancel(_timer); 59 | dispatch_async(dispatch_get_main_queue(), ^{ 60 | //设置界面的按钮显示 根据自己需求设置 61 | [l_timeButton setTitle:@"发送验证码" forState:UIControlStateNormal]; 62 | l_timeButton.userInteractionEnabled = YES; 63 | }); 64 | }else{ 65 | // int minutes = timeout / 60; 66 | int seconds = timeout % 60; 67 | NSString *strTime = [NSString stringWithFormat:@"%.2d", seconds]; 68 | dispatch_async(dispatch_get_main_queue(), ^{ 69 | //设置界面的按钮显示 根据自己需求设置 70 | NSLog(@"____%@",strTime); 71 | [l_timeButton setTitle:[NSString stringWithFormat:@"%@秒后重新发送",strTime] forState:UIControlStateNormal]; 72 | l_timeButton.userInteractionEnabled = NO; 73 | 74 | }); 75 | timeout--; 76 | 77 | } 78 | }); 79 | dispatch_resume(_timer); 80 | 81 | } 82 | 83 | [[RACSignal interval:1 onScheduler:[RACScheduler mainThreadScheduler]]subscribeNext:^(NSDate * date) { 84 | static NSInter = 60; 85 | 60 --; 86 | // 处理显示逻辑 87 | }]; 88 | 89 | ``` 90 | 91 |
96 |
128 |
129 |
130 | ## 使用SDWebImage内存爆涨的问题
131 |
132 | 参考内容
97 | 98 | > **Podfile.lock**：在pod install以后会生成一个Podfile.lock的文件,这个文件在多人协作开发的时候就不建议加入在.gitignore中,因为这个文件会锁定当前各依赖库的版本,就算之后再pod install也不会更改版本,不提交上去的话就可以防止第三方库升级后造成大家各自的第三方库版本不同 99 | 100 | ### **CocoaPods原理** 101 | 102 | > CocoaPods的原理是将所有的依赖库都放到另一个名为Pods的项目中，然后让主项目依赖Pods项目，这样，源码管理工作都从主项目移到了Pods项目中。Pods项目最终会编译成一个名为libPods.a的文件，主项目只需要依赖这个.a文件即可。 103 | 104 | * 运行pre-install hook 105 | 106 | * 生成Pod Project 107 | 108 | * 将该pod文件添加到工程中 109 | 110 | * 添加对应的framework、.a库、bundle等 111 | 112 | * 链接头文件，生成Target 113 | 114 | * 运行post-install hook 115 | 116 | * 生成podfile.lock ，之后生成文件副本mainfest.lock并将其放在Pod文件夹内。（如果出现 The sandbox is not sync with the podfile.lock这种错误，则表示manifest.lock和podfile.lock文件不一致），此时一般需要重新运行pod install命令。 117 | 118 | * 配置原有的project文件(add build phase) 119 | 120 | * 添加了 Embed Pods Frameworks 121 | 122 | * 添加了 Copy Pod Resources 其中，pre-install hook和post-install hook可以理解成回调函数，是在podfile里对于install之前或者之后（生成工程但是还没写入磁盘）可以执行的逻辑，逻辑为： 123 | 124 | * pre_install do |installer| # 做一些安装之前的hook end 125 | * post_install do |installer| # 做一些安装之后的hook end 126 | 127 |
133 |
161 |
162 |
163 | ## isa指针的作用
164 | 参考内容
134 | 135 | - 产生的源码部分如下 136 | 137 | ```objc 138 | 139 | - (UIImage *)diskImageForKey:(NSString *)key { 140 | NSData *data = [self diskImageDataBySearchingAllPathsForKey:key]; 141 | if (data) { 142 | UIImage *image = [UIImage sd_imageWithData:data]; 143 | image = [self scaledImageForKey:key image:image]; 144 | if (self.shouldDecompressImages) { 145 | image = [UIImage decodedImageWithImage:image]; 146 | } 147 | return image; 148 | } 149 | else { 150 | return nil; 151 | } 152 | } 153 | 154 | ``` 155 | 156 | - 在某个VC出栈的时候清除比较合适，因为有可能用户不会再去显示那些图片，但是这些图片依旧占着内存 157 | 158 | - `[[SDImageCache sharedImageCache] setValue:nil forKey:@"memCache"];` 159 | 160 |
165 |
173 |
174 | ## 测试都有哪些方式?优缺点呢
175 |
176 | 参考内容
166 | 167 | - 对象的isa指向类，类的isa指向元类（meta class），元类isa指向元类的根类。isa帮助一个对象找到它的方法 168 | 169 | - 是一个Class 类型的指针. 每个实例对象有个isa的指针,他指向对象的类，而Class里也有个isa的指针, 指向meteClass(元类)。元类保存了类方法的列表。当类方法被调用时，先会从本身查找类方法的实现，如果没有，元类会向他父类查找该方法。同时注意的是：元类（meteClass）也是类，它也是对象。元类也有isa指针,它的isa指针最终指向的是一个根元类(root meteClass).根元类的isa指针指向本身，这样形成了一个封闭的内循环。 170 | 171 | 172 |
177 |
190 |
191 | ## Xcode8开始后自动配置开发证书过程?
192 |
193 | 参考内容
178 | 179 | - 联机调试 (一般而言适用于开发人员) 180 | - 之前需要插线 181 | - 后期版本可以无线调试！ 182 | 183 | - 蒲公英等分发平台(就是需要提供参与app测试人员的设备UDID) 缺点:开发者需要将这些设备的UDID添加到开发者中心，每次有新的测试人员加入，需要重新生成profiles 184 | 185 | - TestFlight进行App Beta版测试 (apple 官方,iOS8及以上版本的iOS设备才能运行): 186 | - 优点: 无需UUID,**外部测试人员的上限是10000人**（2018年后又扩大了测试上限）,只需要参与app测试人员提供一个邮箱 187 | - 188 | 189 |
194 |
200 |
201 |
202 | ## 项目中的图片上传功能如何实现，为什么使用队列上传，为什么不用异步上传
203 |
204 | 参考内容
195 | 196 | - Xcode会在本机钥匙串寻找team对应的开发证书，如果本地钥匙串存在该证书则加载使用 197 | - 不存在：则从开发者中心寻找本机对应的开发证书，如果开发者中心没有则自动生成一个并下载到钥匙串使用 198 | 199 |
205 |
211 |
212 | ## 项目中你是怎么处理网络速度慢、中断抖动等网络请求中的问题?
213 |
214 | 参考内容
206 | 207 | - image -> data 208 | - 如果是所有图片一起传,可以使用异步,但是如果是有按照顺序的需求,则需要按照用户的已知顺序传 209 | 210 |
215 |
223 |
224 |
225 | ### 觉得整理的蛮不错，可以赞赏一下旺仔(收集整理不易，且赞且珍惜)
226 |
227 |
228 | 参考内容
216 | 217 | > dns 和 ping 探测当前网络情况 218 | 219 | - UI -> loading/Tips 220 | - netWorking ->cdn ,IP 直链 221 | 222 |
32 |
74 |
75 |
76 | ## iOS下如何实现指定线程数目的线程池?
77 |
78 | 参考内容
33 | 34 | > 我们在使用多线程的时候多个线程可能会访问同一块资源，这样就很容易引发数据错乱和数据安全等问题，这时候就需要我们保证每次只有一个线程访问这一块资源，锁 应运而生 35 | 36 | - `@synchronized` 性能最差,SD和AFN等框架内部有使用这个. 37 | 38 | - NSRecursiveLock 和 NSLock ：建议使用前者，避免循环调用出现**死锁** 39 | 40 | - OSSpinLock 自旋锁,存在的问题是:优先级反转问题,破坏了spinlock 41 | 42 | - dispatch_semaphore 信号量 : 保持线程同步为线程加锁 43 | 44 | ```objc 45 | dispatch_semaphore_t signal = dispatch_semaphore_create(1); 46 | 47 | dispatch_time_t overTime = dispatch_time(DISPATCH_TIME_NOW, 1.0f * NSEC_PER_SEC); 48 | //Thread1 49 | dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 50 | NSLog(@"Thread1 waiting"); 51 | dispatch_semaphore_wait(signal, overTime); //signal 值 -1 52 | NSLog(@"Thread1"); 53 | dispatch_semaphore_signal(signal); //signal 值 +1 54 | NSLog(@"Thread1 send signal"); 55 | }); 56 | 57 | //Thread2 58 | dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 59 | NSLog(@"Thread2 waiting"); 60 | dispatch_semaphore_wait(signal, overTime); 61 | NSLog(@"Thread2"); 62 | dispatch_semaphore_signal(signal); 63 | NSLog(@"Thread2 send signal"); 64 | }); 65 | dispatch_semaphore_create(1)： 若传入为0(over time 失效) 则阻塞线程并等待timeout,时间到后会执行其后的语句, 66 | 67 | dispatch_semaphore_wait(signal, overTime)：可以理解为 lock,会使得 signal 值 -1 68 | 69 | dispatch_semaphore_signal(signal)：可以理解为 unlock,会使得 signal 值 +1 70 | 71 | ``` 72 | 73 |
79 |
90 |
91 |
92 | ### 参考样例实现代码(基于dispatch_semaphore)
93 |
94 | 参考内容
80 | 81 | ### 回答思路 82 | 83 | - 循环通过pthread_create创建线程，创建s_tf thread对象做为线程句，加入线程数组,s_tftask_content->methord初始化为空函数 84 | 85 | - 创建任务执行函数，执行完通过task初始化函数后，在执行函数中通过pthread_cond_wait信号将当前创建的线程挂起 86 | 87 | - 创建完之后，程序中将会有n个挂起状态的线程，当需要执行新的task的时候查找，我们就可以根据不同的task标志在k_threads中查询出空闲线程，并创建新的s_tftask_content加入s_tfthread的任务列表，通过pthread_cond_signal重新唤醒该线程继续执行任务 88 | 89 |
95 |
116 |
117 |
118 | ## 如何用HTTP实现长连接？
119 | 参考内容
96 | 97 | ``` 98 | dispatch_queue_t workConcurrentQueue = dispatch_queue_create("example.code", DISPATCH_QUEUE_CONCURRENT); 99 | dispatch_queue_t serialQueue = dispatch_queue_create("example.code.task",DISPATCH_QUEUE_SERIAL); 100 | dispatch_semaphore_t semaphore = dispatch_semaphore_create(3); 101 | for (NSInteger i = 0; i < 10; i++) { 102 | dispatch_async(serialQueue, ^{ 103 | dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER); 104 | dispatch_async(workConcurrentQueue, ^{ 105 | NSLog(@"thread-info:%@开始执行任务%d",[NSThread currentThread],(int)i); 106 | sleep(1); 107 | NSLog(@"thread-info:%@结束执行任务%d",[NSThread currentThread],(int)i); 108 | dispatch_semaphore_signal(semaphore);}); 109 | }); 110 | } 111 | NSLog(@"主线程...!"); 112 | 113 | ``` 114 | 115 |
120 |
127 |
128 | ## HTTP的post和get啥区别
129 | 参考内容
121 | 122 | - HTTP是无状态的，要维持一个长连接可以用**心跳包**方式 123 | - 丢包，沾包 ,实际上http连接进行轮询.(滴滴打车较早期版本采用的方式，耗费流量) 124 | - 定时轮询会存在延迟 用户体验就不好 125 | 126 |
130 |
139 |
140 |
141 | ## 使用atomic一定是线程安全的吗？
142 | 参考内容
131 | 132 | - 从语义角度分析 133 | 134 | - 安全性:不会引发 server 端的改变 135 | - 幂等:同一个方法请求多次结果相同 136 | - 可缓存（Get） 137 | 138 |
143 |
151 |
152 |
153 | ## 数据库建表的时候索引有什么用？
154 | 参考内容
144 | 145 | - 只是针对取值和赋值线程安全 146 | - 数组的初始化，赋值，取值安全 147 | - 数组的添加数据元素并非线程安全 148 | - BOOL 类型 修饰符不受到atomic或者noatomic影响 149 | 150 |
155 |
161 |
162 | ## 介绍下iOS设备获取唯一设备号的历史变迁
163 |
164 | 参考内容
156 | 157 | - 创建索引可以大大提高系统的性能，加快数据的检索速度，加速表和表之间的连接，保证数据库表中每一行数据的唯一性 158 | - 但是有些列不应该创建索引，需要综合考虑. 159 | 160 |
165 |
174 |
175 |
176 | ## 如何使用runtime hook一个class的某个方法，又如何hook某个instance的方法？
177 |
178 | 参考内容
166 | 167 | #### iOS中获取设备唯一标示符的方法一直随版本的更新而变化 168 | - iOS 2.0版本以后UIDevice提供一个获取设备唯一标识符的方法uniqueIdentifier 169 | - iOS6是用WiFi的mac地址 170 | - iOS7-iOS10.2通过KeyChain来保存获取到的UDID,因为APP删了再装回来，也可以从KeyChain中读取回来 (广告收益计算等) 171 | - [10.3后用户删掉一个 App，之后再重装就只能手动登录一次](http://mt.sohu.com/20170310/n482880968.shtml) 172 | 173 |
179 |
188 |
189 |
190 | ## 聊下HTTP的POST的body体使用form-urlencoded和multipart/form-data的区别。
191 |
192 | 参考内容
180 | 181 | > 这个问题,首先要考虑怎么回答才能不被套路 182 | 183 | - 考虑 hook是否有公开头文件的类，有的话写一个Utility函数，再使用category， 184 | - 没有的话就建一个类作为新函数载体，然后先为被hook的类增加函数，再替换。 185 | - 如何hook某个instance的方法，应该可以定义一个函数指针变量(IMP)，hook时将要调用的地址赋给这个变量，调用时把这个变量当作函数来用 (参考：RAC框架hook) 186 | 187 |
193 |
205 |
206 |
207 |
208 | ## 通过[UIImage imageNamed:]生成的对象什么时候被释放？
209 |
210 | 参考内容
194 | 195 | - multipart/form-data是当上传文件或者二进制数据和非ASCII数据使用 ,AFN请求如何设置? 196 | 197 | ```objc 198 | [requestSerializer setValue:@"multipart/form-data" forHTTPHeaderField:@"content-type"]; 199 | ``` 200 | - form-urlencoded是默认的mime内容编码类型，是通用的，但是它在传输比较大的二进制或者文本数据时效率极低 201 | - 交互:GET,POST,PUT,PATCH,DELETE等 202 | - AFN的PATCH貌似数组存在问题. 203 | 204 |
211 |
218 |
219 |
220 | ## applicationWillEnterForeground和applicationDidBecomeActive都会在哪些场景下被调用？举例越多越好。
221 |
222 | 参考内容
212 | 213 | - 建议针对小图标/场景出现较多图片（此类方式加载，会缓存到内存） 214 | - `@autoreleasepool` 如果没有使用局部释放池，**并且在主线程，则是当前主线程Runloop一次循环结束前释放**。 215 | - imageWithContentsOfFile ： 加载适用于大图片,不常用的图片,一般无引用时候,会释放 216 | 217 |
223 |
236 |
237 |
238 |
239 | ## 如何终止正在运行的工作线程？
240 | 参考内容
224 | 225 | - applicationDidBecomeActive 226 | - APP首次启动用户授权后，会调用此函数 227 | - APP处于激活态 228 | - applicationWillEnterForeground：从后台进入前台 229 | 230 | - 场景 231 | - 推送、做支付 232 | - 跳转app 233 | - 后台杀进程的时候、IM、第三方授权分享登录回调情况下等 234 | 235 |
241 |
247 |
248 | ## iOS下所有的本地持久化方案?
249 | > [本系列面试题相似问题：iOS中常用的数据存储方式有哪些](./06iOS基础问题系列2017年.md)
250 |
251 | 参考内容
242 | 243 | - 线程中调用exit、pthread_exit、pthread_kill、pthread_cancel 244 | - NSOperation ,接口设计的cancle **实际上只能取消还未运行的,已经运行的无法取消**. 245 | 246 |
252 |
266 |
267 |
268 | ### 觉得整理的蛮不错，可以赞赏一下旺仔(收集整理不易，且赞且珍惜)
269 |
270 |
271 | 参考内容
253 | 254 | - 沙盒 255 | - plist文件（属性列表） 256 | - preference（偏好设置） 257 | 258 | - NSKeyedArchiver（归档） 259 | 260 | - SQLite 3 261 | 262 | - CoreData 263 | - Realm 264 | 265 |
20 |
29 |
30 | ## HTTPS的加密原理
31 |
32 | 参考内容
21 | 22 | - Runtime维护着一个Weak表，用于存储指向某个对象的所有Weak指针 23 | - Weak表是Hash表，Key是所指对象的地址，Value是Weak指针地址的数组 24 | - 在对象被回收的时候，经过层层调用，会最终触发下面的方法将所有Weak指针的值设为nil。 25 | - runtime源码，objc-weak.m 的 arr_clear_deallocating 函数 26 | - weak指针的使用涉及到Hash表的增删改查，**有一定的性能开销**. 27 | 28 |
33 |
42 |
43 | ## 网络通讯中加密方式有哪些，各自的原理?
44 | 参考内容
34 | 35 | - 服务器端用非对称加密(RSA)生成公钥和私钥 36 | - 然后把公钥发给客户端, 服务器则保存私钥 37 | - 客户端拿到公钥后, 会生成一个密钥, 这个密钥就是将来客户端和服务器用来通信的钥匙 38 | - 然后客户端用公钥对密钥进行加密, 再发给服务器 39 | - 服务器拿到客户端发来的加密后的密钥后, 再使用私钥解密密钥, 到此双方都获得通信的钥匙 40 | 41 |
45 |
53 |
54 | ## 开发中iOS缓存的理解
55 |
56 | 参考内容
46 | 47 | - md5(哈希算法)：把任意长度的字符串加密成一个128bit的大整数，并且是不可逆的 (已不再安全) 48 | - RSA(非对称算法加密)：产生一对非对称的公钥和私钥，公钥加密，私钥解密。私钥加密，公钥解密 49 | - AES(对称加密)：加密和解密的密钥是同一个 50 | - base64(现代密码学的基础)：原本8 bit一组的数据改为6bit一组，不足的地方补0，每两个0用一个 = 表示 51 | 52 |
57 |
66 |
67 | ## 你认为开发中那些导致crash?
68 |
69 | 参考内容
58 | 59 | > 一般`缓存` 针对展示类的UI层数据比较多.比如可举例个人资料界面. 60 | 61 | - 网络优先：开始总是从网络获取，如果获取失败，从本地获取(旧数据)。 62 | - 本地优先：在一段时间内从本地获取，当超过这个时间，然后重新请求网络数据(展示同时覆盖旧数据)。 63 | - 混合(智能)：打开程序先从本地获取展示，然后请求数据，请求完成后刷新界面(一般而言)。 64 | 65 |
70 |
98 |
99 | ## SDWebImage
100 |
101 | > [第四份面试题相关点：使用SDWebImage内存爆涨的问题](04interview-iOS-4.md)
102 |
103 | > 加载图片的流程
104 |
105 | > Cache是怎么做数据管理的？
106 |
107 | > 内部做Decoder的原因
108 |
109 | 参考内容
71 | 72 | > 当iOS设备上的App应用闪退时，操作系统会生成一个crash日志，保存在设备上。crash日志上有很多有用的信息，比如每个正在执行线程的完整堆栈跟踪信息和内存映像，这样就能够通过解析这些信息进而定位crash发生时的代码逻辑，从而找到App闪退的原因。 73 | 74 | > 通常来说，crash产生来源于两种问题：违反iOS系统规则导致的crash和App代码逻辑BUG导致的crash 75 | 76 | ### 应用逻辑的Bug 77 | 78 | - SEGV：（Segmentation Violation，段违例），无效内存地址，比如空指针，未初始化指针，栈溢出等； 79 | - SIGABRT：收到Abort信号，可能自身调用abort()或者收到外部发送过来的信号； 80 | - SIGBUS：总线错误。与SIGSEGV不同的是，SIGSEGV访问的是无效地址（比如虚存映射不到物理内存），而SIGBUS访问的是有效地址，但总线访问异常（比如地址对齐问题）； 81 | - SIGILL：尝试执行非法的指令，可能不被识别或者没有权限； 82 | - SIGFPE：Floating Point Error，数学计算相关问题（可能不限于浮点计算），比如除零操作； 83 | - SIGPIPE：管道另一端没有进程接手数据； 84 | 常见的崩溃原因基本都是代码逻辑问题或资源问题，比如数组越界，访问野指针或者资源不存在，或资源大小写错误等 85 | 86 | ### 违反iOS系统规则产生crash的三种类型 87 | - 内存报警闪退 88 | - 当iOS检测到内存过低时，它的VM系统会发出低内存警告通知，尝试回收一些内存；如果情况没有得到足够的改善，iOS会终止后台应用以回收更多内存；最后，如果内存还是不足，那么正在运行的应用可能会被终止掉。在Debug模式下，可以主动将客户端执行的动作逻辑写入一个log文件中，这样程序童鞋可以将内存预警的逻辑写入该log文件，当发生如下截图中的内存报警时，就是提醒当前客户端性能内存吃紧，可以通过Instruments工具中的Allocations 和 Leaks模块库来发现内存分配问题和内存泄漏问题。 89 | 90 | - 响应超时 91 | - 当应用程序对一些特定的事件（比如启动、挂起、恢复、结束）响应不及时，苹果的Watchdog机制会把应用程序干掉，并生成一份相应的crash日志。 92 | 93 | - 用户强制退出 94 | - 一看到“用户强制退出”，首先可能想到的双击Home键，然后关闭应用程序。不过这种场景一般是不会产生crash日志的，因为双击Home键后，所有的应用程序都处于后台状态，而iOS随时都有可能关闭后台进程，当应用阻塞界面并停止响应时这种场景才会产生crash日志。这里指的“用户强制退出”场景，是稍微比较复杂点的操作：先按住电源键，直到出现“滑动关机”的界面时，再按住Home键，这时候当前应用程序会被终止掉，并且产生一份相应事件的crash日志。 95 | 96 | 97 |
110 |
164 |
165 | ## crash的收集和定位bug的方式
166 | 参考内容
111 | 112 | ### 加载图片的流程 113 | 114 | 1.入口 setImageWithURL:placeholderImage:options: 会先把 placeholderImage 显示，然后 SDWebImageManager 根据 URL 开始处理图片。 115 | 116 | 2.进入 SDWebImageManager-downloadWithURL:delegate:options:userInfo:，交给 SDImageCache 从缓存查找图片是否已经下载 queryDiskCacheForKey:delegate:userInfo:. 117 | 118 | 3.先从内存图片缓存查找是否有图片，如果内存中已经有图片缓存，SDImageCacheDelegate 回调 imageCache:didFindImage:forKey:userInfo: 到 SDWebImageManager。 119 | 120 | 4.SDWebImageManagerDelegate 回调 webImageManager:didFinishWithImage: 到 UIImageView+WebCache 等前端展示图片。 121 | 122 | 5.如果内存缓存中没有，生成 NSInvocationOperation 添加到队列开始从硬盘查找图片是否已经缓存。 123 | 124 | 6.根据 URLKey 在硬盘缓存目录下尝试读取图片文件。这一步是在 NSOperation 进行的操作，所以回主线程进行结果回调 notifyDelegate:。 125 | 126 | 7.如果上一操作从硬盘读取到了图片，将图片添加到内存缓存中（如果空闲内存过小，会先清空内存缓存）。SDImageCacheDelegate 回调 imageCache:didFindImage:forKey:userInfo:。进而回调展示图片。 127 | 128 | 8.如果从硬盘缓存目录读取不到图片，说明所有缓存都不存在该图片，需要下载图片，回调 imageCache:didNotFindImageForKey:userInfo:。 129 | 130 | 9.共享或重新生成一个下载器 SDWebImageDownloader 开始下载图片。 131 | 132 | 10.图片下载由 NSURLConnection 来做，实现相关 delegate 来判断图片下载中、下载完成和下载失败。 133 | 134 | 11.connection:didReceiveData: 中利用 ImageIO 做了按图片下载进度加载效果。 135 | 136 | 12.connectionDidFinishLoading: 数据下载完成后交给 SDWebImageDecoder 做图片解码处理。 137 | 138 | 13.图片解码处理在一个 NSOperationQueue 完成，不会拖慢主线程 UI。如果有需要对下载的图片进行二次处理，最好也在这里完成，效率会好很多。 139 | 140 | 14.在主线程 notifyDelegateOnMainThreadWithInfo: 宣告解码完成，imageDecoder:didFinishDecodingImage:userInfo: 回调给 SDWebImageDownloader。 141 | 142 | 15.imageDownloader:didFinishWithImage: 回调给 SDWebImageManager 告知图片下载完成。 143 | 144 | 16.通知所有的 downloadDelegates 下载完成，回调给需要的地方展示图片。 145 | 146 | 17.将图片保存到 SDImageCache 中，内存缓存和硬盘缓存同时保存。写文件到硬盘也在以单独 NSInvocationOperation 完成，避免拖慢主线程。 147 | 148 | 18.SDImageCache 在初始化的时候会注册一些消息通知，在内存警告或退到后台的时候清理内存图片缓存，应用结束的时候清理过期图片。 149 | 150 | 19.SDWI 也提供了 UIButton+WebCache 和 MKAnnotationView+WebCache，方便使用。 151 | 152 | 20.SDWebImagePrefetcher 可以预先下载图片，方便后续使用。 153 | 154 | 155 | ### SDImageCache是怎么做数据管理的？ 156 | 157 | SDImageCache分两个部分，一个是内存层面的，一个是硬盘层面的。内存层面的相当是个缓存器，以Key-Value的形式存储图片。当内存不够的时候会清除所有缓存图片。用搜索文件系统的方式做管理，文件替换方式是以时间为单位，剔除时间大于一周的图片文件。当SDWebImageManager向SDImageCache要资源时，先搜索内存层面的数据，如果有直接返回，没有的话去访问磁盘，将图片从磁盘读取出来，然后做Decoder，将图片对象放到内存层面做备份，再返回调用层。 158 | 159 | 160 | ### 内部做Decoder的原因 (典型的空间换时间) 161 | - 由于UIImage的imageWithData函数是每次画图的时候才将Data解压成ARGB的图像，所以在每次绘图的时候，**会有一个解压操作，这样效率很低，但是只有瞬时的内存需求**。为了提高效率通过SDWebImageDecoder将包装在Data下的资源解压，然后画在另外一张图片上，这样这张新图片就不再需要重复解压了 162 | 163 |
167 |
202 |
203 |
204 | ### 觉得整理的蛮不错，可以赞赏一下旺仔(收集整理不易，且赞且珍惜)
205 |
206 |
207 | 参考内容
168 | 169 | - iTunes Connect（Manage Your Applications - View Details - Crash Reports),但是前提用户设置->隐私->诊断与用量->诊断与用量数据开启.一般不推荐 170 | 171 | - 自己实现应用内崩溃收集，并上传服务器.(收集异常，存储到本地，下次用户打开程序时上传给我们) 172 | - 在程序启动时加上一个异常捕获监听，用来处理程序崩溃时的回调动作UncaughtExceptionHandler是一个函数指针，该函数需要我们实现，可以取自己想要的名字。当程序发生异常崩溃时，该函数会得到调用，这跟C，C++中的回调函数的概念是一样的 173 | 174 | ``` 175 | NSSetUncaughtExceptionHandler (&UncaughtExceptionHandler)。 程序启动代理方法 176 | //:collection crash info by DragonLi 177 | void UncaughtExceptionHandler(NSException *exception) { 178 | NSArray *callStack = [exception callStackSymbols]; 179 | NSString *reason = [exception reason]; 180 | NSString *name = [exception name]; 181 | 182 | NSDateFormatter *formatter = [[NSDateFormatter alloc] init]; 183 | [formatter setDateFormat:@"YYYY-MM-dd HH:mm:ss"]; 184 | NSString * dateStr = [formatter stringFromDate:[NSDate date]]; 185 | 186 | NSString * iOS_Version = [[UIDevice currentDevice] systemVersion]; 187 | NSString * PhoneSize = NSStringFromCGSize([[UIScreen mainScreen] bounds].size); 188 | NSString * App_Version = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleShortVersionString"]; 189 | NSString * iPhoneType = @"当前设备名字"; 190 | NSString *uploadString = @"所有拼接信息"; 191 | // 存储到本地沙盒.下次启动找寻 192 | } 193 | 194 | ``` 195 | 196 | - 第三方收集crash (比如说集成Bugly/友盟,使用dSYM符号化并定位代码) 197 | 198 | - 上报的方式，时机，策略（优缺点）等 199 | 200 | 201 |
32 |
79 |
80 | #### 对象关联
81 |
82 | 参考内容
33 | 34 | #### 消息发送 35 | 36 | > 一个对象的方法像这样[obj foo]，编译器转成消息发送objc_msgSend(obj, foo)，Runtime时执行的流程是这样的： 37 | 38 | - 首先，通过obj的isa指针找到它的 class ; 39 | - 在 class 的 method list 找 foo ; 40 | - 如果 class 中没到 foo，继续往它的 superclass 中找 ; 41 | - 一旦找到 foo 这个函数，就去执行它的实现IMP 。 42 | 43 | 44 | ##### 三级转发 45 | 46 | ``` 47 | + (BOOL)resolveInstanceMethod:(SEL)sel { 48 | return YES;//返回YES，进入下一步转发 49 | } 50 | 51 | - (id)forwardingTargetForSelector:(SEL)aSelector { 52 | return nil;//返回nil，进入下一步转发 53 | } 54 | 55 | - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector { 56 | if ([NSStringFromSelector(aSelector) isEqualToString:@"foo"]) { 57 | return [NSMethodSignature signatureWithObjCTypes:"v@:"];//，进入forwardInvocation 58 | } 59 | 60 | return [super methodSignatureForSelector:aSelector]; 61 | } 62 | 63 | - (void)forwardInvocation:(NSInvocation *)anInvocation { 64 | SEL sel = anInvocation.selector; 65 | 66 | Person *p = [Person new]; 67 | if([p respondsToSelector:sel]) { 68 | [anInvocation invokeWithTarget:p]; 69 | } 70 | else { 71 | [self doesNotRecognizeSelector:sel]; 72 | } 73 | 74 | } 75 | 76 | ``` 77 | 78 |
83 |
102 |
103 | #### 方法交换
104 |
105 | 参考内容
84 | 85 | > 关联对象(Objective-C Associated Objects)给分类增加属性 86 | 87 | ``` 88 | //关联对象 89 | void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy) 90 | //获取关联的对象 91 | id objc_getAssociatedObject(id object, const void *key) 92 | //移除关联的对象 93 | void objc_removeAssociatedObjects(id object) 94 | 95 | id object：被关联的对象 96 | const void *key：关联的key，要求唯一 97 | id value：关联的对象 98 | objc_AssociationPolicy policy：内存管理的策略 99 | 100 | ``` 101 |
106 |
138 |
139 | ### KVO内部实现原理
140 |
141 | 参考内容
107 | 108 | - swizzling应该只在+load中完成。 在 Objective-C 的运行时中，每个类有两个方法都会自动调用。+load 是在一个类被初始装载时调用，+initialize 是在应用第一次调用该类的类方法或实例方法前调用的。两个方法都是可选的，并且只有在方法被实现的情况下才会被调用。 109 | 110 | - swizzling应该只在dispatch_once 中完成,由于swizzling 改变了全局的状态，所以我们需要确保每个预防措施在运行时都是可用的。原子操作就是这样一个用于确保代码只会被执行一次的预防措施，就算是在不同的线程中也能确保代码只执行一次。Grand Central Dispatch 的 dispatch_once满足了所需要的需求，并且应该被当做使用swizzling 的初始化单例方法的标准。 111 | 112 | ```objc 113 | 114 | + (void)load { 115 | static dispatch_once_t onceToken; 116 | dispatch_once(&onceToken, ^{ 117 | Class class = [self class]; 118 | SEL originalSelector = @selector(viewDidLoad); 119 | SEL swizzledSelector = @selector(devViewDidLoad); 120 | 121 | Method originalMethod = class_getInstanceMethod(class,originalSelector); 122 | Method swizzledMethod = class_getInstanceMethod(class,swizzledSelector); 123 | 124 | //judge the method named swizzledMethod is already existed. 125 | BOOL didAddMethod = class_addMethod(class, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod)); 126 | // if swizzledMethod is already existed. 127 | if (didAddMethod) { 128 | class_replaceMethod(class, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod)); 129 | } 130 | else { 131 | method_exchangeImplementations(originalMethod, swizzledMethod); 132 | } 133 | }); 134 | } 135 | ``` 136 | 137 |
142 |
153 |
154 | ### Runloop方面
155 |
156 | * [Runloop相关问题解答参考面试题第六份](./06iOS基础问题系列2017年.md)
157 |
158 | * [runloop相关](./20阿里字节一套高效的iOS面试题2020年2月.md)
159 | - [app如何接收到触摸事件的](./20阿里字节一套高效的iOS面试题2020年2月.md#runloop)
160 | - [为什么只有主线程的runloop是开启的](./20阿里字节一套高效的iOS面试题2020年2月.md#runloop)
161 | - [为什么只在主线程刷新UI](./20阿里字节一套高效的iOS面试题2020年2月.md#runloop)
162 | - [PerformSelector和runloop的关系](./20阿里字节一套高效的iOS面试题2020年2月.md#runloop)
163 | - [如何使线程保活](./20阿里字节一套高效的iOS面试题2020年2月.md#runloop)
164 |
165 | ### UITableView的优化手段方法
166 |
167 | * [参考此份第7题](./06iOS基础问题系列2017年.md)
168 |
169 | ### 多线程方面（GCD、NSOperation居多）
170 |
171 | * [阿里字节面试题之多线程](./20阿里字节一套高效的iOS面试题2020年2月.md#多线程)
172 |
173 | ### SDWebImage源码分析
174 | * [参考此处](./02interview-iOS-2.md)
175 |
176 | ### 事件传递以及响应链
177 |
178 | * 传递的函数调用（pointinside，hittest）
179 |
180 | * 响应者链条
181 |
182 | * [要求详细的描述事件响应链参考答案](./25小米百度bigo滴滴快手等iOS面试题2020年上.md#要求详细的描述事件响应链)
183 |
184 | #### 图片的解压缩
185 |
186 | 参考内容
143 | 144 | > KVO是基于runtime机制实现的 145 | 146 | - 当某个类的属性对象第一次被观察时，系统就会在运行期动态地创建该类的一个派生类，在这个派生类中重写基类中任何被观察属性的setter 方法。派生类在被重写的setter方法内实现真正的通知机制 147 | - 如果原类为ClassName，那么生成的派生类名为NSKVONotifying_ClassName 148 | - 每个类对象中都有一个isa指针指向当前类，当一个类对象的第一次被观察，那么系统会偷偷将isa指针指向动态生成的派生类，从而在给被监控属性赋值时执行的是派生类的setter方法 149 | - 键值观察通知依赖于NSObject 的两个方法: willChangeValueForKey: 和 didChangevlueForKey:；在一个被观察属性发生改变之前， willChangeValueForKey:一定会被调用，这就 会记录旧的值。而当改变发生后，didChangeValueForKey:会被调用，继而 observeValueForKey:ofObject:change:context: 也会被调用。 150 | - 补充：KVO的这套实现机制中苹果还偷偷重写了class方法，让我们误认为还是使用的当前类，从而达到隐藏生成的派生类 151 | 152 |
187 |
200 |
201 |
202 | ### HTTPS通信过程
203 |
204 | - [本系列相似扩展问题：HTTPS的加密原理](./02interview-iOS-2.md)
205 |
206 | 参考内容
188 | 189 | > 在主线程的下一个 run loop 到来时，Core Animation 提交了这个隐式的 transaction ，这个过程可能会对图片进行 copy 操作，而受图片是否字节对齐等因素的影响，这个 copy 操作可能会涉及以下部分或全部步骤： 190 | 191 | > 在将磁盘中的图片渲染到屏幕之前，必须先要得到图片的原始像素数据，才能执行后续的绘制操作，这就是为什么需要对图片解压缩的原因 192 | 193 | * 分配内存缓冲区用于管理文件 IO 和解压缩操作； 194 | * 将文件数据从磁盘读到内存中； 195 | * 将压缩的图片数据解码成未压缩的位图形式，这是一个非常耗时的 CPU 操作； 196 | * 解压缩后的图片大小与原始文件大小之间没有任何关系，而只与图片的像素有关 197 | * 最后 Core Animation 使用未压缩的位图数据渲染 UIImageView 的图层。 198 | 199 |
207 |
217 |
218 | ### 需要了解的知识点
219 |
220 | * APM方面（内存泄漏检测、crash监控，卡顿监控以及底层的实现原理等等）
221 | * [卡顿监控](19新浪公司iOS面试题2019年6月.md)
222 | * [阿里字节面试题之性能优化](./20阿里字节一套高效的iOS面试题2020年2月.md#性能优化)
223 |
224 | * 组件化方（蘑菇街 App 的组件化之路、iOS应用架构谈 组件化方案、在现有工程中实施基于CTMediator的组件化方案、iOS 组件化方案探索、iOS 组件化–路由设计思路分析）
225 | * [业界常用的组件通信方案优缺点概述](https://github.com/DevDragonLi/ProtocolServiceKit#业界常用的组件通信方案)
226 |
227 | * 持续化集成（我们公司使用的是：Jenkins+fastlane）
228 | * [Jenkins官网](https://www.jenkins.io)
229 | * [fastlane](https://docs.fastlane.tools)
230 | * 按照官网相关doc操作，或者网上找下教程即可，实践即可。
231 |
232 | ### 觉得整理的蛮不错，可以赞赏一下旺仔(收集整理不易，且赞且珍惜)
233 |
234 |
235 | 参考内容
208 | 209 | * 客户端发起SSL通信，报文中包含客户端支持的SSL的指定版本，加密组件列表(加密算法及密码长度) 210 | * 服务端通过SSL通信，将SSL版本及加密算法版本中的一组发送至客户端. 211 | * 服务端发送客户端Certificate报文，报文中包含公开密钥证书. 212 | * 客户端验证证书的合法性(颁发证书的机构是否合法，证书中包含的网站地址是否与正在访问的地址一致等),如果证书受信任，则浏览器栏里面会显示一个小锁头，否则会给出证书不受信的提示;如果证书受信任，或者用户接受了不受信的证书，客户端会生成一个Pre-master secret的随机密码串，并且通过接受到公钥加密. 213 | * 服务端会通过私钥解密出Pre-master sercret随机密码串，通过Pre-master sercret解密密发来的握手信息，并验证Hash是否与浏览器发来的一致.之后通过密码加密一段握手信息，发给客户端. 214 | * 客户端解密并计算握手信息的Hash,如果与Server发来的Hash一致，此时握手过程结束，利用对称加密算法进行加密. 215 | 216 |
35 |
41 |
42 | ### 谈谈对自动释放池的理解
43 | 参考内容
36 | 37 | - MRC的优势及劣势 38 | - [ARC的工作原理参考](./03interview-iOS-3.md) 39 | 40 |
44 |
82 |
83 | ### 自动释放池在mrc和arc区别
84 | 参考内容
45 | 46 | - [参考Autorelease的原理](./03interview-iOS-3.md) 47 | 48 | - autorelease方法会把对象存储到AutoreleasePoolPage的链表里。等到auto release pool被释放的时候，把链表内存储的对象删除。所以，AutoreleasePoolPage就是自动释放池的内部实现。 49 | 50 | ``` 51 | public: static inline id autorelease(id obj) 52 | { 53 | assert(obj); 54 | assert(!obj->isTaggedPointer()); 55 | id *dest __unused = autoreleaseFast(obj); 56 | assert(!dest || dest == EMPTY_POOL_PLACEHOLDER || *dest == obj); 57 | return obj; 58 | } 59 | static inline id *autoreleaseFast(id obj) 60 | { 61 | AutoreleasePoolPage *page = hotPage(); 62 | if (page && !page->full()) { 63 | return page->add(obj); 64 | } else if (page) { 65 | return autoreleaseFullPage(obj, page); 66 | } else { 67 | return autoreleaseNoPage(obj); 68 | } 69 | } 70 | id *add(id obj) 71 | { 72 | assert(!full()); 73 | unprotect(); 74 | id *ret = next; // faster than `return next-1` because of aliasing 75 | *next++ = obj; 76 | protect(); 77 | return ret; 78 | } 79 | 80 | ``` 81 |
85 |
92 |
93 | ### 多层自动释放池嵌套的对象在哪一层释放
94 | 参考内容
86 | 87 | > 自动释放池是oc提供的一种自动回收的机制，具有延迟释放的特性，即当我们创建了一个对象，并把他加入到了自动释放池中时，他不会立即被释放，会等到一次runloop结束或者作用域超出{}或者超出[pool release]之后再被释放 88 | - MRC: 通过手动创建的方式来创建自动释放池，这种方式创建的自动释放池需要手动调用release（引用计数环境下，调用release和drain的效果相同，但是在CG下，drain会触发GC,release不会） 89 | - ARC下除了NSAutoreleasePool不可用以外，其他的同MRC 90 | 91 |
95 |
111 |
112 | ### 对于block，理解，mrc和arc下有什么区别，使用注意事项
113 |
114 | ### 对于深拷贝和浅拷贝的理解
115 | 参考内容
96 | 97 | > 嵌套的autoreleasepool 98 | 99 | ``` 100 | @autoreleasepool {//DragonLi被放在该自动释放池里面 101 | XXClass *DragonLi = [[XXClass alloc]init]; 102 | @autoreleasepool {//p2被放在该自动释放池里面 103 | XXClass * DragonLi = [[XXClass alloc]init]; 104 | } 105 | } 106 | autorelease对象被添加进离他最近的自动释放池，多层的pool会有多个哨兵对象。 107 | 108 | ``` 109 | 110 |
116 |
125 |
126 |
127 | ### weak原理
128 |
129 | - [weak弱引用的代码逻辑实现](./03interview-iOS-3.md)
130 |
131 | ### 如果属性完全不加修饰词入weak，atomic，系统会怎么处理
132 | 参考内容
117 | 118 | - 浅拷贝：只创建一个新的指针，指向原指针指向的内存 119 | - 深拷贝：创建一个新的指针，并开辟新的内存空间，内容拷贝自原指针指向的内存，并指向它 120 | 121 | ##### NSString一般使用Copy。 122 | - 如果用strong修饰，当我们给它传一个NSMutableString类型的数据时，它的指针指向了该数据，之后会随NSMutableString的特性去改变 123 | 124 |
133 |
138 |
139 | ### 简述下block的实现
140 |
141 | - [block](./20阿里字节一套高效的iOS面试题2020年2月.md#block)
142 |
143 | ### 描述下IM系统如何保证消息不丢
144 |
145 | ### IM数据库如何设计表
146 |
147 | ### C++引用和指针有什么区别
148 | 参考内容
134 | 135 | - 默认为atomic，Strong，ReadWrite 136 | 137 |
149 |
155 |
156 | ### Http协议30x的错误是什么
157 | 参考内容
150 | 151 | > 本质：引用是别名，指针是地址，具体的： 152 | 153 | 154 |
158 |
191 |
192 | ### 谈谈你懂runloop得理解：由浅入深
193 | 参考内容
159 | 160 | - 1xx - 信息提示 161 | - 这些状态代码表示临时的响应。客户端在收到常规响应之前，应准备接收一个或多个 1xx 响应。 • 100 - 继续。 162 | - 2xx - 成功 163 | - 这类状态代码表明服务器成功地接受了客户端请求。 164 | - **• 200 - 确定。客户端请求已成功。** 165 | - • 201 - 已创建。 166 | - • 202 - 已接受。 167 | - • 203 - 非权威性信息。 168 | - • 204 - 无内容。 169 | - • 205 - 重置内容。 170 | - • 206 - 部分内容。 171 | 172 | - 3xx - 重定向 173 | - 客户端浏览器必须采取更多操作来实现请求。例如，浏览器可能不得不请求服务器上的不同的页面，或通过代理服务器重复该请求。 174 | - • 302 - 对象已移动。 175 | - • 304 - 未修改。 176 | - **• 307 - 临时重定向。** 177 | 178 | - 4xx - 客户端错误 179 | - • 401 - 访问被拒绝。IIS 定义了许多不同的 401 错误，它们指明更为具体的错误原因。这些具体的错误代码在浏览器中显示，但不在 IIS 日志中显示： 180 | - • 401.1 - 登录失败。 181 | - • **403.1 - 执行访问被禁止。** 182 | - • 403.2 - 读访问被禁止。 183 | - • 403.3 - 写访问被禁止。 184 | - 5xx - 服务器错误 185 | - 服务器由于遇到错误而不能完成该请求。 186 | - • 500 - 内部服务器错误。 187 | - • 500.12 - 应用程序正忙于在 Web 服务器上重新启动。 188 | - • 503 - 服务不可用。这个错误代码为 IIS 6.0 所专用。 189 | 190 |
194 |
199 |
200 | ### 谈谈对多线程理解:由浅入深
201 |
202 | - [多线程](./20阿里字节一套高效的iOS面试题2020年2月.md#多线程)
203 |
204 | ### 谈谈category和extension区别，系统如何底层实现category
205 | 参考内容
195 | 196 | - [runloop](./20阿里字节一套高效的iOS面试题2020年2月.md#runloop) 197 | 198 |
206 |
230 |
231 | ### 谈谈消息转发机制实现
232 |
233 | - [消息转发参考](08字节跳动面试题：2018年4月.md)
234 |
235 | ### 谈谈事件响应链，如何响应view之外的事件
236 | 参考内容
207 | 208 | - [分类和扩展有什么区别](./21出一套iOS高级面试题2018年7月.md) 209 | 210 | #### 系统如何底层实现category 211 | 212 | > 从objc-os.mm文件的_objc_init函数开始-->map_images-->map_images_nolock-->_read_images-->remethodizeClass-->attachCategories-->attachLists-->realloc、memmove、 memcpy。 213 | - 合并后分类的方法在前面(最后参与编译的那个分类的方法列表在最前面)，本类的方法列表在最后面。所以当分类中有和本类同名的方法时，调用这个方法执行的就是分类中的方法。从这个现象来看，就好像本类的方法被分类中同名的方法给覆盖了，实际上并没有覆盖，只是调用方法时最先查找到了分类的方法所以就执行分类的方法 214 | 215 | ``` 216 | // 定义在objc-runtime-new.h文件中 217 | struct category_t { 218 | const char *name; // 比如给Student添加分类，name就是Student的类名 219 | classref_t cls; 220 | struct method_list_t *instanceMethods; // 分类的实例方法列表 221 | struct method_list_t *classMethods; // 分类的类方法列表 222 | struct protocol_list_t *protocols; // 分类的协议列表 223 | struct property_list_t *instanceProperties; // 分类的实例属性列表 224 | struct property_list_t *_classProperties; // 分类的类属性列表 225 | }; 226 | 227 | ``` 228 | 229 |
237 |
245 |
246 | ### 界面性能优化
247 |
248 | ## 二面视频面试
249 |
250 | ### 聊一聊过往项目中你觉得收获最大的一个模块
251 | - 就说了上个项目做类似朋友圈的优化思路，谈到了空间换时间，缓存，渲染相关的技术点
252 | - 需求痛点：界面卡顿，体验不好 解决方案：探索的思路-》解决方案
253 | - 该模块引申到的新话题还涉及到了增量更新，内存缓存，本地缓存
254 | - 细节上还谈到了富文本绘制，Coretext框架的使用
255 | - 上个项目中存在视频裁剪，录制等功能。
256 |
257 | 面试官对这块有些兴趣，就聊到了视频裁剪的实现，因为我们项目中使用了ffmpeg做的裁剪功能。包括视频下载，数据裁剪封装，引申聊到了边预览边裁剪，因为我之前的项目并没有做到预览裁剪这块。也就没有深入聊下去了。期间简单谈到了**rstp协议，和HLS，rtmp等协议的对比**，信令协议。虽然之前都有看过协议的大致实现和预览，但是实际使用的是SDK，没有实践加持。这部分知识是很容易忘记的。大致聊了下总体差别
258 | - 项目中有用到过DLNA投屏协议
259 | 说来又是惭愧，自己完整做过的项目，过去了两年，居然连流程，协议都只是零零散散的记起来了，很勉强的说出了大概实现流程。知道最后才记起来是**soap协议**。当初为了做这个可是研究了整整两周的。面试官应该也实现过这个需求，提到了**视频盒子断线如何检测做处理**，什么原因导致的。由于之前我们的产品需求比较简单，没有特别完善。这里我也只能说了大概
260 | - 项目做过视频播放需求，使用的AVPlayer框架（重点聊）
261 | 面试官问到，**AVPlayer怎么监听视频缓冲状态的，有哪几种状态**。说来又是惭愧，我只记得是KVO监听的。具体的API已经记不清了。
262 | 接着面试官问到这个需求遇到过哪些坑，怎么解决的。
263 | 这个还真的有，首先是回调播放进度在拖动时候错乱，加载某些小视频的适配，首帧出图很慢。KVO的模式不灵活。**缓冲进度不受我们控制**。短视频可能直接迅速缓冲到底。还是之前的思路,需求痛点有了.解决方案：探索的思路-》解决方案。
264 | 不得不说之前做的产品，都是需求驱动，解决了需求，很多时候就没有极客精神，在深入的去探讨。这块真的是差！
265 | - 如果网络不好，首帧出图之后，如何优化后续播放不卡顿 当时已经一脸懵逼了：就提到了可以适当加大缓冲区，等到足够的I帧数据再开始播放
266 |
267 | - 项目聊完了之后，又追问了iOS的一些基础问题，属性和成员变量区别，strong，atomic关键字，怎么理解runloop，runloop有几种状态等等
268 |
269 | - 非常有意思的算法题
270 | - 有15个瓶子，其中最多有一瓶有毒，现在有四只老鼠，喝了有毒的水之后，第二天就会死。如何在第二天就可以判断出哪个瓶子有毒
271 | 答：开始我想到的是常规思路二分法，717，和面试官说了，发现四只老鼠根本不够，面试官友好的提示从老鼠面去想，这时候很快想到了一个老鼠有死和不死，也就0和1两个状态，四只老鼠有16个组合，正好是足够的。但是怎么分配瓶子，还没想好，演算了一会儿，因为面试官这边时间有限，就说思路是正确的。下面有兴趣在看怎么分哈。面试就到此结束了。
272 |
273 | ### 觉得整理的蛮不错，可以赞赏一下旺仔(收集整理不易，且赞且珍惜)
274 |
275 |
276 | 参考内容
238 | 239 | 240 | * 函数调用（pointinside，hittest）入手 241 | 242 | * [要求详细的描述事件响应链参考答案](./25小米百度bigo滴滴快手等iOS面试题2020年上.md#要求详细的描述事件响应链) 243 | 244 |
9 |
26 |
27 | #### findMedianSortedArrays (找到两个排序数组的中位数)
28 |
29 | 参考内容
10 | 11 | ``` 12 | func _pow_3(_ base: Double, _ exponent: Int) -> Double { 13 | 14 | var isNegative = false 15 | var exp = exponent 16 | if exp < 0 { 17 | isNegative = true 18 | exp = -exp 19 | } 20 | let result = _pow_2(base, exp) 21 | return isNegative ? 1 / result : result 22 | } 23 | 24 | ``` 25 |
30 |
59 |
60 | #### UIContorl -> UIButton
61 | 参考内容
31 | 32 | ``` 33 | 34 | func findMedianSortedArrays_3(_ array1: [Int], _ array2: [Int]) -> Double { 35 | 36 | let total = array1.count + array2.count 37 | let index = total / 2 38 | let count = array1.count < array2.count ? array2.count : array1.count 39 | var array = [Int]() 40 | 41 | var i = 0, j = 0; 42 | for _ in 0...count { 43 | if array.count >= index + 1 { 44 | break 45 | } 46 | if array1[i] < array2[j] { 47 | array.append(array1[i]) 48 | i += 1 49 | } else { 50 | array.append(array2[j]) 51 | j += 1 52 | } 53 | } 54 | return total % 2 == 1 ? Double(array[index]) : Double(array[index] + array[index - 1]) * 0.5 55 | } 56 | 57 | ``` 58 |
62 |
106 |
107 | ### 网络框架
108 |
109 | 参考内容
63 | 64 | - UIButton setTitle的时候才会创建UILabel, setImage的时候才会创建UIImageView, 你为什么吧frame给写死... 不知道UIView有sizeToFit么, 你怎么不实现sizeThatFits, 你是完全不会用吧... 你知道UIButton用AutoLayout布局的时候只要设置origin坐标, 宽高就可以自适应了, 你自定义的时候怎么不实现呢? setBackgroundImage和setImageEdgeInsets 65 | 66 | ``` 67 | 68 | import UIKit protocol ButtonInterface { func setTitle(_ title: String); func setTitleColor(_ titleColor: UIColor); func setTitleEdgeInsets(_ edgeInsets: UIEdgeInsets); func setImage(_ image: UIImage); func setBackgroundImage(_ image: UIImage); func setImageEdgeInsets(_ edgeInsets: UIEdgeInsets); 69 | } class Button: UIControl, ButtonInterface { lazy var titleLabel: UILabel = UILabel() lazy var imageView: UIImageView = UIImageView() lazy var backgroundImageView: UIImageView = UIImageView() var titleLabelIsCreated = false var imageViewIsCreated = false var backgroundImageViewCreated = false internal func setTitle(_ text: String) { if !titleLabelIsCreated { 70 | addSubview(titleLabel) 71 | titleLabelIsCreated = true } 72 | titleLabel.text = text 73 | } internal func setTitleColor(_ textColor: UIColor) { if !titleLabelIsCreated { return } 74 | titleLabel.textColor = textColor 75 | } internal func setTitleEdgeInsets(_ edgeInsets: UIEdgeInsets) { if !titleLabelIsCreated { return } 76 | } internal func setImage(_ image: UIImage) { if !imageViewIsCreated { 77 | addSubview(imageView) 78 | imageViewIsCreated = true } 79 | imageView.image = image 80 | } internal func setBackgroundImage(_ image: UIImage) { if !backgroundImageViewCreated { 81 | addSubview(backgroundImageView) 82 | insertSubview(backgroundImageView, at: 0) 83 | backgroundImageViewCreated = true } 84 | backgroundImageView.image = image 85 | } internal func setImageEdgeInsets(_ edgeInsets: UIEdgeInsets) { if !imageViewIsCreated { return } 86 | } override func sizeThatFits(_ size: CGSize) -> CGSize { if titleLabelIsCreated && !imageViewIsCreated && !backgroundImageViewCreated { let text: NSString? = titleLabel.text as NSString? let titleLabelW: CGFloat = text?.boundingRect(with: CGSize(width: CGFloat(MAXFLOAT), height: bounds.height), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.width ?? 0.0 let titleLabelH: CGFloat = text?.boundingRect(with: CGSize(width: titleLabelW, height: CGFloat(MAXFLOAT)), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.height ?? 0.0 return CGSize(width: titleLabelW, height: titleLabelH + 10) 87 | } else if !titleLabelIsCreated && imageViewIsCreated { return imageView.image?.size ?? CGSize.zero 88 | } else if titleLabelIsCreated && imageViewIsCreated { let text: NSString? = titleLabel.text as NSString? let titleLabelW: CGFloat = text?.boundingRect(with: CGSize(width: CGFloat(MAXFLOAT), height: bounds.height), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.width ?? 0.0 let titleLabelH: CGFloat = text?.boundingRect(with: CGSize(width: titleLabelW, height: CGFloat(MAXFLOAT)), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.height ?? 0.0 let imageViewW: CGFloat = imageView.image?.size.width ?? 0.0 let imageViewH: CGFloat = imageView.image?.size.height ?? 0.0 return CGSize(width: titleLabelW + imageViewW, height: imageViewH > titleLabelH ? imageViewH : titleLabelH) 89 | } else { return backgroundImageView.image?.size ?? CGSize.zero 90 | } 91 | } override func layoutSubviews() { super.layoutSubviews() if titleLabelIsCreated && !imageViewIsCreated { 92 | titleLabel.frame = bounds 93 | titleLabel.textAlignment = .center 94 | } else if !titleLabelIsCreated && imageViewIsCreated { let y: CGFloat = 0; let width: CGFloat = imageView.image?.size.width ?? 0; let x: CGFloat = (bounds.width - width) * 0.5; let height: CGFloat = bounds.height; 95 | imageView.frame = CGRect(x: x, y: y, width: width, height: height) 96 | } else if titleLabelIsCreated && imageViewIsCreated { let imageViewY: CGFloat = 0; let imageViewW: CGFloat = imageView.image?.size.width ?? 0; let imageViewH: CGFloat = bounds.height; let text: NSString? = titleLabel.text as NSString? let titleLabelW: CGFloat = text?.boundingRect(with: CGSize(width: CGFloat(MAXFLOAT), height: bounds.height), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.width ?? 0.0 let titleLabelH: CGFloat = text?.boundingRect(with: CGSize(width: titleLabelW, height: CGFloat(MAXFLOAT)), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: [NSAttributedStringKey.font : titleLabel.font], context: nil).size.height ?? 0.0 let imageViewX: CGFloat = (bounds.width - imageViewW - titleLabelW) * 0.5; let titleLabelX: CGFloat = imageViewX + imageViewW let titleLabelY = (bounds.height - titleLabelH) * 0.5 titleLabel.frame = CGRect(x: titleLabelX, y: titleLabelY, width: titleLabelW, height: titleLabelH) 97 | imageView.frame = CGRect(x: imageViewX, y: imageViewY, width: imageViewW, height: imageViewH) 98 | } if backgroundImageViewCreated { 99 | backgroundImageView.frame = bounds 100 | } 101 | } 102 | } 103 | 104 | ``` 105 |
110 |
151 |
152 |
153 | ### 觉得整理的蛮不错，可以赞赏一下旺仔(收集整理不易，且赞且珍惜)
154 |
155 |
156 | 参考内容
111 | 112 | > 可以参考`YTKNetworking` 或者`AFN` 113 | 114 | - 设计一个网络框架, 如何进行不同数据解析的设计(header, body), 并能够进行自定义 115 | 116 | - 重连机制如何处理, 状态码错误转发机制的处理 117 | 118 | - 如何避免回调地狱, 实现Promise的自实现. 119 | 120 | #### 网络接口规范 121 | 122 | - 两层三部分数据结构 123 | 124 | #### 多服务器多环境设置 125 | 126 | - 标准的APP是有4个环境的，开发、测试、预发、正式， 127 | 128 | #### 网络层数据传递（请求和返回） 129 | 130 | - Client做两个操作，一个是生成NSURLRequest，一个是生成NSURLSessionDataTask并发起，另外还要暴露取消操作给Engine， 131 | 132 | 133 | #### 业务层对接方式 134 | 135 | - casa:集约型API调用其实就是所有API的调用只有一个类，然后这个类接收API名字，API参数，以及回调着陆点（可以是target-action，或者block，或者delegate等各种模式的着陆点）作为参数。然后执行类似startRequest这样的方法，它就会去根据这些参数起飞去调用API了，然后获得API数据之后再根据指定的着陆点去着陆。 136 | 137 | #### 网络请求怎么自动取消 138 | 139 | - casa思路：在**BaseDataEngine的dealloc里面做取消网络请求操作**，把BaseDataEngine绑定给ViewController，当ViewController销毁时BaseDataEngine也就跟着销毁了 140 | - 每个接口生成一个BaseEngine实例，持有Client返回的requestID，所以就可以做取消操作，简单的使用场景 141 | 142 | #### 网络层错误处理 143 | 144 | > 我们将错误处理分为两个步骤，一个是错误解析，一个是错误的UI展示 145 | 146 | - 设计的接口返回数据是标准的id data, NSError *error,是Client就把error处理好，不管你是网络超时错误也好，或者是数据格式不正确也好，都error解析完整，把code错误码定义好，上层根据需要通过code来做具体的UI展示，因为有的界面的错误需要用户的点击确认，有的页面的错误只是一闪而过的提示框，把error交给BaseEngine或者DataEngine来处理errorUI， 147 | 148 | - 定义了一套errorUI的枚举，当BaseEngine拿到error的时候就去做错误的展示 149 | 150 |
19 |
73 |
74 | ## 请简单写出增、删、改、查的SQL语句
75 | 参考内容
20 | 21 | - 参考如下代码 22 | 23 | ```objc 24 | NSArray *array = @[@"12-11", @"12-11", @"12-11", @"12-12", @"12-13", @"12-14"]; 25 | 26 | 1.开辟新的内存空间，然后判断是否存在，若不存在则添加到数组中，得到最终结果的顺序不发生变化。效率分析：时间复杂度为O ( n2 )： 27 | 28 | NSMutableArray *resultArray = [[NSMutableArray alloc] initWithCapacity:array.count]; 29 | // 外层一个循环 30 | for (NSString *item in array) { 31 | // 调用-containsObject:本质也是要循环去判断，因此本质上是双层遍历 32 | // 时间复杂度为O ( n^2 )而不是O (n) 33 | if (![resultArray containsObject:item]) { 34 | [resultArray addObject:item]; 35 | } 36 | } 37 | NSLog(@"resultArray: %@", resultArray); 38 | 39 | 2.利用NSDictionary去重，字典在设置key-value时，若已存在则更新值，若不存在则插入值，然后获取allValues。若不要求有序，则可以采用此种方法。若要求有序，还得进行排序。效率分析：只需要一个循环就可以完成放入字典，若不要求有序，时间复杂度为O(n)。若要求排序，则效率与排序算法有关： 40 | NSMutableDictionary *resultDict = [[NSMutableDictionary alloc] initWithCapacity:array.count]; 41 | for (NSString *item in array) { 42 | [resultDict setObject:item forKey:item]; 43 | } 44 | NSArray *resultArray = resultDict.allValues; 45 | NSLog(@"%@", resultArray); 46 | 47 | 如果需要按照原来的升序排序，可以这样： 48 | resultArray = [resultArray sortedArrayUsingComparator:^NSComparisonResult(id _Nonnull obj1, id _Nonnull obj2) { 49 | NSString *item1 = obj1; 50 | NSString *item2 = obj2; 51 | return [item1 compare:item2 options:NSLiteralSearch]; 52 | }]; 53 | NSLog(@"%@", resultArray); 54 | 55 | 3.利用集合NSSet的特性(确定性、无序性、互异性)，放入集合就自动去重了。但是它与字典拥有同样的无序性，所得结果顺序不再与原来一样。如果不要求有序，使用此方法与字典的效率应该是差不多的。效率分析：时间复杂度为O (n)： 56 | NSSet *set = [NSSet setWithArray:array]; 57 | NSArray *resultArray = [set allObjects]; 58 | NSLog(@"%@", resultArray); 59 | 如果要求有序，那就得排序，比如这里要升序排序： 60 | 61 | resultArray = [resultArray sortedArrayUsingComparator:^NSComparisonResult(id _Nonnull obj1, id _Nonnull obj2) { 62 | NSString *item1 = obj1; 63 | NSString *item2 = obj2; 64 | return [item1 compare:item2 options:NSLiteralSearch]; 65 | }]; 66 | NSLog(@"%@", resultArray); 67 | 4. 有序集合--->直接使用有序集合 68 | NSOrderedSet *set = [NSOrderedSet orderedSetWithArray:array]; 69 | NSLog(@"%@", set.array); 70 | 71 | ``` 72 |
76 |
87 |
88 | ## 与 NSURLConnection 相比，NSURLsession 改进哪些?
89 | 参考内容
77 | 78 | - 增：`insert into tb_blogs(name, url) values('DragonLi','https://github.com/DevDragonLi');` 79 | 80 | - 删： `delete from tb_blogs where blogid = 1;` 81 | 82 | - 改：`update tb_blogs set url = 'www.textURL.com' where blogid = 1;` 83 | 84 | - 查：`select name, url from tb_blogs where blogid = 1;` 85 | 86 |
90 |
96 |
97 | ## 使用drawRect有什么影响？
98 | 参考内容
91 | 92 | - 可以配置每个 session 的缓存，协议，cookie，以及**证书策略（credential policy）**，甚至跨程序共享这些信息 93 | - session task。它负责处理数据的加载以及文件和数据在客户端与服务端之间的上传和下载。NSURLSessionTask 与 NSURLConnection 最大的相似之处在于它也负责数据的加载，最大的不同之处在于**所有的 task 共享其创造者 NSURLSession** 这一公共委托者（common delegate） 94 | 95 |
99 |
107 |
108 |
109 | ## 什么时候会报unrecognized selector的异常？如何避免?
110 | 参考内容
100 | 101 | > drawRect方法依赖Core Graphics框架来进行自定义的绘制 102 | 103 | - 缺点：它处理touch事件时每次按钮被点击后，都会用setNeddsDisplay进行强制重绘；而且不止一次，每次单点事件触发两次执行。这样的话从性能的角度来说，对CPU和内存来说都是欠佳的。特别是如果在我们的界面上有多个这样的UIButton实例，那就会很糟糕了 104 | - 这个方法的调用机制也是非常特别. 当你调用 setNeedsDisplay 方法时, UIKit 将会把当前图层标记为dirty,但还是会显示原来的内容,直到下一次的视图渲染周期,才会将标记为 dirty 的图层重新建立Core Graphics上下文,然后将内存中的数据恢复出来, 再使用 CGContextRef 进行绘制 105 | 106 |
111 |
130 |
131 | ## 界面多个网络请求,如何处理刷新的?
132 |
133 | 参考内容
112 | 113 | - 当调用该对象上某个方法,而该对象上没有实现这个方法的时候， 可以通过“消息转发”进行解决，如果还是不行就会报unrecognized selector异常 114 | - objc是动态语言，每个方法在运行时会被动态转为消息发送，即：objc_msgSend(receiver, selector)，整个过程介绍如下： 115 | - objc在向一个对象发送消息时，runtime库会根据对象的isa指针找到该对象实际所属的类然后在该类中的方法列表以及其父类方法列表中寻找方法运行 116 | 如果，在最顶层的父类中依然找不到相应的方法时，程序在运行时会挂掉并抛出异常unrecognized selector sent to XXX 。但是在这之前，objc的运行时会给出三次拯救程序崩溃的机会 117 | 118 | ### 三次拯救程序崩溃的机会 119 | 120 | - Method resolution:objc运行时会调用**+resolveInstanceMethod:或者 +resolveClassMethod**:，让你有机会提供一个函数实现。如果你添加了函数并返回 YES，那运行时系统就会重新启动一次消息发送的过程，如果 resolve 方法返回 NO ，运行时就会移到下一步，消息转发 121 | - Fast forwarding:如果目标对象实现了**-forwardingTargetForSelector:**，Runtime 这时就会调用这个方法，给你把这个消息转发给其他对象的机会，只要这个方法返回的不是nil和self，整个消息发送的过程就会被重启，当然发送的对象会变成你返回的那个对象。否则，就会继续Normal Fowarding。这里叫Fast，只是为了区别下一步的转发机制。因为这一步不会创建任何新的对象，但Normal forwarding转发会创建一个NSInvocation对象，相对Normal forwarding转发更快点，所以这里叫Fast forwarding 122 | 123 | - Normal forwarding这一步是Runtime最后一次给你挽救的机会。 124 | 首先它会发送**-methodSignatureForSelector:**消息获得函数的参数和返回值类型。 125 | **如果-methodSignatureForSelector:返回nil，Runtime则会发出-doesNotRecognizeSelector:消息，程序这时也就挂掉了**。如果返回了一个函数签名，Runtime就会创建一个NSInvocation对象并发送-forwardInvocation:消息给目标对象 126 | 127 | #### 可以项目引入类似防Crash的组件（或者自研），平时加强数据逻辑校验等。 128 | 129 |
134 |
181 |
182 |
183 | ## 如果tableView界面网络请求有缓存数据逻辑?
184 |
185 | 参考内容
135 | 136 | > 使用调度组:**问题 : 为多个请求均加载完成，但界面已在未得到数据前提前刷新导致界面空白** 137 | 138 | - dispatch_semaphore信号量为基于计数器的一种多线程同步机制。用于解决在多个线程访问共有资源时候，会因为多线程的特性而引发数据出错的问题。 139 | 140 | - semaphore计数大于等于1，计数-1，返回，程序继续运行。如果计数为0，则等待。 141 | 142 | - dispatch_semaphore_signal(semaphore)为计数+1操作。 143 | 144 | - dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)为设置等待时间，这里设置的等待时间是一直等待 145 | 146 | 147 | ```objc 148 | 1. 调度组 149 | dispatch_group_t group = dispatch_group_create(); 150 | 151 | dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 152 | NSLog(@"netWorking_Frist"); 153 | 154 | }); 155 | 156 | dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 157 | NSLog(@"netWorking_Second"); 158 | }); 159 | dispatch_group_async(group,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ 160 | NSLog(@"netWorking_Three"); 161 | }); 162 | 163 | dispatch_group_notify(group, dispatch_get_main_queue(), ^{ 164 | NSLog(@"complete"); 165 | }); 166 | 167 | 168 | 2. 信号量：dispatch_semaphore 169 | 170 | - (void)netWorkingimplementation{ // 基于自身项目的网络请求 171 | // 1. 发起请求 172 | dispatch_semaphore_t semaphore = dispatch_semaphore_create(0); 173 | // 2. 成功/失败回调标记 174 | dispatch_semaphore_signal(semaphore); 175 | // 3. 计数为0 ,则一直等待 176 | dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER); 177 | } 178 | 179 | ``` 180 |
186 |
194 |
195 | ## init方法私有化
196 |
197 | > SDK或者组件设计API相关
198 |
199 | 参考内容
187 | 188 | - 首次进入一个界面tableview的数据应该先读取缓存，主要防止没有网络或者网络不好的情况下用户等待数据时间过长或者没有数据用户体验不好，主要用于某些tableview请求的数据量很大，或者数据短时间内变化不是很快的地方。 189 | - 用户下拉刷新表示重新请求数据，应该强制更新数据，不论本地是否有缓存,但是这部分数据应该存入数据库，保证退出后下次进入界面的时候能够读取最后更新的缓存。 190 | - 上拉加载更多的时候不读缓存，因为如果客户端自己在处理这部分逻辑比较复杂，不是说实现起来复杂，因为对于本地存储来说调用的是统一的一个方法，主要是因为如果用户下拉刷新需要强制更新数据，不论本地有无缓存，都要从服务器请求最新数据。那么问题来了，如果我把用户上拉加载更多时候的数据也存入本地，假设用户上拉加载了5页数据，然后又强制下拉刷新了一下，这个时候tableview显示的是最新的第一页数据，如果接着上拉加载更多我应该是读取缓存还是直接发起网络请求呢。毫无疑问应该直接发起请求，因为下拉强制刷新已经导致了第一页为最新数据，如果第2-5页数据缓存没有过期并且服务器数据确实变化了的话，客户端将得不到新的数据，**所以干脆仅仅第一次进入界面tableview请求第一页数据的时候要读缓存**。 191 | - 根本不用缓存的地方主要是某些数据变化非常快，或者发起的网络请求是一次性的操作，比如收藏某个题目等等。 192 | 193 |
200 |
231 |
232 | ## 线程中栈与堆是公有的还是私有的 ?
233 |
234 | - 栈私有, 堆公有
235 |
236 |
237 | ### 觉得整理的蛮不错，可以赞赏一下旺仔(收集整理不易，且赞且珍惜)
238 |
239 |
240 | 参考内容
201 | 202 | ```objc 203 | 204 | - (instancetype)init __attribute__((unavailable("Disabled. Use +sharedInstance instead"))); 205 | - (instancetype)init NS_UNAVAILABLE; 206 | 207 | 2.m 208 | //3. 内部不响应 不建议! 209 | - (instancetype)init { 210 | // 抛出不识别,没有说明真的原因 211 | [super doesNotRecognizeSelector:_cmd]; 212 | return nil; 213 | } 214 | 215 | // 通过断言 216 | - (instancetype)init{ 217 | NSAssert(false,@"unavailable, use sharedInstance instead"); 218 | return nil; 219 | } 220 | 221 | // 通过异常 222 | - (instancetype)init{ 223 | [NSException raise:NSGenericException format:@"Disabled. Use +[%@ %@] instead", 224 | NSStringFromClass([self class]), 225 | NSStringFromSelector(@selector(sharedInstance))]; 226 | return nil; 227 | } 228 | 229 | ``` 230 |
17 |
44 |
45 | ### MVVM和MVC的区别
46 |
47 | > 参考内容较长，可直接看总结
48 |
49 | 参考内容
18 | 19 | * 可查阅objc相关源码：**struct** objc_class -> isa 20 | * isa 结构如下 21 | 22 | ``` 23 | /** isa_t 结构体 */ 24 | union isa_t { 25 | Class cls; 26 | uintptr_t bits; 27 | struct { 28 | uintptr_t nonpointer : 1; 29 | uintptr_t has_assoc : 1; 30 | uintptr_t has_cxx_dtor : 1; 31 | uintptr_t shiftcls : 33; 32 | uintptr_t magic : 6; 33 | uintptr_t weakly_referenced : 1; 34 | uintptr_t deallocating : 1; 35 | uintptr_t has_sidetable_rc : 1; 36 | uintptr_t extra_rc : 19; 37 | }; 38 | }; 39 | ``` 40 | * extra_rc：表示该对象的引用计数值，实际上是引用计数值减 1，例如，如果对象的引用计数为 10，那么 extra_rc 为 9。如果引用计数大于 10，则需要使用到下面的 has_sidetable_rc。 41 | * has_sidetable_rc：当对象引用计数大于 10 时，则has_sidetable_rc 的值为 1，那么引用计数会存储在一个叫 SideTable 的类的属性中，这是一个散列表。 42 | * 对象引用计数就存放在extra_rc中 43 |
50 | )C (Update> && 一种可以很好地解决Massive View Controller问题的办法就是将 Controller 中的展示逻辑抽取出来，放置到一个专门的地方，而这个地方就是 viewModel 。MVVM衍生于MVC，是对 MVC 的一种演进，它促进了 UI 代码与业务逻辑的分离。它正式规范了视图和控制器紧耦合的性质，并引入新的组件。他们之间的结构关系如下：
68 |
69 | > 
70 |
71 | - MVVM 基本概念
72 | - 在MVVM 中，view 和 view controller正式联系在一起，我们把它们视为一个组件
73 | view 和 view controller 都不能直接引用model，而是引用视图模型（viewModel）
74 | viewModel 是一个放置用户输入验证逻辑，视图显示逻辑，发起网络请求和其他代码的地方
75 | 使用MVVM会轻微的增加代码量，但总体上减少了代码的复杂性
76 |
77 | - MVVM 的注意事项
78 | * view 引用viewModel ，但反过来不行（即不要在viewModel中引入#import UIKit.h，任何视图本身的引用都不应该放在viewModel中）（PS：基本要求，必须满足）
79 | * viewModel 引用model，但反过来不行* MVVM 的使用建议
80 | * MVVM 可以兼容你当下使用的MVC架构。
81 | * MVVM 增加你的应用的可测试性。
82 | * MVVM 配合一个绑定机制效果最好（PS：ReactiveCocoa你值得拥有）。
83 | * viewController 尽量不涉及业务逻辑，让 viewModel 去做这些事情。
84 | * viewController 只是一个中间人，接收 view 的事件、调用 viewModel 的方法、响应 viewModel 的变化。
85 | * viewModel 绝对不能包含视图 view（UIKit.h），不然就跟 view 产生了耦合，不方便复用和测试。
86 | * viewModel之间可以有依赖。
87 | * viewModel避免过于臃肿，否则重蹈Controller的覆辙，变得难以维护。
88 | - MVVM 的优势
89 | * 低耦合：View 可以独立于Model变化和修改，一个 viewModel 可以绑定到不同的 View 上
90 | * 可重用性：可以把一些视图逻辑放在一个 viewModel里面，让很多 view 重用这段视图逻辑
91 | * 独立开发：开发人员可以专注于业务逻辑和数据的开发 viewModel，设计人员可以专注于页面设计
92 | * 可测试：通常界面是比较难于测试的，而 MVVM 模式可以针对 viewModel来进行测试
93 | - MVVM 的弊端
94 |
95 | * 数据绑定使得Bug 很难被调试。你看到界面异常了，有可能是你 View 的代码有 Bug，也可能是 Model 的代码有问题。数据绑定使得一个位置的 Bug 被快速传递到别的位置，要定位原始出问题的地方就变得不那么容易了。
96 | * 对于过大的项目，数据绑定和数据转化需要花费更多的内存（成本）。主要成本在于：
97 | * 数组内容的转化成本较高：数组里面每项都要转化成Item对象，如果Item对象中还有类似数组，就很头疼。
98 | * 转化之后的数据在大部分情况是不能直接被展示的，为了能够被展示，还需要第二次转化。
99 | * 只有在API返回的数据高度标准化时，这些对象原型（Item）的可复用程度才高，否则容易出现类型爆炸，提高维护成本。
100 | * 调试时通过对象原型查看数据内容不如直接通过NSDictionary/NSArray直观。
101 | * 同一API的数据被不同View展示时，难以控制数据转化的代码，它们有可能会散落在任何需要的地方。
102 |
103 | - 总结
104 | * MVC的设计模式也并非是病入膏肓，无药可救的架构，最起码目前MVC设计模式仍旧是iOS开发的主流框架，存在即合理。针对文章所述的弊端，我们依旧有许多可行的方法去避免和解决，从而打造一个轻量级的ViewController。
105 |
106 | * MVVM是MVC的升级版，完全兼容当前的MVC架构，MVVM虽然促进了UI 代码与业务逻辑的分离，一定程度上减轻了ViewController的臃肿度，但是View和ViewModel之间的数据绑定使得 MVVM变得复杂和难用了，如果我们不能更好的驾驭两者之间的数据绑定，同样会造成Controller 代码过于复杂，代码逻辑不易维护的问题。
107 |
108 | * 一个轻量级的ViewController是基于MVC和MVVM模式进行代码职责的分离而打造的。MVC和MVVM有优点也有缺点，但缺点在他们所带来的好处面前时不值一提的。他们的低耦合性，封装性，可测试性，可维护性和多人协作便利大大提高了开法效率。
109 |
110 | * 同时，我们需要保持的是一个拥抱变化的心，以及理性分析的态度。在新技术的面前，不盲从，也不守旧，一切的决策都应该建立在认真分析的基础上，这样才能应对技术的变化。
111 |
112 |
113 |
114 |
115 | ### UIButton防止多次点击
116 | 参考内容
51 | 52 | - MVC：V(
117 |
204 |
205 | ### 弱网相关
206 |
207 | 参考内容
118 | - userInteractionEnabled 119 | - 通过UIButton的enabled属性和userInteractionEnabled属性控制按钮是否可点击。 120 | - 此方案在逻辑上比较清晰、易懂，**但具体代码书写分散**，常常涉及多个地方。 121 | 122 | - cancelPreviousPerformRequestsWithTarget:selector:object 123 | - 总结：会出现延时现象，并且需要对大量的UIButton做处理，工作量大，不方便。 124 | 125 | ``` 126 | /** 方法一 */ 127 | - (void)tapBtn:(UIButton *)btn { 128 | NSLog(@"按钮点击了..."); 129 | // 此方法会在连续点击按钮时取消之前的点击事件，从而只执行最后一次点击事件 130 | [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(buttonClickedAction:) object:btn]; 131 | // 多长时间后做某件事情 132 | [self performSelector:@selector(buttonClickedAction:) withObject:btn afterDelay:2.0]; 133 | } 134 | 135 | - (void)buttonClickedAction:(UIButton *)btn { 136 | NSLog(@"真正开始执行业务 - 比如网络请求..."); 137 | } 138 | 139 | ``` 140 | - 通过Runtime交换UIButton的响应事件方法，从而控制响应事件的时间间隔。 141 | * 创建一个UIButton的分类，使用runtime增加public属性cs_eventInterval和private属性cs_eventInvalid。 142 | * 在+load方法中使用runtime将UIButton的-sendAction:to:forEvent:方法与自定义的cs_sendAction:to:forEvent:方法进行交换 143 | * 使用cs_eventInterval作为控制cs_eventInvalid的计时因子，用cs_eventInvalid控制UIButton的event事件是否有效。 144 | 145 | 146 | ``` 147 | 148 | @interface UIButton (Extension) 149 | 150 | /** 时间间隔 */ 151 | @property(nonatomic, assign)NSTimeInterval cs_eventInterval; 152 | 153 | @end 154 | 155 | static char *const kEventIntervalKey = "kEventIntervalKey"; // 时间间隔 156 | static char *const kEventInvalidKey = "kEventInvalidKey"; // 是否失效 157 | 158 | @interface UIButton() 159 | 160 | /** 是否失效 - 即不可以点击 */ 161 | @property(nonatomic, assign)BOOL cs_eventInvalid; 162 | 163 | @end 164 | 165 | @implementation UIButton (Extension) 166 | 167 | + (void)load { 168 | // 交换方法 169 | Method clickMethod = class_getInstanceMethod(self, @selector(sendAction:to:forEvent:)); 170 | Method cs_clickMethod = class_getInstanceMethod(self, @selector(cs_sendAction:to:forEvent:)); 171 | method_exchangeImplementations(clickMethod, cs_clickMethod); 172 | } 173 | 174 | 175 | 176 | - (void)cs_sendAction:(SEL)action to:(id)target forEvent:(UIEvent *)event { 177 | if (!self.cs_eventInvalid) { 178 | self.cs_eventInvalid = YES; 179 | [self cs_sendAction:action to:target forEvent:event]; 180 | [self performSelector:@selector(setCs_eventInvalid:) withObject:@(NO) afterDelay:self.cs_eventInterval]; 181 | } 182 | } 183 | 184 | 185 | 186 | - (NSTimeInterval)cs_eventInterval { 187 | return [objc_getAssociatedObject(self, kEventIntervalKey) doubleValue]; 188 | } 189 | 190 | - (void)setCs_eventInterval:(NSTimeInterval)cs_eventInterval { 191 | objc_setAssociatedObject(self, kEventIntervalKey, @(cs_eventInterval), OBJC_ASSOCIATION_RETAIN_NONATOMIC); 192 | } 193 | 194 | - (BOOL)cs_eventInvalid { 195 | return [objc_getAssociatedObject(self, kEventInvalidKey) boolValue]; 196 | } 197 | 198 | - (void)setCs_eventInvalid:(BOOL)cs_eventInvalid { 199 | objc_setAssociatedObject(self, kEventInvalidKey, @(cs_eventInvalid), OBJC_ASSOCIATION_RETAIN_NONATOMIC); 200 | } 201 | 202 | ``` 203 |
208 |
222 |
223 | ### 卡顿检测
224 |
225 | - 通过监测Runloop的kCFRunLoopAfterWaiting，用一个子线程去检查，一次循环是否时间太长。
226 | - 如果超出预定时间，则可以dump堆栈，确定卡顿函数
227 |
228 | ### NSCache，NSDictionary，NSArray的区别
229 | 参考内容
209 | - 合适的超时时间，针对不同网络设定不同的超时时间，加快超时，尽快重试 210 | - 按子模块多请求去拉取数据，避免一次性加载，导致数据太多请求返回慢； 211 | - 缓存和增量请求 212 | - 优化DNS查询：应尽量减少DNS查询，做DNS缓存，避免域名劫持、DNS污染，同时把用户调度到“最优接入点”。 213 | - 减小数据包大小和优化包量：通过压缩、精简包头、消息合并等方式，来减小数据包大小和包量。 214 | - 优化ACK包：平衡冗余包和ACK包个数，达到降低延时，提高吞吐量的目的。（这些难度有点高） 215 | - 断线重连，因为我们是 socket 通信的，所以需要做断线重连，重连时间可以递增 216 | - 减少数据连接的创建次数，由于创建连接是一个非常昂贵的操作，所以应尽量减少数据连接的创建次数，且在 217 | - 一次请求中应尽量以批量的方式执行任务。如果多次发送小数据包，应该尽量保证在2秒以内发送出去。在短时间内访问不同服务器时，尽可能地复用无线连接。 218 | - 用户 UI 体验优化，加载一些动画什么的分散下注意力 219 | - 根据不同网络情况动态调节方案，比如图片下载和视频流就可以按照 3G 4G 和 WIFI 进行区分返回 220 | - HTTP3.0 221 |
230 |
241 |
242 | ### SDWebImage里面用了哪种缓存策略？
243 |
244 | - 使用了NSCache做缓存策略
245 |
246 | ### self + weakSelf + strongSelf ?
247 | 参考内容
231 | - NSArray 232 | - 在数组的开头和结尾插入/删除元素通常是一个O(1)操作，而随机的插入/删除通常是 O(N)的。 233 | - NSDictionary 234 | - NSDictionary中的键是被拷贝的并且需要是恒定的。如果在一个键在被用于在字典中放入一个值后被改变，那么这个值可能就会变得无法获取了。一个有趣的细节，在NSDictionary中键是被拷贝的，而在使用一个toll-free桥接的CFDictionary时却只被retain。CoreFoundation类没有通用对象的拷贝方法，因此这时拷贝是不可能的(*)。这只适用于使用CFDictionarySetValue()的时候。如果通过setObject:forKey使用toll-free桥接的CFDictionary，苹果增加了额外处理逻辑来使键被拷贝。反过来这个结论则不成立 — 转换为CFDictionary的NSDictionary对象，对其使用CFDictionarySetValue()方法会调用回setObject:forKey并拷贝键。 235 | - NSCache 236 | - 当系统资源将要耗尽时，NSCache可以自动删减缓存。如果采用普通的字典，那么就要自己编写挂钩，在系统通知时手动删减缓存，NSCache会先行删减 时间最久为被使用的对象 237 | - NSCache 并不会拷贝键，而是会保留它。此行为用NSDictionary也可以实现，但是需要编写比较复杂的代码。NSCache对象不拷贝键的原因在于，很多时候键都是不支持拷贝操作的对象来充当的。因此NSCache对象不会自动拷贝键，所以在键不支持拷贝操作的情况下，该类比字典用起来更方便 238 | - NScache是线程安全的，NSDictionary不是。在开发者自己不编写加锁代码的前提下，多个线程可以同时访问NSCache。对缓存来说，线程安全通常是很重要的，因为开发者可能在某个线程中读取数据，此时如果发现缓存里找不着指定的键，那么就要下载该键对应的数据了 239 | 240 |
248 |
274 |
275 | ## 链接
276 |
277 | - [面试题系列目录](../README.md)
278 | - **上一份**: [苏州蜗牛iOS开发面试题2018年春](18苏州蜗牛iOS开发面试题2018年春.md)
279 | - **下一份**: [阿里字节一套高效的iOS面试题2020年2月](20阿里字节一套高效的iOS面试题2020年2月.md)
280 |
281 | ## 赞赏一下旺仔(收集整理不易，且赞且珍惜)
282 |
283 |
284 | 参考内容
249 | - 在 Block 内如果需要访问 self 的方法、变量，建议使用 weakSelf。 250 | - 如果在 Block 内需要多次 访问 self，则需要使用 strongSelf。 251 | 252 | ``` 253 | 1.使用__weak __typeof是在编译的时候,另外创建一个局部变量weak对象来操作self，引用计数不变。 254 | block 会将这个局部变量捕获为自己的属性， 255 | 访问这个属性，从而达到访问 self 的效果，因为他们的内存地址都是一样的。 256 | 257 | 2.因为weakSelf和self是两个变量,doSomething有可能就直接对self自身引用计数减到0了. 258 | 所以在[weakSelf doSomething]的时候,你很难控制这里self是否就会被释放了.weakSelf只能看着. 259 | 260 | 3.__strong __typeof在编译的时候,实际是对weakSelf的强引用. 261 | 指针连带关系self的引用计数会增加.但是你这个是在block里面,生命周期也只在当前block的作用域. 262 | 所以,当这个block结束, strongSelf随之也就被释放了.不会影响block外部的self的生命周期. 263 | 264 | __weak __typeof(self)weakSelf = self; //1 265 | 266 | [self.context performBlock:^{ 267 | [weakSelf doSomething]; //2 268 | __strong __typeof(weakSelf)strongSelf = weakSelf; //3 269 | [strongSelf doAnotherSomething]; 270 | }]; 271 | 272 | ``` 273 |
286 |
287 |
--------------------------------------------------------------------------------
/interview-iOS/03interview-iOS-3.md:
--------------------------------------------------------------------------------
1 |
2 | # interview-iOS PartThree (profound understanding)
3 |
4 | - [SEL和Method和IMP？](#sel和method和imp)
5 | - [Autorelease的原理 ?](#autorelease的原理)
6 | - [ARC的工作原理](#arc的工作原理)
7 | - [weak弱引用的代码逻辑实现?](#weak弱引用的代码逻辑实现)
8 | - [大文件离线下载怎么处理?会遇到哪些问题?又如何解决](#大文件离线下载怎么处理会遇到哪些问题又如何解决)
9 | - [Socket建立网络连接的步骤](#socket建立网络连接的步骤)
10 |
11 | ## SEL和Method和IMP？
12 | > 谈下对IMP的理解?
13 |
14 |
15 |
46 |
47 | ## Autorelease的原理 ?
48 | 参考内容
16 | 17 | - SEL是“selector”的一个类型，表示一个方法的名字 18 | - Method（我们常说的方法）表示一种类型，这种类型与selector和实现(implementation)相关 19 | - IMP定义为 **id (*IMP) (id, SEL, …)**。这样说来,**IMP是一个指向函数的指针**，这个被指向的函数包括id(“self”指针)，调用的SEL（方法名），再加上一些其他参数.说白了**IMP就是实现方法**。 20 | 21 | > 知名框架AFN源码涉及IMP的代码 22 | 23 | ```objc 24 | NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration ephemeralSessionConfiguration]; 25 | NSURLSession * session = [NSURLSession sessionWithConfiguration:configuration]; 26 | NSURLSessionDataTask *localDataTask = [session dataTaskWithURL:nil]; 27 | IMP originalAFResumeIMP = method_getImplementation(class_getInstanceMethod([self class], @selector(af_resume))); 28 | Class currentClass = [localDataTask class]; 29 | 30 | while (class_getInstanceMethod(currentClass, @selector(resume))) { 31 | Class superClass = [currentClass superclass]; 32 | IMP classResumeIMP = method_getImplementation(class_getInstanceMethod(currentClass, @selector(resume))); 33 | IMP superclassResumeIMP = method_getImplementation(class_getInstanceMethod(superClass, @selector(resume))); 34 | if (classResumeIMP != superclassResumeIMP && 35 | originalAFResumeIMP != classResumeIMP) { 36 | [self swizzleResumeAndSuspendMethodForClass:currentClass]; 37 | } 38 | currentClass = [currentClass superclass]; 39 | } 40 | 41 | [localDataTask cancel]; 42 | [session finishTasksAndInvalidate]; 43 | ``` 44 | 45 |
49 |
64 |
65 |
66 | ## ARC的工作原理
67 | 参考内容
50 | 51 | > ARC下面,我们使用`@autoreleasepool{}`来使用一个Autoreleasepool,实际上UIKit 通过RunLoopObserver 在RunLoop二次Sleep间Autoreleasepool进行Pop和Push,将这次Loop产生的autorelease对象释放 对编译器会编译大致如下: 52 | 53 | ```objc 54 | 55 | void *DragonLiContext = objc_ AutoreleasepoolPush(); 56 | // {} 的 code 57 | objc_ AutoreleasepoolPop(DragonLiContext); 58 | 59 | ``` 60 | 61 | - 释放时机: 当前RunLoop迭代结束时候释放. 62 | 63 |
68 |
77 |
78 |
79 | ## weak弱引用的代码逻辑实现?
80 | 参考内容
69 | 70 | - Automatic Reference Counting，自动引用计数，即ARC,ARC会自动帮你插入retain和release语句,ARC编译器有两部分，分别是前端编译器和优化器 71 | - 前端编译器:前端编译器会为“拥有的”每一个对象插入相应的release语句。如果对象的所有权修饰符是__strong，那么它就是被拥有的。如果在某个方法内创建了一个对象，前端编译器会在方法末尾自动插入release语句以销毁它。而类拥有的对象（实例变量/属性）会在dealloc方法内被释放。事实上，你并不需要写dealloc方法或调用父类的dealloc方法，ARC会自动帮你完成一切。此外，由编译器生成的代码甚至会比你自己写的release语句的性能还要好，因为编辑器可以作出一些假设。在ARC中，没有类可以覆盖release方法，也没有调用它的必要。ARC会通过直接使用objc_release来优化调用过程。而对于retain也是同样的方法。ARC会调用objc_retain来取代保留消息 72 | 73 | - ARC优化器: 虽然前端编译器听起来很厉害的样子，但代码中有时仍会出现几个对retain和release的重复调用。ARC优化器负责移除多余的retain和release语句，**确保生成的代码运行速度高于手动引用计数的代码** 74 | 75 | 76 |
81 |
177 |
178 |
179 | ## 大文件离线下载怎么处理?会遇到哪些问题?又如何解决
180 | 参考内容
82 | 83 | ```objc 84 | objc_storeWeak() 实现 85 | // HaveOld: true - 变量有值 86 | // false - 需要被及时清理，当前值可能为 nil 87 | // HaveNew: true - 需要被分配的新值，当前值可能为 nil 88 | // false - 不需要分配新值 89 | // CrashIfDeallocating: true - 说明 newObj 已经释放或者 newObj 不支持弱引用，该过程需要暂停 90 | // false - 用 nil 替代存储 91 | template bool HaveOld, bool HaveNew, bool CrashIfDeallocating> 92 | static id storeWeak(id *location, objc_object *newObj) { 93 | // 该过程用来更新弱引用指针的指向 94 | // 初始化 previouslyInitializedClass 指针 95 | Class previouslyInitializedClass = nil; 96 | id oldObj; 97 | // 声明两个 SideTable 98 | // ① 新旧散列创建 99 | SideTable *oldTable; 100 | SideTable *newTable; 101 | // 获得新值和旧值的锁存位置（用地址作为唯一标示） 102 | // 通过地址来建立索引标志，防止桶重复 103 | // 下面指向的操作会改变旧值 104 | retry: 105 | if (HaveOld) { 106 | // 更改指针，获得以 oldObj 为索引所存储的值地址 107 | oldObj = *location; 108 | oldTable = &SideTables()[oldObj]; 109 | } else { 110 | oldTable = nil; 111 | } 112 | if (HaveNew) { 113 | // 更改新值指针，获得以 newObj 为索引所存储的值地址 114 | newTable = &SideTables()[newObj]; 115 | } else { 116 | newTable = nil; 117 | } 118 | // 加锁操作，防止多线程中竞争冲突 119 | SideTable::lockTwoHaveOld, HaveNew>(oldTable, newTable); 120 | // 避免线程冲突重处理 121 | // location 应该与 oldObj 保持一致，如果不同，说明当前的 location 已经处理过 oldObj 可是又被其他线程所修改 122 | if (HaveOld && *location != oldObj) { 123 | SideTable::unlockTwoHaveOld, HaveNew>(oldTable, newTable); 124 | goto retry; 125 | } 126 | // 防止弱引用间死锁 127 | // 并且通过 +initialize 初始化构造器保证所有弱引用的 isa 非空指向 128 | if (HaveNew && newObj) { 129 | // 获得新对象的 isa 指针 130 | Class cls = newObj->getIsa(); 131 | // 判断 isa 非空且已经初始化 132 | if (cls != previouslyInitializedClass && 133 | !((objc_class *)cls)->isInitialized()) { 134 | // 解锁 135 | SideTable::unlockTwoHaveOld, HaveNew>(oldTable, newTable); 136 | // 对其 isa 指针进行初始化 137 | _class_initialize(_class_getNonMetaClass(cls, (id)newObj)); 138 | // 如果该类已经完成执行 +initialize 方法是最理想情况 139 | // 如果该类 +initialize 在线程中 140 | // 例如 +initialize 正在调用 storeWeak 方法 141 | // 需要手动对其增加保护策略，并设置 previouslyInitializedClass 指针进行标记 142 | previouslyInitializedClass = cls; 143 | // 重新尝试 144 | goto retry; 145 | } 146 | } 147 | // ② 清除旧值 148 | if (HaveOld) { 149 | weak_unregister_no_lock(&oldTable->weak_table, oldObj, location); 150 | } 151 | // ③ 分配新值 152 | if (HaveNew) { 153 | newObj = (objc_object *)weak_register_no_lock(&newTable->weak_table, 154 | (id)newObj, location, 155 | CrashIfDeallocating); 156 | // 如果弱引用被释放 weak_register_no_lock 方法返回 nil 157 | // 在引用计数表中设置若引用标记位 158 | if (newObj && !newObj->isTaggedPointer()) { 159 | // 弱引用位初始化操作 160 | // 引用计数那张散列表的weak引用对象的引用计数中标识为weak引用 161 | newObj->setWeaklyReferenced_nolock(); 162 | } 163 | // 之前不要设置 location 对象，这里需要更改指针指向 164 | *location = (id)newObj; 165 | } 166 | else { 167 | // 没有新值，则无需更改 168 | } 169 | SideTable::unlockTwoHaveOld, HaveNew>(oldTable, newTable); 170 | return (id)newObj; 171 | } 172 | 173 | ``` 174 | 175 | 176 |
181 |
270 |
271 |
272 | ## Socket建立网络连接的步骤
273 |
274 | 参考内容
182 | 183 | - NSURLSessionDataTask 大文件离线断点下载 (AFN等框架,旧的connection类已经废弃) 184 | 185 | - 内存飙升问题:(apple 默认实现机制导致),在下载文件的过程中，系统会先把文件保存在内存中，等到文件下载完毕之后再写入到磁盘! 在下载文件时，`一边下载一边写入到磁盘`，减小内存使用 186 | 187 | - 具体实现方法: 188 | - 1.`NSFileHandle` 文件句柄 189 | - 2.`NSOutputStream` 输出流 190 | 191 | ```objc 192 | // code copy from jianshu 193 | ///: 1. NSFileHandle 194 | -(void)URLSession:(NSURLSession *)session dataTask:(nonnull NSURLSessionDataTask *)dataTask 195 | didReceiveResponse:(nonnull NSURLResponse *)response 196 | completionHandler:(nonnull void (^)(NSURLSessionResponseDisposition))completionHandler { 197 | //接受到响应的时候 告诉系统如何处理服务器返回的数据 198 | completionHandler(NSURLSessionResponseAllow); 199 | //得到请求文件的数据大小 200 | self.totalLength = response.expectedContentLength; 201 | //拼接文件的全路径 202 | NSString *fileName = response.suggestedFilename; 203 | NSString *cachePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) lastObject]; 204 | NSString *fullPath = [cachePath stringByAppendingPathComponent:fileName]; 205 | 206 | //【1】在沙盒中创建一个空的文件 207 | [[NSFileManager defaultManager] createFileAtPath:fullPath contents:nil attributes:nil]; 208 | //【2】创建一个文件句柄指针指向该文件（默认指向文件开头） 209 | self.handle = [NSFileHandle fileHandleForWritingAtPath:fullPath]; 210 | } 211 | -(void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data { 212 | //【3】使用文件句柄指针来写数据（边写边移动） 213 | [self.handle writeData:data]; 214 | //累加已经下载的文件数据大小 215 | self.currentLength += data.length; 216 | //计算文件的下载进度 = 已经下载的 / 文件的总大小 217 | self.progressView.progress = 1.0 * self.currentLength / self.totalLength; 218 | } 219 | -(void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error { 220 | //【4】关闭文件句柄 221 | [self.handle closeFile]; 222 | } 223 | ///:NSOutputStream 224 | -(void)URLSession:(NSURLSession *)session dataTask:(nonnull NSURLSessionDataTask *)dataTask 225 | didReceiveResponse:(nonnull NSURLResponse *)response 226 | completionHandler:(nonnull void (^)(NSURLSessionResponseDisposition))completionHandler { 227 | //接受到响应的时候 告诉系统如何处理服务器返回的数据 228 | completionHandler(NSURLSessionResponseAllow); 229 | //得到请求文件的数据大小 230 | self.totalLength = response.expectedContentLength; 231 | //拼接文件的全路径 232 | NSString *fileName = response.suggestedFilename; 233 | NSString *cachePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) lastObject]; 234 | NSString *fullPath = [cachePath stringByAppendingPathComponent:fileName]; 235 | 236 | //（1）创建输出流，并打开 237 | self.outStream = [[NSOutputStream alloc] initToFileAtPath:fullPath append:YES]; 238 | [self.outStream open]; 239 | } 240 | -(void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data { 241 | //（2）使用输出流写数据 242 | [self.outStream write:data.bytes maxLength:data.length]; 243 | //累加已经下载的文件数据大小 244 | self.currentLength += data.length; 245 | //计算文件的下载进度 = 已经下载的 / 文件的总大小 246 | self.progressView.progress = 1.0 * self.currentLength / self.totalLength; 247 | } 248 | -(void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error { 249 | //（3）关闭输出流 250 | [self.outStream close]; 251 | } 252 | 253 | ``` 254 | 255 | - 开始(resume) | 暂停(suspend) | 取消( | 恢复等 256 | 257 | ``` 258 | [self.dataTask cancel]; 259 | //默认情况下取消下载不能进行恢复，若要取消之后还可以恢复，可以清空下载任务，再新建 260 | self.dataTask = nil; 261 | 262 | ``` 263 | 264 | - **下载进度值发生跳跃错乱** :已经下载的数据 / 文件的总数据，在第一个代理方法中，我们得到的文件大小并不是真正的文件大小，而是剩余未下载的大小，所以在第一次开始下载时，可以得到正确的数据，但是在下载过程中执行其他操作，就会使得到的数据大小发生变化，从而导致下载进度值出现问题 `解决方案`：`文件总大小 = 已经下载的数据 + 剩余未下载的数据` 265 | 266 | 267 | - 优化性能(句柄和流一样) 只有第一次接收到响应的时候才需要创建空的文件(lazy load ) 268 | 269 |
275 |
324 |
325 | ### 觉得整理的蛮不错，可以赞赏一下旺仔(收集整理不易，且赞且珍惜)
326 |
327 |
328 | 参考内容
276 | 277 | 278 | > 建立Socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket ，另一个运行于服务器端，称为ServerSocket 。套接字之间的连接过程分为三个步骤：服务器监听，客户端请求，连接确认。(知名的框架 AsyncSocket) 279 | 280 | - 服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求 281 | 282 | - 客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求 283 | 284 | - 连接确认：当服务器端套接字监听到或者说接收到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，双方就正式建立连接。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求 285 | 286 | - AsyncSocket 相关代码 287 | 288 | ``` 289 | 290 | // socket连接 291 | -(void)socketConnectHost{} 292 | self.socket = [[AsyncSocket alloc] initWithDelegate:self]; 293 | NSError *error = nil; 294 | [self.socket connectToHost:self.socketHost onPort:self.socketPort withTimeout:-1 error:&error]; 295 | } 296 | 297 | 心跳通过计时器来实现 // NStimer 298 | -(void)onSocket:(AsyncSocket *)sock didConnectToHost:(NSString *)host port:(UInt16)port 299 | { 300 | 301 | LFLog(@"socket连接成功"); 302 | // 每隔1s像服务器发送心跳包 303 | self.connectTimer = [NSTimer scheduledTimerWithTimeInterval:1 target:self selector:@selector(longConnectToSocket) userInfo:nil repeats:YES]; 304 | // 在longConnectToSocket方法中进行长连接需要向服务器发送的讯息 305 | [self.connectTimer fire]; 306 | } 307 | 308 | // socket发送数据是以栈的形式存放，所有数据放在一个栈中，存取时会出现粘包的现象，所以很多时候服务器在收发数据时是以先发送内容字节长度，再发送内容的形式，得到数据时也是先得到一个长度，再根据这个长度在栈中读取这个长度的字节流，如果是这种情况，发送数据时只需在发送内容前发送一个长度，发送方法与发送内容一样 309 | NSData *dataStream = [@8 dataUsingEncoding:NSUTF8StringEncoding]; 310 | 311 | [self.socket writeData:dataStream withTimeout:1 tag:1]; 312 | // 接收数据 313 | 314 | -(void)onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag 315 | { 316 | // 对得到的data值进行解析与转换即可 317 | [self.socket readDataWithTimeout:30 tag:0]; 318 | 319 | } 320 | 321 | ``` 322 | 323 |序
6 |我是一名普通本科的大四学生（软件工程专业），应聘方向是iOS开发，我在招聘中一共面试了30家左右的公司，每次面试后，都及时进行面经整理和解答扩展，现在筛选出优质面经，将它们汇总，分享给大家。
7 |目录
8 |实习面试
9 |-
10 |
- 百度 11 |
- 今日头条 12 |
- 饿了么 13 |
- SAP 14 |
- 360健康 15 |
校招面试
17 |-
18 |
- 阿里巴巴 19 |
- 百度 20 |
- 腾讯 21 |
- 美团点评 22 |
- 今日头条 23 |
- 京东 24 |
- 小米 25 |
- 迅雷 26 |
- 深信服 27 |
- 商汤科技 28 |
- 顺丰科技 29 |
- 招银网络 30 |
实习面试
32 |百度
33 |百度一面
34 |iOS
35 |-
36 |
- iOS中有哪些设计模式，举出两个例子 37 |
- property有什么作用 38 |
- 事件传递和响应链 39 |
- ARC下，有哪些对象被加入了自动释放池中 40 |
- 子线程中如何管理对象的生命周期 41 |
- 如果使用Category添加了和基类一样的方法名的方法后，调用该方法，执行的是Category中的代码而不是基类的代码 42 |
计算机网络
44 |-
45 |
- HTTP报文格式 46 |
- https的加密过程 47 |
- 响应码有哪些 48 |
- TCP和UDP的区别 49 |
- TCP如何保证可靠传输，分别有哪些机制 50 |
- 简要说明下用于交换网络的设备，从物理层往上进行叙述 51 |
算法
53 |-
54 |
- 在数组中寻找第k大的数，要求时间复杂度为O（n） 55 |
百度二面
57 |iOS
58 |-
59 |
- 属性修饰符
60 |
-
61 |
- 有哪些属性修饰符 62 |
- assign和weak区别 63 |
- assign在MRC和ARC 64 |
- copy的用法 65 |
67 | - autoReleasePool
68 |
-
69 |
- autoReleasePool在什么情况下使用 70 |
- 什么对象会加入autoReleasePool 71 |
- autoReleasePool在什么情况下释放 72 |
74 | - RunLoop
75 |
-
76 |
- RunLoop三种模式的区别 77 |
- 在什么情况下使用RunLoop 78 |
80 | - Delegate、Block、Notification的区别 81 |
算法
83 |-
84 |
- 如何判断一个链表是否有环 85 |
- 如何判断一个环的入口 86 |
- 如何用两个栈模拟一个队列 87 |
计算机网络
89 |-
90 |
- TCP和UDP的区别 91 |
- TCP三次握手的过程和为什么要三次握手 92 |
今日头条
94 |今日头条一面
95 |算法
96 |-
97 |
- 验证一个字符串是否为合法的ipv4地址 98 |
iOS
100 |-
101 |
- 一个被放入到@autureleasepool的对象，当自动释放池调用drain方法时，一定会释放吗 102 |
- @aotureleasepool的嵌套使用，对象内存是如何被释放的 103 |
- 关于block的
104 |
-
105 |
- 在Masonry的block中，使用self，会造成循环引用吗 106 |
- 那如果是在普通的block中呢 107 |
- 那在普通的block中只使用下划线属性去访问，会造成循环引用吗 108 |
110 |
计算机网路
112 |-
113 |
- 状态码 114 |
今日头条二面
116 |算法
117 |-
118 |
- 给出两个有序数组，其中A数组的长度为另外B数组的两倍，并且有效数字个数都是B数组大小，合并两个数组，要求：时间复杂度为O（n），空间复杂度为O（1） 119 |
iOS
121 |-
122 |
- 如何检查循环引用 123 |
- 在delloc方法执行的时候，该对象已经会回收了吗 124 |
今日头条三面
126 |计算机网络
127 |-
128 |
- http和https的区别 129 |
- https的加密过程 130 |
- 有了解过中间人攻击吗 131 |
- https能防止中间人攻击吗 132 |
iOS
134 |-
135 |
- 横向比较C++、andriod和iOS的内存管理机制 136 |
饿了么
138 |饿了么一面
139 |热身
140 |-
141 |
- iOS接触时间 142 |
- 收获最多的地方 143 |
- 看简历上写了sqlite，能简要说明下sqlite的实现原理吗 144 |
- ORM如果要你来设计的话，你觉得有什么瓶颈问题 145 |
数据库
147 |-
148 |
- 描述一下主键和索引的作用 149 |
- 有了解数据库引擎吗 150 |
- 描述一下普通的存储过程和事务性存储过程 151 |
- 描述一下第三范式和BCNF范式 152 |
计算机网络
154 |-
155 |
- session和cookie 156 |
- https的加密过程 157 |
- 如何防止https的证书被篡改 158 |
- 有了解过对称加密和非对称加密吗 159 |
iOS
161 |-
162 |
- 你了解哪些iOS底层知识 163 |
- AFNetworking2.0和3.0的区别 164 |
- automic一定是线程安全的吗 165 |
- iOS中的消息传递是怎么一步一步实现的 166 |
- category和extension有什么区别 167 |
- iOS中的私有属性如何设置 168 |
- 串行队列和同步锁两者在保护线程安全上的性能对比 169 |
- 并行队列是同时执行的吗 170 |
- iOS中有哪些锁，你了解多少 171 |
- iOS中UIKit框架的架构 172 |
- UIView和CALayer之间的关系 173 |
- UIView、CoreAnimation和CoreGraphics的关系 174 |
- 应该知道SegmentFault，这个在iOS中是什么错误，那StackOverFlow呢 175 |
- GCD、NSThread、NSOperation性能上有何区别 176 |
算法
178 |-
179 |
- 说说你觉得在学习过程遇到最难理解的东西 180 |
- 网络缓存中涉及到什么算法思想有研究过吗 181 |
其他
183 |-
184 |
- CSS全称和HTML全称是什么 185 |
- 面向对象和面向过程的区别 186 |
饿了么二面
188 |热身
189 |-
190 |
- 关于参加过项目的一些问题
191 |
-
192 |
- 享问是个创业项目，如何和大家一起协作的 193 |
- ... 194 |
196 | - 在大学里成绩如何（我会说我成绩不好吗，严肃脸） 197 |
设计
199 |-
200 |
- 例如有这样一个场景，一个APP，有很多的横栏，每个横栏中都有很多标签，这些标签都能够被拖动
201 |
-
202 |
- 如何去设计 203 |
- 如果一个横栏中的标签能够被拖到另一个横栏呢 204 |
- 是选择采用重写拖动方法还是选择使用UICollectionView呢 205 |
- 是将整体作为UICollectionView，还是整体使用UITableView，每个横栏中使用UICollectionView呢 206 |
208 |
SAP
210 |SAP一面
211 |计算机网络
212 |-
213 |
- 数据链路层的帧的概念和作用 214 |
- ARP路由协议 215 |
- 传输层有哪些协议 216 |
iOS
218 |-
219 |
- UIView是如何设计的 220 |
- CALayer和UIView的区别 221 |
算法
223 |-
224 |
- 一个链表，如何进行每两个交换一次的操作 225 |
SAP二面
227 |计算机网络
228 |-
229 |
- 简述计算机网络的五层，从底层说起 230 |
- ARP协议如何工作 231 |
- TCP和UDP区别 232 |
- 状态码 233 |
算法
235 |-
236 |
- 给一个int类型数字，判断这个数字是否是回文的 237 |
校招面试
239 |阿里巴巴
240 |阿里巴巴一面
241 |自我介绍
242 |...
243 |数据库
244 |-
245 |
- 提高增删改查的效率手段 246 |
- 数据库同步 247 |
操作系统
249 |-
250 |
- 进程之间通信步骤 251 |
计算机网络
253 |-
254 |
- http和https有什么区别 255 |
- 传输层的优化协议 256 |
设计模式
258 |-
259 |
- 了解哪些设计模式（我：所有设计模式，面：哦？） 260 |
- 讲一下工厂模式 261 |
- 工厂模式和抽象工厂的区别 262 |
iOS
264 |-
265 |
- 如何理解运行时 266 |
- 运行时可以做什么 267 |
- UIViewController的生命周期 268 |
- loadView在什么时候执行，一定会执行吗 269 |
- 如何解决死锁问题 270 |
- 多个线程同时访问一个资源应该注意什么 271 |
- 锁的原理是什么 272 |
- 函数参数传入的一般是什么 273 |
- 如果传入一个对象，函数中做一些改变操作，如果不想改变原对象，该如何 274 |
- iOS有几种复制 275 |
- 什么行为能够产生深复制 276 |
- 复制的应用 277 |
java
279 |-
280 |
- java中如何实现值传递和引用传递 281 |
- java的内存管理和OC区别 282 |
算法
284 |-
285 |
- my name is Z X变成Z X is name my 286 |
- 并分析时间复杂度和空间复杂度 287 |
数据结构
289 |-
290 |
- 用两个队列模仿一个栈 291 |
阿里巴巴二面
293 |闲聊
294 |面：哈哈，看你很多地方都是这个名字，nineteen，你是很喜欢这个吗？
295 |我：.......
296 |面：那我们就直接进入正题吧
297 |项目
298 |-
299 |
- 简单聊了几个项目的内容 300 |
- 要求共享桌面看项目代码 301 |
- 讲述项目的架构过程和细节 302 |
- 如何进行项目瘦身 303 |
算法
305 |-
306 |
- 写冒泡排序（写了三个版本） 307 |
结尾
309 |面：稍微等一下，这边安排一个加面
310 |面：你赶紧吃个饭吧
311 |我：哦好的......
312 |阿里巴巴加面一
313 |自我介绍
314 |...
315 |算法
316 |-
317 |
- 封装一个字符串逆序的API 318 |
编程
320 |-
321 |
- A、B、C、D四个线程，A、B、C执行完毕之后，D执行，且A、B、C同时进行 322 |
- A、B、C、D分别添加执行时间 323 |
- A、B、C中都修改一个资源 324 |
问题
326 |-
327 |
- 线程之间的通信步骤 328 |
- 讲一下开源框架的源码
329 |
-
330 |
- 问：既然说到AF，那么说下基本的NSURLConnection和NSURLSession的区别 331 |
333 | - 用一件事说明你对iOS的热情 334 |
- iphoneX推出，我们应该在哪些方法做改变 335 |
- WWDC11上面说了什么改变 336 |
阿里HR面
338 |自我介绍
339 |面：这是我今天听过的最简单的自我介绍
340 |我：严肃脸
341 |项目相关
342 |公司实习相关
343 |对自己的认识
344 |阿里加面二
345 |闲聊
346 |晚上7点一个电话响起，铃铃铃~
347 |面：现在又把你叫过来面试，你今天应该面了5轮吧
348 |我：恩......
349 |项目
350 |-
351 |
- 享问作为一个创业项目的细节
352 |
-
353 |
- 背景 354 |
- 成员管理 355 |
- 如何运营 356 |
- 技术难点 357 |
- 未来发展 358 |
360 |
实习
362 |-
363 |
- 实习的具体经历 364 |
- 为什么没有选择去大企业实习 365 |
技术
367 |-
368 |
- 如何理解iOS系统 369 |
- iOS和andriod在性能上又和区别，具体到实现呢 370 |
- 设计模式是如何在iOS中体现的 371 |
- 如何去优化项目 372 |
自我认知
374 |-
375 |
- 用三个关键标签定位自己，并说出充分的依据 376 |
阿里补招一面
378 |项目
379 |-
380 |
- 分享一下之前做的项目，难点是什么 381 |
- 刚刚说到你平时会研究的一些技术点，那么分享一两个 382 |
iOS
384 |-
385 |
- 如何利用Runtime进行字典转模型 386 |
- 有没有研究过开源框架，有哪些收获 387 |
- 如何设计保证三方库变动对项目本身影响最小 388 |
- 有什么辅助工具去检测内存泄露 389 |
- 内存泄露有哪些方式 390 |
- block如何导致引用计数增加的 391 |
阿里补招二面
393 |热身
394 |-
395 |
- 确认下是否有Offer了，已经签了三方了吗 396 |
- 在美团的实习主要做了什么 397 |
iOS
399 |-
400 |
- 怎么理解JSBridge工作的 401 |
- 对这种工作原理有觉得有什么缺点吗 402 |
- 有了解哪些开源项目 403 |
- 为什么大家要用AFNetworking 404 |
- AFNetworking做了什么性能方面的优化 405 |
- Masonry有什么亮点 406 |
- Block循环引用如何解决 407 |
- Runloop和线程的关系 408 |
- MVC有什么不好的地方 409 |
- 有了解过MVP吗 410 |
- 如果让你设计dispatch_once，你会如何设计 411 |
计算机基础
413 |-
414 |
- 从浏览器查询一个关键字，从计算机原理到计算机网络，展示整个过程 415 |
- 最后的响应报文如何解析到浏览器上有了解吗 416 |
算法
418 |-
419 |
- 一个算法：A和B两个序列，经历最小次数的操作，使得序列从A变成B 420 |
项目
422 |-
423 |
- 有参与过开源项目吗 424 |
- 之前做的项目或者实习有比较具有挑战性的事情吗 425 |
百度
427 |百度一面
428 |自我介绍
429 |......
430 |算法
431 |-
432 |
- 打印100到200之间的素数 433 |
项目
435 |iOS
436 |-
437 |
- UITableView如何调优 438 |
- iOS内存管理模式
439 |
-
440 |
- ARC全称 441 |
443 |
计算机网络
445 |-
446 |
- TCP和UDP的区别 447 |
- 三次握手 448 |
数据库
450 |-
451 |
- 一个场景，手写SQL查询 452 |
百度二面
454 |自我介绍
455 |面试官好像认识我的样子，并没有自我介绍环节
456 |算法
457 |-
458 |
- 反转链表 459 |
- 三种方式遍历二叉树 460 |
iOS
462 |-
463 |
- 介绍iOS内存管理 464 |
计算机网络
466 |-
467 |
- TCP和UDP的区别 468 |
- 手写TCP三次握手 469 |
设计模式
471 |-
472 |
- 手写代理模式 473 |
百度三面
475 |技术相关
476 |-
477 |
- 花10分钟讲述一个技术点 478 |
- JSPatch的原理以及苹果如何检测 479 |
其他
481 |-
482 |
- 项目细节（享问）
483 |
-
484 |
- 如何带团队 485 |
- 如何协调工作 486 |
- 项目背景和目标 487 |
- 成果 488 |
490 | - 对自己的规划 491 |
- 有没有目标榜样 492 |
- 来北京会不会压力过大 493 |
- 对大公司和初创公司的选择 494 |
- 同级别大公司如何选择
495 |
-
496 |
- 答：提高技术 497 |
499 | - 具体怎么个提高法：
500 |
-
501 |
- 答：三个方面...... 502 |
504 | - 面试官介绍了百度如何能提高技术（大概10分钟） 505 |
腾讯
507 |腾讯一面
508 |自我介绍
509 |......
510 |闲聊
511 |-
512 |
- 我看你面的是iOS岗位，目前成都是没有iOS的 513 |
- 东北大学的为什么来成都呢 514 |
计算机网络
516 |-
517 |
- 计算机网络一共有多少层 518 |
- HTTP和HTTPS的区别 519 |
- TCP三次握手 520 |
项目
522 |-
523 |
- 介绍一个比较典型的项目 524 |
iOS
526 |-
527 |
- MVC模式和MVVM模式区别 528 |
- iOS内存管理方式 529 |
- 如何解决iOS的内存管理出现的问题 530 |
- iOS内存管理和andriod内存管理的区别 531 |
结尾
533 |-
534 |
- 我觉得你作为本科生是很优秀的 535 |
- 介绍了成都这边的情况，目前andriod居多，没有iOS岗位 536 |
- 你介意进入的话转岗到andriod开发或者weex开发吗 537 |
- 你等下，我把你引荐到二面 538 |
腾讯二面
540 |自我介绍
541 |项目
542 |-
543 |
- 介绍一个比较好的项目 544 |
按照简历问
546 |-
547 |
- MVC模式C的臃肿和单薄如何控制，自己是如何写的 548 |
- M不应该和V交互吗，M不是要显示到V上嘛（钓鱼执法） 549 |
- Unicode和UTF-8的区别 550 |
- 数据库事务是什么 551 |
- JS可以用来做什么 552 |
- JS能用来开发服务器吗，开发服务器用的引擎是什么 553 |
美团点评
555 |美团点评一面
556 |自我介绍
557 |......
558 |iOS基础
559 |-
560 |
- C++和OC有什么区别 561 |
- 利用OC的动态特性能做什么 562 |
- UITableView如何调优 563 |
- 事件传递和事件响应 564 |
- MVC和MVVM有什么区别 565 |
- iOS的内存布局 566 |
- 介绍ARC 567 |
- 消息机制具体的步骤 568 |
iOS项目
570 |-
571 |
- 瀑布流如何布局 572 |
- 有多个样式的Cell，你会怎么设计 573 |
算法
575 |-
576 |
- 两个有序数组，求第K大的数 577 |
计算机网络
579 |-
580 |
- TCP和UDP的区别 581 |
美团点评二面
583 |自我介绍
584 |面：这边没有找到你的简历
585 |我：啊？那会不会没有优势啊
586 |面：不会的，讲的好就行
587 |iOS
588 |-
589 |
- iOS内存管理 590 |
操作系统
592 |-
593 |
- 进程之间如何通信 594 |
计算机网络
596 |-
597 |
- TCP三次握手具体流程（画出来） 598 |
- TCP三次握手只允许用一个标志传递，如何控制 599 |
- 为何要进行三次握手 600 |
- TCP的拥塞控制 601 |
智力题
603 |-
604 |
- 坐标系中存在一个不规则多边形，判断一个点是否在其中 605 |
算法
607 |-
608 |
- 求二叉树中最大的距离 609 |
美团点评三面
611 |自我介绍
612 |面：没有我的简历
613 |我：我用手机传一份吧
614 |于是加了微信
615 |项目
616 |-
617 |
- 享问
618 |
-
619 |
- 背景 620 |
- 团队协作 621 |
- 如何设计产品 622 |
- 运营成果 623 |
625 |
技术相关
627 |-
628 |
- 有了解过认证的协议吗 629 |
- SSL的详细通信过程（纸画） 630 |
- JSPatch原理 631 |
- 如何模拟热更新的过程 632 |
产品经理
634 |-
635 |
- 如何设计一个首页 636 |
- 产品经理应该具备哪些素质 637 |
- 产品经理应该向程序猿交付哪些东西 638 |
- 一般情况下，产品和程序猿配合出现问题，细节体现在哪里 639 |
个人
641 |-
642 |
- 你觉得自己最大的优点是什么 643 |
- 是完美主义者吗 644 |
- 在团队协作中会有觉得很垃圾的人吗 645 |
- 团队协作中会觉得别人写的代码很垃圾吗 646 |
美团点评HR面
648 |闲聊
649 |-
650 |
- 听面试官说特别想让你留在成都 651 |
- 你是绵阳的吧，我是德阳的，大学在上海，就一直在上海工作了 652 |
- 介绍了美团的餐饮事业群的详细信息（我并没有问...） 653 |
问题
655 |-
656 |
- 对一个薪资的要求 657 |
- 意愿城市 658 |
- 将来的规划 659 |
项目
661 |-
662 |
- 主要问了享问的细节 663 |
提问
665 |-
666 |
- 请问下我的评分sp机会大吗 667 |
- 请问sp的一个标准是top几大概 668 |
- 后续的通知会什么时候发出 669 |
今日头条
671 |今日头条一面
672 |自我介绍
673 |-
674 |
- 手里有你的简历，但是还是想听听你来自我介绍下 675 |
算法
677 |-
678 |
- 合并两个有序数组 679 |
- 二叉树的反转 680 |
操作系统
682 |-
683 |
- 线程和进程的区别 684 |
- 堆和栈的区别 685 |
iOS
687 |-
688 |
- load和initialize区别以及它们有哪些应用 689 |
- 代码写在load和initialize中会影响启动吗 690 |
- 介绍下iOS中的多线程 691 |
- GCD手动创建的线程和GCD提供的API线程有啥关系 692 |
- 有读过GCD的源码吗 693 |
今日头条二面
695 |算法
696 |-
697 |
- 实现一个LUR Cache，包含读、写两个操作 698 |
iOS
700 |-
701 |
- block相关 702 |
- 发送网络请求 703 |
- MVVM 704 |
- KVO 705 |
- 消息机制 706 |
今日头条三面
708 |算法
709 |-
710 |
- 查找两个节点的最近公共父节点 711 |
闲聊
713 |-
714 |
- 相比上次来面试提高了什么 715 |
- 来段英文介绍 716 |
- 拿过哪些offer 717 |
- 为什么选择去天天狼人杀 718 |
iOS
720 |-
721 |
- AFNetworking的源码架构 722 |
- 自己如何设计网络库 723 |
- Masonry源码架构 724 |
计算机网络
726 |-
727 |
- TCP的三次握手 728 |
- TCP的四次挥手 729 |
京东
731 |京东一面
732 |自我介绍
733 |......
734 |项目
735 |-
736 |
- 挑一个比较典型的项目进行分享 737 |
iOS
739 |-
740 |
- iOS中开发有哪些调优策略 741 |
- KVO和KVC是什么 742 |
- 工厂模式是什么 743 |
- 工厂模式和抽象工厂的区别 744 |
- 单例模式如何设计 745 |
- 多线程有哪些 746 |
- GCD中信号量怎么使用 747 |
- 一个队列负责插入数据操作，一个队列负责读取操作，同时操作一个存储的队列，如何保证顺利进行 748 |
- 原型模式 749 |
小米
751 |小米一面
752 |自我介绍
753 |......
754 |问：面试官您是从事什么岗位的呢
755 |面：我是后台开发的
756 |我：......
757 |算法
758 |-
759 |
- 实现reHash方法细节 760 |
计算机网络
762 |-
763 |
- 在浏览器中输入一个域名会执行哪些操作 764 |
项目
766 |小米二面
767 |闲聊
768 |问： 面试官您是从事什么岗位的呢
769 |面：Andriod系统层开发
770 |我：......
771 |算法
772 |-
773 |
- 多个任务，具有起始时间和结束时间，任务是串行执行，规则如下：前一个任务结束时间和后一个任务开始时间不能相交，则计算最多的执行个数的路径为 774 |
java多线程
776 |-
777 |
- 在一个方法中有一个内部类，声明一个内部类类型的临时对象，然后开辟一个子线程去访问这个临时对象，最后在main中调用这个方法，问程序能正常运行吗，会出现野指针异常吗？ 778 |
java基础
780 |-
781 |
- 弱引用和强引用的区别 782 |
项目
784 |迅雷
785 |迅雷一面
786 |自我介绍
787 |......
788 |iOS
789 |-
790 |
- MVC和MVVM的区别 791 |
- MVVM哪些东西是可以重用的 792 |
- 如何进行自动布局 793 |
- storyboard和纯代码布局的优劣 794 |
- SDWebImage的缓存策略 795 |
项目
797 |-
798 |
- 享问细节 799 |
算法
801 |-
802 |
- LRU算法 803 |
深信服
805 |深信服一面
806 |自我介绍
807 |......
808 |面前摆放着一台联想笔记本
809 |我：面试官是做什么开发的
810 |面：我是做Linux开发的
811 |我：......
812 |面试体验
813 |-
814 |
- 拿着一份像是公司出的题，好几页，整个过程来回翻阅题，然后看到合适的就问 815 |
算法
817 |-
818 |
- 模式串匹配（用牛客的某个后台付费平台出的题）
819 |
-
820 |
- 具体内容：普通字符+（通配符）?+（通配符）* 821 |
823 | - 二叉树的几种遍历方式 824 |
笔试题（可能测试是否作弊）
826 |-
827 |
- iOS数据持久化的几种方式 828 |
- 如果是自定义文件如何持久化 829 |
- 写出相应代码 830 |
C语言
832 |-
833 |
- 如何判断一个C语言结构体相等 834 |
- 那如果是在Java中如何判断一个对象相等呢 835 |
- C语言中static修饰符的作用 836 |
数据库
838 |-
839 |
- 数据库事务的特点 840 |
深信服二面
842 |自我介绍
843 |......
844 |我：面试官您是做什么的岗位的呢
845 |面：哦，我不是iOS的，可能没法面iOS方面的，我们就问一些算法吧
846 |我：......
847 |面试体验
848 |-
849 |
- 同样是不断翻面试题考 850 |
- 基本是算法，以算法能力评估一个人的能力 851 |
算法
853 |-
854 |
- 设计一个算法求圆周率 855 |
- 只能遍历一次文本，需要找出多个关键字的次数，位置 856 |
- 找出一个32位数二进制表示法中1的个数（需要达到最优解） 857 |
商汤科技
859 |商汤科技一面
860 |自我介绍
861 |面：不好意思，我这边好像找不到你的简历了，所以你得比较详细地介绍一下你自己
862 |我：......
863 |算法
864 |数羊，给定一个初始数N，第一次数的数为N，第二次为2N，依次类推，直到kN，那么求当0-9的数全部都出现的时候的k值
865 |iOS
866 |-
867 |
- 介绍property的修饰符 868 |
- bounds和frame的区别 869 |
- 在MRC中如何解决循环引用 870 |
- 介绍多线程的实现方式 871 |
- 介绍iOS中数据库，描述一下sqlite的表结构 872 |
- KVO是什么，使用KVO需要注意哪些问题 873 |
- GCD中的循环引用 874 |
商汤科技二面
876 |自我介绍
877 |我：接触iOS开发三年，上架的项目有5个...
878 | 面：哇，你比我开发还久，我上架项目也没有你多（见笑了大佬），不过我是做底层SDK开发的
算法
880 |-
881 |
- 面试官没说清楚题
882 |
-
883 |
- 然后边讨论题应该怎么设计，边聊思路 884 |
886 |
设计模式
888 |-
889 |
- 拿到一个项目，应该如何设计架构 890 |
- MVC模式是怎么交互的 891 |
- UITableViewCell如何实现代理模式的 892 |
- 谈谈KVO模式如何实现 893 |
计算机网络
895 |-
896 |
- 三次握手的细节 897 |
- 状态码 898 |
- 如何设计缓存策略 899 |
操作系统
901 |-
902 |
- 谈谈多线程的底层原理 903 |
iOS
905 |-
906 |
- 内存管理修饰符的区别 907 |
- 介绍一下深复制和浅复制 908 |
- 描述一下runtime 909 |
- runtime可以做什么事情 910 |
- 描述一下runLoop 911 |
- runLoop又可以做什么事情 912 |
- 介绍一下iOS中的多线程 913 |
- GCD有哪些常用的API 914 |
- 使用GCD应该注意什么问题 915 |
- iOS内存管理方式 916 |
- iOS的沙盒 917 |
商汤科技三面
919 |自我介绍
920 |我：开发过五个上架APP
921 |面：哇，这么多
922 |项目
923 |-
924 |
- 动机 925 |
- 过程 926 |
- 扮演角色 927 |
- 收获 928 |
- 有哪些不足 929 |
- 具体每个项目还聊了可行性（其中有创业项目） 930 |
技术
932 |-
933 |
- git相关操作 934 |
- 多线程底层原理 935 |
人生
937 |-
938 |
- 职业规划 939 |
- iOS工作想要从事前端UI还是高性能 940 |
- 想要从事前端移动端还是愿意从事后台的工作 941 |
商汤科技HR面
943 |-
944 |
- 有了解过相关工作内容吗，是否和预期一致 945 |
- 对公司了解吗 946 |
- 我给你介绍下吧 947 |
- 工作城市选择 948 |
- 目前有offer吗 949 |
- 实习时间 950 |
- 目标公司的特点 951 |
顺丰科技
953 |顺丰科技一面
954 |自我介绍
955 |......
956 |项目
957 |-
958 |
- 享问的细节 959 |
计算机网络
961 |-
962 |
- 三次握手过程 963 |
Java
965 |-
966 |
- Java的引用和对象的区别 967 |
设计模式
969 |-
970 |
- 解释单例设计模式
971 |
-
972 |
- 应用场景 973 |
- 和静态方法的区别 974 |
976 |
算法
978 |-
979 |
- 快速排序的原理 980 |
- 线段树 981 |
iOS
983 |-
984 |
- MVC模式 985 |
- MVVM和MVC的区别 986 |
顺丰科技HR面
988 |自我介绍
989 |......
990 |项目
991 |-
992 |
- 讲一个最好的项目 993 |
闲聊
995 |-
996 |
- 有面过其他哪些公司 997 |
- 对于深圳压力大如何看待 998 |
- 东北大学的学生为什么来成都面试 999 |
- 介绍一下家庭情况 1000 |
- 家里人对于工作地点的建议 1001 |
- 自己对工作城市的选择 1002 |
- 优点和缺点 1003 |
我的提问
1005 |-
1006 |
- iOS岗位主要做什么 1007 |
- 薪资如何 1008 |
- 加班严重吗 1009 |
- 公司有食堂吗 1010 |
招银网络
1012 |招银网络一面
1013 |自我介绍
1014 |......
1015 |项目
1016 |-
1017 |
- 享问细节 1018 |
- 有做过日志管理吗 1019 |
- 更新版本的内容是通过什么方式获得的 1020 |
iOS
1022 |-
1023 |
- iOS内存管理方式 1024 |
- 项目架构图 1025 |
- iOS推送是什么 1026 |
- 浏览器可以分享东西到具体APP，这样是如何实现的 1027 |
- 有做分享吗 1028 |
招银网络二面
1030 |自我介绍
1031 |面：你面试这么多了，自我介绍太累了，就省去吧
1032 |我：（中国好面试官！）
1033 |项目
1034 |-
1035 |
- 享问细节 1036 |
- 如果保证团队顺利运行 1037 |
- 未来目标 1038 |
招银网络HR面
1040 |自我介绍
1041 |.....
1042 |项目
1043 |-
1044 |
- 享问细节 1045 |
闲聊
1047 |-
1048 |
- 成绩排名 1049 |
- 有奖学金吗 1050 |
- 有挂科吗 1051 |
- 意向城市是哪里，成都这边不确定有iOS岗位，我得问问 1052 |
- 优点和缺点 1053 |
结尾
1055 |看到这里的童鞋们，预祝你们秋招成功，成为Offer收割机！
1056 | 点个赞吧~