iOS 编写高质量Objective-C代码（二）

级别： ★★☆☆☆
标签：「iOS」「OC」「Objective-C」
作者： MrLiuQ

文章目录如下：
iOS 编写高质量Objective-C代码（一）
iOS 编写高质量Objective-C代码（二）
iOS 编写高质量Objective-C代码（三）
iOS 编写高质量Objective-C代码（四）
iOS 编写高质量Objective-C代码（五）
iOS 编写高质量Objective-C代码（六）
iOS 编写高质量Objective-C代码（七）
iOS 编写高质量Objective-C代码（八）

---

这篇将从面向对象的角度分析如何提高OC的代码质量。

一、理解“ 属性 ”这一概念

属性（@property）是OC的一项特性。
@property：编译器会自动生成实例变量和getter和setter方法。
_{下文中，getter和setter方法合称为存取方法}
For Example：

@property (nonatomic, strong) UIView *qiShareView; 

等价于：

@synthesize qiShareView = _qiShareView;
- (UIView *)qiShareView;
- (void)setQiShareView:(UIView *)qiShareView; 

如果不希望自动生成存取方法和实例变量，那就要使用@dynamic关键字

@dynamic qiShareView; 

属性特质有四类：

1. 原子性：默认为atomic
   • nonatomic：非原子性，读写时不加同步锁
   • atomic：原子性，读写时加同步锁
2. 读写权限：默认为readwrite
   • readwrite：拥有getter和setter方法
   • readonly：仅拥有getter方法
3. 内存管理：
   • assign：对“纯量类型”做简单赋值操作（NSInteger、CGFloat等）。
   • strong：强拥有关系，设置方法 保留新值，并释放旧值。
   • weak：弱拥有关系，设置方法 不保留新值，不释放旧值。当指针指向的对象销毁时，指针置nil。
   • copy：拷贝拥有关系，设置方法不保留新值，将其拷贝。
   • unsafe_unretained：非拥有关系，目标对象被释放，指针不置nil，这一点和assign一样。区别于weak
4. 方法名：
   • getter=<name>：指定get方法的方法名，常用
   • setter=<name>：指定set方法的方法名，不常用 例如：

@property (nonatomic, getter=isOn) BOOL on; 

在iOS开发中，99.99…%的属性都会声明为nonatomic。 一是atomic会严重影响性能， 二是atomic只能保证读/写操作的过程是可靠的，并不能保证线程安全。 关于第二点可以参考我的博客:iOS 为什么属性声明为atomic依然不能保证线程安全？

二、在对象内部尽量直接访问实例变量

1. 实例变量（ _属性名 ）访问对象的场景：
   • 在init和dealloc方法中，总是应该通过访问实例变量读写数据
   • 没有重写getter和setter方法、也没有使用KVO监听
   • 好处：不走OC的方法派发机制，直接访问内存读写，速度快，效率高。

For Example：

- (instancetype)initWithDic:(NSDictionary *)dic {
    
    self = [super init];
    
    if (self) {
        
        _qi = dic[@"qi"];
        _share = dic[@"share"];
    }
    
    return self;
} 

2. 用存取方法访问对象的场景：
   • 重写了getter/setter方法（比如：懒加载）
   • 使用了KVO监听值的改变

For Example：

- (UIView *)qiShareView {
  
    if (!_qiShareView) {

        _qiShareView = [UIView new];
    }

    return _qiShareView;
} 

三、理解“对象等同性”

思考下面输出什么？

NSString *aString = @"iPhone 8";
NSString *bString = [NSString stringWithFormat:@"iPhone %i", 8];
NSLog(@"%d", [aString isEqual:bString]);
NSLog(@"%d", [aString isEqualToString:bString]);
NSLog(@"%d", aString == bString); 

答案是110
==操作符只是比较了两个指针所指对象的地址是否相同，而不是指针所指的对象的值 所以最后一个为0

四、以类族模式隐藏实现细节

为什么下面这个例子的if永远为false？

id maybeAnArray = @[];
if ([maybeAnArray class] == [NSArray class]) {
     //Code will never be executed
} 

因为[maybeAnArray class] 的返回永远不会是NSArray，NSArray是一个类族，返回的值一直都是NSArray的实体子类。大部分collection类都是某个类族中的抽象基类 所以上面的if想要有机会执行的话要改成

id maybeAnArray = @[];
if ([maybeAnArray isKindOfClass [NSArray class]) {
      // Code probably be executed
} 

这样判断的意思是，maybeAnArray这个对象是否是NSArray类族中的一员 使用类族的好处：可以把实现细节隐藏在一套简单的公共接口后面

五、在既有类中使用关联对象存放自定义数据

先引入runtime类库

#import <objc/runtime.h> 

objc_AssociationPolicy（对象关联策略类型）：

objc_AssociationPolicy（关联策略类型）	等效的@property属性
OBJC_ASSOCIATION_ASSIGN	等效于 assign
OBJC_ASSOCIATION_RETAIN_NONATOMIC	等效于 nonatomic, retain
OBJC_ASSOCIATION_COPY_NONATOMIC	等效于 nonatomic, copy
OBJC_ASSOCIATION_RETAIN	等效于 retain
OBJC_ASSOCIATION_COPY	等效于 copy

三个方法管理关联对象：

• objc_setAssociatedObject（设置关联对象）

/** 
 * Sets an associated value for a given object using a given key and association policy.
 * 
 * @param object The source object for the association.
 * @param key The key for the association.
 * @param value The value to associate with the key key for object. Pass nil to clear an existing association.
 * @param policy The policy for the association. For possible values, see “Associative Object Behaviors.”
 */
OBJC_EXPORT void
objc_setAssociatedObject(id _Nonnull object, const void * _Nonnull key,
                         id _Nullable value, objc_AssociationPolicy policy) 

• objc_getAssociatedObject（获得关联对象）

/** 
 * Returns the value associated with a given object for a given key.
 * 
 * @param object The source object for the association.
 * @param key The key for the association.
 * 
 * @return The value associated with the key \e key for \e object.
 */
OBJC_EXPORT id _Nullable
objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key) 

• objc_removeAssociatedObjects（去除关联对象）

/** 
 * Removes all associations for a given object.
 * 
 * @param object An object that maintains associated objects.
 * 
 * @note The main purpose of this function is to make it easy to return an object 
 *  to a "pristine state”. You should not use this function for general removal of
 *  associations from objects, since it also removes associations that other clients
 *  may have added to the object. Typically you should use \c objc_setAssociatedObject 
 *  with a nil value to clear an association.
 * 
 */
OBJC_EXPORT void
objc_removeAssociatedObjects(id _Nonnull object) 

小结：

• 可以通过“关联对象”机制可以把两个对象联系起来
• 定义关联对象可以指定内存管理策略
• 应用场景：只有在其他做法（代理、通知等）不可行时，才会选择使用关联对象。这种做法难于找bug。
  但也有具体应用场景：比如说前几篇说到 控制Button响应时间间隔 的demo中就遇到了：附上链接

六、理解objc_msgSend（对象的消息传递机制）

首先我们要区分两个基本概念：
1 .静态绑定（static binding）：在编译期就能决定运行时所应调用的函数。_{代表语言：C、C++等}
2 .动态绑定 （dynamic binding）：所要调用的函数直到运行期才能确定。_{代表语言：OC、swift等}

OC是一门强大的动态语言，它的动态性体现在它强大的runtime机制上。

解释：在OC中，如果向某对象传递消息，那就会使用动态绑定机制来决定需要调用的方法。在底层，所有方法都是普通的C语言函数，然而对象收到消息后，由运行期决定究竟调用哪个方法，甚至可以在程序运行时改变，这些特性使得OC成为一门强大的动态语言。

底层实现：基于C语言函数实现。

• 实现的基本函数是objc_msgSend，定义如下：

void objc_msgSend(id self, SEL cmd, ...) 

这是一个参数个数可变的函数，第一参数代表接受者，第二个参数代表选择子（OC函数名），之后的参数就是消息中传入的参数。

• 举例：git提交

id return = [git commit:parameter]; 

上面的方法会在运行时转换成如下的OC函数：

id return = objc_msgSend(git, @selector(commit), parameter); 

objc_msgSend函数会在接收者所属的类中搜寻其方法列表，如果能找到这个跟选择子名称相同的方法，就跳转到其实现代码，往下执行。若是当前类没找到，那就沿着继承体系继续向上查找，等找到合适方法之后再跳转 ，如果最终还是找不到，那就进入消息转发（下一条具体展开）的流程去进行处理了。

可是如果每次传递消息都要把类中的方法遍历一遍，这么多消息传递加起来肯定会很耗性能。所以以下讲解OC消息传递的优化方法。

OC对消息传递的优化：

• 快速映射表（缓存）优化： objc_msgSend在搜索这块是有做缓存的，每个OC的类都有一块这样的缓存，objc_msgSend会将匹配结果缓存在快速映射表(fast map)中，这样以来这个类一些频繁调用的方法会出现在fast map 中，不用再去一遍一遍的在方法列表中搜索了。
• 尾调用优化： 原理：在函数末尾调用某个不含返回值函数时，编译器会自动把栈空间的内存重新进行分配，直接释放所有调用函数内部的局部变量，存储调转至另一函数需要的指令码，然后直接进入被调用函数的地址。（从而不需要为调用函数准备额外的“栈帧”（frame stack））
  好处：最大限度的合理的分配使用的资源，避免过早发生栈溢出的现象。
  （这一块偏底层，以上是小编的个人理解。路过的大神如果有更好的更深的见解，欢迎大神留言与我们讨论）

七、理解消息转发机制

首先区分两个基本概念：
1 .消息传递：对象正常解读消息，传递过去（见上一条）。
2 .消息转发：对象无法解读消息，之后进行消息转发。

消息转发完整流程图：

流程解释：

• 第一步：调用resolveInstanceMethod：征询接受者（所属的类）是否可以添加方法以处理未知的选择子？_{(此过程称为动态方法解析）}若有，转发结束。若没有，走第二步。
• 第二步：调用forwardingTargetForSelector：询问接受者是否有其他对象能处理此消息。若有，转发结束，一切如常。若没有，走第三步。
• 第三步：调用forwardInvocation：运行期系统将消息封装到NSInvocation对象中，再给接受者一次机会。
• 最后：以上三步还不行，就抛出异常：unrecognized selector sent to instance xxxx

八、用“方法调配技术”调试“黑盒方法”

方法调配（Method Swizzling）：使用另一种方法实现来替换原有的方法实现。_{（实际应用中，常用此技术向原有实现中添加新的功能。）}

<objc/runtime.h>里的两个常用的方法：

• 获取给定类的指定实例方法：

/** 
 * Returns a specified instance method for a given class.
 * 
 * @param cls The class you want to inspect.
 * @param name The selector of the method you want to retrieve.
 * 
 * @return The method that corresponds to the implementation of the selector specified by 
 *  \e name for the class specified by \e cls, or \c NULL if the specified class or its 
 *  superclasses do not contain an instance method with the specified selector.
 *
 * @note This function searches superclasses for implementations, whereas \c class_copyMethodList does not.
 */
OBJC_EXPORT Method _Nullable
class_getInstanceMethod(Class _Nullable cls, SEL _Nonnull name) 

• 交换两种方法实现的方法：

/** 
 * Exchanges the implementations of two methods.
 * 
 * @param m1 Method to exchange with second method.
 * @param m2 Method to exchange with first method.
 * 
 * @note This is an atomic version of the following:
 *  \code 
 *  IMP imp1 = method_getImplementation(m1);
 *  IMP imp2 = method_getImplementation(m2);
 *  method_setImplementation(m1, imp2);
 *  method_setImplementation(m2, imp1);
 *  \endcode
 */
OBJC_EXPORT void
method_exchangeImplementations(Method _Nonnull m1, Method _Nonnull m2) 

利用这两个方法就可以交换指定类中的指定方法。在实际应用中，我们会通过这种方式为既有方法添加新功能。

For Example：交换method1与method2的方法实现

Method method1 = class_getInstanceMethod(self, @selector(method1:));
Method method2 = class_getInstanceMethod(self, @selector(method2:));
method_exchangeImplementations(method1, method2); 

九、理解“类对象”的用意

Objective-C类是由Class类型来表示的，实质是一个指向objc_class结构体的指针。它的定义如下：

typedef struct objc_class *Class; 

在<objc/runtime.h>中能看到他的实现：

struct objc_class {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;  //!< 指向metaClass(元类)的指针

#if !__OBJC2__
    Class _Nullable super_class                              OBJC2_UNAVAILABLE;  //!< 父类
    const char * _Nonnull name                               OBJC2_UNAVAILABLE;  //!< 类名
    long version                                             OBJC2_UNAVAILABLE;  //!< 类的版本信息，默认为0
    long info                                                OBJC2_UNAVAILABLE;  //!< 类信息，供运行期使用的一些位标识
    long instance_size                                       OBJC2_UNAVAILABLE;  //!< 该类的实例变量大小
    struct objc_ivar_list * _Nullable ivars                  OBJC2_UNAVAILABLE;  //!< 该类的成员变量链表
    struct objc_method_list * _Nullable * _Nullable methodLists                    OBJC2_UNAVAILABLE;  //!< 方法定义的链表
    struct objc_cache * _Nonnull cache                       OBJC2_UNAVAILABLE;  //!< 方法缓存表
    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;  //!< 协议链表
#endif

} OBJC2_UNAVAILABLE;
/* Use `Class` instead of `struct objc_class *` */ 

此结构体存放的是类的“元数据”（metadata)，例如类的实例实现了几个方法，父类是谁，具备多少实例变量等信息。
这里的isa指针指向的是另外一个类叫做元类（metaClass)。那什么是元类呢？元类是类对象的类。也可以换一种容易理解的说法：

1. 当你给对象发送消息时，runtime处理时是在这个对象的类的方法列表中寻找
2. 当你给类发消息时，runtime处理时是在这个类的元类的方法列表中寻找

我们来看一个很经典的图来加深理解：

可以总结如下：

1. 每一个Class都有一个isa指针指向一个唯一的Meta Class（元类）
2. 每一个Meta Class的isa指针都指向最上层的Meta Class，这个Meta Class是NSObject的Meta Class。(包括NSObject的Meta Class的isa指针也是指向的NSObject的Meta Class)
3. 每一个Meta Class的super class指针指向它原本Class的 Super Class的Meta Class (这里最上层的NSObject的Meta Class的super class指针还是指向自己)
4. 最上层的NSObject Class的super class指向 nil

接下来我将给各位同学划分一张学习计划表！

学习计划

那么问题又来了，作为萌新小白，我应该先学什么，再学什么？
既然你都问的这么直白了，我就告诉你，零基础应该从什么开始学起：

阶段一：初级网络安全工程师

接下来我将给大家安排一个为期1个月的网络安全初级计划，当你学完后，你基本可以从事一份网络安全相关的工作，比如渗透测试、Web渗透、安全服务、安全分析等岗位；其中，如果你等保模块学的好，还可以从事等保工程师。

综合薪资区间6k~15k

1、网络安全理论知识（2天）
①了解行业相关背景，前景，确定发展方向。
②学习网络安全相关法律法规。
③网络安全运营的概念。
④等保简介、等保规定、流程和规范。（非常重要）

2、渗透测试基础（1周）
①渗透测试的流程、分类、标准
②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking
③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察
④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等

3、操作系统基础（1周）
①Windows系统常见功能和命令
②Kali Linux系统常见功能和命令
③操作系统安全（系统入侵排查/系统加固基础）

4、计算机网络基础（1周）
①计算机网络基础、协议和架构
②网络通信原理、OSI模型、数据转发流程
③常见协议解析（HTTP、TCP/IP、ARP等）
④网络攻击技术与网络安全防御技术
⑤Web漏洞原理与防御：主动/被动攻击、DDOS攻击、CVE漏洞复现

5、数据库基础操作（2天）
①数据库基础
②SQL语言基础
③数据库安全加固

6、Web渗透（1周）
①HTML、CSS和JavaScript简介
②OWASP Top10
③Web漏洞扫描工具
④Web渗透工具：Nmap、BurpSuite、SQLMap、其他（菜刀、漏扫等）

那么，到此为止，已经耗时1个月左右。你已经成功成为了一名“脚本小子”。那么你还想接着往下探索吗？

阶段二：中级or高级网络安全工程师（看自己能力）

综合薪资区间15k~30k

7、脚本编程学习（4周）
在网络安全领域。是否具备编程能力是“脚本小子”和真正网络安全工程师的本质区别。在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。在分秒必争的CTF竞赛中，想要高效地使用自制的脚本工具来实现各种目的，更是需要拥有编程能力。

零基础入门的同学，我建议选择脚本语言Python/PHP/Go/Java中的一种，对常用库进行编程学习
搭建开发环境和选择IDE，PHP环境推荐Wamp和XAMPP，IDE强烈推荐Sublime；

Python编程学习，学习内容包含：语法、正则、文件、 网络、多线程等常用库，推荐《Python核心编程》，没必要看完

用Python编写漏洞的exp,然后写一个简单的网络爬虫

PHP基本语法学习并书写一个简单的博客系统

熟悉MVC架构，并试着学习一个PHP框架或者Python框架 (可选)

了解Bootstrap的布局或者CSS。

阶段三：顶级网络安全工程师

如果你对网络安全入门感兴趣，那么你需要的话可以点击这里👉网络安全重磅福利：入门&进阶全套282G学习资源包免费分享！

学习资料分享

当然，只给予计划不给予学习资料的行为无异于耍流氓，这里给大家整理了一份【282G】的网络安全工程师从入门到精通的学习资料包，可点击下方二维码链接领取哦。

用库，推荐《Python核心编程》，没必要看完

用Python编写漏洞的exp,然后写一个简单的网络爬虫

PHP基本语法学习并书写一个简单的博客系统

熟悉MVC架构，并试着学习一个PHP框架或者Python框架 (可选)

了解Bootstrap的布局或者CSS。

阶段三：顶级网络安全工程师

如果你对网络安全入门感兴趣，那么你需要的话可以点击这里👉网络安全重磅福利：入门&进阶全套282G学习资源包免费分享！

学习资料分享

当然，只给予计划不给予学习资料的行为无异于耍流氓，这里给大家整理了一份【282G】的网络安全工程师从入门到精通的学习资料包，可点击下方二维码链接领取哦。