您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

ReactiveCocoa 原始碼解析:RACSignal 變換操作的底層實作(上)

編輯:iOS 開發基礎

前言

上一篇詳細拆解了 RACSignal 的建立與訂閱流程。讀完底層原始碼會發現一件關鍵的事:ReactiveCocoa 這個 FRP 函式庫,實作響應式的方式是用 Block 閉包串起來,而不是靠 KVO。

在整個 RAC 中,RACSignal 佔了核心位置,而它的變換操作更是 RACStream 流操作的骨幹。多數變換其實都建立在 bind 之上,所以先把 bind 簡化一遍,作為本篇的基礎。

- (RACSignal *)bind:(RACStreamBindBlock (^)(void))block {
    return [RACSignal createSignal:^RACDisposable *(id subscriber) {
        RACStreamBindBlock bindBlock = block();
        [self subscribeNext:^(id x) {
            BOOL stop = NO;
            RACSignal *signal = (RACSignal *)bindBlock(x, &stop);   // (2) 做變換,得到新信號
            if (signal == nil || stop) {
                [subscriber sendCompleted];
            } else {
                [signal subscribeNext:^(id x) {
                    [subscriber sendNext:x];                        // (3) 把新值送給下游
                } error:^(NSError *error) {
                    [subscriber sendError:error];
                } completed:^{}];
            }
        } error:^(NSError *error) {
            [subscriber sendError:error];
        } completed:^{
            [subscriber sendCompleted];
        }];
        return nil;
    }];
}

整個流程可以拆成三步:

  • 變換後的信號被訂閱時,才開始執行 bind 回傳的 block。

  • 在 block 中先訂閱原信號 A,並在訂閱回呼裡做變換(變換規則由外部傳入的 block 決定),得到新信號 B。

  • 再訂閱信號 B,把新的值送給 bind 之後的訂閱者。

也就是說 bind 內部有兩次訂閱:第一次是為了拿到 A 的值,第二次是為了把 B 的新值轉發給下游。

目錄

  • 變換操作

  • 時間操作

一、變換操作

RACSignal 繼承自 RACStream,而 RACStream 上已經定義了一批基礎變換,因此這些方法在 RACSignal 上同樣可用。若 RACSignal 沒有覆寫,實際呼叫到的就是父類的實作。以下凡屬父類實作的地方都會標註出來。

1. map(父類 RACStream)

RACSignal *signalB = [signalA map:^id(NSNumber *value) {
    return @([value intValue] * 10);
}];

- (instancetype)map:(id (^)(id value))block {
    NSCParameterAssert(block != nil);
    Class class = self.class;

    return [[self flattenMap:^(id value) {
        return [class return:block(value)];
    }] setNameWithFormat:@"[%@] -map:", self.name];
}

這裡先記下 self.class,是因為 RACStream 有若干子類會覆寫這些方法,保留原型別才能在回呼中調回正確的實作。以 RACSignal 而言,這裡就是 RACDynamicSignal。可以看到 map 是拿 flattenMap 實作的,只是把 map 的入參閉包塞進 flattenMap 的回傳值裡。

- (instancetype)flattenMap:(RACStream *(^)(id value))block {
    Class class = self.class;
    return [[self bind:^{
        return ^(id value, BOOL *stop) {
            id stream = block(value) ?: [class empty];
            NSCAssert([stream isKindOfClass:RACStream.class],
                      @"Value returned from -flattenMap: is not a stream: %@", stream);
            return stream;
        };
    }] setNameWithFormat:@"[%@] -flattenMap:", self.name];
}

flattenMap 可以視為對 bind 的封裝:bind 的入參是 RACStreamBindBlock,flattenMap 的入參則是「輸入 value、回傳 RACStream」的閉包。若 block 回傳 nil,就改用 [class empty]。

+ (RACSignal *)empty {
#ifdef DEBUG
    // DEBUG 下每次建立新實例,方便各自命名
    return [[[self alloc] init] setNameWithFormat:@"+empty"];
#else
    static id singleton;
    static dispatch_once_t pred;
    dispatch_once(&pred, ^{
        singleton = [[self alloc] init];
    });
    return singleton;
#endif
}
- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
    NSCParameterAssert(subscriber != nil);
    return [RACScheduler.subscriptionScheduler schedule:^{
        [subscriber sendCompleted];
    }];
}

RACEmptySignal 一旦被訂閱,就同步送出 completed。所以 flattenMap 遇到空值時,等於直接通知下游結束。

再看正常路徑:block(value) 把原信號的值往下傳,回傳一個型別與原信號相同的 RACDynamicSignal,內容是 map 閉包計算出來的結果。這個結果成為 bind 閉包的值,下游訂閱 map 之後的信號,自然就拿到變換後的值了。

2. mapReplace:(父類 RACStream)

RACSignal *signalB = [signalA mapReplace:@"A"];

不管原信號送什麼,一律替換成 @“A”。

- (instancetype)mapReplace:(id)object {
    return [[self map:^(id _) {
        return object;
    }] setNameWithFormat:@"[%@] -mapReplace: %@", self.name, [object rac_description]];
}

3. reduceEach:(父類 RACStream)

RACSignal *signalB = [signalA reduceEach:^id(NSNumber *num1, NSNumber *num2) {
    return @([num1 intValue] + [num2 intValue]);
}];

- (instancetype)reduceEach:(id (^)())reduceBlock {
    NSCParameterAssert(reduceBlock != nil);
    __weak RACStream *stream __attribute__((unused)) = self;
    return [[self map:^(RACTuple *t) {
        NSCAssert([t isKindOfClass:RACTuple.class],
                  @"Value from stream %@ is not a tuple: %@", stream, t);
        return [RACBlockTrampoline invokeBlock:reduceBlock withArguments:t];
    }] setNameWithFormat:@"[%@] -reduceEach:", self.name];
}

兩個斷言分別檢查閉包是否為 nil、以及入參是否為 RACTuple。

@interface RACBlockTrampoline : NSObject
@property (nonatomic, readonly, copy) id block;
+ (id)invokeBlock:(id)block withArguments:(RACTuple *)arguments;
@end

RACBlockTrampoline 是一個「持有 block 並動態組出 NSInvocation 去執行」的物件。

- (id)invokeWithArguments:(RACTuple *)arguments {
    SEL selector = [self selectorForArgumentCount:arguments.count];
    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:
                                [self methodSignatureForSelector:selector]];
    invocation.selector = selector;
    invocation.target = self;

    for (NSUInteger i = 0; i < arguments.count; i++) {
        id arg = arguments[i];
        NSInteger argIndex = (NSInteger)(i + 2);   // 前兩個位置留給 self 與 _cmd
        [invocation setArgument:&arg atIndex:argIndex];
    }

    [invocation invoke];
    __unsafe_unretained id returnVal;
    [invocation getReturnValue:&returnVal];
    return returnVal;
}

第一步是算出元組裡有幾個元素,再據此挑選對應的 selector:

- (SEL)selectorForArgumentCount:(NSUInteger)count {
    NSCParameterAssert(count > 0);
    switch (count) {
        case 1:  return @selector(performWith:);
        case 2:  return @selector(performWith::);
        case 3:  return @selector(performWith:::);
        // ... 依此類推
        case 15: return @selector(performWith:::::::::::::::);
    }
    NSCAssert(NO, @"The argument count is too damn high! Only blocks of up to 15 arguments are currently supported.");
    return NULL;
}

也就是說元組元素最多支援 15 個。以兩個元素為例:

- (id)performWith:(id)obj1 :(id)obj2 {
    id (^block)(id, id) = self.block;
    return block(obj1, obj2);
}

對應的 Type Encoding 中,argument0 與 argument1 分別是隱藏參數 self 與 _cmd(型別為 @ 與 :),真正的入參從 argument2 開始,這也是 argIndex 要偏移 2 的原因。

組好 invocation 並 invoke 之後,就等於執行了外部傳入的 reduceBlock,回傳值往上成為 map 閉包的結果,後續就完全走 map 的流程。

4. reduceApply

使用條件同樣是「信號的值必須是 RACTuple」,差別在於:每個元組的第 0 位必須是一個閉包,後面 n 位則是它的入參。

RACSignal *signalA = [RACSignal createSignal:^RACDisposable *(id subscriber) {
    id block = ^id(NSNumber *first, NSNumber *second, NSNumber *third) {
        return @(first.integerValue + second.integerValue * third.integerValue);
    };
    [subscriber sendNext:RACTuplePack(block, @2, @3, @8)];

    [subscriber sendNext:RACTuplePack((id)(^id(NSNumber *x) {
        return @(x.intValue * 10);
    }), @9, @10, @30)];

    [subscriber sendCompleted];
    return [RACDisposable disposableWithBlock:^{ NSLog(@"signal dispose"); }];
}];

RACSignal *signalB = [signalA reduceApply];

輸出:

26   // 2 + 3 * 8
90   // 9 * 10

第二個元組的閉包只有一個參數,後面雖然跟了三個值,但只有第一個生效;唯一硬性規則是「後面參數個數不能少於第 0 位閉包的參數個數」,否則會出錯。

- (RACSignal *)reduceApply {
    return [[self map:^(RACTuple *tuple) {
        NSCAssert([tuple isKindOfClass:RACTuple.class],
                  @"-reduceApply must only be used on a signal of RACTuples. Instead, received: %@", tuple);
        NSCAssert(tuple.count > 1,
                  @"-reduceApply must only be used on a signal of RACTuples, with at least a block in tuple[0] and its first argument in tuple[1]");

        NSMutableArray *tupleArray = [NSMutableArray arrayWithCapacity:tuple.count];
        for (id val in tuple) {
            [tupleArray addObject:val];
        }
        RACTuple *arguments = [RACTuple tupleWithObjectsFromArray:
                               [tupleArray subarrayWithRange:NSMakeRange(1, tupleArray.count - 1)]];
        return [RACBlockTrampoline invokeBlock:tuple[0] withArguments:arguments];
    }] setNameWithFormat:@"[%@] -reduceApply", self.name];
}

效果與 reduceEach 基本等價,只是變換規則一個由外部傳入、一個直接打包在每個元組的第 0 位。

5. materialize

把信號包裝成 RACEvent:

- (RACSignal *)materialize {
    return [[RACSignal createSignal:^(id subscriber) {
        return [self subscribeNext:^(id x) {
            [subscriber sendNext:[RACEvent eventWithValue:x]];
        } error:^(NSError *error) {
            [subscriber sendNext:[RACEvent eventWithError:error]];
            [subscriber sendCompleted];
        } completed:^{
            [subscriber sendNext:RACEvent.completedEvent];
            [subscriber sendCompleted];
        }];
    }] setNameWithFormat:@"[%@] -materialize", self.name];
}

next 包裝成 eventWithValue:、error 包裝成 eventWithError:、completed 包裝成 completedEvent。特別注意:原信號發生 error 或 completed 時,新信號都會補送一次 sendCompleted。

6. dematerialize

materialize 的逆向操作,把 RACEvent 還原成正常的值:

- (RACSignal *)dematerialize {
    return [[self bind:^{
        return ^(RACEvent *event, BOOL *stop) {
            switch (event.eventType) {
                case RACEventTypeCompleted:
                    *stop = YES;
                    return [RACSignal empty];
                case RACEventTypeError:
                    *stop = YES;
                    return [RACSignal error:event.error];
                case RACEventTypeNext:
                    return [RACSignal return:event.value];
            }
        };
    }] setNameWithFormat:@"[%@] -dematerialize", self.name];
}

7. not

- (RACSignal *)not {
    return [[self map:^(NSNumber *value) {
        NSCAssert([value isKindOfClass:NSNumber.class],
                  @"-not must only be used on a signal of NSNumbers. Instead, got: %@", value);
        return @(!value.boolValue);
    }] setNameWithFormat:@"[%@] -not", self.name];
}

只接受 NSNumber,逐一把 BOOL 值取反。

8. and

- (RACSignal *)and {
    return [[self map:^(RACTuple *tuple) {
        NSCAssert([tuple isKindOfClass:RACTuple.class],
                  @"-and must only be used on a signal of RACTuples of NSNumbers. Instead, received: %@", tuple);
        NSCAssert(tuple.count > 0,
                  @"-and must only be used on a signal of RACTuples of NSNumbers, with at least 1 value in the tuple");
        return @([tuple.rac_sequence all:^(NSNumber *number) {
            NSCAssert([number isKindOfClass:NSNumber.class],
                      @"-and ... tuple contains a non-NSNumber value: %@", tuple);
            return number.boolValue;
        }]);
    }] setNameWithFormat:@"[%@] -and", self.name];
}

三個斷言分別確認:入參是 RACTuple、元組至少有 1 個元素、且全部都是 NSNumber。

- (RACSequence *)rac_sequence {
    return [RACTupleSequence sequenceWithTupleBackingArray:self.backingArray offset:0];
}

RACTuple 先轉成 RACTupleSequence(本質上就是一個陣列),後續關於 RACTupleSequence 的細節留待別篇。

- (BOOL)all:(BOOL (^)(id))block {
    NSCParameterAssert(block != NULL);
    NSNumber *result = [self foldLeftWithStart:@YES reduce:^(NSNumber *accumulator, id value) {
        return @(accumulator.boolValue && block(value));
    }];
    return result.boolValue;
}

- (id)foldLeftWithStart:(id)start reduce:(id (^)(id, id))reduce {
    NSCParameterAssert(reduce != NULL);
    if (self.head == nil) return start;
    for (id value in self) {
        start = reduce(start, value);
    }
    return start;
}

foldLeft 就是從左邊開始折疊:初始值為 YES,先與第 1 個元素做 AND,結果再與第 2 個元素做 AND,一路推到最後。每個 RACTuple 都被 map 成一個 BOOL,信號也就隨之變換。

9. or

- (RACSignal *)or {
    return [[self map:^(RACTuple *tuple) {
        NSCAssert([tuple isKindOfClass:RACTuple.class],
                  @"-or must only be used on a signal of RACTuples of NSNumbers. Instead, received: %@", tuple);
        NSCAssert(tuple.count > 0,
                  @"-or must only be used on a signal of RACTuples of NSNumbers, with at least 1 value in the tuple");
        return @([tuple.rac_sequence any:^(NSNumber *number) {
            NSCAssert([number isKindOfClass:NSNumber.class],
                      @"-or ... tuple contains a non-NSNumber value: %@", tuple);
            return number.boolValue;
        }]);
    }] setNameWithFormat:@"[%@] -or", self.name];
}

三個斷言與 and 完全一致,差別只在 any 的實作:

- (BOOL)any:(BOOL (^)(id))block {
    NSCParameterAssert(block != NULL);
    return [self objectPassingTest:block] != nil;
}

- (id)objectPassingTest:(BOOL (^)(id))block {
    NSCParameterAssert(block != NULL);
    return [self filter:block].head;
}

- (instancetype)filter:(BOOL (^)(id value))block {
    NSCParameterAssert(block != nil);
    Class class = self.class;
    return [[self flattenMap:^ id (id value) {
        if (block(value)) {
            return [class return:value];
        } else {
            return class.empty;
        }
    }] setNameWithFormat:@"[%@] -filter:", self.name];
}

any 會逐一對 RACTupleSequence 中的值做 filter:為 YES 就回傳含該值的信號,為 NO 則回傳 empty。一旦找到 YES 就停止判斷並輸出 1;若一路都是 NO,走到最後只能回傳 0。

10. any:

- (RACSignal *)any:(BOOL (^)(id object))predicateBlock {
    NSCParameterAssert(predicateBlock != NULL);
    return [[[self materialize] bind:^{
        return ^(RACEvent *event, BOOL *stop) {
            if (event.finished) {
                *stop = YES;
                return [RACSignal return:@NO];
            }
            if (predicateBlock(event.value)) {
                *stop = YES;
                return [RACSignal return:@YES];
            }
            return [RACSignal empty];
        };
    }] setNameWithFormat:@"[%@] -any:", self.name];
}

原信號先被 materialize 包裝成事件,然後逐一判斷 predicate:命中就送出 YES 並 stop;沒命中就回傳 empty 繼續;直到 event 結束才送出 NO。

11. any

- (RACSignal *)any {
    return [[self any:^(id x) {
        return YES;
    }] setNameWithFormat:@"[%@] -any", self.name];
}

等同於 predicate 永遠為真,所以結果固定是一個只送一次 YES 的信號。

12. all:

- (RACSignal *)all:(BOOL (^)(id object))predicateBlock {
    NSCParameterAssert(predicateBlock != NULL);
    return [[[self materialize] bind:^{
        return ^(RACEvent *event, BOOL *stop) {
            if (event.eventType == RACEventTypeCompleted) {
                *stop = YES;
                return [RACSignal return:@YES];
            }
            if (event.eventType == RACEventTypeError || !predicateBlock(event.value)) {
                *stop = YES;
                return [RACSignal return:@NO];
            }
            return [RACSignal empty];
        };
    }] setNameWithFormat:@"[%@] -all:", self.name];
}

只要中途出現 error,或有任何一個值讓 predicate 回傳 NO,就送出 NO;一路順利直到 completed,才送出 YES。實務上很適合用來確認整段流程是否全程符合某個條件。

13. repeat

- (RACSignal *)repeat {
    return [[RACSignal createSignal:^(id subscriber) {
        return subscribeForever(self,
            ^(id x) {
                [subscriber sendNext:x];
            },
            ^(NSError *error, RACDisposable *disposable) {
                [disposable dispose];
                [subscriber sendError:error];
            },
            ^(RACDisposable *disposable) {
                // Resubscribe.
            });
    }] setNameWithFormat:@"[%@] -repeat", self.name];
}
static RACDisposable *subscribeForever(RACSignal *signal,
                                       void (^next)(id),
                                       void (^error)(NSError *, RACDisposable *),
                                       void (^completed)(RACDisposable *)) {
    next      = [next copy];
    error     = [error copy];
    completed = [completed copy];

    RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable];
    RACSchedulerRecursiveBlock recursiveBlock = ^(void (^recurse)(void)) {
        RACCompoundDisposable *selfDisposable = [RACCompoundDisposable compoundDisposable];
        [compoundDisposable addDisposable:selfDisposable];
        __weak RACDisposable *weakSelfDisposable = selfDisposable;

        RACDisposable *subscriptionDisposable =
            [signal subscribeNext:next
                            error:^(NSError *e) {
                @autoreleasepool {
                    error(e, compoundDisposable);
                    [compoundDisposable removeDisposable:weakSelfDisposable];
                }
                recurse();
            } completed:^{
                @autoreleasepool {
                    completed(compoundDisposable);
                    [compoundDisposable removeDisposable:weakSelfDisposable];
                }
                recurse();
            }];

        [selfDisposable addDisposable:subscriptionDisposable];
    };

    // 先訂閱一次,之後的重新訂閱都走遞迴排程
    recursiveBlock(^{
        RACScheduler *recursiveScheduler = RACScheduler.currentScheduler ?: [RACScheduler scheduler];
        RACDisposable *schedulingDisposable = [recursiveScheduler scheduleRecursiveBlock:recursiveBlock];
        [compoundDisposable addDisposable:schedulingDisposable];
    });

    return compoundDisposable;
}

進入 subscribeForever 後立刻執行 recursiveBlock,在其中訂閱原信號。error 與 completed 執行完自己的回呼之後,都會再呼叫 recurse 重新訂閱——這正是 repeat 的本質。

- (RACDisposable *)schedule:(void (^)(void))block {
    NSCParameterAssert(block != NULL);
    RACDisposable *disposable = [[RACDisposable alloc] init];
    dispatch_async(self.queue, ^{
        if (disposable.disposed) return;
        [self performAsCurrentScheduler:block];
    });
    return disposable;
}

只要原信號沒有 dispose,dispatch_async 就會持續執行 block,信號也就無限循環下去。error 之所以要呼叫 recurse,是為了讓 dispose 生效、終止循環;completed 呼叫 recurse 則是為了繼續訂閱。

14. retry:

- (RACSignal *)retry:(NSInteger)retryCount {
    return [[RACSignal createSignal:^(id subscriber) {
        __block NSInteger currentRetryCount = 0;
        return subscribeForever(self,
            ^(id x) {
                [subscriber sendNext:x];
            },
            ^(NSError *error, RACDisposable *disposable) {
                if (retryCount == 0 || currentRetryCount < retryCount) {
                    currentRetryCount++;
                    return;   // Resubscribe.
                }
                [disposable dispose];
                [subscriber sendError:error];
            },
            ^(RACDisposable *disposable) {
                [disposable dispose];
                [subscriber sendCompleted];
            });
    }] setNameWithFormat:@"[%@] -retry: %lu", self.name, (unsigned long)retryCount];
}

與 repeat 的差别只在多了一個計數器:超過 retryCount 之後就在 error 中 dispose,中斷無限循環。所以 retry: 的效果是「出錯時重試 n 次,仍失敗才把錯誤拋給下游」。若原信號本身沒有 error,這個操作等於什麼都沒做。

15. retry

- (RACSignal *)retry {
    return [[self retry:0] setNameWithFormat:@"[%@] -retry", self.name];
}

retryCount 固定為 0,代表永遠不會 dispose,也就是無限重試。同樣地,對沒有 error 的信號呼叫它不會有任何作用。

16. scanWithStart:reduceWithIndex:(父類 RACStream)

RACSignal *signalA = [RACSignal createSignal:^RACDisposable *(id subscriber) {
    [subscriber sendNext:@1];
    [subscriber sendNext:@1];
    [subscriber sendNext:@4];
    return [RACDisposable disposableWithBlock:^{}];
}];

RACSignal *signalB = [signalA scanWithStart:@(2) reduceWithIndex:^id(NSNumber *running, NSNumber *next, NSUInteger index) {
    return @(running.intValue * next.intValue + index);
}];
2    // 2 * 1 + 0
3    // 2 * 1 + 1
14   // 3 * 4 + 2

- (instancetype)scanWithStart:(id)startingValue reduceWithIndex:(id (^)(id, id, NSUInteger))reduceBlock {
    NSCParameterAssert(reduceBlock != nil);
    Class class = self.class;
    return [[self bind:^{
        __block id running = startingValue;
        __block NSUInteger index = 0;
        return ^(id value, BOOL *stop) {
            running = reduceBlock(running, value, index++);
            return [class return:running];
        };
    }] setNameWithFormat:@"[%@] -scanWithStart: %@ reduceWithIndex:", self.name, [startingValue rac_description]];
}

由初始值、變換函式與自增的 index 三者組成,每個值都會累疊到 running 上再往下游送。

17. scanWithStart:reduce:(父類 RACStream)

- (instancetype)scanWithStart:(id)startingValue reduce:(id (^)(id running, id next))reduceBlock {
    NSCParameterAssert(reduceBlock != nil);
    return [[self scanWithStart:startingValue reduceWithIndex:^(id running, id next, NSUInteger index) {
        return reduceBlock(running, next);
    }] setNameWithFormat:@"[%@] -scanWithStart: %@ reduce:", self.name, [startingValue rac_description]];
}

就是上一個方法的縮略版,只是不使用 index。

18. aggregateWithStart:reduceWithIndex:

- (RACSignal *)aggregateWithStart:(id)start reduceWithIndex:(id (^)(id, id, NSUInteger))reduceBlock {
    return [[[[self scanWithStart:start reduceWithIndex:reduceBlock]
              startWith:start]
             takeLast:1]
            setNameWithFormat:@"[%@] -aggregateWithStart: %@ reduceWithIndex:", self.name, [start rac_description]];
}

aggregate 是「聚合」的意思,最終只會吐出一個值。它在 scan 之後多做了兩件事:startWith: 把初始值補進串流開頭,takeLast:1 只取最後一個。要留意的是,若原信號沒有送出 completed,這個方法不會輸出任何值——它會一直在等結束。

19. aggregateWithStart:reduce:

- (RACSignal *)aggregateWithStart:(id)start reduce:(id (^)(id running, id next))reduceBlock {
    return [[[[self scanWithStart:start reduce:reduceBlock]
              startWith:start]
             takeLast:1]
            setNameWithFormat:@"[%@] -aggregateWithStart: %@ reduce:", self.name, [start rac_description]];
}

同上,只是不使用 index。同樣需要原信號完成才會輸出。

20. aggregateWithStartFactory:reduce:

- (RACSignal *)aggregateWithStartFactory:(id (^)(void))startFactory reduce:(id (^)(id running, id next))reduceBlock {
    NSCParameterAssert(startFactory != NULL);
    NSCParameterAssert(reduceBlock != NULL);
    return [[RACSignal defer:^{
        return [self aggregateWithStart:startFactory() reduce:reduceBlock];
    }] setNameWithFormat:@"[%@] -aggregateWithStartFactory:reduce:", self.name];
}

多了一個「產生初始值」的工廠閉包,並用 defer: 延後到訂閱時才建立初始值,避免多個訂閱者共用同一個可變物件。

21. collect

- (RACSignal *)collect {
    return [[self aggregateWithStartFactory:^{
        return [[NSMutableArray alloc] init];
    } reduce:^(NSMutableArray *collectedValues, id x) {
        [collectedValues addObject:(x ?: NSNull.null)];
        return collectedValues;
    }] setNameWithFormat:@"[%@] -collect", self.name];
}

把所有值收集進 NSMutableArray,完成後一次送出。注意 nil 被替換成 NSNull,因為陣列不能放 nil。

二、時間操作

1. throttle:valuesPassingTest:

傳入一個時間間隔與一個判斷閉包。間隔之內送來的值若 predicate 為真,會被「吞掉」,直到該間隔內沒有新值出現,才把最後一個值放行。

- (RACSignal *)throttle:(NSTimeInterval)interval valuesPassingTest:(BOOL (^)(id next))predicate {
    NSCParameterAssert(interval >= 0);
    NSCParameterAssert(predicate != nil);

    return [[RACSignal createSignal:^(id subscriber) {
        RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable];
        RACScheduler *scheduler = [RACScheduler scheduler];
        __block id nextValue = nil;
        __block BOOL hasNextValue = NO;
        RACSerialDisposable *nextDisposable = [[RACSerialDisposable alloc] init];

        void (^flushNext)(BOOL send) = ^(BOOL send) {
            @synchronized (compoundDisposable) {
                [nextDisposable.disposable dispose];
                if (!hasNextValue) return;
                if (send) [subscriber sendNext:nextValue];
                nextValue = nil;
                hasNextValue = NO;
            }
        };

        RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) {
            RACScheduler *delayScheduler = RACScheduler.currentScheduler ?: scheduler;
            BOOL shouldThrottle = predicate(x);
            @synchronized (compoundDisposable) {
                flushNext(NO);
                if (!shouldThrottle) {
                    [subscriber sendNext:x];
                    return;
                }
                nextValue = x;
                hasNextValue = YES;
                nextDisposable.disposable = [delayScheduler afterDelay:interval schedule:^{
                    flushNext(YES);
                }];
            }
        } error:^(NSError *error) {
            [compoundDisposable dispose];
            [subscriber sendError:error];
        } completed:^{
            flushNext(YES);
            [subscriber sendCompleted];
        }];

        [compoundDisposable addDisposable:subscriptionDisposable];
        return compoundDisposable;
    }] setNameWithFormat:@"[%@] -throttle: %f valuesPassingTest:", self.name, (double)interval];
}

兩個斷言分別檢查間隔不能為負、predicate 不能為 nil。以 RACCompoundDisposable 作為 @synchronized 的鎖物件,是因為所有 disposable 都掛在它身上。

subscribeNext 裡實際做了四件事:

  • 先呼叫 flushNext(NO),把上一個待送的值取消。

  • 判斷 predicate(x) 這個「閥門」是否要節流。

  • 若需要節流,把值存進 nextValue 並標記 hasNextValue。

  • 開啟一個延遲 interval 的排程,時間到才呼叫 flushNext(YES)。

- (RACDisposable *)afterDelay:(NSTimeInterval)delay schedule:(void (^)(void))block {
    return [self after:[NSDate dateWithTimeIntervalSinceNow:delay] schedule:block];
}

- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block {
    NSCParameterAssert(date != nil);
    NSCParameterAssert(block != NULL);
    RACDisposable *disposable = [[RACDisposable alloc] init];
    dispatch_after([self.class wallTimeWithDate:date], self.queue, ^{
        if (disposable.disposed) return;
        [self performAsCurrentScheduler:block];
    });
    return disposable;
}

關鍵就在 if (disposable.disposed) return; 這一行:若 interval 之內又來了新值,前一個排程早已被 dispose,於是直接 return,那個值就被丟掉了。

兩個容易忽略的細節:一是恰好落在 interval 那一刻抵達的新值,舊值一樣會被丟棄,必須「間隔內完全沒有新值」才算通過;二是原信號 completed 時會立刻 flushNext(YES),把最後一個值補送出去。

2. throttle:

- (RACSignal *)throttle:(NSTimeInterval)interval {
    return [[self throttle:interval valuesPassingTest:^(id _) {
        return YES;
    }] setNameWithFormat:@"[%@] -throttle: %f", self.name, (double)interval];
}

predicate 永遠為真,等於對每個值都啟用節流。

3. bufferWithTime:onScheduler:

- (RACSignal *)bufferWithTime:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler {
    NSCParameterAssert(scheduler != nil);
    NSCParameterAssert(scheduler != RACScheduler.immediateScheduler);

    return [[RACSignal createSignal:^(id subscriber) {
        RACSerialDisposable *timerDisposable = [[RACSerialDisposable alloc] init];
        NSMutableArray *values = [NSMutableArray array];

        void (^flushValues)() = ^{
            @synchronized (values) {
                [timerDisposable.disposable dispose];
                if (values.count == 0) return;
                RACTuple *tuple = [RACTuple tupleWithObjectsFromArray:values];
                [values removeAllObjects];
                [subscriber sendNext:tuple];
            }
        };

        RACDisposable *selfDisposable = [self subscribeNext:^(id x) {
            @synchronized (values) {
                if (values.count == 0) {
                    timerDisposable.disposable = [scheduler afterDelay:interval schedule:flushValues];
                }
                [values addObject:x ?: RACTupleNil.tupleNil];
            }
        } error:^(NSError *error) {
            [subscriber sendError:error];
        } completed:^{
            flushValues();
            [subscriber sendCompleted];
        }];

        return [RACDisposable disposableWithBlock:^{
            [selfDisposable dispose];
            [timerDisposable dispose];
        }];
    }] setNameWithFormat:@"[%@] -bufferWithTime: %f onScheduler: %@", self.name, (double)interval, scheduler];
}

兩個斷言都在保護 scheduler:不能為 nil,也不能是 immediate 型別(這個方法本來就需要「緩衝」的語意)。邏輯上,陣列為空時啟動計時器,其後的值陸續堆進陣列;時間到就把整批打包成一個 RACTuple 送出並清空。原信號完成時同樣會立即 flush 一次。

4. delay:

- (RACSignal *)delay:(NSTimeInterval)interval {
    return [[RACSignal createSignal:^(id subscriber) {
        RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
        // 即使可能用不到,也要先建立 scheduler,確保排程的 block 是序列執行的
        RACScheduler *scheduler = [RACScheduler scheduler];

        void (^schedule)(dispatch_block_t) = ^(dispatch_block_t block) {
            RACScheduler *delayScheduler = RACScheduler.currentScheduler ?: scheduler;
            RACDisposable *schedulerDisposable = [delayScheduler afterDelay:interval schedule:block];
            [disposable addDisposable:schedulerDisposable];
        };

        RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) {
            schedule(^{
                [subscriber sendNext:x];
            });
        } error:^(NSError *error) {
            [subscriber sendError:error];
        } completed:^{
            schedule(^{
                [subscriber sendCompleted];
            });
        }];

        [disposable addDisposable:subscriptionDisposable];
        return disposable;
    }] setNameWithFormat:@"[%@] -delay: %f", self.name, (double)interval];
}

結構與前面幾個一致,唯一差別在 subscribeNext 裡只是單純把送值包進 schedule,延遲 interval 之後才真正 sendNext。

5. interval:onScheduler:withLeeway:

+ (RACSignal *)interval:(NSTimeInterval)interval
             onScheduler:(RACScheduler *)scheduler
               withLeeway:(NSTimeInterval)leeway {
    NSCParameterAssert(scheduler != nil);
    NSCParameterAssert(scheduler != RACScheduler.immediateScheduler);

    return [[RACSignal createSignal:^(id subscriber) {
        return [scheduler after:[NSDate dateWithTimeIntervalSinceNow:interval]
                 repeatingEvery:interval
                     withLeeway:leeway
                       schedule:^{
            [subscriber sendNext:[NSDate date]];
        }];
    }] setNameWithFormat:@"+interval: %f onScheduler: %@ withLeeway: %f", (double)interval, scheduler, (double)leeway];
}
- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval
              withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block {
    NSCParameterAssert(date != nil);
    NSCParameterAssert(interval > 0.0 && interval < INT64_MAX / NSEC_PER_SEC);
    NSCParameterAssert(leeway >= 0.0 && leeway < INT64_MAX / NSEC_PER_SEC);
    NSCParameterAssert(block != NULL);

    uint64_t intervalInNanoSecs = (uint64_t)(interval * NSEC_PER_SEC);
    uint64_t leewayInNanoSecs   = (uint64_t)(leeway   * NSEC_PER_SEC);

    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, self.queue);
    dispatch_source_set_timer(timer, [self.class wallTimeWithDate:date],
                              intervalInNanoSecs, leewayInNanoSecs);
    dispatch_source_set_event_handler(timer, block);
    dispatch_resume(timer);

    return [RACDisposable disposableWithBlock:^{
        dispatch_source_cancel(timer);
    }];
}

底層就是 GCD 的 dispatch source timer。leeway 是給系統的「容許誤差」,讓核心能把相近的定時事件合併處理、減少喚醒次數,實務上建議給一個合理值。不過即使填 0,也不代表能在奈秒精度上準時觸發。

6. interval:onScheduler:

+ (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler {
    return [[RACSignal interval:interval onScheduler:scheduler withLeeway:0.0]
            setNameWithFormat:@"+interval: %f onScheduler: %@", (double)interval, scheduler];
}

結語

原本想在一篇之內把所有 RACSignal 操作都拆解完,但數量實在太多,只好分篇進行。剩下還有用於組合多個信號的操作、冷熱信號轉換,以及更高階的 operators,留待下篇繼續。若文中有理解上的錯誤,也歡迎指正。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved