Ios 从givven索引开始枚举NSArray双向搜索（无环绕）

例如。我有一个包含15个对象的数组。我想从给定的索引开始枚举。假设从指数5开始，然后是上面的指数，下面的指数，上面的指数，下面的指数等等。。。我不想让它卷土重来，而是停下来，朝着未知的方向继续前进

因此，在我的示例中，索引的顺序是。 5、6、4、7、3、8、2、9、1、10、0、11、12、13、14

---

如何做到这一点？

它回答了这个问题，但不是特别干燥，创建子阵列使其效率低于应有的效率

@implementation NSArray (Extensions)

- (void)enumerateFromIndex:(NSUInteger)index goBothWaysUsingBlock:(void (^)(id obj, NSUInteger idx, BOOL *stop))block
{
    NSArray *lastObjects = [self subarrayFromIndex:index];
    NSArray *firstObjects = [self subarrayToIndex:index];
    int currentIndex = 0;

    NSEnumerator *firstObjectsEnumerator = [firstObjects reverseObjectEnumerator];
    NSEnumerator *lastObjectsEnumerator = [lastObjects objectEnumerator];
    BOOL shouldStop = NO;
    NSUInteger numberOfIndexesEnumerated = 0;
    id obj = nil;

    while(numberOfIndexesEnumerated < self.count)
    {
        if (obj = [lastObjectsEnumerator nextObject])
        {
            NSInteger objIndex = [self indexOfObject:obj];
            block(obj, objIndex, &shouldStop);
            currentIndex++;
            numberOfIndexesEnumerated++;
        }
        if (shouldStop)
        {
            return;
        }

        if (obj = [firstObjectsEnumerator nextObject])
        {
            NSInteger objIndex = [self indexOfObject:obj];
            block(obj, objIndex, &shouldStop);
            currentIndex++;
            numberOfIndexesEnumerated++;
        }
        if (shouldStop)
        {
            return;
        }
    }
}

@end

@实现NSArray（扩展）
-（void）enumerateFromIndex:（nsInteger）索引goBothWaysUsingBlock:（void（^）（id obj，nsInteger idx，BOOL*stop））块
{
NSArray*lastObjects=[self subrayFromIndex:index]；
NSArray*firstObjects=[自子阵列索引：索引]；
int currentIndex=0；
N分子*firstObjectsEnumerator=[FirstObjectsReverseObjectEnumerator]；
NSEnumerator*lastObjectsEnumerator=[LastObjectsObjectEnumerator]；
BOOL shouldStop=否；
NSUInteger numberOfIndexesEnumerated=0；
id obj=nil；
while（numberOfIndexesEnumerated

---

这个答案归功于@jalmas，这里有一个更紧凑的实现，不需要创建子阵列：

@implementation NSArray (Extensions)

- (void)enumerateFromIndex:(NSUInteger)index goBothWaysUsingBlock:(void (^)(id obj, NSUInteger idx, BOOL *stop))block
{
    BOOL stop = NO;
    for (NSUInteger i = 0; i < self.count && !stop; i++) {
        if (index + i < self.count) {
            block([self objectAtIndex:index + i], index + i, &stop);
        }
        if (i != 0 && !stop && i <= index) {
            block([self objectAtIndex:index - i], index - i, &stop);
        }
    }
}

@end

@实现NSArray（扩展）
-（void）enumerateFromIndex:（nsInteger）索引goBothWaysUsingBlock:（void（^）（id obj，nsInteger idx，BOOL*stop））块
{
布尔停止=否；
对于（i=0；i-（void）enumerateArray:（NSArray*）数组在BothDirectionsFromIndex:（int）startIndex中
{
对于（int i=0；i 0&&indexBefore>-1）| | indexAfter>array.count-1）
{
指数=指数之前；
if（indexAfter>array.count-1）
index-=indexAfter-array.count；；
}
id item=[array objectAtIndex:index]；
//你想怎么处理这里的物品
}
}

您想让它“环绕”阵列的末端，还是在未探测方向停止并继续？好问题！对我来说，我只能考虑使用后一个（在未探测方向停止并继续），但当然也会用到另一个。也许我会就此提出另一个问题。我已经为总结发表了自己的帖子：

-(void)enumerateArray:(NSArray *)array inBothDirectionsFromIndex:(int)startIndex
{
    for (int i=0; i<array.count; i++)
    {
        int index = startIndex;
        int indexAfter = startIndex + round(i/2.f) + (i%2 ? 0 : 1);
        int indexBefore = startIndex - round(i/2.f);

        if ((i%2 && indexAfter < array.count) || indexBefore < 0)
        {
            index = indexAfter;
            if (indexBefore < 0)
                index -= indexBefore + 1;
        }
        else if ((i > 0 && indexBefore > -1) || indexAfter > array.count-1)
        {
            index = indexBefore;
            if (indexAfter > array.count-1)
                index -= indexAfter - array.count;;
        }

        id item = [array objectAtIndex:index];

        //Do what you want with the item here

    }
}