
上一篇詳細拆解了 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 沒有覆寫,實際呼叫到的就是父類的實作。以下凡屬父類實作的地方都會標註出來。
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 之後的信號,自然就拿到變換後的值了。
RACSignal *signalB = [signalA mapReplace:@"A"];

不管原信號送什麼,一律替換成 @“A”。
- (instancetype)mapReplace:(id)object {
return [[self map:^(id _) {
return object;
}] setNameWithFormat:@"[%@] -mapReplace: %@", self.name, [object rac_description]];
}
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 的流程。
使用條件同樣是「信號的值必須是 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 位。
把信號包裝成 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。
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];
}
- (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 值取反。
- (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,信號也就隨之變換。
- (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。
- (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。
- (RACSignal *)any {
return [[self any:^(id x) {
return YES;
}] setNameWithFormat:@"[%@] -any", self.name];
}
等同於 predicate 永遠為真,所以結果固定是一個只送一次 YES 的信號。
- (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。實務上很適合用來確認整段流程是否全程符合某個條件。
- (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 則是為了繼續訂閱。
- (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,這個操作等於什麼都沒做。
- (RACSignal *)retry {
return [[self retry:0] setNameWithFormat:@"[%@] -retry", self.name];
}
retryCount 固定為 0,代表永遠不會 dispose,也就是無限重試。同樣地,對沒有 error 的信號呼叫它不會有任何作用。
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 上再往下游送。
- (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。
- (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,這個方法不會輸出任何值——它會一直在等結束。
- (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。同樣需要原信號完成才會輸出。
- (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: 延後到訂閱時才建立初始值,避免多個訂閱者共用同一個可變物件。
- (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。

傳入一個時間間隔與一個判斷閉包。間隔之內送來的值若 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),把最後一個值補送出去。
- (RACSignal *)throttle:(NSTimeInterval)interval {
return [[self throttle:interval valuesPassingTest:^(id _) {
return YES;
}] setNameWithFormat:@"[%@] -throttle: %f", self.name, (double)interval];
}
predicate 永遠為真,等於對每個值都啟用節流。
- (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 一次。
- (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。
+ (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,也不代表能在奈秒精度上準時觸發。
+ (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,留待下篇繼續。若文中有理解上的錯誤,也歡迎指正。