编写高质量iOS与OS X代码的52个有效方法学习总结

1.掌握C语言的内存模型与指针

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

可以降低类耦合，减少编译时间，增加代码优雅度。

使用@class前向声明，将引入位置尽量后移，只在却有需要时引入，主要有以下几种情况：

如果你写的类继承自某个类个超类，则必须引入定义那个超类的头文件。

声明写的类遵守某个协议，那么该协议必须有完整定义，且不能使用前向声明。

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

如：

NSNumber *someNumber = @1;	

优点：简明扼要、有nil值会抛错，提前发现bug

应该通过取下标操作访问数组下标或字典中的键所对应的元素。

4.多用类型常量，少用#define宏定义。

可将如下代码替换为类型常量：

#define ANIMATION_DURATION 0.3	

替换成如下:

static const NSTimeInterval kAnimationDuration = 0.3;	

常量常用的命名法则：若常量局限于某编译单元（即.m实现文件）之内，则在前面加字幕k;若常量在类之外可见，则通常以类名为前缀。

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

凡是需要以按位或操作来组合的枚举都应使用NS_OPTIONS定义；若是枚举不需要互相组合，则应使用NS_ENUM来定义。并指明底层数据类型。这样可确保枚举是开发者所选的数据类型实现，而不会采用编译器所选的类型。

在处理枚举类型的switch语句中不要实现default分支，加入新枚举后编译器会提示：switch未处理所有分支。

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

assign:纯量类型的简单赋值操作。

strong：拥有关系，为此类属性设置值时，设置方法会先保留新值，并释放旧值，然后再将新值设置上去。

weak：非拥有关系，设置方法既不保留新值，也不释放旧值，同assign类似，特殊之处在所指对象遭到摧毁时，属性值会清空（nil）。

unsafe_unretained：语义与assign相同，但适用于对象类型，表达一种非用用关系，对象遭摧毁时，属性值不会清空。与weak有区别。

copy：类似strong，但执行拷贝操作。

绝不应该在init（或dealloc）方法中调用存取方法

开发iOS程序时应适用nonatomic属性，因为atomic会严重影响性能。

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

强烈建议在读取实例变量的时候采用直接访问的形式，而在设置实例变量的时候通过属性来做。特殊情况：

初始化方法中直接访问实例变量，因为子类可能会重写设置方法。

待初始化的实例变量声明在超类中，子类中无法直接访问此实例变量时，需要调用设置方法。

懒加载属性必须通过存取方法访问。

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

- (BOOL)isEqual:(id)object;
- (NSUinteger)hash;

NSObject的默认实现：当且仅当其指针值完全相等时，这两个对象才相等。如果isEqual:方法判断两个对象相等，那么其hash方法也必须返回同一个值。

检测对象等同性时需要提供isEqual:与hash方法。

编写hash方法的推荐算法：

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

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

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

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

iOS的控制器中需要多次使用UIAlertView时，其代理方式需要判断按钮来源，代码比较分散，因此可以使用关联对象，关联对象在iOS的UIAlertView中使用示例如下：

#import "ViewController.h"
#import <objc/runtime.h>

@interface ViewController ()<UIAlertViewDelegate>

@end

static void *EOCMyAlertViewKey = "EOCMyAlertViewKey";

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    [self askUserAQuestion];
}

- (void)askUserAQuestion {
    UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Question"
                                                    message:@"What do you want to do?"
                                                   delegate:self
                                          cancelButtonTitle:@"Cancel"
                                          otherButtonTitles:@"Continue", nil];
    void (^finishedHandle)(NSInteger) = ^ (NSInteger buttonIndex){
        if (buttonIndex == 0) {
            [self doCancel];
        }else {
            [self doContinue];
        }
    };
    
    objc_setAssociatedObject(alertView, EOCMyAlertViewKey, finishedHandle, OBJC_ASSOCIATION_COPY);
    [alertView show];
}

- (void)doCancel {
    NSLog(@"LOG_doCancel");
}

- (void)doContinue {
    NSLog(@"doContinue");
}

#pragma mark - UIAlertViewDelegate
- (void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex {
    void (^finishedHandle)(NSInteger) = objc_getAssociatedObject(alertView, EOCMyAlertViewKey);
    if (finishedHandle) {
        finishedHandle(buttonIndex);
    }
}

@end

**注意：**此做法很有用，但是只有在其他方法行不通的情况下去考虑使用，由于块可能会捕获某些变量，也许会造成保留环，造成内存泄漏和难以查找的bug。上述功能最好的实现方式就是继承UIAlertView创建子类，把块保存为子类的属性。关联属性方法只是举例而已。

11.理解objc_msgSend的作用

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

通过消息转发机制，实现一种可直接通过属性访问的NSDictionary(字典)，用到了消息转发的思路，仔细体会：

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface EOCAutoDictionary : NSObject
/** string */
@property(nonatomic, copy) NSString *string;
@property(nonatomic, strong) NSDate *date;
@end

NS_ASSUME_NONNULL_END

#import "EOCAutoDictionary.h"
#import <objc/runtime.h>

@interface EOCAutoDictionary()

/**  */
@property(nonatomic, strong) NSMutableDictionary *backingStore;
@end

@implementation EOCAutoDictionary

@dynamic string, date;

- (instancetype)init {
    if (self = [super init]) {
        _backingStore = [NSMutableDictionary new];
    }
    return self;
}

+(BOOL)resolveInstanceMethod:(SEL)sel {
    NSString *selectorString = NSStringFromSelector(sel);
    if ([selectorString hasPrefix:@"set"]) {
        class_addMethod(self,
                        sel,
                        (IMP)autoDictionarySetter,
                        "v@:@");
    }else {
        class_addMethod(self,
                        sel,
                        (IMP)autoDictionaryGetter,
                        "@@:");
    }
    return YES;
}

id autoDictionaryGetter(id self, SEL _cmd) {
    //获取backingStore
    EOCAutoDictionary *typedefSelf = (EOCAutoDictionary *)self;
    NSMutableDictionary *backingStore = typedefSelf.backingStore;
    
    NSString *key = NSStringFromSelector(_cmd);
    
    return [backingStore objectForKey:key];
}

void autoDictionarySetter(id self, SEL _cmd, id value) {
    EOCAutoDictionary *typedeSelf = (EOCAutoDictionary *)self;
    NSMutableDictionary *backingStore = typedeSelf.backingStore;
    
    NSString *selectorString = NSStringFromSelector(_cmd);
    NSMutableString *key = [selectorString mutableCopy];
    
    //remove the ":"
    [key deleteCharactersInRange:NSMakeRange(key.length - 1, 1)];
    
    //remove "set"
    [key deleteCharactersInRange:NSMakeRange(0, 3)];
    
    //lowercase the first character
    NSString *lowercaseFirstStrChar = [[key substringToIndex:1] lowercaseString];
    [key replaceCharactersInRange:NSMakeRange(0, 1) withString:lowercaseFirstStrChar];
    
    if (value) {
        [backingStore setObject:value forKey:key];
    }else {
        [backingStore removeObjectForKey:key];
    }
}

@end

12.理解消息转发机制

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

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

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

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

在运行期，可以向类总新增或替换选择子所对应的方法实现;使用另一份实现来替换原有的方法实现，叫做方法调配。常用此技术向原有实现中添加新功能;建议在调试期间使用，不宜滥用

14.理解类对象的用意

每个实例都有一个指向Class对象的指针，用以表明其类型，而这些class对象则构成了类的继承体系。尽量使用类型信息查询方法来确定对象类型，而不要直接比较类对象，因为某些对象可能实现了消息转发功能。

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

Apple宣称其保留使用所有“两字母前缀”的权利，所以你自己选用的前缀应该是三个字母。不仅是类名，应用程序中的所有名称都应加前缀。若自己所开发的程序库中用到了第三方库，则应为其中的名称加上前缀。

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

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

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

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

17.实现description方法

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

若想在调试时打印出更详尽的对象描述信息，则应实现debugDescription方法。（调试器通过po命令打印）

18.尽量使用不可变对象

尽量创建不可变的对象。

若属性仅可对于对象内部修改，则在“class-continuation”分类中将其由readonly属性扩展为readwrite属性。

不要把可变的Collection作为属性公开，而应提供相关方法，以此修改对象中的可变collection。

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

方法使用驼峰法命名，起名时要遵守Objective-C命名规范

方法名要言简意赅，读起来像个句子

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

20.为私有方法名加前缀

优势：可以将公共方法和私有方法区别开；便于修改方法名或者方法签名

常用前缀： p_

例如：- (void)p_privateMethod;

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

21.理解Objective-C错误模型

Objective-C语言采用的方式：只在极其罕见的情况下抛出异常，异常抛出之后，无需考虑恢复问题，而且应用程序此时也应该退出。

feta error 抛出异常，不那么严重的错误通过代理或者“输出参数”的方式处理。

22.理解NSCopying协议

自己写的类想实现拷贝功能，需要实现NSCopying协议

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

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

如果自定义对象需要实现深拷贝，那么可考虑新增一个专门执行深拷贝的方法。

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

频繁检测对象能否相应某协议方法时，建议将该信息缓存起来，而将方法相应能力缓存起来的最佳途径是使用“位段(bitfield)”数据类型。

struct data {
    unsigned int fieldA : 8;
    unsigned int fieldA : 4;
    unsigned int fieldA : 2;
    unsigned int fieldA : 1;
};

使用示例：

@interface EOCNetWorkFetcher () {
    struct {
        unsigned int didReceiveData : 1;
        unsigned int didFailWithError : 1;
        unsigned int didUpdateProgressTo : 1;
    }_delegateFlags;
}
@end
   
@implementation EOCNetWorkFetcher
    - (void)setDelegate:(id<EOCNetworkFetcher>)delegate {
    _delegate = delegate;
    
    _delegateFlags.didReceiveData = [_delegate respondsToSelector:@selector(networkFetcher:didReceiveData:)];
    _delegateFlags.didFailWithError = [_delegate respondsToSelector:@selector(networkFetcher:didFailWithError:)];
    _delegateFlags.didUpdateProgressTo = [_delegate respondsToSelector:@selector(networkFetcher:didReceiveData:)];
}
@end

使用时，直接检测标记即可：

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

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

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

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

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

分类可能会覆盖原有类的方法，而且可能是多次覆盖，此类bug难以追查。

解决办法：以命名空间来区别，而OC实现命名空间功能唯一的办法就是给类名加前缀。示例如下：

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

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

26.勿在分类中声明属性

分类无法把实现属性所需的实例变量合成出来。

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

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

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

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

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

29.理解引用计数

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

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

• 方法中返回对象时，建议使用autorelease。

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

30.以ARC简化引用计数

1.由方法返回的对象，内存管理语义总是通过方法名来体现。注意,如下方法名返回的对象归调用者所有：

• new

• alloc

• copy

• mutableCopy

2.ARC只管理Objective-C对象的内存，尤其要注意：CoreFoundation对象不归ARC管理，开发者必须适时调用CFRetain/CFRelease。

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

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

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

默认不开启 -fobjc-arc-exceptions标志的原因是：

在Objective-C中，只有当应用程序必须因异常状况而终止时才应抛出异常。若使用ARC且必须捕获异常，则需打开编译器的 -fobjc-arc-exceptions标志。

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

33.以弱引用避免保留环

• 将某些引用设为weak，可避免出现“保留环”
• weak引用可以自动清空，也可以不自动清空。自动清空是随ARC引入的新特性，由运行期系统来实现。unsafe_unretained不会自动清空，可能导致引用指向已经回收过的对象。

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

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

首先监控内存用量，判断有无需要解决的内存峰值问题，如果有再按照下述逻辑进行。

常用在for循环内部处理内存峰值：

NSArray *databaseArr = /***/;
for (NSDictionary *dic in databaseArr) {
    @autorelease {
        /** 产生很多临时变量的方法 **/
    }
}

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

• 系统在回收对象时，可以不降其真的回收，而是把它转化为僵尸对象。通过环境变量NSZombieEnabled可开启此功能。
• 系统会修改对象的isa指针，另起指向特殊的僵尸类，从而使该对象变为僵尸对象。

36.不要使用retainCount

• 对象的保留计数看似有用，实则不然，因为任何给定时间节点上的“绝对保留计数”都无法反应对象生命期的全貌。
• 引入ARC之后，retainCount方法就正式废止了。建议就是：绝对不要使用。

37.理解”块“这一概念

块类型的语法与函数指针相似，块的强大之处：在声明它的范围内里，所有变量都可以为其捕获。如果块所捕获的变量是对象类型，那么就会自动保留它。系统在释放这个块的时候会将其一并释放。

块总能修改实例变量，所以在声明时无须加 __block。

全局块、栈块、堆块：定义块的时候，其所占的内存区域是分配在栈中的。下述用法错误：

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

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

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

• 用typedef重新定义块类型，可令变量用起来更加简单。
• 定义新类时应遵从现有的命名习惯，勿使其名称与别的类型相冲突。
• 不妨为同一个块签名定义多个类型别名。

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

• 在创建对象时，可以使用内联的handler块将业务逻辑一并声明。
• 在有多个实例需要监控时，采用handler块来实现，则可直接将块与相关对象放在一起，而代理方式不得行，需要判断相关对象。
• 设计API时用到了handler块，那么可以增加一个参数，使调用者可以通过该参数来决定应该把块安排在哪个队列上执行。

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

深入理解常见的两种保留环。

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

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

OC中，如果有多个线程要执行同一份代码，可能会出问题，此时需要使用同步锁解决问题。GCD之前的两种解决办法：

- (void)synchronizedMethod {
    @synchronized(self) {
        //safe
    }
}

滥用@synchronized(self)会降低效率，且有很多无关代码运行，这样做其实没必要。

另一中加锁方式：

_lock = [[NSLock alloc] init];
- (void)synchronizedMethod {
    [_lock lock];
    //safe
    [_lock unlock];
}

两者都有其缺陷。在极端情况下同步锁会出现死锁，另外效率也不高，而如果直接使用锁对象，一旦遇到死锁就会非常麻烦。替代方案就是使用GCD代替块或锁对象：使用”串行同步队列“。将读取操作及写入操作都安排在同一个队列里，即可保证数据同步。用法如下：

_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;
    });
}

此模式的设计思路：**多个获取方法之间可以并行，而获取方法与设置方法之间不能并发执行。**因此，使用了栅栏函数，栅栏块必须单独执行，不能与其他块并行。注意：设置函数也可以改为同步的栅栏块，那样做可能会更高效，因为执行异步派发时，需要拷贝块，若拷贝块所花的时间超过执行所花的时间，则异步派发比原来更慢，若是派发给队列的块要执行更为繁重的任务，那么仍然可以考虑使用异步派发。需要根据实际情况测试决定使用哪种

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

performSelector 系列方法在内存管理方面容易有疏失，它无法确定将要执行的选择子具体是什么，因而ARC编译器也就无法插入适当的内存管理方法。

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

执行后台任务时，GCD并不一定是最佳方法。

GCD是纯C的API，而操作队列是Objective-C对象。

使用NSOperation和NSOperationQueue的好处如下：

• 取消某个操作
• 指定操作间的依赖关系。
• 通过键值观测机制监控NSOperation对象的属性。
• 指定操作的优先级
• 重用NSOperation对象

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

在并发队列中使用Dispatch_Group方式如下：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, queue, ^{
        //object performTask;
    });
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);//阻塞当前线程
    //继续处理其他任务
    
    //若当前线程不应阻塞，可用notify函数来取代dispatch_group_wait
    dispatch_queue_t notifyQueue = dispatch_get_main_queue();
    dispatch_group_notify(group, notifyQueue, ^{
        //继续处理其他任务
    });

notify回调时所选的队列，完全应该根据具体情况来定，

在串行队列中Dispatch_Group用处不大，可通过等价方法实现

dispatch_queue_t serialQueue = dispatch_queue_create("com.zhanlong.serialQueue", NULL);
    for (id object in collection) {
        dispatch_async(serialQueue, ^{
           //object performTask;
        });
    }
    dispatch_async(serialQueue, ^{
       serialQueue中上述任务已经完成，继续处理其他任务
    });

要点：

• 一系列任务可归入一个dispatch group之中，开发者可以在这组任务执行完毕时获得通知。
• 通过dispatch group，可以在并发式派发队列里同时执行多项任务。GCD会根据系统资源状况来调度这些并发执行的任务。

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

不适用GCD实现单例方式如下：

+ (id)shareInstance {
    static CommandManager *shareInstance = nil;
    @synchronized (self) {
        if (!shareInstance) {
            shareInstance = [[CommandManager alloc] init];
        }
    }
    return shareInstance;
}

使用GCD实现单例方式如下：

static CommandManager *shareInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        if (!shareInstance) {
            shareInstance = [[self alloc] init];
        }
    });
    return shareInstance;

推荐后者写法，经测试，后者速度是前者的两倍。

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循环，其次是NSEnumeration遍历法及快速遍历法，最新、最先进的方式则是”块枚举法“
• ”块枚举法“本身就能通过GCD来并发执行遍历操作，无须另行编写代码。其他遍历方式无法轻易实现这一点。
• 若提前知道遍历对象的类型，则应该修改块签名，指出对象的具体类型。

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

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

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

NSCache胜过NSDictionary之处在于，当系统资源将要耗尽时，它可以自动删减缓存。

NSCache是线程安全的。

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

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

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

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

类的实例中有定时器，而定时器需要反复执行。NSTimer会保留其目标对象，因此可能会造成内存泄漏。解决方式如下：

#import <Foundation/Foundation.h>
@interface NSTimer (ZZLBlockSupport)

+ (NSTimer *)scheduleTimeWithTimeInterval:(NSTimeInterval)interval
                                    block:(void(^)())block
                                  repeats:(BOOL)repeats;
@end

#import "NSTimer+ZZLBlockSupport.h"

@implementation NSTimer (ZZLBlockSupport)

+ (NSTimer *)scheduleTimeWithTimeInterval:(NSTimeInterval)interval
                                    block:(void(^)())block
                                  repeats:(BOOL)repeats {
    return [self scheduledTimerWithTimeInterval:interval target:self selector:@selector(zzl_blockInvoke:) userInfo:[block copy] repeats:repeats];
}

- (void)zzl_blockInvoke:(NSTimer *)timer {
    void (^block)() = timer.userInfo;
    if (block) {
        block();
    }
}

@end

在需要调用时类的实例方法时注意循环引用问题，若存在循环引用，可通过：

__weak typeof(self) weakSelf = self;

打破保留环。在block内部再次将self转换为强引用即可。如下：

- (void)startPolling {
    __weak typeof(self) weakSelf = self;
    _timer = [NSTimer zzl_scheduleTimeWithTimeInterval:5.0 block:^{
        EOCClass *strongSelf = weakSelf;
        [strongSelf p_doPoll];
    } repeats:YES];
}

• NSTimer会保留其目标，直到计时器本身失效为止，调用invalidate方法可令计时器失效，另外，一次性的计时器在触发完任务之后也会失效。
• 反复执行任务的计时器很容易引入保留环。
• 可以扩充NSTimer的功能，用”块“来打破保留环。