Effective Objective-C读后感

一、熟悉OC

1、了解OC语言的起源

该语言使用“消息结构”（message structure）。
OC是C的“超类”(superset)。

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

• 除非确有必要，否则不要引入头文件。一般来说，应在某个类的头文件中使用向前声明来提及别的类，并在实现文件中引入那些类的头文件。这样做可以尽量降低类之前的耦合（coupling）。

向前声明（forward declaring） @class xxxx;（也可以解决两个类相互引用问题）。

将引入头文件的时机尽量延后，只在确有需要时才引入，这样就可以减少累的使用者所需引入的头文件数量。

• 疑问
  减少编译时间，但是别的类如果需要使用该class，必须再次引用，是否增加了工作量？

• 有时无法使用向前声明，比如要声明某个类遵循一项协议。这种情况下，尽量把“该类遵循某协议”的这条声明移至“class-continuation分类”中。如果不行的话，就把协议单独放在一个头文件中，然后将其引入。

若因为要实现属性、实例变量或者要遵循协议而必须引入头文件，则应尽量将其移至“class-continuation分类”。

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

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

4、多用类型常量，少用#define预处理命令

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

常用的命名法是：
若常量局限于某“编译单元”（translation unit，也就是“实现文件”，implementation file）之内，则在前面加字母k；若常量在类之外可见，则通常以类名为前缀。

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

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

---

二、对象、消息、运行期

用OC等面向对象语言编程时，“对象”（object）就是“基本构造单元”（building block），开发者可以通过对象来存储并传递数据。

在对象之间传递数据并执行任务的过程就叫做“消息传递”（Messaging）。

当应用程序运行起来以后，为其提供相关支持的代码叫做“OC运行期环境”（Objective-C runtime），它提供了一些使得对象之间能够传递消息的重要函数，并且包含创建类实例所用的全部逻辑。

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

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

可以把属性（property）当做一种简称，其意思就是：编译器会自动写出一套存取方法，用以访问给定类型中具有给定名称的变量。

可以在类的实现代码里通过@synthesize语法来制定实例变量的名字。

使用@dynamic关键字，它会告诉编译器：不要自动创建实现属性所用的实例变量，也不要为其创建存取方法。

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

• 在对象内部读取数据时，应该直接通过实例变量来读，而写入数据时，则应通过属性来写。

“通过属性访问”与“直接访问”有几个区别:
由于不经过OC的“方法派送”（method dispatch），所以直接访问实例变量的速度当然比较快。在这种情况下，编译器所生成的代码会直接访问保存对象实例变量的那块内存。

直接访问实例变量时，不会调用其“设置方法”，这就绕过了为相关属性所定义的“内存管理语义”。比方说，如果在ARC下直接访问一个声明为copy的属性，那么并不会拷贝该属性，只会保留新值并释放旧值。

如果直接访问实例变量，那么不会触发“键值观察”（Key-Value Observing，KVO）通知。这样做是否会产生问题，还取决于具体的对象行为。

通过属性来访问有助于排查与之相关的错误，因为可以给“获取方法”和“设置方法”中新增“断点”（Breakpoint），监控该属性的调用者及其访问时机

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

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

• 若想检测对象的等同性，请提供isEqual:与hash方法

-(BOOL)isEqual:(id)object {
    if (self == Object) return YES;
    if ([self class] != [object class]) return NO;
    EOCPerson *otherPerson = (EOCPerson *)object;
    if (![_firstName isEqualToString:otherPerson.firstName])
        return NO;
    if (![_lastName isEqualToString:otherPerson.lastName])
        return NO;
    if (_age != otherPerson.age)
        return NO;
    return YES;
}

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

- (NSUInteger)hash {
    NSUInteger firstNameHash = [_firstName hash];
    NSUInteger lastNameHash = [_lastName hash];
    NSUInteger ageHash = _age;
    return firstNameHash ^ lastNameHash ^ ageHash;
}

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

• 类族模式可以把实现细节隐藏在一套简单的公共接口后面。
• 系统框架中经常使用类族。

cocoa里的类簇：
大部分collection类都是类族（NSArray、NSMutableArray）。

• 从类族的公共抽象基类中继承子类时要当心，若有开发文档，则应首先阅读。

类族有办法新增子类，但是需要遵守几条规则：
子类应该继承自类族中的抽象基类；
子类应该定义自己的数据存储方式；
子类应当覆写超类文档中指明需要覆写的方法。

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

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

11、理解objc_msgSend的作用

• 消息由接受者、选择子及参数构成。给某对象“发送消息”（invoke a message）也就相当于在该对象上“调用方法”（call a method）

• 疑问
  消息传递时如何传递一个基本类型？
  和正常对象一致

       NSInteger nTag = 1；
       NSMethodSignature * method = [NSMethodSignature signatureWithObjCTypes:"v@:@i"];
       NSInvocation * inv = [NSInvocation invocationWithMethodSignature:method];
       [inv setArgument:&nTag atIndex:3];
       

• 发给某对象的全部消息都要由“动态消息派发系统”（dynamic message dispatch system）来处理，该系统会查出对应的方法，并执行其代码。

12、理解消息转发机制

• 若对象无法响应某个选择子，则进入消息转发流程。

消息转发分为两大阶段。
第一阶段先征询接收者，所属的类，看其是否能动态添加方法，以处理当前这个“未知的选择子”（unknown selector），这叫做“动态方法解析”（dynamic method resolution）。
第二阶段涉及“完整的消息转发机制”（full forwarding mechanism）。

• 通过运行期的动态方法解析功能，我们可以在需要用到某个方法时再将其加入类中。

动态方法解析
对象在收到无法解读的消息后，首先将调用其所属类的下列类方法：
+(BOOL)resolveInstanceMethod:(SEL)selector

resolveClassMehtod:

• 对象可以把其无法解读的某些选择子转交给其他对象来处理。

备援接收者
当前接收者还有第二次机会能处理未知的选择子，在这一步中，运行期系统会问它；能不能把这条消息转给其他接收者来处理。
-(id)forwardingTargetForSelector:(SEL)selector

• 经过上述两步之后，如果还是没办法处理选择子，那就启动完整的消息转发机制。

首先创建NSInvocation对象，把与尚未处理的那条消息有关的全部细节都封与其中。
-(void)forwardInvocation:(NSIncovation *)invocation

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

• 在运行期，可以向类中新增或替换选择子所对应的方法实现。
• 使用另一份实现来替换原有的方法实现，这道工序叫做“方法调配”（method swizzling），开发者常用此技术向原有实现中添加新功能。

通过此方案，开发者可以为那些“完全不知道其具体实现的”（completely opaque，“完全不透明的”）黑盒方法增加日志记录功能，这非常有助于程序调试。

• 一般来说，只有调试程序的时候才需要在运行期修改方法实现，这种做法不宜滥用。

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

• 每个实例都有一个指向Class对象的指针，用以表明其类型，而这些Class对象则构成了类的继承体系。

• 如果对象类型无法在编译期确定，那么就应该使用类型信息查询方法来探知。
  isMemberOfClass:
isKindOfClass:

• 尽量使用类型信息查询方法来确定对象类型，而不要直接比较类对象，因为某些对象可能实现了消息转发功能。

---

三、接口与API设计

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

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

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

• 在类中提供一个全能初始化方法，并于文档里指明。其他初始化方法均应调用此方法。

• 疑问
  会不会导致一个全能初始化方法修改，到处需要重新测试？

• 若全能初始化方法与超类不同，则需覆写超类中的对应方法。

如果超类的初始化方法不适用与子类，那么应该覆写这个超类方法，并在其中抛出异常。

17、实现description方法

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

18、尽量使用不可变对象

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

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

• 起名时应遵从标准的OC命名规范，这样创建出来的接口更容易为开发者所理解。
• 方法名要言简意赅，从左至右读起来要像日常用语中的句子才好。

方法命名：
如果方法的返回值是新创建的，那么方法名的首个词应是返回值的类型，除非前面还有修饰语，例如localizedString。属性的存取方法不遵循这种命名方式，因为一般认为这些方法不会创建新对象，即使有时返回内部对象的一份拷贝，我们也认为那相当于原有的对象。这些存取方法应该按照其所对应的属性来命名：
-localizedString
-lowercaseString

应该把表示参数类型的名词放在参数前面。

如果方法要在当前对象上执行操作，那么就应该包含动词；若执行操作时还需要参数，则应该在动词后面加上一个或多个名词。

• 方法名里不要使用缩略后的类型名称。

不要使用str这种简称，应该用视图string这样的全称。

Boolean属性应加is前缀。如果某方法返回非属性的Boolean值，那么应该根据其功能，选用has或is当前缀
-hasPrefix
-isEqualToString
有个属性叫做enabled，则其两个存取方法应该分别起名为setEnabled:与isEnabled。

将get这个前缀留个前些借由“输出参数”来保存返回值的方法，比如说，把返回值填充到“C语言式数组”（C-style array）里的那种方法就可以使用这个词做前缀
-getCharacters:range:
OC一般不以get开头。该方法用get作其前缀，原因在于，调用此方法时，要在其首个参数中传入数组，而该方法所获取的字符串正是要放在这个数组里面。

• 给方法起名时的第一要务就是确保其风格与你自己的代码或所要集成的框架相符。

类与协议的命名
继承自UITableView的子类命名为EOCImageTableView。不过这时要加上自己的前缀EOC，而不是延用超类的前缀UI。这样做的原因在于，你不应该把自己的类放在其他框架额命名空间里面。

如果要从其他框架中继承子类，那么务必遵循其命名习惯。比方说，要从UIView类中继承自定义的子类，那么类名末尾的词必须是View。同理，若要创建自定义的委托协议，则其名称中应该包含委托发起方的名称，后面再跟上Delegate一词。

20、为私有方法名加前缀

• 给私有方法的名称加上前缀，这样可以很容易地将其同公共方法区分开。

为私有方法名加前缀还有一个原因，就是便于修改方法名或方法签名。对于公共方法来说，修改其名称或签名之前要三思，因为来的公共API不便随意改动。
具体使用何种前缀可根据个人喜好来定，其中最好包含下划线与字母p。笔者喜欢用p_。

• 疑问
  私有方法前缀使用--。

• 不要单用一个下划线做私有方法的前缀，因为这种做法是预留给苹果公司用的。

21、理解OC错误模型

• 只有发生了可使整个应用程序崩溃的严重错误时，才应使用异常。

只在极其罕见的情况下抛出异常，异常抛出后，无须考虑恢复问题，而且应用程序此时也应该退出。

• 在错误不那么严重的情况下，可以指派“委托方法”。

在设计API时，NSError的第一种常见用法是通过委托协议来传递此错误。

-(void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error

NSError的另外一种常见用法是：经由方法的“输出参数”返回给调用者。比如像这样：

-(BOOL)doSomething:(NSError **)error {
    //Do something that may cause an error
    if (/*there was an error*/) {
        if (error) {
            //Pass the ‘error’ through the out-parameter
            *error = [NSError errorWithDomain:domain code:code userInfo:userInfo];
        }
        return NO; ///< Indicate failure
    } else {
        return YES; ///< Indicate success
    }
}

这段代码以*error语法为error参数“解引用”（dereference），也就是说，error所指的那个指针现在要指向一个新的Error对象。在解引用之前，必须先保证error参数不是nil，因为空指针解引用会导致“段错误”（segmentation fault）并使应用程序崩溃。

NSError *error = nil;
BOOL ret = [object doSomething:&error];
if (error) {
    //There was an error
}

BOOL ret = [object doSomething:nil];
if (ret) {
    //There was an error
}

在使用ARC时，编译器会把方法签名中的NSError **转换成NSError __autoreleasing,也就是说，指针所指的对象会在方法执行完毕后自动释放。

22、理解NSCopying协议

• 若想令自己所写的对象具有拷贝功能，则需实现NSCopying

- (id)copyWithZone:(NSZone *)zone

为何会出现NSZone呢？因为以前开发程序时，会据此把内存分成不同的“区”（zone），而对象会创建在某个区里面。现在不用了，每个程序只有一个区：“默认区”（default zone）。

• 如果自定义的对象分为可变版本与不可变版本，那么就要同时实现NSCopying与NSMutableCopying协议。

• 复制对象时需决定采用浅拷贝还是深拷贝，一般情况下应该尽量执行浅拷贝。

Foundation框架中的所有collection类在默认情况下都执行浅拷贝。

• 如果你所写的对象需要深拷贝，那么可考虑新增一个专门执行深拷贝的方法。

---

四、协议与分类

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

• 委托模式为对象提供了一套接口，使其可由此将相关事件告知其他对象。
• 将委托对象应该支持的接口定义为协议，在协议中把可能需要处理的事件定义成方法。
• 当某对象需要从另外一个对象中获取数据时，可以使用委托模式。这种情境下，该模式亦称“数据源协议”（data source protocol）。

若有必要，可实现含有段位的结构体，将委托对象是否能响应相关的协议方法这一信息缓存至其中。
将方法响应能力缓存起来的最佳途径是使用“位段”（bitfield）数据类型。以网络数据获取器为例，可以在该实例中嵌入一个含有段位的结构体作为实例变量，而结构体的每个位段则表示delegate对象是否实现了协议中的相关方法。此结构体的用法如下：

struct {
    unsigned int didReceiveData : 1;
    unsigned int didFailWithError : 1;
    unsigned int didUpdateProgressTo : 1;
}_delegateFlags;

- (void)setDelegate:(id<EOCNetworkFetcher>)delegate {
    _delegate = delegate;
    _delegateFlags.didReceiveData = [delegate respondsToSelector@selector(networkFetcher:didReceiveData)];
    ……
}

if (_delegateFlags.didUpdateProgressTo) {
    [_delegate networkFetcher:self didUpdateProgressTo:currentProgress];
}

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

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

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

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

@interface NSString (ABC_HTTP)
- (NSString *)abc_urlEncodedString;
- (NSString *)abc_urlDecodedString;

26、勿在分类中声明属性

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

只读属性还是可以在分类中使用的。

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

• 通过“class-continuation分类”向类中新增实例变量。

如果某属性在主接口中声明为“只读”，而类的内部又要用设置方法修改此属性，那么就在“class-continuation分类”中将其扩展为“可读写”。

//公共接口：
#import <Foundation/Foundation>
@interface EOCPerson:NSObject
@property (nonatomic, copy, readonly) NSString *firstName;
@property (nonatomic, copy, readonly) NSString *lastName;
- (id)initWithFirstName:(NSString *)firstName lastName:(NSString *)lastName;
@end

//我们一般会在“class-continuation分类”中把这两个属性扩展为“可读写”
@interface EOCPerson()
@property (nonatomic, copy, readwrite) NSString *firstName;
@property (nonatomic, copy, readwrite) NSString *lastName;
@end

若观察者（observer）正读取属性值而内部代码又在写入该属性时，则有可能引发“竞争条件”（race condition）。合理使用同步机制（41条）能缓解此问题。

• 把私有方法的原型声明在“class-continuation分类”里面。

@interface EOCPerson()
- (void)p_privetaMethod;
@end

笔者在编写类的实现代码之前，经常喜欢像这样先把方法原型写出来，然后再逐个实现。要想使类的代码更易读懂，可以试试这个好方法。

• 若想使类所遵循的协议不为人所知，则可于“class-continuation分类”中声明。

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

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

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

//NSDictionary
- (void)setObject:(id)object forKey:(id<NSCopying>)key;

---

五、内存管理

29、理解引用计数

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

30、以ARC简化引用计数

• 在ARC之后，程序员就无须担心内存管理问题了。使用ARC来编程，可省去类中的许多“样板代码”。
• ARC管理对象生命期的办法基本上就是：在合适的地方插入“保留”及“释放”操作。在ARC环境下，变量的内存管理语义可以通过修饰符指明，而原来则需要手工执行“保留”及“释放”操作。

除了会自动调用“保留”与“释放”方法外，使用ARC还有其他好处，它可以执行一些手动操作很难甚至无法完成的优化。

_myPerson = [EOCPerson personWithName:@“BOb Smith”];
EOCPerson *tmp = [EOCPerson personWithName:@“BOb Smith”];
_myPerson = [tmp retain];

这段代码演示了ARC是如何通过这些特殊函数来优化程序的：

+(EOCPerson *)personWithName:(NSString *)name {
    EOCPerson *person = [[EOCPerson alloc] init];
    person.name = name;
    objc_autoreleaseReturnValue(person);
}

EOCPerson *tmp = [EOCPerson personWithName:@“BOb Smith”];
_myPerson = objc_retainAutoreleaseReturnValue(tmp);

为了求得最佳效率，这些特殊函数的实现代码都因处理器而异。下面这段伪代码描述了其中的步骤：

id objc_autoreleaseReturnValue(id object) {
    if (/*caller will retain object*/) {
        set_flag(object);
        return object; ///< No autorelease
    } else {
        return [object autorelease];
    }
}

id objc_retainAutoreleaseReturnValue(id object) {
    if (get_flag(object)) {
        clear_flag(object);
        return object; ///< No retain
    } else {
        return [object retain];
    }
}

变量的内存管理语义

- (void)setObject:(id)object {
    [_object release];
    _object = [object retain];
}

- (void)setObject:(id)object {
    _object = object;
}

• 由方法所返回的对象，其内存管理语义总是通过方法名来体现。ARC将此确定为开发者必须遵守的规则。

使用ARC时必须遵循的方法命名规则：
若方法名以下列词语开头，则其返回的对象归调用者所有：alloc、new、copy、mutableCopy。

• ARC只负责管理OC对象的内存。尤其要注意：CoreFoundation对象不归ARC管理，开发者必须适时调用CFRetain/CGRelease。

如果有非OC的对象，比如CoreFoundation中的对象或是由malloc()分配在堆中的内存，那么仍然需要清理。

- (void)dealloc {
    CFRelease(_coreFoundationObject);
    free(_heapAllocatedMemoryBlob);
}

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

• 在dealloc方法里，应该做的事情就是释放指向其他对象的引用，并取消原来订阅的“键值观测”（KVO）或NSNotificationCenter等通知，不要做其他事情。

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

• 如果对象持有文件描述符等系统资源，那么应该专门编写一个方法来释放此种资源。这样的类要和其他使用者约定：用完资源后必须调用close方法。

在清理方法而非deallocation方法中清理资源还要一个原因，就是系统并不保证每个创建出来的对象的dealloc都会执行。如果一定要清理某些对象，那么可在此方法中调用那些对象的“清理方法”。

- (void)applicationWillTerminate:(UIApplication *)application

• 执行异步任务的方法不应在dealloc里调用；只能在正常状态下执行的那些方法也不应该在dealloc里调用，因为此时对象已处于正在回收的状态了。

调用dealloc方法的那个线程会执行“最终的释放操作”（final release），令对象的保留计数降为0，而某些方法必须在特定的线程里（比如主线程里）调用才行。若在dealloc里调用了那些方法，则无法保证当前这个线程就是那些方法所需的线程。通过编写常规代码的方式，无论如何都没办法保证其会安全运行在正确的线程上，因为对象处于“正在回收的状态”（deallocating state），为了指明此状况，运行期系统已经改动了对象内部的数据结构。

在dealloc里也不要调用属性的存取方法，因为有人可能会覆写这些方法，并于其中做一些无法在回收阶段安全执行的操作。此外，属性可能正处于“键值观测”（Key-Value Observation，KVO）机制的监控之下，改属性的观察者（observer）可能会在属性值改变时“保留”或使用这个即将回收的对象。这种做法会令运行期系统的状态完全失调，从而导致一些莫名其妙的错误。

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

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

@try {
    EOCSomeClass *object = [[EOCSomeClass alloc] init];
    [object doSomethingThatMayThrow];
}
@catch (…){
    NSLog(@“Whoops , there was an error. Oh well …");
}

由于不能调用release，所以无法像手动管理引用计数时那样把释放操作移到@finally块中。你可能会认为这种状况ARC自然会处理的。但实际上ARC不会自动处理，因为这样做需要加入大量样板代码，以便跟踪待清理的对象，从而在抛出异常时将其释放。

-fobjc-arc-exceptions这个编译器标志用来开启此功能。

有种情况编译器会自动把-fobjc-arc-exceptions标志打开，就是处于OC++模式时。

33、以弱引用避免保留环

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

一般来说，如果不拥有某对象，那就不要保留它。这条规则对collection例外，collection虽然并不直接拥有其内容，但是它要代表自己所属的那个对象来保留这些元素。有时，对象中的引用会指向另外一个并不归自己所拥有的对象，比如Delegate模式就是这样。

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

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

通常只有一个地方需要创建自动释放池，那就是在main函数里，我们用自动释放池来包裹应用程序的主入口点（main application entry point）。

int main (int argc, char *argv[]){
    @autoreleasepool{
        return UIApplicationMain(argc,argv,nil,@“EOCAppDelegate”);
    }
}

这个池可以理解成最外围捕捉全部自动释放对象所用的池。

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

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

36、不要使用retainCount

---

六、块与大中枢派发

当前多线程编程的核心就是“块”（block）与“大中枢派发”（Grand Central Dispatch，GCD）。

“块”是一种可在C、C++及OC代码中使用的“词法闭包”（lexical closure），它极为有用，这主要是因为借由此机制，开发者可将代码像对象一样传递，令其在不同环境（context）下运行。还有个关键的地方是，在定义“块”的范围内，它可以访问到其中的全部变量。

GCD是一种与块有关的技术，它提供了对线程的抽象，而这种抽象则基于“派发队列”（dispatch queue）。

37、理解“块”这一概念

• 块是C、C++、OC中的词法闭包

块的基础知识：
块其实就是个值，而且自有其相关类型。

• 块可接受参数，也可返回值。
• 块可以分配在栈或堆上，也可以是全局的。分配在栈上的块可拷贝到堆里，这样的话，就和标准的OC对象一样，具备引用计数了。

全局块、栈块及堆块
定义块的时候，其所占的内存区域是分配在栈中，下面这段代码就有危险：

void (^block)();
if (/*some condition*/) {
    block = ^{ 
        NSLog(@“Block A”);
    };
}else {
    block = ^{ 
        NSLog(@“Block B”);
    };
}
block();

定义在if及else语句中的两个块都分配在栈内存中。编译器会给每个块分配好栈内存，然而等离开了相应的范围之后，编译器有可能把分配给块的内存覆写掉。于是这两个块只能保证在对应的if或else语句范围内有效。这样写出来的代码可以编译，但是运行起来时而正确，时而错误。
为解决此问题，可给块对象发送copy消息以拷贝之。这样的话，就可以把块从栈复制到堆了。

void (^block)();
if (/*some condition*/) {
    block = [^{ 
        NSLog(@“Block A”);
    } copy];
}else {
    block = [^{ 
        NSLog(@“Block B”);
    } copy];
}
block();

由于运行该块所需的全部信息都能在编译期确定，所以可把它做出全局块。

void (^block)() = ^{
    NSLog(@“This is a block”);
};

38、为常用的块类型创建typedef

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

39、用handler块降低代码分散程度

• 在创建对象时，可以使用内联的handler块将相关业务逻辑一并声明。
• 在有多个实例需要监控时，如果采用委托模式，那么经常需要根据传入的对象来切换，而若改用handler块来实现，则可直接将块与相关对象放在一起。

与使用委托模式的代码相比，用块写出来的代码显示更为整洁。异步任务执行完毕后所需运行的业务逻辑，和启动异步任务所用的代码放在一起。而且，由于块声明在创建获取器的范围里，所以它可以访问此范围内的全部变量。
总体来说，笔者建议使用同一个块来处理成功与失败情况。

• 设计API时如果用到了handler块，那么可以增加一个参数，使调用者可通过此参数来决定应该把块安排在哪个队列上执行。

40、用块引用其所属对象时不要出现保留环

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

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

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

有种简单而高效的办法可以代替同步块或锁对象，那就是使用“串行同步队列”（serial synchronization queue）。将读取操作及写入操作都安排在同一个队列里，即可保证数据同步。其用法如下：

_syncQueue = dispatch_queue_create(“com.effectiveobjectivec.syncQueue”,NULL);

- (NSString *)someString {
    __block NSString *localSomeString;
    dispatch_sync(_syncQueue, ^{
        localSomeString = _someString;
    });
    return localSomeString;
}

- (void)setSomeString:(NSString *)someString {
    dispatch_sync(_syncQueue, ^{
        _someString = someString;
    });
}

• 使用同步队列及栅栏块，可以令同步行为更加高效。

多个获取方法可以并发执行，而获取方法与设置方法之间不能并发执行，利用这个特点，还能写出更快的一些代码来。改用并发队列（concurrent queue）。在队列中，栅栏块必须单独执行，不能与其他块并行。可以用栅栏块来实现属性的设置方法。在设置方法中使用了栅栏块之后，对属性的读取操作依然可以并发执行，但是写入操作却必须单独执行了。

_syncQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);

- (NSString *)someString {
    __block NSString *localSomeString;
    dispatch_sync(_syncQueue, ^{
        localSomeString = _someString;
    });
    return localSomeString;
}

- (void)setSomeString:(NSString *)someString {
    dispatch_barrier_async(_syncQueue, ^{
        _someString = someString;
    });
}

设置函数也可以改用同步的栅栏块（synchronous barrier）来实现，那样做可能会更高效。（因为执行异步派发时，需要拷贝块。若拷贝块所用的时间明显超过执行块所花的时间，则这样做法将比原来更慢）

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

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

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

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

使用NSOperation及NSOperationQueue的好处如下：
取消某个操作。
指定操作间的依赖关系。
通过键值观察机制监控NSOperation对象的属性。
指定操作的优先级。

经常会有人说：应该进可能选用高层API，只在确有必要时才求助于底层。笔者也同意这个说法，但我并不盲从。某些功能确实可以用高层的OC方法来做，但这并不等于说它就一定比底层实现方案更佳，最好还是测试一下性能。

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

• 一系列任务可归入一个dispatch group之中。开发者可以在这组任务执行完毕时获得通知。

dispatch_queue_t lowPriorityQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW,0);
dispatch_queue_t highPriorityQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH,0);

dispatch_group_t dispatchGroup = dispatch_group_create();

for (id object in lowPriorityObjects) {
    dispatch_group_async(dispatchGroup, lowPriorityQueue,^{
        [object performTask];
    });
}
for (id object in highPriorityObjects) {
    dispatch_group_async(dispatchGroup, highPriorityQueue,^{
        [object performTask];
    });
}

dispatch_queue_t notifyQueue = dispatch_get_main_queue();
dispatch_group_notify(dispatchGroup, notifyQueue, ^{
    //Continue processing after completing tasks
});

• 通过dispatch group，可以在并发式派发队列里同时执行多项任务。此时GCD会根据系统资源状况来调度这些并发执行的任务。开发者若自己来实现此功能，则需编写大量代码。

如果所有任务都排在同一个串行队列里面，那么dispatch group就用处不大了。因为此时任务总要逐个执行，所以只需在提交完全全部任务之后再提交一个块即可。开发者未必总需要使用dispatch group。有时候采用单个队列搭配标准的异步派发，也可以实现同样效果。

dispatch_queue_t queue = dispatch_queue_create(“com.effectiveobjectivec.queue”,NULL);

for (id object in collection) {
    dispatch_async(queue, ^{
        [object performTask];
    });
}

dispatch_async(queue,^{
    //Continue processing after completing tasks
});

for循环要处理的collection若是数组，则可用dispatch_apply改写如下：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);

dispatch_apply(array.count, queue, ^(size_t i){
    id object = array[i];
    [object performTask];
});

这个例子再次表面：未必总是使用dispatch group。然而，dispatch_apply会持续阻塞，直到所有任务都执行完毕为止。由此可见：假如把块派给了当前队列（或者体系中高于当前队列的某个串行队列），就将导致死锁。若想在后台执行任务，则应使用dispatch group。

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函数用于解决由不可重入的代码所引发的死锁，然而能用此函数解决的问题，通常也能改用“队列特定数据”来解决。

死锁

dispatch_queue_t queueA = dispatch_queue_create(“com。effectiveobjectivec.queueA”,NULL);
dispatch_queue_t queueB = dispatch_queue_create(“com。effectiveobjectivec.queueB”,NULL);

dispatch_sync(queueA, ^{
    dispatch_sync(queueB, ^{
        dispatch_sync(queueA, ^{
            //Deadlock
        });
    });
});

dispatch_sync(queueA, ^{
    dispatch_sync(queueB, ^{
        dispatch_block_t block = ^{
             //Deadlock
        };
        if (dispatch_get_current_queue() == queueA) {
            block();
        } else {
            dispatch_sync(queueA, block);
        }
    });
});

“可重入”，要解决这个问题，最好的办法就是通过GCD所提供的功能来设定“队列特有数据”（queue-specific data），此功能可以把任意数据以键值对的形式关联到队列里。最重要之处在于，假如根据指定的键获取不到关联数据，那么系统就会沿着层级体系向上查找，直至找到数据或到达根队列位置。

dispatch_queue_t queueA = dispatch_queue_create(“com.effectiveobjectivec.queueA”,NULL);
dispatch_queue_t queueB = dispatch_queue_create(“com.effectiveobjectivec.queueB”,NULL);

dispatch_set_target_queue(queueB, queueA);

static int kQueueSpecific;
CFStringRef queueSpecificValue = CFSTR(“queueA”);
dispatch_queue_set_specific(queueA, &kQueueSpecific, (void *)queueSpecificValue, (dispatch_function_t)CFRelease);

dispatch_sync(queueB, ^{
    dispatch_block_t block = ^{
        NSLog(@“NO deadlock!");
    };
    CFStringRef retrievedValue = dispatch_get_specific(&kQueueSpecific);
    if (retrieveValue) {
        block();
    } else {
        dispatch_sync(queueA, block);
    }
});

---

七、系统框架

47、熟悉系统框架

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

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

• 遍历collection有四种方式。最基本的办法是for循环，其次是NSEnumerate遍历法及快速遍历法，最新、最先进的方式则是“块枚举法”。

for循环

NSArray *anArray = /* … */;
for (int i = 0; i < anArray.count; i++) {
    id object = anArray[i];
    // Do something with ‘object'
}

NSDictionary *aDictionary = /* … */;
NSArray *keys = [aDictionary allKeys];
for (int i = 0; i < keys.count; i++) {
    id key = keys[i];
    id value =  aDictionary[key];
    // Do something with ‘key’ and ‘value'
}

NSSet *aSet = /* … */;
NSArray *keys = [aSet allObjects];
for (int i = 0; i < objects.count; i++) {
    id object = objects[i];
    // Do something with ‘object'
}

NSEnumerator来遍历

NSArray *anArray = /* … */;
NSEnumerator *enumerator = [anArray objectEnumerator];
id object;
while ((object = [enumerator nextObject]) != nil) {
    // Do something with ‘object'
}

//反向遍历数组
NSArray *anArray = /* … */;
NSEnumerator *enumerator = [anArray reverseObjectEnumerator];
id object;
while ((object = [enumerator nextObject]) != nil) {
    // Do something with ‘object'
}

快速遍历

NSArray *anArray = /* … */;
for (id object in anArray){
    // Do something with ‘object'
}
//反向遍历数组
NSArray *anArray = /* … */;
for (id object in [anArray reverseObjectEnumerator]){
    // Do something with ‘object'
}

基于块的遍历方式

NSArray *anArray = /* … */;
[anArray enumerateObjectsUsingBlock: ^(id object, NSUInteger idx, BOOL *stop) {
        // Do something with ‘object’
        if(shouldStop) {
            *stop = YES;
        }
}];

用此方法也可以执行反向遍历。

- (void)enumerateObjectsWithOptions:(NSEnumerationOptions)options
                         usingBlock:(void(^)(id object, NSUInteger idx, BOOL *stop))block;

- (void)enumerateKeysAndObjectsWithOptions:(NSEnumerationOptions)options
                                usingBlock:(void(^)(id object, NSUInteger idx, BOOL *stop))block;

NSEnumerationOptions类型是个enumerate，其各种取值可用“按位或”（bitwise OR）连接，用以表面遍历方式。反向遍历通过NSEnumerationReverse选择来实现的。

• “块枚举法”本身就能通过GCD来并发执行遍历操作，无须另行编写代码。而采用其他遍历方式则无法轻易实现这一点。
• 若提前知道待遍历的collection含有何种对象，则应修改块签名，指出对象的具体类型。

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

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

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

• 实现缓存时应选用NSCache而非NSDictionary对象。因为NSCache可以提供优雅的自动删减功能，而且是“线程安全的”，此外，它与字典不同，并不会拷贝键。

NSCache并不会“拷贝”键，而是会“保留”它。

• 可以给NSCache对象设置上限，用以限制缓存中的对象总个数及“总成本”，而这些尺度则定义了缓存删减其中对象的时机。但是绝对不要把这些尺度当成可靠的“硬限制”（hard limit）。它们仅对NSCache起指导作用。
• 将NSPurgeableData与NSCache搭配使用，可实现自动清除数据的功能，也就是说，当NSPurgeableData对象所占内存为系统所丢弃时，该对象自身也会从缓存中移除。

如果将NSPurgeableData对象加入NSCache，那么当该对象为系统所丢弃时，也会自动从缓存中移除。通过NSCache的evictsObjectsWithDiscardedContent属性，可以开启或关闭此功能。

- (void)downloadDataForURL:(NSURL *)url {
    NSPurgeableData *cachedData = [_cache objectForKey:url];
    if (cachedData) {
        //Stop the data being purged
        [cachedData beginContentAccess];
        
        //Use the cached data
        [self useData:cachedData];

        //Mark that the data may be purged again
        [cacheData endContentAccess];
    } else {
        //Cache miss 
        EOCNetworkFetcher *fetcher = [[EOCNetworkFetcher alloc] initWithURL:url];
        [fetcher startWithCompletionHandler :^(NSData *data) {
            NSPurgeableData *purgeableData = [NSPurgeableData dataWithData:data];
            [_cache setObject:purgeableData forKey:url cost:purgeableData.length];

            //Don’t need to beginContentAccess as it begins
            //with access already marked

            //Use the retrieved data
            [self useData:data];

            //Mark that the data may be purged now
            [purgeableData endContentAccess];
        }];
    }
}

• 如果缓存使用得当，那么应用程序的响应速度就能提高。只有那种“重新计算起来很费事的”数据，才值得放入缓存，比如那些需要从网络获取或从磁盘读取的数据。

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

• 在加载阶段，如果类实现了load方法，那么系统就会调用它。分类里也可以定义此方法，类的load方法要比分类中的先调用。与其他方法不同，load方法不参与覆写机制。

load方法的问题在于，执行该方法时，运行期系统处于“脆弱状态”（fragile state）。在执行子类的load方法之前，必定会先执行所有超类的load方法，而如果代码还依赖了其他程序库，那么程序库里相关类的load方法也必定会先执行。然而，根据某个给定的程序库，却无法判断出其中各个类的载入顺序。因此，在load方法中使用其他类是不安全的。

• 首次使用某个类之前，系统会向其发送initialize消息。由于此方法遵从普通的覆写规则，所以通常应该在里面判断当前要初始化的是哪个类。

它是“惰性调用的”，也就是说，只有当程序用到了相关的类时，才会调用。
运行期系统才能确保initialize方法一定会在“线程安全的环境”（thread-safe environment）中执行。
如果某个类未实现它，而其超类实现了，那么就会运行超类的实现代码。

@interface EOCBaseClass : NSObject
@end

@implementation EOCBaseClass
+ (void)initialize {
    NSLog(@“%@ initialize”,self);
}
@end

@interface EOCSubClass : EOCBaseClass
@end

@implementation EOCSubClass
@end

首次使用EOCSubClass时，控制台会输出如下消息：

EOCBaseClass initialize
EOCSubClass initialize

只有当开发者所期望的那个类载入系统时，才会执行相关的初始化操作

+ (void)initialize {
    if (self == [EOCBaseClass class]) {
        NSLog(@“%@ initialize”,self);
    }
}

• load和initialize方法都应该实现得精简一些，这有助于保持应用程序的响应能力，也能减少引入“依赖环”（interdependency cycle）的几率。
• 无法在编译期设定的全局常量，可以放在initialize方法里初始化。

static NSMutableArray *kSomeObjects = [NSMutableArray new];

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

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

@interface NSTimer (EOCBlocksSupport)

+ (NSTimer *)eoc_scheduledTimerWithTimeInterval:(NSTimerInterval)interval 
                                          block:(void(^)())block
                                        repeats:(BOOL)repeats;
@end

@inplementation NSTimer (EOCBlocksSupport)
+ (NSTimer *)eoc_scheduledTimerWithTimeInterval:(NSTimerInterval)interval 
                                          block:(void(^)())block
                                        repeats:(BOOL)repeats {
    return [self scheduledTimerWithTimeInterval:interval target:self          selector:@selector(eoc_blockInvoke:) userInfo:[block copy] repeats:repeats];
}

+ (void)eoc_blockInvoke:(NSTimer *)timer {
    void (^block)() = timer.userInfo;
    if (block) {
        block();
    }
}
@end

只有改用weak引用，即可打破保留环

- (void)startPolling {
    _weak EOCClass *weakSelf = self;
    _pollTimer = [NSTimer eoc_scheduledTimerWithTimeInterval:5.0 block:^{
        EOCClass *strongSelf = weakSelf;
        [strongSelf p_doPoll];}
    repeats:YES];
}

• 疑问
  使用NSProxy弱引用。