Effective Objective-C 2.0 编写高质量i

作者: Ghostlord | 来源:发表于2017-03-02 21:06 被阅读107次

说明：
1.此文章不是原创，是读书笔记，大多数是摘抄自书籍的要点，作为自己日后复习使用
2.此文纯手打，包括代码，难免有错误，请指(qing)正(pen)

1.了解C语言

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

一般来说，应该在某个类头文件中使用前向声明来提及别的类，并在实现文件中引入那些类的头文件，这样做可以尽量降低类之间的耦合性

假如声明某个类遵循一项协议，这样的情况下，尽量把”该类遵循某协议“的这条声明移至“class-continuation 分类”中，如果不行的话，就把协议单独放在一个头文件中，然后将其引入。

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

应该使用字面量语法来创建字符串、数值、数组、字典，优点就是简明扼要。

应该通过取下标操作来访问数组下标或字典中的键所对应的元素。
用字面量语法创建数组或字典时，若值中有nil,则会抛出异常。因此务必确保值中不含nil。

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

不要用预处理指令定义常量。这样定义出来的常量不含类型信息，编译器只是会在编译前据此执行查找与替换操作。即使有人重新定义了常量值，编译器也不会产生警告信息，这将导致应用程序中常量值不一致的问题。

在实现文件中使用 static const 来定义“只在编译单元内可见的常量”，由于此类常量不在全局符号表中，所以无需为其名称加前缀
在头文件中使用extern来生命全局常量，并在相关文件中定义其值。这种常量要出现在全局符号表中，所以其名称应加以区分，通常使用与之相关的类名做前缀。

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

应该用枚举来表示状态机的状态、传递给方法的选项以及状态码等值，给这些值起个简单易懂的名字。

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

6.理解属性的概念

可以使用@property语法来定义对象中所封装的数据

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

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

不解释

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

== 操作符比较的是两个指针本身

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

// 8条的代码示例
@interface EOCPerosn : NSObject
@property (nonatomic, copy) NSString *firstName;
@Property (nonatomic, copy) NSString *lastName;
@property (nonatomic, assign) NSUInteger age;
@end


- (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;
}

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

类族模式可以把实现细节隐藏在一套简单的公共接口后面

系统框架中经常使用类族
从类族的公共抽象基类中继承子类是要小心，若有开发文档，则应该首先阅读

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

可以通过“关联对象”机制来把两个对象连起来

定义关联对象时可指定内存管理语义，用以模仿定义属性时采用的“拥有关系”与非拥有关系
只有在其他做法不可行时才选用关联对象，因为此种做法通常会引入难以查找的bug

// 10条的代码示例
#import <objc/runtime.h>
static void *EOCMyAlertViewKey = "EOCMyAlertViewKey";

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

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

11.理解objc_msgSend的作用

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

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

// 11 条代码示例
// OC中给对象发送消息
id returnValue = [someObject messageName:parameter];

// objc_msgSend的原型（prototype）
void objc_msgSend(id self, SEL cmd, ...)

// 每个OC方法都可以视为简单的C函数，原型如下
<return_type> Class_selector (id self, SEL _cmd, ... )

12. 理解消息转发机制

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

通过运行期的动态方法解析功能，我们可以在需要用到某个方法时再加入类中
对象那个可以把其无法解读的默写选择子转交给其他对象来处理
经过上述两部后，如果还是不能处理选择子，就启动完整的消息转发机制

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

在运行期，可以向类中新增或替换选择子所对应的方法实现

使用另一份实现来替换原有的方法实现，这道工序叫做“方法调配”，开发者常用此技术向原有实现中添加新功能
一般来说，只有调试程序的时候才需要在运行期修改方法实现，这种做法不宜滥用

// 13条的代码示例
// 交换方法
void method_exchangeImplementations(Method m1, Method m2)

// 取出方法
Method class_getInstanceMethod(Class aClass , SEL aSelector)

// 方法交换示例（NSString 的lowercaseString 与 uppercaseString） 
Method originalMethod = class_getInstanceMethod([NSString class],@selector(lowercaseString));

Method swappedMethod = class_getInstanceMethod([NSString class],@selector(uppercaseString));

method_exchangeImplementations(originalMethod, swappedMethod);

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

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

如果对象类型无法再编译器确定，那么就应该使用类型信息查询方法来探知
尽量使用类型信息查询方法来确定对象类型，而不要直接比较类对象，因为某些对象可能实现了消息转发功能

// 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;
};

------------------------
// id的定义
typedef struct objc_object {
    Class isa;
} *id;
-----------------------

// “isMemberOfClass:” 能够判断出对象是否为某个特定类的实例，而“isKindOfClass:”则能判断除对象是否为某类或器派生类的实例
NSMutableDictionary *dict = [NSMutableDictionary new];
[dict isMemberOfClass:[NSDictionary class]];    // NO
[dict isMemberOfClass:[NSMutableDictionary class]]; // YES
[dict isKindOfClass: [NSDictionary class]]; // YES
[dict isKindOfClass: [NSArray class]];      // NO

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

选择与你公司、应用程序或二者皆有关联之名作为类名的前缀，并在所有代码中均使用这一前缀

若自己所开发的程序库中用到了第三方库，则应为其中的名称加上前缀

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

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

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

17. 实现description 方法

实现description 方法返回一个有意义的字符串，用以描述改实例。

若想在调试时打印出更详细的对象描述属性，应该实现debugDescription方法

// 17条代码示例
- (NSString *)debugDescription {
    return [NSString stringWithFormat:@"<%@: %p, \" %@  %@ \"> ",[self class],self,_firstName,_lastName];
}

// 'po 对象'的打印结果：
(lldb) po person
(EOCPerson *) $1 = 0X123430 <EOCPerson: 0X123430, "Bob Smith">

18. 尽量使用不可变对象

尽量创建不可变的对象

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

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

起名是应遵从标准的Ojbective-C命名规范，这样创建出来的接口更容易为开发者所理解

方法名要言简意赅，从左至右读起来要像个日常用语中的句子才好
方法名利不要使用缩略后的类型名称
给方法起名时第一要务就是确保其风格于你自己的代码或所要集成的框架相符

20. 为私有方法名加前缀

要给私有方法加前缀，这样可以很容易地将其与公共方法区分开

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

21. 理解Ojbective-C 错误模型

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

有错误不那么严重的情况下，可以指派“委托方法”（delegate method）来处理错误，可以把错误信息放在NSError对象里，经由“输出参数”返回给调用者

NSError 对象封装了三条信息
* Error domain (错误范围，类型为字符串)
* Error code   (错误码，其类型为整数)
* User info (用户信息，其类型为字典)

22. 理解NSCopying协议

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

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

---------------------------------------------------------------------------------
// 代码示例1：
#import<Foundation/Foundation.h>
@interface EOCPerson : NSObject <NSCopying>

@property (nonatomic, copy, readonly) NSString *firstName;
@property (nonatomic, copy, readonly) NSString *lastName;
- (instancetype)initWithFirstName:(NSString *)firstName andLastName:(NSString *)lastName;

@end

------------------- 在协议中实现下列方法 ---------------
- (id)copyWithZone:(NSZone *)zone {
    EOCPerson *copy = [[[self class] allocWithZone:zone] initWithFirstName:_firstName andLastName:_lastName];
    return copy;
}


--------------------------------------------------------------------------------
// 代码示例2：
// 若copyItem 参数设为YES，则该方法会向数组中的每个元素发送copy消息，用拷贝好的元素创建新的set，并将其返回给调用者
- (id)initWithSet:(NSArray *)array copyItems:(BOOL)copyItems;
// 如果EOCPerson 中有friends数组，并且想将数组中的元素都复制过来，可以编写一个专门的深拷贝的方法
- (id)deepCopy{
    EOCPerson *copy = [[[self class] alloc] initWithFirstName:_firstName andLastName:_lastName];
    copy->_friends = [[NSMutableSet alloc] initWithSet:_friends copyItems:YES];
    return copy;
}

----------20170303 update-----

协议与分类

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

委托模式为对象提供了一套接口，使其可由此将相关事件告知其他对象

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

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

使用分类机制把类的实现代码划分成易于管理的小块

将应该视为“私有”的方法归入名叫Private的分类中，以隐藏实现细节

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

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

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

@interface NSString (ABC_HTTP)

- (NSString *)abc_urlEncodedString;

- (NSString *)abc_urlDecodedString;

26.勿在分类中声明属性

把封装数据所用的全部属性都定义在主接口里。

在“class-continuation”分类之外的其他分类中，可以定义存取方法，但尽量不要定义属性。

------------- 20170308 update -------------

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

通过"class-continuation" 分类向类中新增示例变量

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

// 第27条示例代码

// 这样总得按照Objective-C++来编译
#import <Foundation/Foundation.h>
#include "SomeCppClass.h"
@interface EOCClass : NSObject {
@private 
    SomeCppClass _cppClass;
}
@end

// ------------------
// 而使用“class-continuation”分类来解决,就不用每个引用此类的类都使用Objecetive-C++环境编译
// EOCClass.h
#import <Foundation/Foundation.h>
@interface EOCClass : NSObject
@end

// EOCClass.mm
#import "EOCClass.h"
#include "SomeCppClass.h"

@interface EOCClass () {
    SomeCppClass _cppClass;
}
@end

@implemenetation EOCClass
@end

// 将public接口中声明为“只读”的属性扩展为“可读写”，以便在类的内部设置其值。
#import <Foundation/Foundation.h>
@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

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

协议可以在某种程度上提供匿名类型。具体的对象类型可以淡化成遵从某协议的id类型，协议里规定了对象所应实现的方法

使用匿名对象来隐藏类型名称（或类名）
如果具体类型不重要，重要的是对象能够响应（定义在协议里的）特定的方法，那么可使用匿名对象来表示

内存管理

29.理解引用计数

引用计数机制通过可以递增递减的计数器来管理内存。对象创建好之后，其保留计数至少为1.若保留计数为正，则对象继续存活。当保留计数降为0时，对象就被销毁了。

在对象生命期中，其余对象通过引用来保留或释放此对象。保留与释放操作分别会递增及递减保留计数。

30. 以ARC简化引用计数

使用ARC来编程，可省去类中的许多“样板代码”

ARC管理对象生命期的办法基本上就是：再合适的地方插入“保留”及“释放”操作。在ARC环境下，变量的内存管理语义可以通过修饰符指明，而原来则需要手工执行“保留”和“释放”操作。
由方法所返回的对象，其内存管理语义总是通过方法名来体现。ARC将此确定为开发者必须遵守的规则。
ARC只负责管理Objective-C对象的内存。尤其要注意：CoreFoundation对象不归ARC管理，开发者必须适时调用CFRetain/CFRelease.

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

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

如果对象持有文件描述符等系统资源，那么应该专门编写一个方法来释放此种资源。这样的类要和其使用者约定：用完资源后必须调用close方法。
执行异步任务的方法不应在dealloc里调用；只能在正常状态下执行的那些方法也不应在dealloc里调用，因为此时对象已经在回收的状态了。

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

捕获异常时，一定要注意将try块内所创立的对象清理干净

在默认情况下，ARC不生成安全处理异常所需的清理代码。开启编译器标识(-fobjc-arc-exceptions)后，可生成这种代码，不过会导致应用程序变大，而且会降低运行效率。

// 第32条示例代码
// 以下代码会导致内存泄漏
@try {
    EOCSomeClass *object = [[EOCSomeClass alloc] init];
    [object doSomethingThatMayThrow];
    [object release];
}
@catch (...) {
    NSLog(@"Whoops, there was an error .");
}
// ------- 应该使用@finally块会使其中的代码都保证会运行，且只运行一次
EOCSomeClass *object;
@try {
    object = [[EOCSomeClass alloc] init];
    [object doSomethingThatMayThrow];
}
@catch(...) {
    NSLog(@"Whoops, there was an error .");
}
@finally {
    [object release];
}

33.以弱引用避免保留环

将某些引用设为weak,可避免出现“保留环”

weak引用可以自动清空，也可以不自动清空。自动清空(autonilling)是随着ARC而引入的新特性，由运行期系统来实现。在具备自动清空功能的弱引用上，可以随意读取其数据，因为这种引用不会指向已经回收过的对象。

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

自动释放池排布在栈中，对象收到autorelease消息后，系统将其放入最顶端的池里

合理运用自动释放池，可降低应用程序的内存峰值
@autoreleasepool 这种新式写法能创建出更为轻便的自动释放池

NSArray *databaseRecords = /*...*/;
NSMutableArray *people = [NSMutableArray new];
for (NSDictionary *record in databaseRecords) {
    @autoreleasepool {
        EOCPerson *person = [[EOCPerson alloc] initWithRecord:record];
        [people addObject:person];
    }
}

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

系统在回收对象时，可以不将其真的回收，而是把它转化为僵尸对象。通过环境变量NSZombieEnabled可开启此功能。

系统会修改对象的isa指针，灵气指向特殊的僵尸类，从而使该对象变为僵尸对象。僵尸类能够响应所有的选择子，响应方式为：打印一条包含信息内容及其接受者的消息，然后终止应用程序。

36.不要使用retainCount

对象的保留计数看似有用，实则不然，因为任何给定时间点上的“绝对保留计数”(absolute retain count)都无法反应对象声明期的全貌

引入ARC之后，retatinCount方法就正式废除了，在ARC下调用该方法会导致编译器报错。

------------20170328--update------------

第6章，块与大中枢派发

37.理解“块”这一概念

块是C，C++，Objective-C中的语法闭包

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

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

以typedef重新定义块类型，可令块变量用起来更加简单。

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

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

在创建对象时，可以使用内联的handler块将相关业务逻辑一并生命

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

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

如果块所捕获的对象直接或间接地保留了块本身，那么就得当心保留换环问题

一定要找个适当的时机解除爆流缓，而不能把责任推给API的调用者

- (void)downloadData {
    NSURL *url = [[NSURL alloc] initWithString:@"http://www.exaple.com/something.dat"];
    EOCNetworkFetcher *networkFetcher = [[EOCNetworkFetcher alloc] initWithURL]


}

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

派发队列可用来表述同步语义(synchroinzation 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函数时，传进去的标记也是相同的。

+ (id)sharedInstance {
    static EOCClass *shareInstance = nil;
    static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
           shareInstance = [[self alloc] init];
        });
        return sharedInstance;
}

46.不要使用dispatch_get_current_queue

dispatch_get_current_queue 函数的行为常常与开发者预想的不同。此函数已经废弃，只应做调试之用。

由于派发队列是按层级来组织的，所以无法单用某个队列对象来描述“当前队列”这一概念
dispatch_get_current_queue函数用于解决由不可重入得代码所引发的死锁，然而能用此函数解决的问题，通常也能改用“队列特定数据”来解决。

第七章，熟悉系统框架

许多系统框架都可以直接使用。其中最重要的是Foundation与CoreFoundation,这两个框架提供了构建应用程序所需的许多核心功能。

很多常见任务都能用框架来做，例如音频与视频处理、网络通信、数据管理等。
请记住：用纯C编写的框架与用Objective-C写成的一样重要，若想成为优秀的objective-C开发者，应该掌握C语言的核心概念。

第48条：多用块枚举，少用for循环

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

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

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

NSArray *anArray = /* ... */;
[anArray enumerateObjectsUsingBlock:
    ^(id object, NSUinteger id x, BOOL *stop) {
    
        // Do something with 'object'
            if(shouldStop) {
                *stop = YES;
            }
            
}]

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

通过u无缝桥接技术，可以在Foundation框架中的Objective-C 对象和CoreFoundation框架中的C语言数据结构之间来回转换。

在CoreFoundation层面创建collection时，可以指定许多回调函数，这些函数表示此Collection应如何处理器元素。然后，可运用无缝桥接技术，将其转换成具备特殊内存管理语义的Objective-C collection。

NSArray *anNSArray = @[@1,@2,@3,@4,@5];
CFArrayRef aCFArray = (__bridge CFArrayRef)anNSArray;
NSLog(@"size of array = %li",CFArrayGetCount(aCFArray));
// Output :size of array = 5;

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

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

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

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

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

首次使用某个类之前，系统会向其发送inintialize消息。由于此方法遵从普通的覆写规则，所以同城应该在里面判断当前要初始化的是哪个类。
load和initialize方法都应该实现的精简一些，这有助于保持应用程序的响应能力，也能减少引入“依赖环”的几率。
无法在编译器设定的全局常量，可以放在initialize方法里初始化。

52.NSTimer会保留其目标对象

NSTimer对象会保留其目标，直到计时器本身失效为止，调用invalidate方法可令计时器失效，另外，一次性的计时器在触发完任务之后也会失效

反复执行任务的计时器(repeating timer)，很容易引入保留环。这种环状保留关系，可能是直接发生的，也可能是通过对象图例的其他对象间接发生的。
可以扩充NSTimer的功能，用“块”来打破保留环。不过，除非NSTimer将来在公共接口里提供此功能，否则必须创建分类，将相关实现代码加入其中。
备注：iOS10 中已经有带有block的计时器创建的API，可以解决循环引用问题

已完_20170328