最近看完了《编写高质量iOS与OS X代码的52个有效方法》，也就是《Effective Objective-C 2.0》这本书，现在总结一下，以便今后回顾。

熟悉 Objective-C

1. 了解Objective-C语言的起源

• Objective-C为C语言添加了面向对象特性，是其超集。Objective-C使用动态绑定的消息结构，也就是说，在运行时才会检查对象类型。接收一条消息之后，究竟应执行何种代码，由运行环境而非编译器来决定；
• 理解C语言的核心概念有助于写好Objective-C程序。尤其要掌握内存模型与指针。

2. 在类的头文件中尽量少引入其他头文件

• 除非确有必要，否则不要引入头文件。一般来说，应在某个类的头文件中使用向前声明来提及别的类，并在实现文件中引入那些类的头文件。这样做可以尽量降低类之间的耦合；
• 有时无法使用向前声明，比如要声明某个类遵循一项协议。这种情况下，尽量把“该类遵循某协议”的这条声明移至“class-continuation分类”中。如果不行的话，就把协议单独放到一个头文件中，然后将其引入。

3. 多用字面量语法，少用与之等价的方法

NSString *someString = @"Effective Objective-C 2.0";
NSNumber *intNumber = @1;
NSNumber *floatNumber = @2.5f;
NSNumber *boolNumber = @YES;
NSNumber *charNumber = @'a'
NSNumber *animals = @[@"cat", @"dog", @"mouse", @"badger"];
NSNumber *dog = animals[1];
NSDictionary *personData = @{@"firstName": @"Matt", @"lastName": @"Galloway", @"age": @28};

• 应该使用字面量语法来创建字符串、数值、数组、字典。与创建此类对象的常规方法相比，这么做更加简明扼要；
• 应该通过取下标操作来访问数组下标或字典中的键所对应的元素；
• 用字面量语法创建数组或字典时，若值中有nil，则会抛出异常。因此，务必确保值里不含nil。

4. 多用类型常量，少用 #define 预处理指令

// In the header file
extern NSString * const EOCStringConstant;

// In the  implementation file
NSString * const EOCStringConstant = @"VALUE"

• 不要用预处理指令定义常量。这样定义出来的常量不含类型信息，编译器只是会在编译前据此执行查找与替换操作。即使有人重新定义了常量值，编译器也不会产生警告信息，这将导致应用程序中的常量值不一致；
• 在实现文件中使用“static const”来定义“只在编译单元内可见的常量”（translation-unit-specific constant）。由于此类常量不在全局符号表中，所以无须为其名称加前缀；
• 在头文件中使用extern来声明全局常量，并在相关实现文件中定义其值。这种常量要出现在全局符号表中，所以其名称应加以区隔，通常用与之相关的类名做前缀。

5. 用枚举表示状态、选项、状态码

typedef NS_ENUM (NSUInteger, EOCConnectionState) {
        EOCConnectionStateDisconnected,
        EOCConnectionStateConnecting,
        EOCConnectionStateConnected
};

typedef NS_OPTIONS (NSUInteger, EOCPermittedDirection) {
        EOCPermittedDirectionUp = 1 << 0,
        EOCPermittedDirectionDown = 1 << 1,
        EOCPermittedDirectionLeft = 1 << 2,
        EOCPermittedDirectionRight = 1 << 3
}

• 应该用枚举来表示状态机的状态、传递给方法的选项以及状态码等值，给这些值起个易懂的名字；
• 凡是需要以按位或操作来组合的枚举都应使用NS_OPTIONS定义，若是枚举不需要互相组合，则应使用NS_ENUM来定义；
• 如果把传递给某个方法的选项表示为枚举类型，而多个选项又可同时使用，那么就将各选项值定义为2的幂，以便通过按位或操作将其组合起来；
• 用NS_ENUN 与 NS_OPTIONS宏来定义枚举类型，并指明其底层数据类型。这样做可以确保枚举是用开发者所选的底层数据类型实现出来的，而不会采用编译器所选的类型；
• 在处理枚举类型的switch语句中不要实现default分支。这样的话，加入新枚举之后，编译器就会提示开发者：switch语句并未处理所有枚举。

对象、消息、运行期

6. 理解 “属性” 这一概念

如果开发过iOS程序，你就会发现，其中所有属性都声明为 nonatomic。这样做的历史原因是：在iOS中使用同步锁的开销较大，这会带来性能问题。一般情况下并不要求属性必须是 “原子的”，因为这并不能保证 “线程安全”（thread safety），若要实现 “线程安全” 的操作，还需采用更为深层的锁定机制才行。例如，一个线程在连续多次读取某属性值的过程中有别的线程在同时改写该值，那么即便将属性声明为 atomic，也还是会读到不同的属性值。因此，开发iOS程序时一般都会使用 nonatomic 属性。但是在开发Mac OS X 程序时，使用atomic 属性通常都不会有性能瓶颈。

• 可以用@property语法来定义对象中所封装的数据；
• 通过 “特质” 来指定存储数据所需的正确语义；
• 在设置属性所对应的实例变量时，一定要遵从该属性所声明的语义；
• 开发iOS程序时应该使用 nonatomic 属性，因为atomic属性会严重影响性能。

7. 在对象内部尽量直接访问实例变量

• 在对象内部读取数据时，应该直接通过实例变量来读，而写入数据时，则应通过属性来写；
• 在初始化方法及 dealloc 方法中，总是应该直接通过实例变量来读写数据；
• 有时会使用惰性初始化技术配置某份数据，这种情况下，需要通过属性类读取数据。

8. 理解 “对象等同性” 这一概念

• 若想检测对象的等同性，请提供 “isEqual:” 与 hash 方法；
• 相同的对象必须具有相同的哈希码，但是两个哈希码相同的对象却未必相同；
• 不要盲目地逐个检测每条属性，而是应该依据具体需求来制定检测方案；
• 编写 hash 方法时，应该使用计算速度快而且哈希码碰撞几率低的算法。

9. 以 “类族模式” 隐藏实现细节

“类族”（class cluster）是一种很有用的模式（pattern），可以隐藏 “抽象基类”（abstract base class）背后的实现细节。Objective-C 的系统框架中普遍使用此模式。比如，iOS的用户界面框架（user interface framework）UIKit 中就有一个名为 UIButton 的类。想创建按钮，需要调用下面这个 “类方法”（class method）:
+ (UIButton *)buttonWithType:(UIButtonType) type;

• 类族模式可以把实现细节隐藏在一套简单的公共接口后面；
• 系统框架中经常使用类族；
• 从类族的公共抽象基类中继承子类时要当心，若有开发文档，则应首先阅读。

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

// 创建完警告视图之后，设定一个与之关联的 “块”（block），等到执行 delegate 方法时再将其读出来，此方案的实现代码如下：
#import <objc/runtime.h>

static void *EOCMyAlertViewKey = "EOCMyAlertViewKey";
- (void)askUserAQuestion {
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle: @"Question" message: @"What do you want to do?" delegarte: self cancelButtonTitle: @"cancel" otherButtonTitles: @"Continue", nil ];
    void (^block)(NSInteger) = ^(NSInteger buttonIndex) {
        if (buttonIndex == 0) {
            [self doCancel];
        } else {
            [self doContinue];
        }
    };

    objc_setAssociatedObject(alert, EOCMyAlertViewKey, block, OBJC_ASSOCIATION_COPY);
    [alert show];
}

// UIAlertViewDelegate protocol method
- (void)alertView:(UIAlertView *)alertView clickedButtonAtIndex: (NSInteger)buttonIndex
{
    void (^block)(NSInteger) = objc_getAssociatedObject(alertView, EOCMyAlertViewKey);
    block(buttonIndex);
}

// 以这种方式改写之后，创建警告视图与处理操作结果的代码都放在一起了，这样比原来更易读懂，因为我们无须在两部分代码之间来回游走，即可明白警告视图的用处。

• 可以通过 “关联对象” 机制来把两个对象连起来；
• 定义关联对象时可指定内存管理语义，用以模仿定义属性时所采用的 “拥有关系” 与 “非拥有关系”；
• 只有在其他做法不可行时才应选用关联对象，因为这种做法通常会引入难于查找的bug。

11. 理解 objc_msgSend 的作用

• 消息由接收者、选择子及参数构成。给某对象 “发送消息” （invoke a message）也就相当于在该对象上 “调用方法” （call a method）；
• 发给某对象的全部消息都要由 “动态消息派发系统” （dynamic message dispatch system）来处理，该系统会查出对应的方法，并执行其代码。

12. 理解消息转发机制

动态方法解析阶段
+ (BOOL)resolveInstanceMethod: (SEL)selector

备援接受者阶段
- (id)forwardingTargetForSelector: (SEL)selector

启用完整的消息转发
- (void)forwardInvocation: (NSInvocation *)invocation

• 若对象无法响应某个选择子，则进入消息转发流程；
• 通过运行期的动态方法解析功能，我们可以在需要用到某个方法时再将其加入类中；
• 对象可以把其无法解读的某些选择子转交给其他对象来处理；
• 经过上述两步之后，如果还是没办法处理选择子，那就启动完整的消息转发机制。

13. 用 “方法调配技术” 调试 “黑盒方法”

交换 lowercaseString 与 uppercaseString 方法实现：
Method originalMethod = class_getInstanceMethod([NSString class], @selector(lowercaseString));
Method swappedMethod = class_getInstanceMethod([NSString class], @selector(uppercaseString));
method_exchangeImplementations(originalMethod, swappedMethod);

• 在运行期，可以向类中新增或替换选择子所对应的方法实现；
• 使用另一份实现来替换原有的方法实现，这道工序叫做 “方法调配”，开发者常用此技术向原有实现中添加新功能；
• 一般来说，只有调试程序的时候才需要在运行期修改方法实现，这种做法不易滥用。

14. 理解 “类对象” 的用意

// 描述Objective-C 对象所用的数据结构定义在运行期程序库的头文件里，id类型本身也定义在这里：
typedef struct objc_object {
    Class isa;
} * id;

// 由此可见每个对象结构体的首个成员是Class类的变量。该变量定义了对象所属的类，通常称为 “is a” 指针。例如，刚才的例子中所用的对象 “是一个” （is a）NSString，所以其 “is a” 指针就指向 NSString。Class 对象也定义在运行期程序库的头文件中：

typedef struct objc_class *Class;
struct objc_class {
    Class isa;
    Class super_class;
    const char *name;
    long version;
    long info;
    long instance_size;
    struct objc_ivar_list *ivars;
    struct objc_method_list **methodLists;
    struct objc_cache *cache;
    struct objc_protocol_list *protocols;
};

// 此结构体存放类的 “元数据” （metadata），例如类的实例实现了几个方法，具备多少个实例变量等信息。此结构体的首个变量也是isa指针，这说明Class 本身也是Objective-C对象。结构体里还有个变量叫做 super_class，它定义了本类的超类。类对象所属的类型（也就是isa指针所指向的类型）是另外一个类，叫做 “元类” （metadata），用来表述类对象本身所具备的元数据。“类方法” 就定义于此，因为这些方法可以理解成类对象的实例方法。每个类仅有一个 “类对象”，而每个 “类对象” 仅有一个与之相关的 “元类”。

• 每个实例都有一个指向 Class 对象的指针，用以表名其类型，而这些Class对象则构成了类的继承体系；
• 如果对象类型无法在编译期确定，那么就应该使用类型信息查询方法来探知；
• 尽量使用类型信息查询方法来确定对象类型，而不要直接比较类对象，因为某些对象可能实现了消息转发功能。

接口与API设计

15. 用前缀避免命名空间冲突

• 选择与你的公司、应用程序或二者节有关联之名称作为类名的前缀，并在所有代码中均使用这一前缀；
• 若自己所开发的程序库中用到了第三方库，则应为其中的名称加上前缀。

16. 提供 “全能初始化方法”

• 在类中提供一个全能初始化方法，并于文档里指明。其他初始化方法均应调用此方法；
• 若全能初始化方法与超类不同，则需覆写超类中的对象方法；
• 如果超类的初始化方法不适用于子类，那么应该覆写这个超类方法，并在其中抛出异常。

17. 实现 description 方法

• 实现 description 方法返回一个有意义的字符串，用以描述该实例；
• 若想在调试时打印出更详尽的对象描述信息，则应实现 debugDescription 方法。

18. 尽量使用不可变对象

将属性在对象内部重新声明为readwrite 这一操作可于 “class-continuation 分类” 中完成，在公共接口中声明的属性可于此处重新声明，属性的其他特质必须保持不变，而 readonly 可扩展为 readwrite。

• 尽量创建不可变的对象
• 若某属性仅可于对象内部修改，则在 “class-continuation 分类” 中将其由 readonly 属性扩展为 readwrite 属性；
• 不要把可变的 collection 作为属性公开，而应提供相关方法，以此修改对象中的可变collection。

19. 使用清晰而协调的命名方式

• 起名时应遵从标准的 Objective-C 命名规范，这样创建出来的接口更容易为开发者所理解；
• 方法名要言简意赅，从左至右读起来要像个日常用语中的句子才好；
• 方法名里不要使用缩略后的类型名称；
• 给方法起名时的第一要务就是确保其风格与你自己的代码或所要集成的框架相符。

20. 为私有方法名加前缀

与公有方法不同，私有方法不出现在接口定义中。有时可能要在 “class-continuation 分类”里声明私有方法，然而最近修订的编译器已经不要求在使用方法前必须先行声明了。所以说私有方法一般只在实现的时候声明。

• 给私有方法的名称加上前缀，这样可以很容易地将其同公共方法区分开；
• 不要单用一个下划线做私有方法的前缀，因为这种做法是预留给苹果公司用的。

21. 理解 Objective-C 错误模型

Objective-C 语言现在所采用的办法是：只在极其罕见的情况下抛出异常，异常抛出之后，无须考虑恢复问题，而且应用程序此时也应该退出。这就是说，不用再编写复杂的 “异常安全” 代码了。

• 只有发生了可使整个应用程序崩溃的严重错误时，才应使用异常；
• 在错误不那么严重的情况下，可以指派 “委托方法” （delegate method）来处理错误，也可以把错误信息放在 NSError 对象里，经由 “输出参数” 返回给调用者。

22. 理解 NSCopying 协议

mutableCopy 这个 “辅助方法”（helper）与 copy 相似，也是用默认的zone参数来调 “mutableCopyWithZone：”。如果你的类分为可变版本（mutable variant）与不可变版本（immutable variant），那么就应该实现 NSMutableCopying。若采用此模式，则在可变类中覆写 “copyWithZone;” 方法时，不要返回可变的拷贝，而应该返回一份不可变的版本。无论当前实例是否可变，若需获取其可变版本的拷贝，均应调用 mutableCopy 方法。同理，若需要不可变的拷贝，则总应通过copy方法来获取。
对于不可变的 NSArray 与 可变的 NSMutableArray 来说，下列关系总是成立的：
- [NSMutableArray copy] => NSArray
- [NSArray mutableCopy] => NSMutableArray

• 若想令自己所写的对象具有拷贝功能，则需实现 NSCopying 协议；
• 如果自定义的对象分为可变版本与不可变版本，那么就要同时实现 NSCopying 与 NSMutableCopying 协议；
• 复制对象时需决定采用浅拷贝还是深拷贝，一般情况下应该尽量执行浅拷贝；
• 如果你所写的对象需要深拷贝，那么可考虑新增一个专门执行深拷贝的方法。

协议与分类

23. 通过委托与数据源协议进行对象间通信

• 委托模式为对象提供了一套接口，使其可由此将相关事件告知其他对象；
• 将委托对象应该支持的接口定义成协议，在协议中把可能需要处理的事件定义成方法；
• 当某对象需要从另外一个对象中获取数据时，可以使用委托模式。这种情境下，该模式也称 “数据源协议” （data source protocol）；
• 若有必要，可实现含有位段的结构体，将委托对象是否能相应相关协议方法这一信息缓存至其中。

24. 将类的实现代码分散到便于管理的数个分类之中

• 使用分类机制把类的实现代码划分成易于管理的小块；
• 将应该视为 “私有” 的方法归入名叫Private的分类中，以隐藏实现细节。

25. 总是为第三方类的分类名称加前缀

• 向第三方类中添加分类时，总应给其名称加上你专用的前缀；
• 向第三方类中添加分类时，总应给其中的方法名加上你专用的前缀。

26. 勿在分类中声明属性

属性是封装数据的方式。尽管从技术上说，分类里也可以声明属性，但这种做法还是要尽量避免。原因在于，出了 “class-continuation分类” 之外，其他分类都无法向类中新增实例变量，因此，它们无法把实现属性所需的实例变量合成出来。

• 把封装数据所用的全部属性都定义在主接口里；
• 在 “class-continuation 分类” 之外的其他分类中，可以定义存取方法，但尽量不要定义属性。

27. 使用 “class-continuation 分类” 隐藏实现细节

“class-continuation 分类” 和普通的分类不同，它必须定义在其所接续的那个类的实现文件里。其重要之处在于，这是唯一能声明实例变量的分类，而且此分类没有特定的实现文件，其中的方法都应该定义在类的主实现文件里。与其他分类不同，“class-continuation 分类” 没有名字。

为什么需要这种分类呢？因为其中可以定义方法和实例变量。为什么能在其中定义方法和实例变量呢？只因为 “ 稳定的ABI” 这一机制，使得我们无须知道对象大小即可使用它。由于类的使用者不一定需要知道实例变量的内存布局，所以，它们也就未必得定义在公共接口中了。基于上述原因，我们可以像在类的实现文件里那样，于 “class-continuation 分类” 中给类新增实例变量。

“class-continuation 分类” 还有一种合理用法，就是将public接口中声明为 “只读” 的属性扩展为 “可读写” ，以便在类的内部设置其值。我们通常不直接访问实例变量，而是通过设置访问方法来做，因为这样能够触发 “键值观测” （Key-Value Observing， KVO）通知，其他对象有可能正监听此事件，出现在 “class-continuation 分类” 或其他分类中的属性必须同类接口里的属性具备相同的特质 （attribute），不过，其 “只读” 状态可以扩充为 “可读写” 。

• 通过 “class-continuation 分类”向类中新增实例变量；
• 如果某属性在主接口中声明为 “只读” ，而类的内部又要用设置方法修改此属性，那么就在 “class-continuation 分类” 中将其扩展为 “可读写”；
• 把私有方法的原型声明在 “class-continuation 分类” 里面；
• 若想使类所遵循的协议不为人所知，则可于 “class-continuation 分类”中声明。

28. 通过协议提供匿名对象

@property (nonatomic, weak) id<EOCDelegate> delegate

// 由于该属性的类型是 id<EOCDelegate> ，所以实际上任何类型的对象都能充当这一属性，即便该类不继承自 NSObject 也可以，只要遵循 EOCDelegate 协议就行。对于具备此属性的类来说，delegate 就是 “匿名的” （anonymous）。如有需要，可在运行期查出此对象所属的类型。然而这样做不太好，因为指定属性类型时所写的那个 EOCDelegate 契约已经表明此对象的具体类型无关紧要了。

• 协议可在某种程度上提供匿名类型。具体的对象类型可以淡化成遵从某协议的 id 类型，协议里规定了对象所应实现的方法；
• 使用匿名对象来隐藏类型名称（或类名）；
• 如果具体类型不重要，重要的是对象能够响应（定义在协议里的）特定方法，那么可使用匿名对象来表示。

内存管理

29. 理解引用计数

在Objective-C 的引用计数架构中，自动释放池是一项重要特性。调用release会立刻递减对象的保留计数（而且还有可能令系统回收此对象），然而有时候可以不调用它，改为调用autorelease，此方法会在稍后递减计数，通常是在下一次 “事件循环”（event loop）时递减，不过也可能执行得更早些。

- (NSString *)stringValue {
    NSString *str = [[NSString alloc] initWithFormat: @“I am this: %@”, self];
    return [str autorelease];
}

• 引用计数机制通过可以递增递减的计数器来管理内存。对象创建好之后，其保留计数至少为1。若保留计数为正，则对象计数存活。当保留计数将为0时，对象就被销毁了；
• 在对象生命期中，其余对象通过引用来保留或释放此对象。保留与释放操作分别会递增及递减保留计数。

30. 以ARC简化引用计数

• 有ARC之后，程序员就无须担心内存管理问题了。使用ARC来编程，可省去类中许多 “样板代码”；
• ARC管理对象生命周期的办法基本上就是：在合适的地方插入 “保留” 及 “释放” 操作；
• 由方法所返回的对象，其内存管理语义总是通过方法名来体现。ARC将此确定为开发者必须遵守的规则；
• ARC 只负责管理 Objective-C 对象的内存。尤其要注意：CoreFoundation对象不归ARC 管理，开发者必须适时调用 CFRetain/CFRelease。

31. 在dealloc 方法中只释放引用并解除监听

- (void)dealloc {
    CFRelease(coreFoundationObject);
    [[NSNotificationCenter defaultCenter] removeObserver: self];
}

• 在dealloc方法里，应该做的事情就是释放指向其他对象的引用，并取消原来订阅的 “键值观测”（KVO）或 NSNotificationCenter 等通知，不要做其他事情；
• 如果对象持有文件描述符等系统资源，那么应该专门编写一个方法来释放此种资源。这样的类要和其使用者约定：用完资源后必须调用 close 方法；
• 执行异步任务的方法不应在 dealloc 里调用；只能在正常状态下执行的那些方法也不应该在dealloc里调用，因此此时对象已处于正在回收的状态了。

32. 编写 “异常安全代码” 时留意内存管理问题

@try {
   EOCSomeClass *object = [[EOCSomeClass alloc] init];
   [object doSomethingThatMayThrow];
}
@catch (...) {
   NSLog(@"Whoops, there was an error.  Oh well...");
}
// 现在问题更大了，由于不能调用release，所以无法像手动管理引用计数时那样把释放操作移到 @finally 块中。你可能认为这种状况 ARC 自然会处理的。但实际上ARC不会自动处理，因为这样做需要加入大量样板代码，以便跟踪待清理的对象，从而在抛出异常时将其释放。可是，这段代码会严重影响运行期的性能，即便在不抛异常时也如此。而且，添加进来的额外代码还会明显增加应用程序的大小。这些副作用都不甚理想。

// 虽说默认状况下未开启，但ARC依然能生成这种安全处理异常所用的附加代码。-fobjc-arc-exception 这个编译器标志用来开启此功能。其默认不开启的原因是：在 Objective-C 代码中，只有当应用程序必须因异常状况而终止时才应抛出异常。因此如果应用程序即将终止，那么是否还会发生内存泄露就已经无关紧要了，在应用程序必须立即终止的情况下，还去添加安全处理异常所用的附加代码是没有意义的。

• 捕获异常时，一定要注意将 try 块内所创立的对象清理干净；
• 在默认情况下，ARC不生成安全处理异常所需的清理代码。开启编译器标志后，可生成这种代码，不过会导致应用程序变大，而且会降低运行效率。

33 以弱引用避免保留环

用 unsafe_unretained 修饰的属性特质，其语义通assign特质等价。然而，assign通常只用于 “整体类型”（int、float、结构体等），unsafe_unretained则多用于对象类型。这个词本身就表明其所修饰的属性可能无法安全使用（unsafe）。Objective-C中还有一项与ARC相伴的运行期特性，可以令开发者安全使用弱引用：这就是weak属性特质，它与unsafe_unretained的作用完全相同。然而，只要系统把属性回收，属性值就会自动设为nil。

• 将某些引用设为 weak，可避免出现 “保留环”；
• weak引用可以自动清空，也可以不自动清空。自动清空（autonilling）是随着ARC而引入的新特性，由运行期系统来实现。在具备自动清空功能的弱引用上，可以随意读取其数据，因为这种引用不会指向已经回收过的对象。

34. 以 “自动释放池块” 降低内存峰值

• 自动释放池排布在栈中，对象收到 autorelease 消息后，系统将其放入最顶端的池里；
• 合理运用自动释放池，可降低应用程序的内存峰值；
• @autoreleasepool 这种新式写法能创建出更为轻便的自动释放池。

35. 用 “僵尸对象” 调试内存管理问题

Cocoa 提供了 “僵尸对象” （Zombie Object）这个非常方便的功能。启用这项调试功能之后，运行期系统会把所有已经回收的实例转化为特殊的 “僵尸对象”，而不会真正回收它们。这种对象所在的核心内存无法重用，因此不可能遭到覆写。僵尸对象收到消息后，会抛出异常，其中准确说明了发送过来的消息，并描述了回收之前的那个对象。僵尸对象是调试内存管理问题的最佳方式。

僵尸对象的工作原理是什么呢？它的实现代码深植于 Objective-C 的运行期程序库、Foundation框架及 CoreFoundation框架中。系统在即将回收对象时，如果发现通过环境变量启用了僵尸对象功能，那么还将执行一个附加步骤。这一步就是把对象转化为僵尸对象，而不彻底回收。

• 系统在回收对象时，可以不将其真的回收，而是把它转化为僵尸对象。通过环境变量NSZombieEnabled可开启此功能；
• 系统会修改对象的isa指针，令其指向特殊的僵尸类，从而使该对象变为僵尸对象。僵尸类能够响应所有的选择子，响应方式为：打印一条包含消息内容及其接受者的消息，然后终止应用程序。

36. 不要使用 retainCount

• 对象的保留计数看似有用，实则不然，因为任何给定时间点上的 “绝对保留计数”（absolute retain count）都无法反映对象生命周期的全貌；
• 引入ARC之后，retainCount方法就正式废止了，在ARC下调用该方法会导致编译器报错。

块与大中枢派发

37. 理解 “块” 这一概念

• 块是C、C++、Objective-C 中的词法闭包；
• 块可接受参数，也可返回值；
• 块可以分配在栈或堆上，也可以是全局的。分配在栈上的块可拷贝到堆里，这样的话，就和标准的Objective-C 对象一样，具备引用计数了。

38. 为常用的块创建 typedef

• 以 typedef 重新定义块类型，可以令块变量用起来更加简单；
• 定义新类型时应遵从现有的命名习惯，勿使其名称与别的类型相冲突；
• 不妨为同一个块签名定义多个类型别名。如果要重构的代码使用了块类型的某个别名，那么只需修改相应 typedef中的块签名即可，无须改动其他 typedef。

39. 用handle 块降低代码分散程度

• 在创建对象时，可以使用内联的handler 块将相关业务逻辑一并声明；
• 在有多个实例需要监控时，如果采用委托模式，那么经常需要根据传入的对象来切换，而若改用 handler块来实现，则可直接将块与相关对象放在一起；
• 设计API时如果用到了 handler块，那么可以增加一个参数，使调用者可通过此参数来决定应该把块安排在哪个队列上执行。

40. 用块引用其所属性对象是不要出现保留环

• 如果块所捕获的对象直接或间接地保留了块本身，那么就得当心保留环问题；
• 一定要找个适当的实际解除保留环，而不能把责任推给API的调用者。

41. 多用派发队列，少用同步锁

• 派发队列可用来表述同步语义（synchronization semantic），这种做法要比使用 @synchronized块或 NSLock 对象更简单；
• 将同步与异步派发结合起来，可以实现与普通枷锁机制一样的同步行为，而这么做却不会阻塞执行异步派发的线程；
• 使用同步队列及栅栏块，可以令同步行为更加高效。

42. 多用GCD，少用 performSelector 系列方法

• performSelector些列方法在内存管理方面有疏失。它无法确定将要执行的选择子具体是什么，因而ARC编译器也就无法插入适当的内存管理方法；
• performSelector 系列方法所能处理的选择子太过局限了，选择子的返回值类型及发送给方法的参数个数都受到限制；
• 如果想把任务放在另一个线程上执行，那么最好不要用performSelector系列方法，二十应该把任务封装到块里，然后调用大中枢派发机制的相关方法来实现。

43. 掌握GCD及操作队列的使用时机

• 在解决多线程与任务管理问题时，派发队列并非唯一方案；
• 操作队列提供了一套高层的Objective-C API，能实现纯 GCD 所具备的绝大部分功能，而且还能完成一些更为复杂的操作，那些操作若改用GCD来实现，则需另外编写代码；

44. 通过Dispatch Group机制，根据系统资源状况来执行任务

• 一系列任务可归入一个 dispatch group之中。开发者可以在这组任务执行完毕时获得通知；
• 通过 dispatch group，可以在并发派发队列里同时执行多项任务。此时GCD会根据系统资源状况来调度这些并发执行的任务。开发者若自己来实现此功能，则需要编写大量代码。

45. 使用 dispatch_once 来执行只需运行一次的线程安全代码

• 经常需要编写 “只需执行一次的线程安全代码”（thread-safe single-code execution）。通过GCD所提供的dispatch_once 函数，很容易就能实现此功能；
• 标记应该声明在 static 或 global作用域中，这样的话，在把只需执行一次的块传给 dispatch_once函数时，传进去的标记也是相同的。

46. 不要使用 dispatch_get_current_queue

• dispatch_get_current_queue函数的行为常常与开发者所预期的不同。此函数已经废弃，只应做调试之用；
• 由于派发队列是按层级来组织的，所以无法单用某个队列对象来描述 “当前队列” 这一概念；
• dispatch_get_current_queue函数用于解决由不可重入的代码所引起的死锁，然而能用此函数解决的问题，通常也能改用 “队列特定数据” 来解决。

系统框架

47. 熟悉系统框架

• 许多系统框架都可以直接使用。其中最重要的是Foundation 与 CoreFoundation，这两个框架提供了构建应用程序所需的许多核心功能；
• 很多常见任务都能用框架来做，例如音频与视频处理、网络通信、数据管理等；
• 请记住：用纯C写成的框架与用Objective-C写成的一样重要，若想成为优秀的Objective-C开发者，应该掌握C语言的核心概念。

48. 多用块枚举，少用for循环

• 遍历collection有四种方式。最基本的办法是for循环，其次是NSEnumerator遍历法及快速遍历法，最新、最先进的方式则是 “块枚举法”；
• “块枚举法” 本身就能通过GCD来并发执行便利操作，无须另行编写代码。而采用其他遍历方式则无法轻易实现这一点；
• 若提前知道待遍历的 collection 含有何种对象，则应修改块签名，支出对象的具体类型。

49. 对自定义其内存管理语义的collection使用无缝桥接

• 使用无缝桥接技术，可以在Foundation框架中的 Objective-C对象与CoreFoundation框架中的C语言数据结构之间来回转换；
• 在CoreFoundation 层面创建collection时，可以指定许多回调函数，这些函数表示此collection应如何处理其元素。然后，可运用无缝桥接技术，将其转换成具备特殊内存管理语义的 Objective-C collection。

50. 构建缓存时选用NSCache 而非 NSDictionary

• 实现缓存时应选用 NSCache 而非 NSDictionary对象。因为 NSCache可以提供优雅的自动删减功能，而且是 “线程安全的”，此外，它与字典不同，并不会拷贝键；
• 可以给 NSCache 对象设置上限，用以限制缓存中的对象总个数及 “总成本”，而这些尺度则定义了缓存删减其中对象的时机。但是绝对不要把这些尺度当成可靠的 “硬限制”（hard limit），它们仅对NSCache起指导作用；
• 将 NSPurgeableData 与 NSCache 搭配使用，可实现自动清除数据的功能，也就是说，当NSPurgeableData 对象所占内存为系统所丢弃时，该对象自身也会从缓存中移除；
• 如果缓存使用得当，那么应用程序的响应速度就能提高。只有那种 “重新计算起来很费事的”数据，才值得放入缓存，比如那些需要从网络获取或从磁盘读取的数据。

51. 精简 initialize 与 load 的实现代码

• 在加载阶段，如果类实现了load方法，那么系统就会调用它。分类里也可以定义此方法，类的load方法要比分类中的先调用。与其他方法不同，load方法不参与覆写机制；
• 首次使用某个类之前，系统会向其发送initialize消息。由于此方法遵从普通的覆写规则，所以通常应该在里面判断当前要初始化的是哪个类；
• load 与 initialize 方法都应该实现得精简一些，这有助于保持应用程序的响应能力，也能减少引入 “依赖环” 的几率；
• 无法在编译期设定的全局变量，可以放在initialize方法里初始化。

52. 别忘了 NSTimer 会保留其目标对象

• NSTimer 对象会保留其目标，知道计时器本身失效为止，调用 invalidate 方法可令计时器失效，另外，一次性的计时器在触发完任务之后也会失效；
• 反复执行任务的计时器，很容易引入保留环，如果这种计时器的目标对象也保留了计时器本身，那肯定会导致保留环。这种环状保留关系，可能是直接发生的，也可能是通过对象图里的其他对象间接发生的；
• 可以扩充NSTimer的功能，用“块”来打破保留环。不过，除非 NSTimer 将来在公共接口里提供此功能，否则必须创建分类，将相关实现代码加入其中。