miniLV

赛博朋克摸鱼计数器(100% Vibe Coding)

Mon, 26 Jan 2026 20:00:00 +0800

💡 背景: 有时候你会迷茫，上班的意义是什么，特别是工作多年之后。当你感觉班上不下去的时候，可能会想说自己上班的意义是什么。这时候，你需要知道自己每分钟的价值，才能有继续工作的动力。于是就有了这个工具 —— 一个实时显示你当前已赚多少钱的小玩意儿~

🤖 关于 Vibe Coding

这个项目有点特别，是一次 100% Vibe Coding 的实践。

整个开发过程中，我的角色是产品经理 —— 负责提需求、定方向、做决策。代码实现 100% 由 Claude Code (Opus 4.5) 完成，UI 设计则是用 Figma AI 自动生成后微调。

同时，这也是一次 Spec-Driven Development (SDD) 的实操。感兴趣可以看看 github/spec-kit。

整个过程下来效率确实高了不少，这种开发方式值得尝试。

🎬 效果展示

💰 正常状态	🙈 隐私模式	⏰ 加班提醒

实时收入	遮住数字	该下班了

视觉上走的是赛博朋克风，霓虹绿主色调，CRT扫描线效果，偶尔来点Glitch故障风。

✨ 项目功能

实时收入显示 — 菜单栏直接看，精确到分
愿望清单 — 想买啥设置啥，看进度条慢慢填满
加班提醒 — 过了下班时间界面变红，提醒你时薪正在被稀释
上下班通知 — 到点自动弹出系统通知，提醒你该上班/下班了
隐私保护 — 同事凑过来看屏幕的时候一键切换，支持快捷键
- Emoji模式：数字变成 🍎🚀⭐
- 模糊模式：高斯模糊
- 打码模式：显示 **
多语言支持 — 在 Settings → Advanced 中切换语言，支持中文/英文

🛠️ 技术栈

Swift 6.0
SwiftUI（纯代码）
macOS菜单栏应用
本地数据存储
多语言本地化（中文/英文）
Apple公证签名
Figma AI 生成 UI

📦 使用方法

去 Releases 下载 Paytick.dmg
拖进应用程序文件夹
输入月薪、工作天数、上下班时间
看数字跳

已通过Apple公证，双击就能跑。如果提示无法验证，右键选”打开”就行。

🔒 隐私说明

所有数据存本地。不联网，不上传，不追踪。代码开源，不放心可以自己看。

💭 写在最后

老实说，上班就是拿时间换钱，没什么情怀可言。老板付钱，我出力，公平交易。

但是吧，工作只是生活的一部分，不是全部。到点了就下班，该休息休息，该玩玩。给自己定个小目标，攒够多少钱，就奖励自己一顿好吃的、一个新手机、一次说走就走的旅行。

这个工具的初衷很简单：让你知道自己每小时值多少钱，希望大家都可以准时下班，好好享受生活把～

本文Demo：Paytick

觉得有用的话，欢迎 Star ⭐

Swift5 + MVVM + 文艺复兴微博(纯代码)

Mon, 27 Apr 2020 07:30:00 +0800

背景: 现在越来越多的公司会尝试用 Swift 做 native 的开发了，很多之前习惯用 Objective-C 的开发，有新项目启动的时候，也会想说用 Swift 试试。如果从 2020年编程语言排行榜上看的话，Swift的热度也领先 Objective-C 10个身位了。而我们现在公司所做的项目，也是用 Swift 开发的，虽然说之前有些 OC 基础，写起 Swift 功能也是能实现，但是代码不是很优雅，不够 ‘Swift Style’。熟练度不够的话，很多 Swift 的高级写法还得去翻文档才知道什么意思，所以就打算从0单排一个Swift的项目，而微博正好有开放API , 所以这里就选择它了。

主页界面

表情界面

项目架构

项目功能

用到的技术点

TableView高度缓存
SDWebImage圆角处理
FMDB数据缓存
OAuth授权
单张图片的高度计算
Cell滚动自动加载更多
撰写页面的动画处理
发布界面的Emoji处理
多图的展示
…

不足点

Weibo 的 App 包里的素材图片实在太多了，找到完全匹配的要花费超多时间，所以有的资源不是很匹配，或者不是当前最新的
该Demo使用了FMDB，其实微博这种时效性毕竟高，且有较高政治敏感度的，不适合用本地缓存, 这里只是一个 FMDB 使用的简单案例，更适合更新不用太及时，或者类似qq这种接收服务端推送消息的app.
这个文艺复兴版的微博(2016年的)，现在的微博已经有了较大的变动，且很多API接口现在已经不开放了，所以暂时先用此怀旧版本.
SVProgressHUD 在Swift5.0会crash，所以这个app里没有 toast 功能，坐等修复…
Gif图片由于现在门户网站只能传 < 5M 的，所以看上去毕竟模糊，实际效果会比 Gif 图片好得多，建议用真机跑一下试试~
这版本来打算用本人拙劣的英文写全篇的注释，后来由于本人 Chinelish 水平有限，毕竟复杂的逻辑/业务就用中文写了(求轻喷)
…

使用的第三方库

AFNetworking
SDWebImage
YYModel
SnapKit
FMDB
pop
HMPhotoViewerController

工具分享

图片素材获取: cartool

取色标注工具: MarkMan

数据库工具: Navicat

画图工具: MindNode

…

总结

从事了一段时间的 Swift 开发，发现没有一定量的代码积淀(踩坑)还是不行，所以就打算自己写一个入门的纯Swift App。这个项目是本萌新的第一个发布swift项目，有些粗糙，但是如果新手作为 Swift 上手，入门的，其实应该还可以。该项目基本都是用的 “纯代码+纯Swift” 的方式写的，用的也是尽量新的 API, 萌新们想玩的话感觉还是可以上手的。

最近发现，时间管理 真的很重要，很多事情，一开始以为自己做不到，就打退堂鼓了，但是只要咬咬牙，挑战一下自己的极限，这不，这个Demo就出来了~ (为了写这破玩意，老夫都颈椎病去做针灸了，骗波 star不过分吧~ (开玩笑的，大家开心就好😂))

觉得哪里写的不好的，哪里能改进的，有时间帮忙做code review，提PR的，热烈欢迎啊，这里先谢过了~

本文Demo：MNWeibo

本文感谢新浪提供的 API 支持，感谢天涯刀哥-傅红雪的指导

萌新iOS面试官迷你厂第一视角

Sun, 29 Dec 2019 20:00:00 +0800

之前做过一段时间的面试官，负责了一段时间 iOS 端的技术招聘，身边也有不少朋友咨询过关于这方面的细节。借着这个机会，以一个初级面试官第一视角介绍下招聘方的想法。

当时组里就我一个 iOS 开发，老大安排要扩招两个人，于是临时兼任了一段时间的面试官。

小公司的面试流程一般比较简单，第一轮技术面（就是本弟弟）, 第二轮我们老大面进行 (大佬后来去了阿里，所以他这轮也不算很好过)，第三轮就是和HR谈钱了，基本上半天搞定。当然，怕有的大佬看到要做笔试题扭头就跑，所以一般是没有笔试题。算法的话一般也不怎么考，一般是确定他淘汰了，才会出一题来劝退。

从我们发出招聘之后，第二天就开始陆续有简历收到了。第一个哥们就是来面高级岗的，接近四年经验，当时拿到简历其实心里有点虚，怕hold不住，所以那天拿到他简历之后，认真地过了一下他写的技术点（>.<）因为一般招人，是面试者写什么我们问什么，我们是要发现面试者会什么，而不是出一些只有我们自己会的很冷门的东西去刁难面试者，那样对面试者其实有点不友好。(招人，不就是想招一个能展示)

第二天那个小哥就来了，我先给他倒了一杯水，其实第一次有点紧张，所以我先让他做一下自我介绍，小哥介绍得特别的简短，三句话概括完。然后我事先有先去看了一下他项目，让他展示一下他做的 App，让他从最擅长的地方上手，问一些比较有技术难度的。老实说，那哥们的项目还可以，但是我问到项目中技术点的实现的时候，他的回答都是使用XXX第三方库，但是并不知道具体实现原理，他的回答都是 “这个很简单，用XXX，一行代码集成搞定“ 之类的，以我当时的面试官视角，感觉他是个比较熟悉API调用的，其他技术细节也不够深入，最后遗憾道别。

以一个普通开发者视角来看，我们平时遇到的需求，也不一定说全部的第三方库都能完美解决，所以我们有时候一些功能不得不自己实现，而如果招一个基本只会用第三方库的同事，想必他很难 hold 得住一个全新的项目。

第一次面试之后，面试起来比较得心应手了，但是这里还是要友情提示一下，HR和面试者约的是几点，面试者在那个时间点提前10分钟到就行，太早到。那时候有个哥们，约的下午1点30面试，11点多就来了，我们是12点到1点30休息，一般我中午是有午休的，那哥们这一来，虽然最后还是1：30面试，但是我一中午没睡，有点伤。还有那哥们的一个操作，也是差点把老夫秀翻，那时候正在面试ing…，突然他电话响了，他说他接个电话，然后走开离我差不多三米的地方，和对方约第二天下午的面试。。。😆

其实面了三四个的时候，就有一个哥们，很合适了，我使劲浑身解数尽量往深度问，发现他都能答上来，反正技术肯定甩我好几个身位的，然后我也如实和我们老大说了，由他进行二面，但是最终这哥们还是理智地选择了大厂🤣~

小厂招聘有一个劣势，就是比如你钱和大厂一样，甚至稍高一点，别人也大概率会选择大厂，光环在那，但是小厂毕竟资金有限，所以其实有时候就陷入一种境地，要的人他不来，想来的又达不到要求。陆陆续续面了可能半个多月吧，发现如果不降低面试要求，就我们厂应该很难抢到别人要的人了，最后把目标锁定在 => 经验丰富，能干活的就行。

最终有两个哥们入围了决赛圈，如果仅从短暂的面试来看，实力应该差不多，期望薪资有点差距，最终 HR 从经济的角度出发，选择了那个性价比较高的，（当然那哥们那时候的工资也远超过我🥺）但是这里确实有一个很血粼粼的现实问题出现了，当两个人水平相当的时候，确实招聘方从成本角度出发，可能会优先考虑要价低的，所以有时候你面试的时候，对方说几天内给你消息，这时候可能就是在权衡性价比🤣

理想目标

面试官招人要说合格的话，最理想的目标应该是符合以下几个标准：

要基础扎实，头脑灵活聪明的
思维清晰，善于沟通的
和团队风格匹配的
喜欢钻研，对技术有追求的

敲黑板！重点来了

这段时间，看了不下一百分简历，面了也有一二十个人，简历合格的其实不多，这里有几个小小的建议：

简历可以直接用 markdown 格式的
- 接到过好多word格式的，打开排版全乱了
简历不要写太多，一般 2 页够了，不要从网上抄一大堆 JD，不要有错别字
简历实事求是，别太浮夸
- 收到过好几个哥们简历 5 年经验，面试表现不如实习生的，感觉水分可能还是有一点
写进简历的，都要对他负责任，做好准备
- 完全不懂的就不要写
- 慎用精通！
- 用技术亮点吸引面试官
要有亮点
- 大厂背景
- 名校背景
- 都没有的话，GitHub && 技术博客很重要
  - （如果想进大厂的话，这个很重要！）
面试前，准备工作要先准备好
- 把要演示的 App 先安装好，面试官如果要看能直接演示的
  - 遇到过不止一个被问到能否演示的时候，才去 App Store 下载的
- 如果你是iOS开发，尽量用 iPhone 手机演示
  - 遇到过用安卓手机演示的，说iOS的和这个都一样，有点醉
- 来之前检查下手机电量
  - 遇到过3%电的，我首页点了没两分钟，直接没电了😹
- 注意App的版本是否正确
  - 遇到过一个 App 一划就crash的，最后得出的结论，是版本装错了，其实这个bug修复了~ 😹
回答问题简明扼要，挑重点回答
- 不要问你 who，你回答 how。问你 where，你回答 when (英语老师饶命😝)
- 不要回答一大堆毫不相干的，一句话能表述的，说一两百字，但是回答不到重点的
要掌握主动权
- 从自我介绍开始，挑一些自己比较擅长的领域，引导面试官来问你
- 如果面试官进入到自己熟悉的领域，由浅入深慢慢引导其继续发问
  - 🌰: KVO -> isa混写 -> 底层原理 ->。。。
- 如果正好问到知识盲区，虚心请教，让面试官给点提示引导下~
其实面试过没过，面试结束的时候，凭自己的感觉，也能猜到个八分了，如果全程无障碍沟通，对方问的问题也都能答得上七七八八，准备接offer吧兄弟~

面试考点（根据简历由浅入深提问）

初级

copy 和 mutablecopy 的区别
- NSarry 用 copy 和 mutablecopy 修饰的不同
- NSMutableArry 用 copy 和 mutablecopy 修饰的不同
介绍一下 TableView 的代理和数据源方法
- 讲一下他们的调用顺序
介绍控制器的声明周期
介绍下通知，代理和 block，使用的场景分别是什么
代理修饰为什么用weak，
- 扩展：知道什么是循环引用吗
属性的关键字都有哪些，默认的是哪些
使用 #import 跟 #include 、@class 的区别是什么，分别在什么情况下使用
- 扩展：在.h 文件中一般使用哪个，为什么
原子(atomic)跟非原子(non-atomic)属性有什么区别?
- atomic一定是线程安全的吗？
浅复制和深复制的区别? 可以举个🌰吗
category 和 extensions 的区别，在项目中使用过吗
- category 可以添加属性吗
了解KVO 和 KVC 吗？
对于单例的理解
frame和bounds有什么不同
iOS 中的多线程有哪些
- GCD的一些常用的函数（group，barrier，信号量，线程同步）
实现数据持久化的几个方案
- 介绍一下沙盒模型，存储的位置
用过 UICollectionView 吗？如何实现一个流水布局
- 一般是根据项目问
了解 svn, git 等版本控制工具么
- 如果有写git，可以拓展一下 git 的一些指令问题（merge 和 rebase 区别等等）
- 分支管理
- 一次发版的流程
简述内存分区情况
队列和栈有什么区别
Http请求了解吗
- 知道什么是Restful API 吗
- GET 和 POST 请求的区别
- 特殊的状态码，比如401、503，201的意义
  - 或者直接问 4XX 是哪端的错误

中级

讲述类和结构体的区别，了解什么是 isa指针吗
消息查找的顺序
- 子类调用父类的对象方法，执行的流程是如何的？
如何实现消息转发
给一个nil对象发消息会crash吗
有使用过分类吗
- 分类会”覆盖” 原来的方法吗
- 分类可以添加属性吗，了解关联对象吗
- 分类的内部结构是什么
各种Block
- 有遇到过内存泄漏吗

Block的几种类型
- Block的变量捕捉
__block中的 _ forwarding 指针
- ARC下和MRC下，__block的区别

KVO & KVC 细问
- 什么是 isa 混写
- 如何手动触发一个 value 的 KVO
- KVC修改属性是否会触发KVO
为什么 delegate 设置为 weak 就不会有循环引用
- 了解什么是哈希表吗
- 弱引用表做了什么
对UITableView有做过什么优化吗
- UITableView 为什么会卡顿
- 如何避免卡顿
最熟悉的第三方库是什么
- 99.9%是回答 SDWebImage
  - 问一下 SDWebImage 的缓存机制
  - 如果设计一个图片下载框架
  - 引导对方说出 LRU 算法
- 万一回答 AFNetworking
  - 问下 AFNetworing 有遇到内存泄漏吗
  - 有没有对 AFNetworing 进行二次封装过
  - 有没有对 AFNetworing 中的常驻现场有了解
  - 有办法自己写一个常驻线程吗
- 如果回答 Masonry
  - 问一些自动布局相关的
  - 两个label相互挤压拉伸的
  - 让几个控件平等均匀分布的
  - 原生的autolayout了解吗
RunLoop （除非对方有写，不然不建议问！！）
- 介绍下主线程的 RunLoop
- RunLoop有几种mode
- 为什么 ScrollView 滚动的时候图片轮播器会停止
  - 如果面试者项目中有这个情况
内存管理可以问一问(如果他有写)
- 定时器target的内存泄漏
- autorelease的原理
- weak 和 assign 的原理
- 引用计数器的存储

高级

没有😹（本人水平有限，距离高级距离太远，就不嫌丑了）

闲聊

沟通能力，理解能力其实都算软实力，在面试过程中如果对面试官的问题理解不过来的，可以多和面试官多沟通，一定要等真正get到考点的时候再答，不要乱答一气。(其实很多题目就是让你回答不上来的，面试官有时候并不是真的要考你某个很深的知识点，是想看你思维能力，能否在他引导之下给出他想要的答案，哪怕是错的，有很多时候其实也过了~)

有没有开源精神其实在面试中也是很加分的。不过确实很多面试者没有写博客的习惯，也不少人不了解 GitHub 是啥。如果是大厂，对这方面要求会比较高，然后问下

当然和team风格是否合拍也特别重要，如果你在面试过程中觉得特别不舒服，一般这个团队就不适合你，毕竟面试也算双向选择(虽然企业相对来说处于领先的位置)。

老实说，一个人面试者过来合不合适，聊个5~10分钟其实在面试官心里就能看个七七八八了。一个人还没来面试前，从他的简历上其实也很多时候能看个五五六六了😹，所以简历和第一印象真的非常重要哈~

总的来说，今年的大环境确实不太好，但是还是希望大家可以找到一个心仪的工作~

打个广告，如果是厦门地区的，有打算换工作的，Ringcentral了解一下，955榜上有名的，简历可以发我内推，成功之后请你吃大餐😹 （2020年Q1前能入职的，送air pod pro！！）

iOS初中级开发简历指北

Mon, 06 May 2019 00:00:00 +0800

之前在老东家当过一阵子的 iOS 面试官，看过的简历不下于 100 份，感觉能合格的简历大概只有 30% 左右，很多同学在简历这一关就被刷掉了。这里给经验比较不足的同学们，来一波基础的简历指导~

简历的作用

面试的敲门砖
最大的作用：争取面试机会的时候
引导面试官问问题的方向

好的简历，面试官看完之后，大致就能确定你就是他们需要的人了!!

HR简历关

HR一般是你投完简历之后的第一关，但是其实很多HR可能只做初筛，比如看你的工作年限，学历是否符合要求，然后最终拍板是否邀请你来面试的还是技术，所以对HR的那套其实不怎么吃香，写出技术面试官感兴趣的其实更为重要

大多数的开发都是从初级到中级，一步一步往上走的，基本上每个公司的开发者，也都是涵盖了各个层次的开发者，刚毕业的时候都是一步一步慢慢走，先找到一份工作，慢慢学习，慢慢成长

如果刚毕业的，写个3年经验，侥幸面试遇到不懂技术的面试官，过了，但是对方对你的期望是3年经验的能独当一面的开发者，后来发现你的能力和对方所期望的严重不符，最后其实对双方都没有好处

拒绝虚假简历，不要因为招聘需求需要精通，就全部写精通

iOS简历格式常见错误

Object-C，OC
Foudation
ios / IOS / Ios
iphone / Iphone/ IPone
…

简历闪光点

大厂经历 (BAT等)
知名App开发经验 (说出去有人知道的)
Blog
GitHub
对技术的态度，追求与探索
…

对Blog的看法

不要太功利化，不要随便什么东西都丢到 GitHub 上

Blog 可以看做加分项，是非一线大厂 or 非名牌大学背景的开发者们，进入一二线大厂的加分项，很重要，但是不是全部，不过可以慢慢积累

最好的写博客的时间是三年前，其次是现在

- 鲁迅

切记 - Blog && GitHub一定不要造假！买星星的行为感觉不是很好( FuckFakeGitHubStars 了解一下~)

无大厂经验、无重点大学背景的简历投递

前面说的，Blog那些是加分项，但是如果你的公司和学校都比较一般，不是那些有比较有名头的，其实Blog就变成了比较重要的部分了

因为，大部分人肯定都是想进大厂，或者至少是比现在更大的厂，而我们知道，越好的公司，越多的人竞争，比如某BAT大厂要招一个iOS开发，可能一个HC，就能收到上百份简历，如果我们手里没有加分项的情况下，很难脱颖而出，简历投出去很可能石沉大海

那如果目前你想找工作，但是简历上可能体现不出亮点的话，怎么办呢？

建议，不要直接投一线大厂！先找个二线的厂镀镀银，做跳板。

举个🌰：如果你在一家50人的公司，想直接进一家万人大厂可能比较难，但是你可以争取先进一家500人的，500人的厂其实一般业内也是有点名气了，然后如果目标一直很坚定，比如瞄准BAT的话，就在这家500的人厂做准备，看你的目标厂需求是什么，你就在工作之余以他们的需求为目标，不断学习，可能一年后，你就能成长为他们所需要的人才了~

简历细节处理

英文中文之间，加一个半角空格
- 使用 iOS 开发 ✅
- 使用iOS开发 ❎
英文命名最好统一
- 比如前文使用 ‘app’，后面就不要用 ‘App’ 或者 ‘APP’ 之类的
不要使用“精通”
- 精通Objective-C、C、C++ 。。。
  - 基本宣布gg
- 不要直接抄招聘要求
第三方框架最好不要写，特别是只用简单 API 调用的话
除非一线知名大厂或者知名 App，不然很多项目其实面试官是不知道的，所以如果上架AppStore了，建议加个App Store链接
会OC、会 Runtime、Block、只这样写是不够的
- 最好连实际操作具体描述下，类似AOP打点上传逻辑（不要太空泛，最好实际举🌰）
- 例如熟悉 Runtime，在项目中使用 Method Swizzling 技术实现AOP打点上传功能；
简历最好2-3页，1页太少了，看不出东西，也不用写太多，8000字作文警告也是对简历阅读者的一大考验
不需要自我评价
不需要贴自拍
不需要过多无用信息
排版一定不要错乱，强烈建议使用 PD F格式，不要用 word 格式
如果有比较需要理解的技术点，最好有自己对该知识点理解的blog链接
每次用 markdown 写完准备投递的时候，一定要先生成 PDF 文件先自己 review 下，不要有错别字，尽量不要出现内容模块被划分的情况
- 比如你在介绍你的某一段工作经历，尽量不要，第一页写3点，然后剩下的内容被划分到下一页，最好是每页的结尾，都把某个部分的内容介绍完毕，下一页开始新的介绍
- 如果某个工作经历的出现了一共划分成两页的5个点，第一页结尾3点，第二页开头2点，尽量想办法，弄成要不从第二页开始介绍全部5点，要么在第一页的格式上，看能否全写在第一页结尾
每页要尽量写满，比如你写了3页，最后一页只有不到三分之一，就浓缩成2页，不要留下大面积空白
如果工作经历真的特别多的，但是技术点有很重复的，没必要每个都写，挑重要的，有技术的写，尽量不要出现多个项目，描述使用相同的技术
简历的两个闪光点
- 开源项目 / GitHb & Blog
- 技能清单
- 如果没有开源项目，技能清单一定认真写，写出亮点出来
最最最重要的一点，简历写的是自己，要为简历上的每个字负责！不能说一顿乱写，跟写小说一样，最后主人公不是自己（手动🐶）

简历模板

如果自己投递的话，不要用什么模板，直接 markdown 搞定一切~

推荐软件 typora(免费，非广告🐶)

小蠢驴脱敏简历

总结

最近的金三银四确实好像比往年差一些，iOS开发没人要的新闻，也已经听了很多年了，看到论坛上，很多人再说找了三个月还没面试邀请，这时候，可能就是真的简历写的不够好，可以写一份，投递几家，没面试邀请，复盘下，看有哪里可以改进优化的。老夫作为一个108本无任何大厂背景的3年iOSer，以上面的模板基本投出去的简历都有接到面试，所以说 简历是面试的敲门砖~

打个隐藏广告，面试驱动技术系列了解一下！面试的时候其实很能派上用场(本人亲测)!

还有些技术点，比如多线程、 RunLoop、内存管理的之后会继续补上

一道高级iOS面试题(runtime方向)

Thu, 28 Mar 2019 07:00:00 +0800

面试驱动技术合集（初中级iOS开发），关注仓库，及时获取更新 Interview-series

说到iOS，要么公司规模比较小，<=3人，不需要面试。

其他的，大概率要让你刀枪棍棒十八般武艺都拿出来耍耍。

而其中，但凡敌军阵营中有iOSer的，又极大概率会考到 Runtime 的知识点。

以下，是一题 sunnyxx的一道 runtime 考题，给大伙练练手，如果掌握了，Runtime层面的初中级问题应该都不在话下~

题目来袭：

//MNPerson
@interface MNPerson : NSObject

@property (nonatomic, copy)NSString *name;

- (void)print;

@end

@implementation MNPerson

- (void)print{
    NSLog(@"self.name = %@",self.name);
}

@end

---------------------------------------------------

@implementation ViewController

- (void)viewDidLoad {

    [super viewDidLoad];
    
    id cls = [MNPerson class];
    
    void *obj = &cls;
    
    [(__bridge id)obj print];
    
}

问输出结果是啥，会不会崩溃。

最终结果：

self.name = <ViewController: 0x7fe667608ae0>

what？

问题1：print 是实例方法，但是并没有哪里调用了 [MNPerson alloc]init] ??
问题2: 为啥打印了 viewController？

当前内存地址结构 - 与正常的 [person print] 对比

person变量的指针，执行 MNPerson 实例对象
实例对象的本身是个结构体，之前指向他，等价于执行结构体的第一个成员
结构体的第一个成员是isa，所以可以理解为，person->isa
所以两个print，其实内存结构一致
- obj -> cls -> [MNPerson Class]
- person -> isa -> [MNPerson Class]

调用print 方法，不需要关心有没有成员变量 _name，所以可以理解为，cls == isa

函数调用，是通过查找isa，其实本质，是查找结构体的前八个字节;
前八个字节正好是isa，所以这里可以理解为 cls == isa，这么理解的话，cls其实等于isa;
所以可以找得到 MNPerson 类，就可以找到MNPerson 类内部的方法，从而调用 ` print` 函数

问题2：为啥里面打印的是 ViewController

这就需要了解到iOS的内存分配相关知识

内存分配

void test(){
    int a = 4;
    int b = 5;
    int c = 6;
    
    NSLog(@"a = %p,b = %p,c = %p",&a,&b,&c);
}
---------------------------
a = 0x7ffee87e9fdc,
b = 0x7ffee87e9fd8,
c = 0x7ffee87e9fd4

局部变量是在栈空间
上图可以发现，a先定义，a的地址比b高，得出结论：栈的内存分配是从高地址到低地址
栈的内存是连续的 (这点也很重要！！)

OC方法的本质，其实是函数调用, 底层就是调用 objc_msgSend() 函数发送消息。

- (void)viewDidLoad {

    [super viewDidLoad];
    
    NSString  *test = @"666";
    
    id cls = [MNPerson class];
    
    void *obj = &cls;
    
    [(__bridge id)obj print];
    
}

以上述代码为例，三个变量 - test、cls、obj，都是局部变量，所以都在栈空间

栈空间是从高地址到低地址分配，所以test是最高地址，而obj是最低地址

MNPerson底层结构

struct MNPerson_IMPL{
    Class isa;
    NSString *_name;
}

- (void)print{
    NSLog(@"self.name = %@",self->_name);
}

要打印的 _name 成员变量，其实是通过 self -> 去查找；
这里的 self，就是函数调用者；
[(__bridge id)obj print]; 即通过 obj 开始找；
而找 _name ，是通过指针地址查找，找得 MNPerson_IMPL 结构体
因为这里的 MNPerson_IMPL 里面就两个变量，所以这里查找 _name，就是通过 ` isa 的地址，跳过8个字节，找到 _name`

而前面又说过，cls = isa，而_name 的地址 = isa往下偏移 8 个字节，所以上面的图可以转成

_name的本质，先找到 isa，然后跳过 isa 的八个字节，就找到 _name这个变量

所以上图输出

self.name = 666

最早没有 test变量的时候呢

- (void)viewDidLoad {

    [super viewDidLoad];
    
    id cls = [MNPerson class];
    
    void *obj = &cls;
    
    [(__bridge id)obj print];
    
}

[super viewDidLoad];做了什么

底层 - objc_msgSendSuper

` objc_msgSendSuper({ self, [ViewController class] },@selector(ViewDidLoad)),`

等价于：

struct temp = {
    self,
    [ViewController class] 
}

objc_msgSendSuper(temp, @selector(ViewDidLoad))

所以等于有个局部变量 - 结构体 temp，

结构体的地址 = 他的第一个成员，这里的第一个成员是self

所以等价于 _name = self = 当前ViewController，所以最后输出

self.name = <ViewController: 0x7fc6e5f14970>

话外篇 super 的本质

**其实super的本质，不是 objc_msgSendSuper({self,[super class],@selector(xxx)}) **

而是

objc_msgSendSuper2(
{self,
[current class]//当前类
},
@selector(xxx)})

函数内部逻辑，拿到第二个成员 - 当前类，通过superClass指针找到他的父类，从superClass开始搜索，最终结果是差不多的~

友情演出:小马哥MJ

题目来源:

神经病院入学考试

runtime消息机制理解

isa详解 & class 内部结构

Tue, 19 Mar 2019 06:49:00 +0800

面试驱动技术合集（初中级iOS开发），关注仓库，及时获取更新 Interview-series

isa详解

arm64架构之后，isa进行了优化，变成了一个共用体( union)结构，使用了位域的技术，可以存储更多的信息

  #define MNWhiteMask (1<<0) //Ox0000 0001
  #define MNRichMask (1<<1) //Ox0000 0010
  #define MNBeautyMask (1<<2) //Ox0000 0100
  
  
  @interface MNObject ()
  {
      //位域
      struct {
          char white : 1;
          char rich : 1;
          char beauty : 1;
      }_whiteRichBeauty;
  }
  @end

番外篇 - 假设一个程序员都喜欢对象，有白富美三个属性，能否用一个字节去存储呢？

具体实现

  @implementation MNGirl
  
  - (void)setWhite:(BOOL)white{
      _whiteRichBeauty.white = white;
  }
  - (void)setRich:(BOOL)rich{
      _whiteRichBeauty.rich = rich;
  }
  - (void)setBeauty:(BOOL)beauty{
      _whiteRichBeauty.beauty = beauty;
  }
  
  - (BOOL)white{
      return _whiteRichBeauty.white;
  }
  - (BOOL)rich{
      return _whiteRichBeauty.rich;
  }
  - (BOOL)beauty{
      return _whiteRichBeauty.beauty;
  }
  
  @end

使用情况

  MNGirl *girl = [MNGirl new];
  [girl setWhite:NO];
  [girl setRich:YES];
  [girl setBeauty:NO];
  
  NSLog(@"white = %d, rich = %d, beauty = %d", girl.white, girl.rich, girl.beauty);
  
  ------------------------------------------------------------------
  输出：
  white = 0, rich = -1, beauty = 0

white 和 beauty的值都是正确的，为啥rich 出错了？

涉及到符号位覆盖的问题！

  (lldb) p/x girl->_whiteRichBeauty
  ((anonymous struct)) $1 = (white = 0x00, rich = 0x01, beauty = 0x00)

赋值的时候，其实还是正确的，rich = 1，取值的时候，怎么出问题了呢?

这里假设结构体 _whiteRichBeauty 占8位，假设是0x 0000 0000

rich = 1，占1位，就是 0x1

要把 0x1 赋值到 0x 0000 0000，就要涉及到拷贝

0x的第一位是1，所以将1拷贝过去，最后变成 0x 1111 1111

全是1，8个1 = 255 = 0xff

0xff 有符号 = 255，无符号 = -1，

所以这里输出-1 ==> 错误输出！

解决办法：

  {
      //位域
      struct {
          char white : 2;
          char rich : 2;
          char beauty : 2;
      }_whiteRichBeauty;
  }

一个占2位，三个属性合起来也才6位，1个字节还是可以放得下

然后现在 rich = 1，占2位，就是 0x01

rich的第一位是0，第二位才是1，所以将第一位0拷贝过去，最后变成 0x 0000 0001 = 结果！

苹果的做法 -> 共用体：

里面的成员共用一块内存，和结构体不一样，存储采取位运算，结构体只是增加可读性

  @interface MNGirl ()
  {
      //共用体
      union {
          //存放所有数据
          char bits;
          
          //位域:增加可读性，可以省略
          struct {
              char white : 1;
              char rich : 1;
              char beauty : 1;
          };
      }_whiteRichBeauty;
      
  }
  @end
  

  //共用体
  union isa_t {
      isa_t() { }
      isa_t(uintptr_t value) : bits(value) { }
  
      Class cls;
      uintptr_t bits;
  #if defined(ISA_BITFIELD)
      struct {
          ISA_BITFIELD;  // defined in isa.h
      };
  #endif
  };
  ISA_BITFIELD = struct{
        uintptr_t nonpointer        : 1;                                       \
        uintptr_t has_assoc         : 1;                                       \
        uintptr_t has_cxx_dtor      : 1;                                       \
        uintptr_t shiftcls          : 33; /*MACH_VM_MAX_ADDRESS 0x1000000000*/ \
        uintptr_t magic             : 6;                                       \
        uintptr_t weakly_referenced : 1;                                       \
        uintptr_t deallocating      : 1;                                       \
        uintptr_t has_sidetable_rc  : 1;                                       \
        uintptr_t extra_rc          : 19
  }

arm64架构下，isa不是直接指向class的地址，而且要&上一个MASK

shiftcls: class存放的地址，通过 & ISA_MASK ==> 取出表示 class地址的44位

这样其他位就还能存储数据了

释放更快的源码 - objc_destructInstance

  void *objc_destructInstance(id obj) 
  {
      if (obj) {
          // Read all of the flags at once for performance.
          //如果没有C++析构函数
          bool cxx = obj->hasCxxDtor();
          //没有设置过关联对象
          bool assoc = obj->hasAssociatedObjects();
  
          // This order is important.
          //移除操作
          if (cxx) object_cxxDestruct(obj);
          if (assoc) _object_remove_assocations(obj);
          obj->clearDeallocating();
      }
  
      return obj;
  }

Class内部结构

class_rw_t

rw –> readwrite 可读可写，可以修改

  struct class_rw_t {
  
      method_array_t methods;//方法列表
      property_array_t properties;//属性列表
      protocol_array_t protocols;//协议列表
      }

class_rw_t 中的 methods、properties、protocols 都是二维数组，以methods为例

methods 里面是一组一组的 method_list_t，可以理解为一个一个的分类，每个method_list_t里面是该分类下的一个一个method_t 组成的方法列表

对于分类想了解得更深一点的，怎么拼接组装的，底层实现的，可以看下Category相关知识

class_ro_t

ro –> readonly，只读，不可修改，保留类最初始的属性

  struct class_ro_t {
  
      method_list_t * baseMethodList;//原方法列表
      protocol_list_t * baseProtocols;
      const ivar_list_t * ivars;//成员变量列表
      }

class_ro_t 里面baseMethodList 是一维数组，因为原始的类对象只有一个，就是宿主类，不包含分类信息，所以不需要二维数组，直接 baseMethodList 里面直接放 method_t就行了

  struct method_t {
      SEL name;//函数名
      const char *types;//返回值类型&参数
      MethodListIMP imp;//函数地址 
      }
  

Type Encodings

  // "i24@0:8i16f20"
  // 0id 8SEL 16int 20float  == 24
  - (int)test:(int)age height:(float)height

每一个方法都有两个默认参数self和_cmd 我们可以查到id类型为@，SEL类型为:

1、第一个参数i返回值
2、第二个参数@ 是id 类型的self
3、第三个参数:是SEL 类型的_cmd
4、第四个参数i 是Int age
5、第五个参数f 是float height

其中加载的数字其实是跟所占字节有关

1、24 总共占有多少字节
2、@0 是id 类型的self的起始位置为0
3、:8 是因为id 类型的self占字节为8，所以SEL 类型的_cmd`的起始位置为8

这里的数字都可以省略 i24@0:8i16f20 ==> i@:if

Runtime - 消息机制详解

Mon, 18 Mar 2019 07:49:00 +0800

面试驱动技术合集（初中级iOS开发），关注仓库，及时获取更新 Interview-series

Class 结构详解

struct objc_class : objc_object {
    Class isa;
    Class superclass;
    cache_t cache;--> 方法缓存      
    class_data_bits_t bits;  
}

struct cache_t {
    struct bucket_t *_buckets;//散列表
    mask_t _mask;//散列表长度-1
    mask_t _occupied;//已经缓存的方法数量
    }

struct bucket_t {
    cache_key_t _key;//@selecter(xxx) 作为key
    MethodCacheIMP _imp;//函数的执行地址
    }

buckets 散列表，是一个数组，数组里面的每一个元素就是一个bucket_t,bucket_t里面存放两个
- _key SEL作为key
- _imp 函数的内存地址
_mask 散列表的长度
_occupied已经缓存的方法数量

函数调用底层走的是objc_msgSend

正常的流程：

对象通过isa，找到函数所在的类对象
这时候先做缓存查找，如果缓存的函数列表中没找到该方法
就去类的class_rw中的methods中找，如果找到了，调用并缓存该方法
如果类的class_rw中没找到该方法，通过superclass到父类中，走的逻辑还是先查缓存，缓存没有查类里面的方法。
最终如果在父类中调用到了，会将方法缓存到当前类的方法缓存列表中

方法缓存

如何进行缓存查找->使用散列表(散列表 - 空间换时间)

MNGirl *girl = [[MNGirl alloc]init];
mj_objc_class *girlClass = (__bridge mj_objc_class *)[MNGirl class];

[girl beauty];
[girl rich];

//遍历缓存(散列表长度 = mask + 1)
cache_t cache = girlClass->cache;
bucket_t *buckets = cache._buckets;

for (int i = 0; i < cache._mask + 1; i++) {
    
    bucket_t bucket = buckets[i];
    
    NSLog(@"%s %p", bucket,bucket._imp);
}

----------------------------------------
2019-03-13 22:11:42.911494+0800 rich 0x100000be0
2019-03-13 22:11:42.912946+0800 beauty 0x100000c10
2019-03-13 22:11:42.912970+0800 (null) 0x0
2019-03-13 22:11:42.913002+0800 init 0x7fff4f98ff4d

发现缓存中已经有三个方法了，分别是初始化调用的init，第一次调用的beauty和第二次调用的rich

散列表取方法

[girl beauty];
[girl rich];

//遍历缓存(散列表长度 = mask + 1)
cache_t cache = girlClass->cache;
bucket_t *buckets = cache._buckets;

bucket_t bucket = buckets[(long long)@selector(beauty) & cache._mask];

NSLog(@"%s %p", bucket,bucket._imp);

-----------------------------------------
2019-03-13 22:15:00 beauty 0x100000c60

确实是取方法的时候，不用遍历，通过@selector( ) & mask = index索引，数组同index就

注意，不一定每次都能准确的index索引，算出来的index取出来的内容不一定是想要的，但是经常是比较接近，最差的情况下，也只是一边的循环遍历

索引散列表效率远高于数组！

方法查找的源码: bucket_t * cache_t::find(cache_key_t k, id receiver)

bucket_t * cache_t::find(cache_key_t k, id receiver)
{
assert(k != 0);

bucket_t *b = buckets();
mask_t m = mask();
mask_t begin = cache_hash(k, m);
mask_t i = begin;
do {
if (b[i].key() == 0  ||  b[i].key() == k) {
return &b[i];
}
} while ((i = cache_next(i, m)) != begin);

// hack
Class cls = (Class)((uintptr_t)this - offsetof(objc_class, cache));
cache_t::bad_cache(receiver, (SEL)k, cls);
}

索引值 Index 的计算

static inline mask_t cache_hash(cache_key_t key, mask_t mask) 
{
    return (mask_t)(key & mask);
}

mask_t begin = cache_hash(k, m);

走的是 key & mask的方法， A & B 一定是小于 A的

 1111 0010
&0011 1111
----------
 0011 0010 <= 原来的值

哈希表的算法也有用求余的，和&类似

实现如下:

(i = cache_next(i, m)) != begin

查找流程梳理：比如起始下标是4，总长度是6，目标不在列表中

取出index = 4的值，发现不是想要的，i - - 变成3

3 依次 - - 到0，然后mask长度开始 = 6继续

当6 又 - - 到起始index = 4的时候，说明已经遍历一圈了，还是没找到，方法缓存查找结束

OC的消息机制

三个阶段

消息发送
动态方法解析
消息转发

消息发送

当前类查找顺序

排序好的列表，采用二分查找算法查找对应的执行函数
未排序的列表，采用一般遍历的方法查找对象执行函数

父类逐级查找

动态方法解析

@interface IOSer : NSObject

- (void)interview;

@end

@implementation IOSer

- (void)test{
    
    NSLog(@"%s",__func__);
    
}

+ (BOOL)resolveInstanceMethod:(SEL)sel{
    if (sel == @selector(interview)) {
        
        Method method = class_getInstanceMethod(self, @selector(test));
        
        //动态添加interview方法
        class_addMethod(self, sel, method_getImplementation(method), method_getTypeEncoding(method));
        
        return YES;
        
    }
    return [super resolveInstanceMethod:sel];
}

@end

----------------------------------------------

//调用
IOSer *ios = [[IOSer alloc]init];
[ios interview];


---------------------------------------------
结果，不会crash，进入了动态添加的方法了
2019-03-17 21:33:51.475717+0800 Runtime-TriedResolverDemo[11419:9277997] -[IOSer test]

消息转发流程

消息转发流程1：forwardingTargetForSelector

@implementation IOSer

- (void)interview{
    
    NSLog(@"%s",__func__);
}
@end

@interface Forwarding : NSObject

- (void)interview;

@end

@implementation Forwarding

- (id)forwardingTargetForSelector:(SEL)aSelector{
    if (aSelector == @selector(interview)) {
    
        //objc_msgSend([[IOSer alloc]init],aSelector)
        //由IOSer作为消息转发的接收者
        return [[IOSer alloc]init];
    }
    return [super forwardingTargetForSelector:aSelector];
}

@end

---------------------------------------------------------------
调用
Forwarding *obj = [[Forwarding alloc]init];
[obj interview];


---------------------------------------------
结果，不会crash，进入了动态添加的方法了
2019-03-17 22:57:45.130805+0800 Runtime-TriedResolverDemo[13776:9355195] -[IOSer interview]

消息转发流程2：forwardingTargetForSelector

@implementation Forwarding

//返回方法签名
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    if (aSelector == @selector(interview)) {

        //v16@0:8 = void xxx (self,_cmd)
        return [NSMethodSignature signatureWithObjCTypes:"v16@0:8"];
    }
    return [super methodSignatureForSelector:aSelector];
}

//NSInvocation - 方法调用
- (void)forwardInvocation:(NSInvocation *)anInvocation{
    //设置方法调用者
    [anInvocation invokeWithTarget:[[IOSer alloc]init]];
}

@end

NSInvocation 其实封装了一个方法调用，包括：
- 方法名 - anInvocation.selector
- 方法调用 - ` anInvocation.target`
- 方法参数 - anInvocation getArgument: atIndex:

冷门知识补充

//类方法的消息转发
[Forwarding test]；

类方法也可以实现消息转发，但是用的是+ (id)forwardingTargetForSelector:(SEL)aSelector函数

因为__forwarding底层，是用receiver去发送 forwardingTargetForSelector消息，如果是类方法，receiver是类对象，所以要调用的是 “+” 方法

小tips：默认是没有+ (id)forwardingTargetForSelector:(SEL)aSelector方法，可以先打- (id)forwardingTargetForSelector:(SEL)aSelector，“-” 替换成“+”，完成~

友情演出:小马哥MJ

参考资料：

Objective-C-Message-Sending-and-Forwarding

Type Encodings

面试驱动技术 - Block详解

Wed, 27 Feb 2019 20:00:00 +0800

面试驱动技术合集（初中级iOS开发），关注仓库，及时获取更新 Interview-series

Block 在 iOS 算比较常见常用且常考的了，现在面试中，要么没面试题，有面试题的，基本都会考到 block 的点。本文特别干！(但是初中级iOSer应该能有所收获~)

先来个面试题热热身，题目: 手撕代码 - 用Block实现两个数的求和

(这题如果会的，block基础知识可以跳过了，直接到 Block原理探究）

简单介绍block入门级用法

Block结构比较复杂，一般用 typedef 定义，直接调用的感觉比较简单、清晰易懂

//typedef block的时候有提示
typedef void(^MNBlock)(int);

@interface ViewController ()

@property (nonatomic, copy) MNBlock block;

@end


@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    //直接用self.block调用
    self.block = ^(int a) {
        //dosomething...
    };
}

参数解释:

typedef <#returnType#>(^<#name#>)(<#arguments#>);

题目: 手撕代码 - 用Block实现两个数的求和

日常开发中，block声明一般写的比较多，实现一般是靠Xcode自动补全提示出现的，手撕代码的情况下，等号右侧的block实现要怎么写？

声明:

typedef int(^MNBlock)(int a, int b);

@interface ViewController ()

@property (nonatomic, copy) MNBlock sum;

Vip补全功能:

纸上按Enter没用啊兄弟！看来还是需要了解一下Block右边的东西~

先在 Xcode上按下 Enter，了解下再撕

^int(int a, int b) {
    //Control reaches end of non-void block    
    因为返回值是int类型，所以这里需要返回
}

int(^Sum)(int, int) = ^(int a, int b){
    return a + b;
};
int result = Sum(5, 10);

Block的坑出现！新手可能会写错的地方

1.声明出错 - void ^(testBlock)

修正版：

void (^testBlock)() = ^{
    
};

block的声明，^ 和 blockName 都是在小括号里面！！

2.block各种实现的参数问题

声明typedef int(^MNBlock)(int, int);

    self.sum = ^int(int a, int b) {
        return a + b;
    };

这里要注意，block声明里面只有参数类型，没有实际参数的话，Xcode提示也只有参数，这里涉及到形参和实参的问题

声明是形参，可以不写参数，但是使用的时候，必须有实际参数，才可以进行使用，所以这里需要实参，可以在 ^int(int , int) 中手动添加实参^int(int a, int b)，就可以让a 和 b 参与运算

小tips：实际开发中，建议声明的时候，如果需要带参数，最好形参也声明下，这样使用Xcode提示的时候，会把参数带进去，方便得多~(踩过坑的自然懂！)

省略void导致看不懂block结构的 (正常是两个void导致局面混乱)

//声明
typedef void(^MNBlock)(void);

//实现
self.sum = ^{
    //dosomething...
};

这种情况下，能知道怎么省略的，声明里两个void，能知道怎么对应的吗？

这个其实比较简单，block不管声明 or 实现，最后一个小括号，里面都是参数，而参数是可以省略的！

而为了把声明的两个void区分开，返回值 or 参数区分开，其实就ok了

参数非void的例子

//声明非void的参数
typedef void(^MNBlock)(int a);

//实现就必须带参数，不可省略！
self.sum = ^(int a) {
    
}

参数void的例子 ==> 参数可以省略

typedef int(^MNBlock)(void);

self.sum = ^{
    //声明的返回值类型是int，所以一定要return；
    return 5;
};

其实-返回值是void的，也可以不省略

typedef void(^MNBlock)(void);

//实现的返回值不省略
self.sum = ^void () {
    
};

参数是void的省略:

typedef int(^MNBlock)();

//实现里面，没有参数，就可以不写()
self.sum = ^int{
    return 5;
}

注意！！声明里面的返回值void是不可以省略的！！

小箭头^混乱的问题,到底放小括号内还是小括号外

声明是 int(^MNBlock)(int a , int b)

实现是 ^int(int a, int b)

注意，这里箭头之后的，不管是多写() 还是少写，都会出错

所以这里还不能死记，比如不管声明还是实现,死记 (^ xxx) 是没问题的 or 死记 ^…… xxx 不加括号是没问题的,在这里都行不通，只能靠脑记了

这时候，就需要用到巧记了！

^ 和小括号组合的，一共有三种情况

一种是声明的，void(^MNBlock)
一种是实现的，^int(int a,)
还一种 ^(int a)

兄弟，看到这你还不乱吗！！

怎么记看这里，

手写分为两个部分，block等号左边 or 等号右边的，左边为声明，右边为实现区分开
声明记住：^后面跟blockName，他们需要包起来！ (^blockName),只有声明会用到blockName，先记住一点，如果有blockName，要和^一起，用小括号包起来
实现又分为两种：
- ^int:^后面跟的是返回值类型
  - ^ 直接跟类型，不用加”( )” ==> ^int
- ^(int a):^后面直接跟参数 (返回值是void)。
  - 参数都是要用”( )”包起来的，如果^后面跟参数，就得用”( )” ==> ^(int a),
  - 实现里，肯定有实际参数，这时候，参数类型和实参，就得用( )包起来

^与小括号纠缠的总结

^ 后面仅跟类型，不需要小括号，==> ^int
^ 后面跟参数，参数需要小括号 ==> ^(int a)
^ 后面跟block名称，^和blockName需要小括号 ==> void (^MNBlock)

Block原理探究

void (^MNBlock)(void) = ^(void){
    NSLog(@"this is a Block~ rua~");
};
MNBlock();

使用 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m 转成 C++ 代码, 查看底层结构

//对应上面的 MNBlock声明
void (*MNBlock)(void) = (&__main_block_impl_0(__main_block_func_0,
                                                      &__main_block_desc_0_DATA));
        
//对应上面的 MNblock() 调用
MNBlock->FuncPtr(MNBlock);

//block声明调用的 - __main_block_impl_0
struct __main_block_impl_0 {
  //结构体内的参数
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  
  //c++中的构造函数，类似于 OC 的 init 方法，返回一个结构体对象
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
}

这里的block封装的函数调用解释MNBlock->FuncPtr(MNBlock);

MNBlock 其实内部结构是 __main_block_impl_0，

struct __main_block_impl_0 {

  //函数调用地址在这个结构体内
  struct __block_impl impl;

  struct __main_block_desc_0* Desc;
  }
  
  struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  //函数调用地址在这里
  void *FuncPtr;
};

内部只有两个参数，一个impl，一个Desc，而函数的调用地址 - FuncPtr是再impl中的，为什么这里能直接这样写呢？

因为，__main_block_impl_0 结构的地址和他的第一个成员一样，第一个成员的地址是__block_impl，所以__main_block_impl_0 和 __block_impl 的地址其实是同一个，通过格式强制转换，将 main_block_impl_0 转成 block_impl 就可以直接拿到他内部的 FuncPtr 函数地址，然后进行调用！

可见- block本质上是OC对象，内部有一个isa指针
block是封装了函数调用以及函数调用的oc对象

Block面试题抛砖引玉~

开胃菜先来一下，以下结果输出什么

int a = 10;
void (^MNBlock)(void) = ^{
    NSLog(@"a = %d",a);
};
a += 20;

MNBlock();

调用 MNBlock(); 之前，a 已经 + 20了，输出30？太天真了兄弟，这里涉及到capture的概念，即变量捕获

Block捕获变量(capture)

捕获：Block内部会新增一个成员，来存储传进来的变量

block 内部直接捕获了传进去的这个变量a(10)

创建block的时候，已经将变量a=10 捕获到 block内部，之后再怎么修改，不会影响block 内部的 a

auto 和 static的区别:以下会输出什么~

static int b = 10;
void (^MNBlock)(void) = ^{
    NSLog(@"a = %d, b = %d",a,b);
};
a = 20;
b = 20;

MNBlock();

输出

2019-03-07 21:49:49 Block-Demo a = 10, b = 20

why?

查看原因:

auto int a = 10;
static int b = 10;
void (*MNBlock)(void) = (&__main_block_impl_0(__main_block_func_0,
                                              &__main_block_desc_0_DATA,
                                              a,
                                              &b));

发现：两种变量，都有捕获到block内部。

a 是auto变量，走的是值传递，

b 是 static 变量，走的是地址传递，所以会影响(指针指向同一块内存，修改的等于是同个对象)

总结

只有局部变量才需要捕获，
全局变量不需要捕获，因为在哪都可以访问
需不需要捕获，其实主要是看作用域问题
auto局部变量 ==>值传递->因为会销毁
static局部变量==>不会销毁==>所以地址传递

看图就行~

进阶考题 - self 会被捕获到 block 内部吗

void (^MNBlock)(void) = ^{
    NSLog(@"p = %p",self);
};

模拟看官作答：不会，因为整个类里，都能调用self，应该是全局的，全局变量不会捕获到block中

哈哈哈哈！中计了！其实 self 是参数(局部变量)

struct __MNDemo__test_block_impl_0 {
  struct __block_impl impl;
  struct __MNDemo__test_block_desc_0* Desc;
  MNDemo *self; ==> 捕捉到了兄弟
  }

解释原因：

每个OC函数，其实默认有两个参数，一个self，一个_cmd，只是他们倆兄弟默认是隐藏的

而由于他们是参数，所以是局部变量，局部变量就要被 block 捕获

- (void)test(self, SEL _cmd){XXX} 默认的OC方法里面其实有这两个隐藏的参数！所以上题的答案，self是会被block捕获的！（能听懂掌声！）

进进阶考题 - 成员变量_name 会被捕获到 block 内部吗

void (^MNBlock)(void) = ^{
    NSLog(@"==%@",_name);
};

模拟看官作答：呵呵，老子都中了这么多次技了，这题学会了！！因为_name是成员变量，全局的，也没有self，所以不需要捕获整个类就都可以随便访问它！

哎，兄弟，还是太年轻了！！

void (^MNBlock)(void) = ^{
    NSLog(@"==%@",self->_name);
};

看图说话：

Block的类型

__NSGlobalBlock__
__NSStackBlock__
__NSMallocBlock__

MRC环境下

void (^global)() = ^{
    NSLog(@"globalValue = %d",globalValue);
};

void (^autoBlock)() = ^{
    NSLog(@"this is a Block~ rua~ = %d",a);
};

void (^copyAuto)() = [autoBlock copy];

--------------------------------------------
print class
2019-03-08 17:40:43 Block-Demo

 global class = __NSGlobalBlock__ 
 autoBlock class = __NSStackBlock__ 
 copyAuto = __NSMallocBlock__

总结:

内存分配示意图：

栈上的内存系统会自动回收

栈空间的block 不会对对象进行强引用
堆空间的block 可能会对对象产生强引用：
- 如果是weak指针，不会强引用
- 如果是strong指针，会强引用

堆上的内存是由程序员控制，所以一般将block 拷贝到堆上，让程序员控制他与内部变量的生命周期

题目：以下输出的顺序是什么(ARC环境下)

@implementation MNPerson

- (void)dealloc{
    NSLog(@"MNPerson - dealloc");
}

@end

--------------------------------------

MNPerson *person = [[MNPerson alloc]init];

__weak MNPerson *weakPerson = person;

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    
    NSLog(@"1-----%@",person);
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"2------%@",weakPerson);
    });
    
});

NSLog(@"touchesBegan");

输出结果

2019-03-08 22:38:59.038452+0800 touchesBegan
2019-03-08 22:39:00.056746+0800 1-----<MNPerson: 0x604000207840>
2019-03-08 22:39:00.057891+0800 MNPerson - dealloc
2019-03-08 22:39:02.058011+0800 2-----(null)

解释：

gcd的block会自动对auto变量进行copy操作
block内部对 auto 变量的强弱引用，取决于指针类型
1 中的auto变量是 person，没声明默认对象是 strong 类型，所以 gcd1 会对 person进行 1s的强引用
gcd2 中的变量是 weakPerson，看到是__wesk指针，所以block内部不会对其产生强引用
随后，gcd1 对 person进行1s的强引用之后，gcd1 的block销毁，person对象销毁，打印MNPerson dealloc
最终，2s过后打印 2——weakPerson，因为person对象在gcd1 block结束之后，释放掉了，所以此时person是空，因为是weak指针，对象是null不会crash，最终打印null

对象类型的auto变量

当 block 内部访问了对象类型的auto变量时
- 如果block在展示，不会对 auto 变量产生强引用
- 如果 block 被拷贝到堆上
  - 会调用 block 内部的 copy 函数
  - copy 函数内部会调用 _Block_object_assign 函数
  - _Block_object_assign 函数会根据auto变量的修饰符 ( strong、 weak、unsafe_unretained ) 做出对应的操作，看对内部auto变量进行强引用还是弱引用(类似于 retain)
- 如果 block 从堆上移除
  - 会调用 block 内部的 dispose 函数
  - dispose函数内部会调用_Block_object_dispose 函数
  - _Block_object_dispose 类似于 release，会对auto变量进行自动释放(当引用计数器=0的时候 )

block中的copy

在ARC环境下，编译器会根据情况，自动将栈上的block拷贝到堆上，比如以下几种情况
- block 作为函数返回值的时候
- 将block复制给__strong指针的时候
- block作为Cocoa API中方法名含有usingBlock的方法参数事
  - 比如：[array enumerateObjectsUsingBlock:XXX]

__block 修饰符的使用

题目：以下代码的是否编译通过，可以的话输出结果是什么

int a = 10;
void (^block)() = ^{
    a = 20;
    NSLog(@"a = %d",a);
};

结果如下：

思考：无法编译，为啥呢？编译的时候，block应该是会把auto变量捕获进去的，那block结构中应该有a才对啊

//main函数
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        int a = 10;
        void (*block)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));

    }
    return 0;
}

//block执行地址
  static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int a = __cself->a; // bound by copy
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_kh_0rp73c0s2mvfp5gjf25j5y6h0000gn_T_main_1a12fa_mi_0,a);}

block执行的时候，内部是 __main_block_func_0 函数，而a的声明，是在main函数，两个函数相互独立，对于他们来说，a都是一个局部变量，而且两个函数中都对a初始化，两个函数的中a不是同一个，那怎么可以在执行函数中，修改main函数中的局部变量呢，所以编译报错！

如何改？

方案一：使用static

static int a = 10;
void (^block)() = ^{
    a = 20;
    NSLog(@"a = %d",a);
};

因为static修饰的auto变量，最终在block中进行的不是值传递，而是地址传递，措意执行函数中的a 和 main 函数中的a，是同一个地址 ==> 等于同一个a，所以可以修改，输出20

但是使用static，就会变成静态变量，永远在内存中

方案二：使用__blcok

__block auto int a = 10;
void (^block)() = ^{
    a = 20;
    NSLog(@"a = %d",a);
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_a_0 *a; // by ref ==> auto的话，是int a，__block，变成对象了
}

struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;==> 指向自己的结构体
 int __flags;
 int __size;
 int a; ==> 10在这里
};

a = 20;最终转成 (a->__forwarding->a) = 20;

解释下：__forwarding 是指向结构体本身的指针，等价于a本身，其实就是通过a的结构体指针，拿到里面的成员a，再对他赋值

指针传递，所以可以修改 auto 变量，通过block，间接引用 auto 变量

__block的内存管理

当 block 在栈上的时候，不会对内部的__block 变量产生强引用
当 block 从栈上被 copy 到堆上的时候
- 会调用block内部的copy函数
- copy函数内部会调用_Block_object_assign 函数
- _Block_object_assign 函数会对 __block 变量进行一次 retain操作，产生强引用

抄图分析 :

当block从堆中移除时
- 会调用 block 内部的 dispose 函数
- dispose内部会调用_Block_object_dispose函数
- _Block_object_dispose函数会对__block变量进行一次release操作，如果retainCount为0，自动释放该__block变量

总结：

block在栈上的时候，不会对内部的变量产生强引用
当block从栈上 copy 到堆上的时候，内部都会调用 __Block_object_assign
- 如果是__block修饰的变量，会__block修饰的对象产生强引用
- 如果是普通auto变量，看修饰的指针类型是strong 还是 weak(unsafe_unretained)
  - strong修饰的，block就会对内部的auto变量产生强引用
  - weak修饰的，block就不会对内部的auto变量产生强引用
- 特别注意！上述条件仅在ARC环境下生效，如果是MRC环境下，block不会对内部auto变量产生强引用！(MRC下不会进行retain操作)
当block从堆上移除的时候，内部会调用__Block_object_dispose 函数，相当于对block内部所持有的对象进行移除release操作，如果retainCount为0，自动释放该__block变量

__block中的 _ forwarding 指针

内存拷贝的时候，如果block从栈被copy到堆上，肯定也希望内部的变量一起存储到堆上(让变量的生命周期可控，才不会被回收)

加入变量a在栈上，在栈上的指针，指向堆上的 block，堆上的block的 forwarding指向他自己，就可以保证，修改&获取的变量，都是堆上的变量

最终，__block指向的变量，是指向堆上的

__block 修饰的类型

@implementation MNObject

- (void)dealloc{
    NSLog(@"MNObject - dealloc");
}

@end


--------------------------------------------

typedef void (^MNBlock)();

MNBlock block;
{
    MNObject *obj = [[MNObject alloc]init];
    __block __weak MNObject *weakObj = obj;
    
    block = ^{
        NSLog(@"----------%p",weakObj);
    };
}
block();

问，上述代码的输出顺序是？

2019-03-09 21:57:56.673296+0800 Block-Demo[72692:8183596] MNObject - dealloc
2019-03-09 21:57:56.673520+0800 Block-Demo[72692:8183596] ----------0x0

解释：ARC下

上述代码，block 持有的是 weakObj，weak指针，所以block内部的__block结构体，对他内部持有的person不强引用！所以出了小括号后，person没有被强引用，生命gg，先dealloc，输出dealloc，之后进行block调用，打印 ———

特别注意，上述逻辑进在ARC下，如果在MRC下，中间结构体对象，不会对person 进行retain操作! 即便 person 是强指针修饰，也不会对内部的person对象进行强引用！

MRC环境下

MNBlock block;
{
    MNObject *obj = [[MNObject alloc]init];
    block = [^{
        NSLog(@"----------%p",obj);
    }copy];
    
    [obj release];
}
block();

[block release];

--------------------
输出:
2019-03-09 21:59:56.673296+0800 Block-Demo[72692:8183596] MNObject - dealloc
2019-03-09 21:59:56.673520+0800 Block-Demo[72692:8183596] ----------0x0

上述代码，obj 是 __strong 修饰，但是并没有被 block 强引用！可见MRC环境下，__修饰的对象，生成的中间block对象不会对 auto变量产生强引用。

Block的循环应用问题

传送门：实际开发中-Block导致循环引用的问题(ARC环境下)

考题：MRC 下，block的循环引用如何解决呢？

方案1：unsafe_unretained

MRC下，没有__weak，所以只能用_unsafe_unretained指针，原理和 weak 一样(ARC环境下不推荐使用，可能导致野指针，推荐使用weak)

__unsafe_unretained MNObject *weakSelf = self;
self.block = [^{
    NSLog(@"----------%p",weakSelf);
}copy];

方案2： __block

__block self;
self.block = [^{
    NSLog(@"----------%p",self);
}copy];

why? 上面关于 __block的总结

特别注意！上述条件仅在ARC环境下生效，如果是MRC环境下，block不会对内部auto变量产生强引用！(MRC下不会进行retain操作)

方案3: 手动在block函数内将对象制空，并且必须手动保证block调用

MNObject *obj = [[MNObject alloc]init];
__unsafe_unretained MNObject *weakObj = obj;
obj.block = [^{
    NSLog(@"----------%p",obj);
    obj = nil;
}copy];

obj.block();

但是这个一定要注意，block必须调用，因为对象指针的清空操作，是写在block函数中的，如果没调用block，循环引用问题还是会存在，所以不推荐使用。

实际开发中，循环引用的检测工具推荐，facebook开源的 FBRetainCycleDetector，用过的都说好~

话外篇补充 - Block 和 delegate使用场景

个人愚见

直接异步返回的，可以用block，比如网络请求，无需其他人工动作触发的
如果是需要类似点击才能触发的，比如 Button的点击事件，可以用 delegate

老实说，block其实非常难，能考得特别深，本文也只是简单探究&总结下中级iOS常见的block考题，以及对Block底层的初步探究，如果是像我所在的三线城市，去面试那种非一线公司的话，如果能掌握本文，可能block相关的题目能答个八九不离十吧！(可能题目会变换组合，但是万变不离其宗)

block的文章其实很多，但是如果要真的深入理解，还是得动手，这里推荐初中级iOSer可以跟着本文的思路，一步一步跟着探究试试，本文只是起个抛砖引玉的作用

友情演出:小马哥MJ

参考资料

Objective-C 高级编程 iOS与OS X多线程和内存管理

实际开发中-Block导致循环引用的问题(ARC环境下)

招聘一个靠谱的 iOS

ChenYilong/iOSInterviewQuestions

面试驱动技术 - Category 相关考点

Wed, 27 Feb 2019 20:00:00 +0800

面试驱动技术合集（初中级iOS开发），关注仓库，及时获取更新 Interview-series

Category 相关的问题一般初中级问的比较多，一般最深的就问到关联对象，本文把比较常见的 Category 的问题都罗列解决了一下，如果还有其他常见的 Category 的试题欢迎补充~

I. Category

Category相关面试题

Category实现原理？
实际开发中，你用Category做了哪些事？
Category能否添加成员变量，如果可以，如何添加？
load 、initialize方法的区别是什么，他们在category中的调用顺序？以及出现继承时他们之间的调用过程？
Category 和 Class Extension的区别是什么？
为什么分类会“覆盖”宿主类的方法？

1.Category的特点

运行时决议
- 通过 runtime 动态将分类的方法合并到类对象、元类对象中
- 实例方法合并到类对象中，类方法合并到元类对象中
可以为系统类添加分类

2.分类中可以添加哪些内容

实例方法
类方法
协议
属性

分类中原理解析

使用 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc MNPerson+Test.m 函数，生产一个cpp文件,窥探其底层结构(编译状态)

struct _category_t {
    //宿主类名称 - 这里的MNPerson
    const char *name;
    
    //宿主类对象,里面有isa
    struct _class_t *cls;
    
    //实例方法列表
    const struct _method_list_t *instance_methods;
    
    //类方法列表
    const struct _method_list_t *class_methods;
    
    //协议列表
    const struct _protocol_list_t *protocols;
    
    //属性列表
    const struct _prop_list_t *properties;
};

//_class_t 结构
struct _class_t {
    struct _class_t *isa;
    struct _class_t *superclass;
    void *cache;
    void *vtable;
    struct _class_ro_t *ro;
};

每个分类都是独立的
每个分类的结构都一致，都是category_t

函数转换

@implementation MNPerson (Test)

- (void)test{
    NSLog(@"test - rua~");
}

@end

static void 
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    if (!cats) return;
    if (PrintReplacedMethods) printReplacements(cls, cats);

    bool isMeta = cls->isMetaClass();

    // fixme rearrange to remove these intermediate allocations
    
    /* 二维数组( **mlists => 两颗星星，一个)
     [
        [method_t,],
        [method_t,method_t],
        [method_t,method_t,method_t],
     ]
     
     */
    method_list_t **mlists = (method_list_t **)
        malloc(cats->count * sizeof(*mlists));
    property_list_t **proplists = (property_list_t **)
        malloc(cats->count * sizeof(*proplists));
    protocol_list_t **protolists = (protocol_list_t **)
        malloc(cats->count * sizeof(*protolists));

    // Count backwards through cats to get newest categories first
    int mcount = 0;
    int propcount = 0;
    int protocount = 0;
    int i = cats->count;//宿主类，分类的总数
    bool fromBundle = NO;
    while (i--) {//倒序遍历，最先访问最后编译的分类
        
        // 获取某一个分类
        auto& entry = cats->list[i];

        // 分类的方法列表
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            //最后编译的分类，最先添加到分类数组中
            mlists[mcount++] = mlist;
            fromBundle |= entry.hi->isBundle();
        }

        property_list_t *proplist = 
            entry.cat->propertiesForMeta(isMeta, entry.hi);
        if (proplist) {
            proplists[propcount++] = proplist;
        }

        protocol_list_t *protolist = entry.cat->protocols;
        if (protolist) {
            protolists[protocount++] = protolist;
        }
    }

    auto rw = cls->data();

    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
    
    // 核心：将所有分类的对象方法，附加到类对象的方法列表中
    rw->methods.attachLists(mlists, mcount);
    free(mlists);
    if (flush_caches  &&  mcount > 0) flushCaches(cls);

    rw->properties.attachLists(proplists, propcount);
    free(proplists);

    rw->protocols.attachLists(protolists, protocount);
    free(protolists);
}

void attachLists(List* const * addedLists, uint32_t addedCount) {
    if (addedCount == 0) return;
    
    if (hasArray()) {
        // many lists -> many lists
        uint32_t oldCount = array()->count;
        uint32_t newCount = oldCount + addedCount;
        
        //realloc - 重新分配内存 - 扩容了
        setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
        array()->count = newCount;
        
        //memmove,内存挪动
        //array()->lists 原来的方法列表
        memmove(array()->lists + addedCount,
                array()->lists,
                oldCount * sizeof(array()->lists[0]));
        
        //memcpy - 将分类的方法列表 copy 到原来的方法列表中
        memcpy(array()->lists,
               addedLists,
               addedCount * sizeof(array()->lists[0]));
    }
    ...
}

画图分析就是

3.实际开发中，你用Category做了哪些事？

声明私有方法
分解体积庞大的类文件
- 把Framework的私有方法公开
。。。

4.Category实现原理？

Category编译之后，底层结构是category_t，里面存储着分类的各种信息，包括对象方法、类方法、属性、协议信息
分类的在编译后，方法并不会直接添加到类信息中，而是要在程序运行的时候，通过 runtime, 讲Category的数据，

5.为什么分类会“覆盖”宿主类的方法？

其实不是真正的“覆盖”，宿主类的同名方法还是存在
分类将附加到类对象的方法列表中，整合的时候，分类的方法优先放到前面
OC的函数调用底层走的是msg_send() 函数，它做的是方法查找，因为分类的方法优先放在前面，所以通过选择器查找到分类的方法之后直接调用，宿主类的方法看上去就像被“覆盖”而没有生效

6.Category 和 Class Extension的区别是什么？

Class Extension(扩展)

声明私有属性
声明私有方法
声明私有成员变量
编译时决议，Category 运行时决议
不能为系统类添加扩展
只能以声明的形式存在，多数情况下，寄生于宿主类的.m文件中

II. load 、initialize

load实现原理

类第一次加载进内存的时候，会调用 + load 方法，无需导入，无需使用

每个类、分类的 + load 在程序运行过程中只会执行一次

+ load 走的不是消息发送的 objc_msgSend 调用，而是找到 + load 函数的地址，直接调用

void call_load_methods(void)
{
    static bool loading = NO;
    bool more_categories;

    loadMethodLock.assertLocked();

    // Re-entrant calls do nothing; the outermost call will finish the job.
    if (loading) return;
    loading = YES;

    void *pool = objc_autoreleasePoolPush();

    do {
        // 1. Repeatedly call class +loads until there aren’t any more
        while (loadable_classes_used > 0) {
            //先加载宿主类的load方法(按照编译顺序，调用load方法)
            call_class_loads();
        }

        // 2. Call category +loads ONCE
        more_categories = call_category_loads();

        // 3. Run more +loads if there are classes OR more untried categories
    } while (loadable_classes_used > 0  ||  more_categories);

    objc_autoreleasePoolPop(pool);

    loading = NO;
}

static void schedule_class_load(Class cls)
{
    if (!cls) return;
    assert(cls->isRealized());  // _read_images should realize

    if (cls->data()->flags & RW_LOADED) return;

    // Ensure superclass-first ordering
    // 递归调用，先将父类添加到load方法列表中，再将自己加进去
    schedule_class_load(cls->superclass);

    add_class_to_loadable_list(cls);
    cls->setInfo(RW_LOADED); 
}

调用顺序

先调用宿主类的+ load 函数
- 按照编译先后顺序调用（先编译，先调用）
- 调用子类的+load之前会先调用父类的+load
再调用分类的的+ load 函数
- 按照编译先后顺序调用（先编译，先调用）

实验证明：宿主类先调用，分类再调用

2019-02-27 17:28:00.519862+0800 load-Initialize-Demo[91107:2281575] MNPerson + load
2019-02-27 17:28:00.520032+0800 load-Initialize-Demo[91107:2281575] MNPerson (Play) + load
2019-02-27 17:28:00.520047+0800 load-Initialize-Demo[91107:2281575] MNPerson (Eat) + load

2019-02-27 17:39:10.354050+0800 load-Initialize-Demo[91308:2303030] MNDog + load (宿主类1)
2019-02-27 17:39:10.354237+0800 load-Initialize-Demo[91308:2303030] MNPerson + load (宿主类2)
2019-02-27 17:39:10.354252+0800 load-Initialize-Demo[91308:2303030] MNDog (Rua) + load (分类1)
2019-02-27 17:39:10.354263+0800 load-Initialize-Demo[91308:2303030] MNPerson (Play) + load(分类2)
2019-02-27 17:39:10.354274+0800 load-Initialize-Demo[91308:2303030] MNPerson (Eat) + load(分类3)
2019-02-27 17:39:10.354285+0800 load-Initialize-Demo[91308:2303030] MNDog (Run) + load(分类4)

Initialize实现原理

类第一次接收到消息的时候，会调用该方法，需导入，并使用

+ Initialize 走的是消息发送的 objc_msgSend 调用

Initialize题目出现

/*父类*/
@interface MNPerson : NSObject
@end

@implementation MNPerson

+ (void)initialize{
    NSLog(@"MNPerson + initialize");
}
@end

/*子类1*/
@interface MNTeacher : MNPerson
@end

@implementation MNTeacher
@end

/*子类2*/
@interface MNStudent : MNPerson
@end

@implementation MNStudent
@end

问题出现:以下会输出什么结果?

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

        [MNTeacher alloc];
        [MNStudent alloc];
    }
    return 0;
}

结果如下：

2019-02-27 17:57:33.305655+0800 load-Initialize-Demo[91661:2331296] MNPerson + initialize
2019-02-27 17:57:33.305950+0800 load-Initialize-Demo[91661:2331296] MNPerson + initialize
2019-02-27 17:57:33.306476+0800 load-Initialize-Demo[91661:2331296] MNPerson + initialize

为什么打印了三次？

原理分析：

initialize 在类第一次接收消息的时候会调用，OC里面的 [ xxx ] 调用都可以看成 objc_msgSend,所以这时候，[MNTeacher alloc] 其实内部会调用 [MNTeacher initialize]
initialize 调用的时候，要先实现自己父类的 initialize 方法，第一次调用的时候，MNPerson 没被使用过，所以未被初始化，要先调用一下父类的 [MNPerson initialize],输出第一个MNPerson + initialize
MNPerson 调用了 initialize 之后，轮到MNTeacher 类自己了，由于他内部没有实现 initialize方法，所以调用父类的initialize, 输出第二个MNPerson + initialize
然后轮到[MNStudent alloc]，内部也是调用 [MNStudent initialize], 然后判断得知父类MNPerson类调用过initialize了，因此调用自身的就够了，由于他和MNTeacher 一样，也没实现initialize 方法，所以同理调用父类的[MNPerson initialize],输出第3个MNPerson + initialize

initialize 与 load 的区别

load 是类第一次加载的时候调用，initialize 是类第一次接收到消息的时候调用，每个类只会initialize一次（父类的initialize方法可能被调用多次）
load 和 initialize，加载or调用的时候，都会先调用父类对应的 load or initialize 方法，再调用自己本身的;
load 和 initialize 都是系统自动调用的话，都只会调用一次
调用方式也不一样，load 是根据函数地址直接调用，initialize 是通过objc_msgSend
调用时刻，load是runtime加载类、分类的时候调用（只会调用一次）
调用顺序:
- load:
  - 先调用类的load
    - 先编译的类，优先调用load
    - 调用子类的load之前，会先调用父类的load
  - 在调用分类的load
- initialize：
  - 先初始化父列
  - 再初始化子类（可能最终调用的是父类的初始化方法）

/*父类*/
@interface MNPerson : NSObject
@end

@implementation MNPerson

+ (void)initialize{
    NSLog(@"MNPerson + initialize");
}

+ (void)load{
    NSLog(@"MNPerson + load");
}
@end

/*子类1*/
@interface MNTeacher : MNPerson
@end

@implementation MNTeacher

+ (void)load{
    NSLog(@"MNTeacher + load");
}
@end

/*子类2*/
@interface MNStudent : MNPerson
@end

@implementation MNStudent

+ (void)load{
    NSLog(@"MNStudent + load");
}
@end

问题出现:以下会输出什么结果?

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

        [MNTeacher load];
    }
    return 0;
}

答案出现！！！

2019-02-27 18:17:12.034392+0800 load-Initialize-Demo[92064:2370496] MNPerson + load
2019-02-27 18:17:12.034555+0800 load-Initialize-Demo[92064:2370496] MNStudent + load
2019-02-27 18:17:12.034569+0800 load-Initialize-Demo[92064:2370496] MNTeacher + load
2019-02-27 18:17:12.034627+0800 load-Initialize-Demo[92064:2370496] MNPerson + initialize
2019-02-27 18:17:12.034645+0800 load-Initialize-Demo[92064:2370496] MNPerson + initialize
2019-02-27 18:17:12.034658+0800 load-Initialize-Demo[92064:2370496] MNTeacher + load

输出比预期多了不少，为什么连 load 也出现了？

解释：

前三个 load 很好理解，程序一运行，runtime 直接将全部的类加载到内存中，最先输出；
第一个 MNPerson + initialize，因为是MNTeacher的调用，所以会先让父类MNPerson 调用一次initialize，输出第一个 MNPerson + initialize
第二个 MNPerson + initialize, MNTeacher 自身调用，由于他自己没有实现 initialize, 调用父类的initialize，输出第二个 MNPerson + initialize
最后一个MNTeacher + load可能其实有点奇怪，不是说 load只会加载一次吗，而且他还不走 objc_msgSend 吗，怎么还能调用这个方法？
- 因为！当类第一次加载进内存的时候，调用的 load 方法是系统调的，这时候不走 objc_msgSend
- 但是，你现在是[MNTeacher load]啊，这个就是objc_msgSend(MNTeacher,@selector(MNTeacher))，这就跑到MNTeacher + load里了！
- 只是一般没人手动调用load 函数，但是，还是可以调用的！

III. 关联对象AssociatedObject

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

这道题实际上考的就是关联对象

如果是普通类声明生命属性的话

@interface MNPerson : NSObject

@property (nonatomic, copy)NSString *property;

@end

上述代码系统内部会自动三件事：

帮我们生成一个生成变量_property
生成一个 get 方法 - (NSString *)property
生成一个 set 方法 - (void)setProperty:(NSString *)property

@implementation MNPerson{
    NSString *_property;
}

- (void)setProperty:(NSString *)property{
    _property = property;
}

- (NSString *)property{
    return _property;
}

@end

分类也是可以添加属性的 - 类结构里面，有个properties 列表，里面就是存放属性的;

分类里面，生成属性，只会生成方法的声明，不会生成成员变量 && 方法实现！

翻译：实例变量不能放在分类中

所以：

不能直接给category 添加成员变量，但是可以间接实现分类有成员变量的效果(效果上感觉像成员变量)

@interface MNPerson (Test)

@property (nonatomic, assign) NSInteger age;

@end

@implementation MNPerson (Test)

@end

person.age = 10等价于 [person setAge:10]，所以证明了，给分类声明属性之后，并没有添加其对应的实现！

关联对象

objc_setAssociatedObject Api

objc_setAssociatedObject(    <#id  _Nonnull object#>, (对象)
                             <#const void * _Nonnull key#>,(key)
                             <#id  _Nullable value#>,(关联的值)
                             <#objc_AssociationPolicy policy#>)(关联策略)

关联策略，等价于属性声明

typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
    OBJC_ASSOCIATION_ASSIGN = 0,          
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, 
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,  
    OBJC_ASSOCIATION_RETAIN = 01401,      
    OBJC_ASSOCIATION_COPY = 01403         
};

比如这里的age属性，默认声明是@property (nonatomic, assign) NSInteger age;，就是 assign，所以这里选择OBJC_ASSOCIATION_ASSIGN

取值

objc_getAssociatedObject(<#id  _Nonnull object#>, <#const void * _Nonnull key#>)

面试题 - 以下代码输出的结果是啥

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

        MNPerson *person = [[MNPerson alloc]init];

        {
            MNPerson *test = [[MNPerson alloc]init];
            objc_setAssociatedObject(person,
                                     @"test",
                                     test,
                                     OBJC_ASSOCIATION_ASSIGN);
        }
        
        NSLog(@"%@",objc_getAssociatedObject(person, @"test"));
    }
    return 0;
}

原因，关联的对象是person，关联的value是 test，test变量出了他们的{} 作用域之后，就会销毁; 此时通过key 找到对应的对象，访问对象内部的value，因为test变量已经销毁了，所以程序崩溃了，这也说明了 => 内部 test 对 value是强引用！

关联对象的本质

在分类中，因为类的实例变量的布局已经固定，使用 @property 已经无法向固定的布局中添加新的实例变量（这样做可能会覆盖子类的实例变量），所以我们需要使用关联对象以及两个方法来模拟构成属性的三个要素。

引用自关联对象 AssociatedObject 完全解析

关联对象的原理

实现关联对象技术的核心对象有

AssociationsManager
AssociationsHashMap
ObjectAssociationMap
ObjcAssociation

class AssociationsManager {
    static spinlock_t _lock;//自旋锁，保证线程安全
    static AssociationsHashMap *_map;
}

class AssociationsHashMap : public unordered_map<disguised_ptr_t, ObjectAssociationMap> 

class ObjectAssociationMap : public std::map<void *, ObjcAssociation>

class ObjcAssociation {
    uintptr_t _policy;
    id _value;
}

以关联对象代码为例:

  objc_setAssociatedObject(obj, @selector(key), @"hello world", OBJC_ASSOCIATION_COPY_NONATOMIC);

关联对象并不是存储在被关联对象本身的内存中的
关联对象，存储在全局的一个统一的AssociationsManager中
关联对象其实就是 ObjcAssociation 对象,关联的 value 就放在 ObjcAssociation 内
关联对象由 AssociationsManager 管理并在 AssociationsHashMap 存储
对象的指针以及其对应 ObjectAssociationMap 以键值对的形式存储在 AssociationsHashMap 中
ObjectAssociationMap 则是用于存储关联对象的数据结构
每一个对象都有一个标记位 has_assoc 指示对象是否含有关联对象
存储在全局的一个统一的AssociationsManager 内部有一持有一个_lock，他其实是一个spinlock_t(自旋锁),用来保证AssociationsHashMap操作的时候，是线程安全的

Category 相关的问题一般初中级问的比较多，一般最深的就问到关联对象，上面的问题以及解答已经把比较常见的 Category 的问题都罗列解决了一下，如果还有其他常见的 Category 的试题欢迎补充~

本文基于 MJ老师的基础知识之上，结合了包括 draveness 在内的一系列大神的文章总结的，如果不当之处，欢迎讨论~

友情演出:小马哥MJ

参考资料:

关联对象 AssociatedObject 完全解析

associated-objects

iOS：添加一个全局悬浮按钮

Thu, 31 Jan 2019 00:00:00 +0800

在多设备测试和联调场景里，最常见的问题不是“有没有问题”，而是“当前这台设备跑的到底是哪一个包”。如果不能快速确认包体对应的环境、版本和 Build 信息，排查过程就很容易绕远路。

这篇文章要解决的就是这个问题：做一个全局悬浮按钮，在应用任意页面都能直接看到当前环境，并按需补充版本号和 Build 信息。

思路：

既然需要全局展示，就应该把控件加在最上层，也就是 UIWindow 上。
需求里既有文字也有背景图，用 UIButton 来承载会更直接。
按钮会遮挡部分界面内容，因此必须支持拖动，交互上可以通过手势来处理。
整体实现并不复杂，本质上就是创建一个可拖拽的 UIButton，再把它挂到 UIWindow 上。

知识1：按钮显示 2 行文字

// UIButton 支持多行标题显示
button.titleLabel.lineBreakMode = NSLineBreakByWordWrapping;

// title 中插入 "\n" 即可换行
title = @"123\n666";

知识2：获取 Version 和 Build 号

NSString *versionStr = [[[NSBundle
       mainBundle]infoDictionary]valueForKey:@"CFBundleShortVersionString"];
NSString *buildStr = [[[NSBundle
       mainBundle]infoDictionary]valueForKey:@"CFBundleVersion"];

知识3：拖动的本质是更新 `frame.origin`

// 拖动时更新控件的 x 坐标
- (CGRect)changeXWithFrame:(CGRect)originalFrame point:(CGPoint)point{
    BOOL q1 = originalFrame.origin.x >= 0;
    BOOL q2 = originalFrame.origin.x + originalFrame.size.width <= screenW;
    
    if (q1 && q2) {
        originalFrame.origin.x += point.x;
    }
    return originalFrame;
}

// 拖动时更新控件的 y 坐标
- (CGRect)changeYWithFrame:(CGRect)originalFrame point:(CGPoint)point{
    
    BOOL q1 = originalFrame.origin.y >= 0;
    BOOL q2 = originalFrame.origin.y + originalFrame.size.height <= screenH;
    if (q1 && q2) {
        originalFrame.origin.y += point.y;
    }
    return originalFrame;
}

知识4：越界处理与回弹

// 记录按钮是否越界
        BOOL isOver = NO;
        if (frame.origin.x < 0) {
            frame.origin.x = 0;
            isOver = YES;
            
        } else if (frame.origin.x + frame.size.width > screenW) {
            frame.origin.x = screenW - frame.size.width;
            isOver = YES;
        }

        if (frame.origin.y < 0) {
            frame.origin.y = 0;
            isOver = YES;
            
        } else if (frame.origin.y+frame.size.height > screenH) {
            frame.origin.y = screenH - frame.size.height;
            isOver = YES;
        }
        
        if (isOver) {
            // 如果越界，则回弹到可见区域
            [UIView animateWithDuration:0.3 animations:^{
                self.frame = frame;
            }];
        }

知识5：支持不同方向的拖动限制

MNAssistiveTouchTypeNone = 0,         // 不限制方向，可自由拖动
MNAssistiveTouchTypeVerticalScroll,   // 只能垂直移动
MNAssistiveTouchTypeHorizontalScroll, // 只能水平移动

  switch (type) {
        case MNAssistiveTouchTypeNone:
        {
            水平方向坐标 ++；
            竖直方向坐标 ++；
            break;
        }case MNAssistiveTouchTypeHorizontalScroll:{
            水平方向坐标 ++；
            break;
        }
        case MNAssistiveTouchTypeVerticalScroll:{
            竖直方向坐标 ++；
            break;
        }
    }

最终效果

集成与使用

通过 CocoaPods 引入：

pod 'MNFloatBtn'

导入头文件后，就可以直接使用：

#import <MNFloatBtn/MNFloatBtn.h>

如果希望悬浮按钮在任何环境下都显示，可以直接调用：

[MNFloatBtn show];

更推荐在 Debug 环境中显示，避免影响线上包：

[MNFloatBtn showDebugModeWithType:MNAssistiveTypeNone];

不再需要时，可以移除悬浮按钮：

[MNFloatBtn hidden];

也可以为按钮补充点击事件：

[MNFloatBtn sharedBtn].btnClick = ^(UIButton *sender) {

    NSLog(@"btn.btnClick ~");
    
};

如果希望按钮上默认展示当前构建日期，可以这样设置：

[[MNFloatBtn sharedBtn] setBuildShowDate:YES];

如果项目区分测试、开发、生产等 API 环境，也可以直接配置环境映射：

#define kAddress            @"testapi.miniLV.com"
//#define kAddress            @"devapi.miniLV.com"
//#define kAddress            @"api.miniLV.com"
    
// 自定义不同 Host 对应的展示文案
NSDictionary *envMap = @{
                         @"测试":@"testapi.miniLV.com",
                         @"开发":@"devapi.miniLV.com",
                         @"生产":@"api.miniLV.com"
                         };
                             
// 设置当前 Host，并展示对应的环境标识
[[MNFloatBtn sharedBtn]setEnvironmentMap:envMap currentEnv:kAddress]; 
    

demo地址

喜欢的可以给个star，不胜感激~