NSFastEnumeration

好久没写些什么东西了，似乎快有半年了吧。也不知道要写些什么，最近也跳槽了，复习了一段时间，所以应该重新开启新的行程了。
废话不多说，今天来研究下NSFastEnumeration这个协议。

for循环

遍历集合一般都想到使用for循环，这是一个很基本的办法，因此功能十分有限，通常会这样写代码：

NSArray *array = /* ... */;
for (int i = 0; i < array.count; i++) {
	id obj = array[i];
	// Do something with `obj`
}

假设我们要遍历字典，就会先获取到字典所有的key，然后再通过key获取value,因为字典是无序的，所以无法根据特点的整数下标来直接访问其中的值. 这样就需要转化，就很麻烦。

NSEnumerator

在Objective-C 1.0的时候，我们可以使用NSEnumerator来遍历， NSEnumerator是个抽象类，只定义了1个方法和一个属性：

- (nullable ObjectType)nextObject;
@property (readonly, copy) NSArray<ObjectType> *allObjects;

如果我们想遍历数组，可以这样：

NSArray *array = /* ... */;
NSEnumerator *enumerator = [array objectEnumerator];
id obj;
while ((obj = [enumerator nextObject]) != nil) {
	// Do something with `obj`
}

这种写法与for循环差不多，但是代码量似乎变多了

NSFastEnumeration

在Objective-C 2.0引入了一种快速遍历的方法，我们可以直接使用for in关键字

NSArray *array = /* ... */;
for (id obj in array) {
	// Do something with `obj`
}

这样写是不是就简单了很多。但是这个for in只是一个语法糖, 但是具体底层是怎么实现的呢？ 我们先来看一下NSArray类的头文件NSArray<__covariant ObjectType> : NSObject <NSCopying, NSMutableCopying, NSSecureCoding, NSFastEnumeration> 会发现它实现了NSFastEnumeration这么个协议。也正是这个协议，支持了for in这种语法。

这个协议只有一个方法和一个结构体。

- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(id __unsafe_unretained _Nullable [_Nonnull])buffer count:(NSUInteger)len;

typedef struct {
    unsigned long state;
    id __unsafe_unretained _Nullable * _Nullable itemsPtr;
    unsigned long * _Nullable mutationsPtr;
    unsigned long extra[5];
} NSFastEnumerationState;

看到这个结构体。。。简直一脸懵逼。。。这是个什么玩意？ 于是只能去查下官方文档了，在官方demo中我们看到了这个协议方法的实现，跟这个结构体的含义。

- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state
								  objects:(id __unsafe_unretained [])stackbuf
									count:(NSUInteger)stackbufLength {
	NSUInteger count = 0;
	// 使用 state->state 来保存当前遍历到了 _list 的什么位置
	unsigned long countOfItemsAlreadyEnumerated = state->state;
	
	// 当 countOfItemsAlreadyEnumerated 为 0 时，表示第一次调用这个方法
	if(countOfItemsAlreadyEnumerated == 0) {
        // state->mutationsPtr 是用来追踪集合在遍历过程中的突变
        // 它不能为 NULL ，也不应该指向 self
        
        // 因为我们的 Array 类是不可变的，所以我们不需要追踪它的突变
        // 因此，我们将它指向 state->extra 的其中一个值
        // 如果你的集合是可变的，可以将 state->mutationsPtr 指向一个内部变量
        // 而这个内部变量的值会在你的集合突变时发生变化
		state->mutationsPtr = &state->extra[0];
	}
	
#if USE_STACKBUF // Method One.
 	// 判断我们是否已经遍历完 _list
	if(countOfItemsAlreadyEnumerated < _list.size()) {
	// 将 state->itemsPtr 指向调用者提供的 C 数组 stackbuf
		state->itemsPtr = stackbuf;
		
		  // 将 _list 中的元素填充到 stackbuf 中，直到以下两个条件中的任意一个满足时为止
        // 1. 已经遍历完 _list 中的所有元素
        // 2. 已经填充满 stackbuf
		while((countOfItemsAlreadyEnumerated < _list.size()) && (count < stackbufLength)) {
			// 取出 _list 中的元素填充到 stackbuf 中
			stackbuf[count] = _list[countOfItemsAlreadyEnumerated];
			// 更新遍历位置
			countOfItemsAlreadyEnumerated++;
			// 更新返回的 C 数组的长度，使之与 state->itemsPtr 中的元素个数相匹配
			count++;
		}
	} else {
		count = 0;
	}
	
#else // Method Two.
	
	// 判断是否已经遍历完 _list
	if (countOfItemsAlreadyEnumerated < _list.size()) {
		// 直接将 state->itemsPtr 指向内部的 C 数组指针，因为它的内存地址是连续的
		__unsafe_unretained const id * const_array = _list.data();
		state->itemsPtr = (__typeof__(state->itemsPtr))const_array;
		// 一次性返回了 _list 中的所有元素
       // 所以，countOfItemsAlreadyEnumerated 和 count 的值均为 _list 中的元素个数
		count = _list.size();
		countOfItemsAlreadyEnumerated = _list.size();
	} else {
		count = 0;
	}
	
#endif
	 // 将本次调用得到的 countOfItemsAlreadyEnumerated 保存到 state->state 中
    // 因为 NSFastEnumeration 协议本身并没有用到 state->state
    // 所以，可以将这个值保留到下一次调用
	state->state = countOfItemsAlreadyEnumerated;
	// 返回C数组长度
	return count;
}

将注释翻译一下，剩下的代码是这样，countByEnumeratingWithState: 一共有两种实现方式，通过宏来控制. 我们可以看出：

* countByEnumeratingWithState是被外部循环调用的
* 使用结构体指针NSFastEnumerationState记录当前最新的遍历状态，循环的次数取决于参数stackbufLength缓冲区的大小。
* NSFastEnumerationState中state用来记录最后遍历的位置，itemsPtr指向缓冲区数组,mutationsPtr和extra是用来检测和控制原始数组是否改变
* 当最终返回'count = 0'是表示遍历结束

通过上面的了解后，接下来，我们通过一个小例子来说明for in是如果工作的.
简单的写了一个数组遍历的代码：

int main(int argc, const char * argv[]) {
	@autoreleasepool {
		NSArray *array = /* ... */;
		for (id obj in array) {
			NSLog(@"%@",obj);
		}
	}
    return 0;
}

然后我们通过clang -rewrite-objc main.m, 然编译器翻译下for in，我们会看到一个.cpp的文件，里面代码实在是太多了, 我们找到我们写的那个地方,

id obj;
 // 初始化结构体 NSFastEnumerationState
struct __objcFastEnumerationState enumState = { 0 };
// 初始化数组 stackbuf，缓冲区数组初始化固定的大小为16
id __rw_items[16];
id l_collection = (id) array;
_WIN_NSUInteger limit =
	((_WIN_NSUInteger (*) (id, SEL, struct __objcFastEnumerationState *, id *, _WIN_NSUInteger))(void *)objc_msgSend)
	((id)l_collection,
	sel_registerName("countByEnumeratingWithState:objects:count:"),
	&enumState, (id *)__rw_items, (_WIN_NSUInteger)16);
if (limit) {
// 获取 mutationsPtr 的初始值
unsigned long startMutations = *enumState.mutationsPtr;
// 外层的 do/while 循环，用于调用 - countByEnumeratingWithState:objects:count: 方法，获取 C 数组
do {
	unsigned long counter = 0;
	// 内层的 do/while 循环，用于遍历获取到的 C 数组
	do {
		// 判断 mutationsPtr 的值是否有发生变化，如果有则使用 objc_enumerationMutation 函数抛出异常
		if (startMutations != *enumState.mutationsPtr)
			objc_enumerationMutation(l_collection);
		obj = (id)enumState.itemsPtr[counter++]; {
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_q1_yw_3n1px5bb6019pv_7gmtb00000gn_T_main_6938ec_mi_0,obj);
 };
__continue_label_1: ;
	} while (counter < limit);
} while ((limit = ((_WIN_NSUInteger (*) (id, SEL, struct __objcFastEnumerationState *, id *, _WIN_NSUInteger))(void *)objc_msgSend)
	((id)l_collection,
	sel_registerName("countByEnumeratingWithState:objects:count:"),
	&enumState, (id *)__rw_items, (_WIN_NSUInteger)16)));
obj = ((id)0);
__break_label_1: ;
}
else
	obj = ((id)0);
}

其实for in快速遍历是通过两层 do/while 循环来实现的, 外层循环负责调用 - countByEnumeratingWithState:objects:count:方法，获取 C 数组，内层循环则负责遍历获取到的 C 数组, 通过mutationsPtr值的变化来判断集合在遍历过程中是否突变.

通过对NSFastEnumeration的学习，了解了for in快速遍历是如何实现的.

本文作者： Aeron_Xie
最后更新： 2023年03月25日 22:39:55
本文链接： http://aeronxie.github.io/post/a454a4e0.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可，转载请注明出处！