ReactiveCocoa 中 RACSignal 所有變換操作底層實現(xiàn)分析(中)

前言

緊接著上篇的源碼實現(xiàn)分析，繼續(xù)分析RACSignal的變換操作的底層實現(xiàn)。

目錄

1.過濾操作
2.組合操作

一. 過濾操作

過濾操作也屬于一種變換，根據(jù)過濾條件，過濾出符合條件的值。變換出來的新的信號是原信號的一個子集。

  1. filter: (在父類RACStream中定義的)

這個filter:操作在any:的實現(xiàn)中用到過了。

- (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];
}

filter:中傳入一個閉包，是用篩選的條件。如果滿足篩選條件的即返回原信號的值，否則原信號的值被“吞”掉，返回空的信號。這個變換主要是用flattenMap的。

  1. ignoreValues
- (RACSignal *)ignoreValues {
    return [[self filter:^(id _) {
        return NO;
    }] setNameWithFormat:@"[%@] -ignoreValues", self.name];
}

由上面filter的實現(xiàn)，這里把篩選判斷條件永遠的傳入NO，那么原信號的值都會被變換成empty信號，故變換之后的信號為空信號。

  1. ignore: (在父類RACStream中定義的)
- (instancetype)ignore:(id)value {
    return [[self filter:^ BOOL (id innerValue) {
        return innerValue != value && ![innerValue isEqual:value];
    }] setNameWithFormat:@"[%@] -ignore: %@", self.name, [value rac_description]];
}

ignore:的實現(xiàn)還是由filter:實現(xiàn)的。傳入的篩選判斷條件是一個值，當(dāng)原信號發(fā)送的值中是這個值的時候，就替換成空信號。

  1. distinctUntilChanged (在父類RACStream中定義的)
- (instancetype)distinctUntilChanged {
    Class class = self.class;

    return [[self bind:^{
        __block id lastValue = nil;
        __block BOOL initial = YES;

        return ^(id x, BOOL *stop) {
            if (!initial && (lastValue == x || [x isEqual:lastValue])) return [class empty];

            initial = NO;
            lastValue = x;
            return [class return:x];
        };
    }] setNameWithFormat:@"[%@] -distinctUntilChanged", self.name];
}

distinctUntilChanged的實現(xiàn)是用bind來完成的。每次變換中都記錄一下原信號上一次發(fā)送過來的值，并與這一次進行比較，如果是相同的值，就“吞”掉，返回empty信號。只有和原信號上一次發(fā)送的值不同，變換后的新信號才把這個值發(fā)送出來。

關(guān)于distinctUntilChanged，這里關(guān)注的是兩兩信號之間的值是否不同，有時候我們可能需要一個類似于NSSet的信號集，distinctUntilChanged就無法滿足了。在ReactiveCocoa 2.5的這個版本也并沒有向我們提供distinct的變換函數(shù)。

我們可以自己實現(xiàn)類似的變換。實現(xiàn)思路也不難，可以把之前每次發(fā)送過來的信號都用數(shù)組存起來，新來的信號都去數(shù)組里面查找一遍，如果找不到，就把這個值發(fā)送出去，如果找到了，就返回empty信號。效果如上圖。

  1. take: (在父類RACStream中定義的)
- (instancetype)take:(NSUInteger)count {
    Class class = self.class;

    if (count == 0) return class.empty;

    return [[self bind:^{
        __block NSUInteger taken = 0;

        return ^ id (id value, BOOL *stop) {
            if (taken < count) {
                ++taken;
                if (taken == count) *stop = YES;
                return [class return:value];
            } else {
                return nil;
            }
        };
    }] setNameWithFormat:@"[%@] -take: %lu", self.name, (unsigned long)count];
}

take:實現(xiàn)也非常簡單，借助bind函數(shù)來實現(xiàn)的。入?yún)⒌腸ount是原信號取值的個數(shù)。在bind的閉包中，taken計數(shù)從0開始取原信號的值，當(dāng)taken取到count個數(shù)的時候，就停止取值。

在take:的基礎(chǔ)上我們還可以繼續(xù)改造出新的變換方式。比如說，想取原信號中執(zhí)行的第幾個值。類似于elementAt的操作。這個操作在ReactiveCocoa 2.5的這個版本也并沒有直接向我們提供出來。

其實實現(xiàn)很簡單，只需要判斷taken是否等于我們要取的那個位置就可以了，等于的時候把原信號的值發(fā)送出來，并*stop = YES。

// 我自己增加實現(xiàn)的方法

- (instancetype)elementAt:(NSUInteger)index {
    Class class = self.class;

    return [[self bind:^{
        __block NSUInteger taken = 0;

        return ^ id (id value, BOOL *stop) {
            if (index == 0) {
                *stop = YES;
                return [class return:value];
            }
            if (taken == index) {
                *stop = YES;
                return [class return:value];
            } else if (taken < index){
                taken ++;
                return [class empty];
            }else {
                return nil;
            }
        };
    }] setNameWithFormat:@"[%@] -elementAt: %lu", self.name, (unsigned long)index];
}
  1. takeLast:
- (RACSignal *)takeLast:(NSUInteger)count {
    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        NSMutableArray *valuesTaken = [NSMutableArray arrayWithCapacity:count];
        return [self subscribeNext:^(id x) {
            [valuesTaken addObject:x ? : RACTupleNil.tupleNil];

            while (valuesTaken.count > count) {
                [valuesTaken removeObjectAtIndex:0];
            }
        } error:^(NSError *error) {
            [subscriber sendError:error];
        } completed:^{
            for (id value in valuesTaken) {
                [subscriber sendNext:value == RACTupleNil.tupleNil ? nil : value];
            }

            [subscriber sendCompleted];
        }];
    }] setNameWithFormat:@"[%@] -takeLast: %lu", self.name, (unsigned long)count];
}

takeLast:的實現(xiàn)也是按照套路來。先創(chuàng)建一個新信號，return的時候訂閱原信號。在函數(shù)內(nèi)部用一個valuesTaken來保存原信號發(fā)送過來的值，原信號發(fā)多少，就存多少，直到個數(shù)溢出入?yún)⒔o定的count，就溢出數(shù)組第0位。這樣能保證數(shù)組里面始終都裝著最后count個原信號的值。

當(dāng)原信號發(fā)送completed信號的時候，把數(shù)組里面存的值都sendNext出去。這里要注意的也是該變換發(fā)送信號的時機。如果原信號一直沒有completed，那么takeLast:就一直沒法發(fā)出任何信號來。

  1. takeUntilBlock: (在父類RACStream中定義的)
- (instancetype)takeUntilBlock:(BOOL (^)(id x))predicate {
    NSCParameterAssert(predicate != nil);

    Class class = self.class;

    return [[self bind:^{
        return ^ id (id value, BOOL *stop) {
            if (predicate(value)) return nil;

            return [class return:value];
        };
    }] setNameWithFormat:@"[%@] -takeUntilBlock:", self.name];
}

takeUntilBlock:是根據(jù)傳入的predicate閉包作為篩選條件的。一旦predicate( )閉包滿足條件，那么新信號停止發(fā)送新信號，因為它被置為nil了。和函數(shù)名的意思是一樣的，take原信號的值，Until直到閉包滿足條件。

  1. takeWhileBlock: (在父類RACStream中定義的)
- (instancetype)takeWhileBlock:(BOOL (^)(id x))predicate {
    NSCParameterAssert(predicate != nil);

    return [[self takeUntilBlock:^ BOOL (id x) {
        return !predicate(x);
    }] setNameWithFormat:@"[%@] -takeWhileBlock:", self.name];
}

takeWhileBlock:的信號集是takeUntilBlock:的信號集的補集。全集是原信號。takeWhileBlock:底層還是調(diào)用takeUntilBlock:，只不過判斷條件的是不滿足predicate( )閉包的集合。

  1. takeUntil:
- (RACSignal *)takeUntil:(RACSignal *)signalTrigger {
    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
        void (^triggerCompletion)(void) = ^{
            [disposable dispose];
            [subscriber sendCompleted];
        };

        RACDisposable *triggerDisposable = [signalTrigger subscribeNext:^(id _) {
            triggerCompletion();
        } completed:^{
            triggerCompletion();
        }];

        [disposable addDisposable:triggerDisposable];

        if (!disposable.disposed) {
            RACDisposable *selfDisposable = [self subscribeNext:^(id x) {
                [subscriber sendNext:x];
            } error:^(NSError *error) {
                [subscriber sendError:error];
            } completed:^{
                [disposable dispose];
                [subscriber sendCompleted];
            }];

            [disposable addDisposable:selfDisposable];
        }

        return disposable;
    }] setNameWithFormat:@"[%@] -takeUntil: %@", self.name, signalTrigger];
}

takeUntil:的實現(xiàn)也是“經(jīng)典套路”——return一個新信號，在新信號中訂閱原信號。入?yún)⑹且粋€信號signalTrigger，這個信號是一個Trigger。一旦signalTrigger發(fā)出第一個信號，就會觸發(fā)triggerCompletion( )閉包，在這個閉包中，會調(diào)用triggerCompletion( )閉包。

  void (^triggerCompletion)(void) = ^{
   [disposable dispose];
   [subscriber sendCompleted];
  };

一旦調(diào)用了triggerCompletion( )閉包，就會把原信號取消訂閱，并給變換的新的信號訂閱者sendCompleted。

如果入?yún)ignalTrigger一直沒有sendNext，那么原信號就會一直sendNext:。

  1. takeUntilReplacement:
- (RACSignal *)takeUntilReplacement:(RACSignal *)replacement {
    return [RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        RACSerialDisposable *selfDisposable = [[RACSerialDisposable alloc] init];

        RACDisposable *replacementDisposable = [replacement subscribeNext:^(id x) {
            [selfDisposable dispose];
            [subscriber sendNext:x];
        } error:^(NSError *error) {
            [selfDisposable dispose];
            [subscriber sendError:error];
        } completed:^{
            [selfDisposable dispose];
            [subscriber sendCompleted];
        }];

        if (!selfDisposable.disposed) {
            selfDisposable.disposable = [[self
                                          concat:[RACSignal never]]
                                         subscribe:subscriber];
        }

        return [RACDisposable disposableWithBlock:^{
            [selfDisposable dispose];
            [replacementDisposable dispose];
        }];
    }];
}

原信號concat:了一個[RACSignal never]信號，這樣原信號就一直不會disposed，會一直等待replacement信號的到來。
控制selfDisposable是否被dispose，控制權(quán)來自于入?yún)⒌膔eplacement信號，一旦replacement信號sendNext，那么原信號就會取消訂閱，接下來的事情就會交給replacement信號了。
變換后的新信號sendNext，sendError，sendCompleted全部都由replacement信號來發(fā)送，最終新信號完成的時刻也是replacement信號完成的時刻。

  1. skip: (在父類RACStream中定義的)
- (instancetype)skip:(NSUInteger)skipCount {
    Class class = self.class;

    return [[self bind:^{
        __block NSUInteger skipped = 0;

        return ^(id value, BOOL *stop) {
            if (skipped >= skipCount) return [class return:value];

            skipped++;
            return class.empty;
        };
    }] setNameWithFormat:@"[%@] -skip: %lu", self.name, (unsigned long)skipCount];
}

skip:信號集和take:信號集是補集關(guān)系，全集是原信號。take:是取原信號的前count個信號，而skip:是從原信號第count + 1位開始取信號。

skipped是一個游標，每次原信號發(fā)送一個值，就比較它和入?yún)kipCount的大小。如果不比skipCount大，說明還需要跳過，所以就返回empty信號，否則就把原信號的值發(fā)送出來。

通過類比take系列方法，可以發(fā)現(xiàn)在ReactiveCocoa 2.5的這個版本也并沒有向我們提供skipLast:的變換函數(shù)。這個變換函數(shù)的實現(xiàn)過程也不難，我們可以類比takeLast:來實現(xiàn)。

實現(xiàn)的思路也不難，原信號每次發(fā)送過來的值，都用一個數(shù)組存儲起來。skipLast:是想去掉原信號最末尾的count個信號。

我們先來分析一下：假設(shè)原信號有n個信號，從0 - (n-1)，去掉最后的count個，前面還剩n - count個信號。那么從 原信號的第 count + 1位的信號開始發(fā)送，到原信號結(jié)束，這樣中間就正好是發(fā)送了 n - count 個信號。

分析清楚后，代碼就很容易了：

// 我自己增加實現(xiàn)的方法
- (RACSignal *)skipLast:(NSUInteger)count {
    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        NSMutableArray *valuesTaken = [NSMutableArray arrayWithCapacity:count];
        return [self subscribeNext:^(id x) {
            [valuesTaken addObject:x ? : RACTupleNil.tupleNil];

            while (valuesTaken.count > count) {
                [subscriber sendNext:valuesTaken[0] == RACTupleNil.tupleNil ? nil : valuesTaken[0]];
                [valuesTaken removeObjectAtIndex:0];
            }
        } error:^(NSError *error) {
            [subscriber sendError:error];
        } completed:^{            
            [subscriber sendCompleted];
        }];
    }] setNameWithFormat:@"[%@] -skipLast: %lu", self.name, (unsigned long)count];
}

原信號每發(fā)送過來一個信號就存入數(shù)組，當(dāng)數(shù)組里面的個數(shù)大于count的時候，就是需要我們發(fā)送信號的時候，這個時候每次都把數(shù)組里面第0位發(fā)送出去即可，數(shù)組維護了一個FIFO的隊列。這樣就實現(xiàn)了skipLast:的效果了。

  1. skipUntilBlock: (在父類RACStream中定義的)
- (instancetype)skipUntilBlock:(BOOL (^)(id x))predicate {
    NSCParameterAssert(predicate != nil);

    Class class = self.class;

    return [[self bind:^{
        __block BOOL skipping = YES;

        return ^ id (id value, BOOL *stop) {
            if (skipping) {
                if (predicate(value)) {
                    skipping = NO;
                } else {
                    return class.empty;
                }
            }

            return [class return:value];
        };
    }] setNameWithFormat:@"[%@] -skipUntilBlock:", self.name];
}

skipUntilBlock: 的實現(xiàn)可以類比takeUntilBlock: 的實現(xiàn)。

skipUntilBlock: 是根據(jù)傳入的predicate閉包作為篩選條件的。一旦predicate( )閉包滿足條件，那么skipping = NO。skipping為NO，以后原信號發(fā)送的每個值都原封不動的發(fā)送出去。predicate( )閉包不滿足條件的時候，即會一直skip原信號的值。和函數(shù)名的意思是一樣的，skip原信號的值，Until直到閉包滿足條件，就不再skip了。

  1. skipWhileBlock: (在父類RACStream中定義的)
- (instancetype)skipWhileBlock:(BOOL (^)(id x))predicate {
    NSCParameterAssert(predicate != nil);

    return [[self skipUntilBlock:^ BOOL (id x) {
        return !predicate(x);
    }] setNameWithFormat:@"[%@] -skipWhileBlock:", self.name];
}

skipWhileBlock:的信號集是skipUntilBlock:的信號集的補集。全集是原信號。skipWhileBlock:底層還是調(diào)用skipUntilBlock:，只不過判斷條件的是不滿足predicate( )閉包的集合。

到這里skip系列方法就結(jié)束了，對比take系列的方法，少了2個方法，在ReactiveCocoa 2.5的這個版本中 takeUntil: 和 takeUntilReplacement:這兩個方法沒有與之對應(yīng)的skip方法。

// 我自己增加實現(xiàn)的方法
- (RACSignal *)skipUntil:(RACSignal *)signalTrigger {
    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];

        __block BOOL sendTrigger = NO;

        void (^triggerCompletion)(void) = ^{
            sendTrigger = YES;
        };

        RACDisposable *triggerDisposable = [signalTrigger subscribeNext:^(id _) {
            triggerCompletion();
        } completed:^{
            triggerCompletion();
        }];

        [disposable addDisposable:triggerDisposable];

        if (!disposable.disposed) {
            RACDisposable *selfDisposable = [self subscribeNext:^(id x) {

                if (sendTrigger) {
                    [subscriber sendNext:x];
                }

            } error:^(NSError *error) {
                [subscriber sendError:error];
            } completed:^{
                [disposable dispose];
                [subscriber sendCompleted];
            }];

            [disposable addDisposable:selfDisposable];
        }

        return disposable;
    }] setNameWithFormat:@"[%@] -skipUntil: %@", self.name, signalTrigger];
}

skipUntil實現(xiàn)方法也很簡單，當(dāng)入?yún)⒌膕ignalTrigger開發(fā)發(fā)送信號的時候，就讓原信號sendNext把值發(fā)送出來，否則就把原信號的值“吞”掉。

skipUntilReplacement:就沒什么意義了，把原信號經(jīng)過skipUntilReplacement:變換之后得到的新的信號就是Replacement信號。所以說這個操作也就沒意義了。

  1. groupBy:transform:
- (RACSignal *)groupBy:(id<NSCopying> (^)(id object))keyBlock transform:(id (^)(id object))transformBlock {
    NSCParameterAssert(keyBlock != NULL);

    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        NSMutableDictionary *groups = [NSMutableDictionary dictionary];
        NSMutableArray *orderedGroups = [NSMutableArray array];

        return [self subscribeNext:^(id x) {
            id<NSCopying> key = keyBlock(x);
            RACGroupedSignal *groupSubject = nil;
            @synchronized(groups) {
                groupSubject = groups[key];
                if (groupSubject == nil) {
                    groupSubject = [RACGroupedSignal signalWithKey:key];
                    groups[key] = groupSubject;
                    [orderedGroups addObject:groupSubject];
                    [subscriber sendNext:groupSubject];
                }
            }

            [groupSubject sendNext:transformBlock != NULL ? transformBlock(x) : x];
        } error:^(NSError *error) {
            [subscriber sendError:error];

            [orderedGroups makeObjectsPerformSelector:@selector(sendError:) withObject:error];
        } completed:^{
            [subscriber sendCompleted];

            [orderedGroups makeObjectsPerformSelector:@selector(sendCompleted)];
        }];
    }] setNameWithFormat:@"[%@] -groupBy:transform:", self.name];
}

看groupBy:transform:的實現(xiàn)，依舊是老“套路”。return 一個新的RACSignal，在新的信號里面訂閱原信號。

groupBy:transform:的重點就在subscribeNext中了。

首先解釋一下兩個入?yún)ⅰ蓚€入?yún)⒍际情]包，keyBlock返回值是要作為字典的key，transformBlock的返回值是對原信號發(fā)出來的值x進行變換。
先創(chuàng)建一個NSMutableDictionary字典groups，和NSMutableArray數(shù)組orderedGroups。
從字典里面取出key對應(yīng)的value，這里的key對應(yīng)著keyBlock返回值。value的值是一個RACGroupedSignal信號。如果找不到對應(yīng)的key值，就新建一個RACGroupedSignal信號，并存入字典對應(yīng)的key值，與之對應(yīng)。
新變換之后的信號，訂閱之后，RACGroupedSignal進行sendNext，這是一個信號，如果transformBlock不為空，就發(fā)送transformBlock變換之后的值。
sendError和sendCompleted都要分別對數(shù)組orderedGroups里面每個RACGroupedSignal都要進行sendError或者sendCompleted。因為要對數(shù)組里面每個信號都執(zhí)行一個操作，所以需要調(diào)用makeObjectsPerformSelector:withObject:方法。
經(jīng)過groupBy:transform:變換之后，原信號會根據(jù)keyBlock進行分組。

寫出測試代碼，來看看平時應(yīng)該怎么用。

    RACSignal *signalA = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber)
                         {
                             [subscriber sendNext:@1];
                             [subscriber sendNext:@2];
                             [subscriber sendNext:@3];
                             [subscriber sendNext:@4];
                             [subscriber sendNext:@5];
                             [subscriber sendCompleted];
                             return [RACDisposable disposableWithBlock:^{
                                 NSLog(@"signal dispose");
                             }];
                         }];

    RACSignal *signalGroup = [signalA groupBy:^id<NSCopying>(NSNumber *object) {
        return object.integerValue > 3 ? @"good" : @"bad";
    } transform:^id(NSNumber * object) {
        return @(object.integerValue * 10);
    }];

    [[[signalGroup filter:^BOOL(RACGroupedSignal *value) {
        return [(NSString *)value.key isEqualToString:@"good"];
    }] flatten]subscribeNext:^(id x) {
        NSLog(@"subscribeNext: %@", x);
    }];

假設(shè)原信號發(fā)送的1，2，3，4，5是代表的成績的5個等級。當(dāng)成績大于3的都算“good”，小于3的都算“bad”。

signalGroup是原信號signalA經(jīng)過groupBy:transform:得到的新的信號，這個信號是一個高階的信號，因為它里面并不是直接裝的是值，signalGroup這個信號里面裝的還是信號。signalGroup里面有兩個分組，分別是“good”分組和“bad”分組。

想從中取出這兩個分組里面的值，需要進行一次filter:篩選。篩選之后得到對應(yīng)分組的高階信號。這時還要再進行一個flatten操作，把高階信號變成低階信號，再次訂閱才能取到其中的值。

訂閱新信號的值，輸出如下：

subscribeNext: 40
subscribeNext: 50

關(guān)于flatten的實現(xiàn)：

- (instancetype)flatten {
    __weak RACStream *stream __attribute__((unused)) = self;
    return [[self flattenMap:^(id value) {
        return value;
    }] setNameWithFormat:@"[%@] -flatten", self.name];
}

flatten操作就是調(diào)用了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];
}

flatten是把高階信號變換成低階信號的常用操作。flattenMap:具體實現(xiàn)上篇文章分析過了，這里不再贅述。

  1. groupBy:
- (RACSignal *)groupBy:(id<NSCopying> (^)(id object))keyBlock {
    return [[self groupBy:keyBlock transform:nil] setNameWithFormat:@"[%@] -groupBy:", self.name];
}
groupBy:操作就是groupBy:transform:的縮減版，transform傳入的為nil。

關(guān)于groupBy:可以干的事情很多，可以進行很高級的分組操作。這里可以舉一個例子：


// 簡單算法題，分離數(shù)組中的相同的元素，如果元素個數(shù)大于2，則組成一個新的數(shù)組，結(jié)果得到多個包含相同元素的數(shù)組，
// 例如[1,2,3,1,2,3]分離成[1,1],[2,2],[3,3]
RACSignal *signal = @[@1, @2, @3, @4,@2,@3,@3,@4,@4,@4].rac_sequence.signal;

  NSArray * array = [[[[signal groupBy:^NSString *(NSNumber *object) {
      return [NSString stringWithFormat:@"%@",object];
  }] map:^id(RACGroupedSignal *value) {
      return [value sequence];
  }] sequence] map:^id(RACSignalSequence * value) {
      return value.array;
  }].array;

for (NSNumber * num in array) {
    NSLog(@"最后的數(shù)組%@",num);
}

// 最后輸出 [1,2,3,4,2,3,3,4,4,4]變成[1],[2,2],[3,3,3],[4,4,4,4]

二. 組合操作


1. startWith: (在父類RACStream中定義的)

  • (instancetype)startWith:(id)value {

    return [[[self.class return:value]
    concat:self]
    setNameWithFormat:@"[%@] -startWith: %@", self.name, [value rac_description]];
    }

startWith:的實現(xiàn)很簡單，就是先構(gòu)造一個只發(fā)送一個value的信號，然后這個信號發(fā)送完畢之后接上原信號。得到的新的信號就是在原信號前面新加了一個值。

2. concat: (在父類RACStream中定義的)

這里說的concat:是在父類RACStream中定義的。
  • (instancetype)concat:(RACStream *)stream {
    return nil;
    }
父類中定義的這個方法就返回一個nil，具體的實現(xiàn)還要子類去重寫。

3. concat: (在父類RACStream中定義的)

  • (instancetype)concat:(id<NSFastEnumeration>)streams {
    RACStream *result = self.empty;
    for (RACStream *stream in streams) {
    result = [result concat:stream];
    }

    return [result setNameWithFormat:@"+concat: %@", streams];
    }

這個concat:后面跟著一個數(shù)組，數(shù)組里面包含這很多信號，concat:依次把這些信號concat:連接串起來。

4. merge:

  • (RACSignal *)merge:(id<NSFastEnumeration>)signals {
    NSMutableArray *copiedSignals = [[NSMutableArray alloc] init];
    for (RACSignal *signal in signals) {
    [copiedSignals addObject:signal];
    }

    return [[[RACSignal
    createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
    for (RACSignal *signal in copiedSignals) {
    [subscriber sendNext:signal];
    }

                [subscriber sendCompleted];
            return nil;
        }]
       flatten]
      setNameWithFormat:@"+merge: %@", copiedSignals];

}

merge:后面跟一個數(shù)組。先會新建一個數(shù)組copiedSignals，把傳入的信號都裝到數(shù)組里。然后依次發(fā)送數(shù)組里面的信號。由于新信號也是一個高階信號，因為sendNext會把各個信號都依次發(fā)送出去，所以需要flatten操作把這個信號轉(zhuǎn)換成值發(fā)送出去。

從上圖上看，上下兩個信號就像被拍扁了一樣，就成了新信號的發(fā)送順序。

5. merge:
  • (RACSignal *)merge:(RACSignal *)signal {
    return [[RACSignal
    merge:@[ self, signal ]]
    setNameWithFormat:@"[%@] -merge: %@", self.name, signal];
    }
merge:后面參數(shù)也可以跟一個信號，那么merge:就是合并這兩個信號。具體實現(xiàn)和merge:多個信號是一樣的原理。

6. zip: (在父類RACStream中定義的)
  • (instancetype)zip:(id<NSFastEnumeration>)streams {
    return [[self join:streams block:^(RACStream *left, RACStream *right) {
    return [left zipWith:right];
    }] setNameWithFormat:@"+zip: %@", streams];
    }
zip:后面可以跟一個數(shù)組，數(shù)組里面裝的是各種信號流。

它的實現(xiàn)是調(diào)用了join: block: 實現(xiàn)的。

  • (instancetype)join:(id<NSFastEnumeration>)streams block:(RACStream * (^)(id, id))block {
    RACStream *current = nil;
    // 第一步
    for (RACStream *stream in streams) {

      if (current == nil) {
      current = [stream map:^(id x) {
          return RACTuplePack(x);
      }];

      continue;
  }

  current = block(current, stream);

    }
    // 第二步
    if (current == nil) return [self empty];

    return [current map:^(RACTuple *xs) {

      NSMutableArray *values = [[NSMutableArray alloc] init];
  // 第三步
  while (xs != nil) {
      [values insertObject:xs.last ?: RACTupleNil.tupleNil atIndex:0];
      xs = (xs.count > 1 ? xs.first : nil);
  }
  // 第四步
  return [RACTuple tupleWithObjectsFromArray:values];

    }];
    }

join: block: 的實現(xiàn)可以分為4步：

依次打包各個信號流，把每個信號流都打包成元組RACTuple。首先第一個信號流打包成一個元組，這個元組里面就一個信號。接著把第一個元組和第二個信號執(zhí)行block( )閉包里面的操作。傳入的block( )閉包執(zhí)行的是zipWith:的操作。這個操作是把兩個信號“壓”在一起。具體實現(xiàn)分析請看第一篇文章里面分析過的，這里就不再贅述了。得到第二個元組，里面裝著是第一個元組和第二個信號。之后每次循環(huán)都執(zhí)行類似的操作，再把第二個元組和第三個信號進行zipWith:操作，以此類推下去，直到所有的信號流都循環(huán)一遍。

經(jīng)過第一步的循環(huán)操作之后，還是nil，那么肯定就是空信號了，就返回empty信號。

這一步是把之前第一步打包出來的結(jié)果，還原回原信號的過程。經(jīng)過第一步的循環(huán)之后，current會是類似這個樣子，(((1), 2), 3)，第三步就是為了把這種多重元組解出來，每個信號流都依次按照順序放在數(shù)組里。注意觀察current的特點，最外層的元組，是一個值和一個元組，所以從最外層的元組開始，一層一層往里“剝”。while循環(huán)每次都取最外層元組的last，即那個單獨的值，插入到數(shù)組的第0號位置，然后取出first即是里面一層的元組。然后依次循環(huán)。由于每次都插入到數(shù)組0號的位置，類似于鏈表的頭插法，最終數(shù)組里面的順序肯定也保證是原信號的順序。

第四步就是把還原成原信號的順序的數(shù)組包裝成元組，返回給map操作的閉包。

  • (instancetype)tupleWithObjectsFromArray:(NSArray *)array {
    return [self tupleWithObjectsFromArray:array convertNullsToNils:NO];
    }

  • (instancetype)tupleWithObjectsFromArray:(NSArray *)array convertNullsToNils:(BOOL)convert {
    RACTuple *tuple = [[self alloc] init];

    if (convert) {
    NSMutableArray *newArray = [NSMutableArray arrayWithCapacity:array.count];
    for (id object in array) {
    [newArray addObject:(object == NSNull.null ? RACTupleNil.tupleNil : object)];
    }
    tuple.backingArray = newArray;
    } else {
    tuple.backingArray = [array copy];
    }

    return tuple;
    }

在轉(zhuǎn)換過程中，入?yún)onvertNullsToNils的含義是，是否把數(shù)組里面的NSNull轉(zhuǎn)換成RACTupleNil。

這里轉(zhuǎn)換傳入的是NO，所以就是把數(shù)組原封不動的copy一份。

測試代碼:


RACSignal *signalD = [RACSignal interval:3 onScheduler:[RACScheduler mainThreadScheduler] withLeeway:0];
RACSignal *signalO = [RACSignal interval:1 onScheduler:[RACScheduler mainThreadScheduler] withLeeway:0];
RACSignal *signalE = [RACSignal interval:4 onScheduler:[RACScheduler mainThreadScheduler] withLeeway:0];
RACSignal *signalB = [RACStream zip:@[signalD,signalO,signalE]];

[signalB subscribeNext:^(id x) {
    NSLog(@"最后接收到的值 = %@",x);
}];

打印輸出：

2016-11-29 13:07:57.349 最后接收到的值 = <RACTuple: 0x608000011440> (
"2016-11-29 05:07:56 +0000",
"2016-11-29 05:07:54 +0000",
"2016-11-29 05:07:57 +0000"
)

2016-11-29 13:08:01.350 最后接收到的值 = <RACTuple: 0x608000010c60> (
"2016-11-29 05:07:59 +0000",
"2016-11-29 05:07:55 +0000",
"2016-11-29 05:08:01 +0000"
)

2016-11-29 13:08:05.352 最后接收到的值 = <RACTuple: 0x60000001a350> (
"2016-11-29 05:08:02 +0000",
"2016-11-29 05:07:56 +0000",
"2016-11-29 05:08:05 +0000"
)

最后輸出的信號以時間最長的為主，最后接到的信號是一個元組，里面依次包含zip:數(shù)組里每個信號在一次“壓”縮周期里面的值。

7. zip: reduce: (在父類RACStream中定義的)
  • (instancetype)zip:(id<NSFastEnumeration>)streams reduce:(id (^)())reduceBlock {
    NSCParameterAssert(reduceBlock != nil);
    RACStream *result = [self zip:streams];
    if (reduceBlock != nil) result = [result reduceEach:reduceBlock];
    return [result setNameWithFormat:@"+zip: %@ reduce:", streams];
    }
zip: reduce:是一個組合的方法。具體實現(xiàn)可以拆分成兩部分，第一部分是先執(zhí)行zip:，把數(shù)組里面的信號流依次都進行組合。這一過程的實現(xiàn)在上一個變換實現(xiàn)中分析過了。zip:完成之后，緊接著進行reduceEach:操作。

這里有一個判斷reduceBlock是否為nil的判斷，這個判斷是針對老版本的“歷史遺留問題”。在ReactiveCocoa 2.5之前的版本，是允許reduceBlock傳入nil，這里為了防止崩潰，所以加上了這個reduceBlock是否為nil的判斷。

  • (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];
    }

reduceEach:操作在上篇已經(jīng)分析過了。它會動態(tài)的構(gòu)造閉包，對原信號每個元組，執(zhí)行reduceBlock( )閉包里面的方法。具體分析見上篇。一般用法如下：

[RACStream zip:@[ stringSignal, intSignal ] reduce:^(NSString *string, NSNumber *number) {
return [NSString stringWithFormat:@"%@: %@", string, number];
}];

8. zipWith: (在父類RACStream中定義的)
  • (instancetype)zipWith:(RACStream *)stream {
    return nil;
    }
這個方法就是在父類的RACStream中定義了，具體實現(xiàn)還要看RACStream各個子類的實現(xiàn)。

它就可以類比concat:在父類中的實現(xiàn)，也是直接返回一個nil。


- (instancetype)concat:(RACStream *)stream { return nil;}
在第一篇中分析了concat:和zipWith:在RACSignal子類中具體實現(xiàn)。忘記了具體實現(xiàn)的可以回去看看。

9. combineLatestWith:

  • (RACSignal *)combineLatestWith:(RACSignal *)signal {
    NSCParameterAssert(signal != nil);

    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
    RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];

      // 初始化第一個信號的一些標志變量
  __block id lastSelfValue = nil;
  __block BOOL selfCompleted = NO;

  // 初始化第二個信號的一些標志變量
  __block id lastOtherValue = nil;
  __block BOOL otherCompleted = NO;

  // 這里是一個判斷是否sendNext的閉包
  void (^sendNext)(void) = ^{ };

  // 訂閱第一個信號
  RACDisposable *selfDisposable = [self subscribeNext:^(id x) { }];
  [disposable addDisposable:selfDisposable];

  // 訂閱第二個信號
  RACDisposable *otherDisposable = [signal subscribeNext:^(id x) { }];
  [disposable addDisposable:otherDisposable];

  return disposable;

    }] setNameWithFormat:@"[%@] -combineLatestWith: %@", self.name, signal];
    }

大體實現(xiàn)思路比較簡單，在新信號里面分別訂閱原信號和入?yún)ignal信號。

RACDisposable *selfDisposable = [self subscribeNext:^(id x) {
@synchronized (disposable) {
lastSelfValue = x ?: RACTupleNil.tupleNil;
sendNext();
}
} error:^(NSError *error) {
[subscriber sendError:error];
} completed:^{
@synchronized (disposable) {
selfCompleted = YES;
if (otherCompleted) [subscriber sendCompleted];
}
}];

先來看看原信號訂閱的具體實現(xiàn)：

在subscribeNext閉包中，記錄下原信號最新發(fā)送的x值，并保存到lastSelfValue中。從此lastSelfValue變量每次都保存原信號發(fā)送過來的最新的值。然后再調(diào)用sendNext( )閉包。

在completed閉包中，selfCompleted中記錄下原信號發(fā)送完成。這是還要判斷otherCompleted是否完成，即入?yún)⑿盘杝ignal是否發(fā)送完成，只有兩者都發(fā)送完成了，組合的新信號才能算全部發(fā)送完成。

RACDisposable *otherDisposable = [signal subscribeNext:^(id x) {
@synchronized (disposable) {
lastOtherValue = x ?: RACTupleNil.tupleNil;
sendNext();
}
} error:^(NSError *error) {
[subscriber sendError:error];
} completed:^{
@synchronized (disposable) {
otherCompleted = YES;
if (selfCompleted) [subscriber sendCompleted];
}
}];

這是對入?yún)⑿盘杝ignal的處理實現(xiàn)。和原信號的處理方式完全一致。現(xiàn)在重點就要看看sendNext( )閉包中都做了些什么。

void (^sendNext)(void) = ^{
@synchronized (disposable) {
if (lastSelfValue == nil || lastOtherValue == nil) return;
[subscriber sendNext:RACTuplePack(lastSelfValue, lastOtherValue)];
}
};

在sendNext( )閉包中，如果lastSelfValue 或者 lastOtherValue 其中之一有一個為nil，就return，因為這個時候無法結(jié)合在一起。當(dāng)兩個信號都有值，那么就把這兩個信號的最新的值打包成元組發(fā)送出來。


可以看到，每個信號每發(fā)送出來一個新的值，都會去找另外一個信號上一個最新的值進行結(jié)合。

這里可以對比一下類似的zip:操作


zip:操作是會把新來的信號的值存起來，放在數(shù)組里，然后另外一個信號發(fā)送一個值過來就和數(shù)組第0位的值相互結(jié)合成新的元組信號發(fā)送出去，并分別移除數(shù)組里面第0位的兩個值。zip:能保證每次結(jié)合的值都是唯一的，不會一個原信號的值被多次結(jié)合到新的元組信號中。但是combineLatestWith:是不能保證這一點的，在原信號或者另外一個信號新信號發(fā)送前，每次發(fā)送信號都會結(jié)合當(dāng)前最新的信號，這里就會有反復(fù)結(jié)合的情況。

10. combineLatest:
  • (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals {
    return [[self join:signals block:^(RACSignal *left, RACSignal *right) {
    return [left combineLatestWith:right];
    }] setNameWithFormat:@"+combineLatest: %@", signals];
    }
combineLatest:的實現(xiàn)就是把入?yún)?shù)組里面的每個信號都調(diào)用一次join: block:方法。傳入的閉包是把兩個信號combineLatestWith:一下。combineLatest:的實現(xiàn)就是2個操作的組合。具體實現(xiàn)上面也都分析過，這里不再贅述。

11. combineLatest: reduce:
  • (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals reduce:(id (^)())reduceBlock {
    NSCParameterAssert(reduceBlock != nil);
    RACSignal *result = [self combineLatest:signals];
    if (reduceBlock != nil) result = [result reduceEach:reduceBlock];
    return [result setNameWithFormat:@"+combineLatest: %@ reduce:", signals];
    }
combineLatest: reduce: 的實現(xiàn)可以類比zip: reduce:的實現(xiàn)。

具體實現(xiàn)可以拆分成兩部分，第一部分是先執(zhí)行combineLatest:，把數(shù)組里面的信號流依次都進行組合。這一過程的實現(xiàn)在上一個變換實現(xiàn)中分析過了。combineLatest:完成之后，緊接著進行reduceEach:操作。

這里有一個判斷reduceBlock是否為nil的判斷，這個判斷是針對老版本的“歷史遺留問題”。在ReactiveCocoa 2.5之前的版本，是允許reduceBlock傳入nil，這里為了防止崩潰，所以加上了這個reduceBlock是否為nil的判斷。

12. combinePreviousWithStart: reduce:(在父類RACStream中定義的)

這個方法的實現(xiàn)也是多個變換操作組合在一起的。
  • (instancetype)combinePreviousWithStart:(id)start reduce:(id (^)(id previous, id next))reduceBlock {
    NSCParameterAssert(reduceBlock != NULL);
    return [[[self
    scanWithStart:RACTuplePack(start)
    reduce:^(RACTuple *previousTuple, id next) {
    id value = reduceBlock(previousTuple[0], next);
    return RACTuplePack(next, value);
    }]
    map:^(RACTuple *tuple) {
    return tuple[1];
    }]
    setNameWithFormat:@"[%@] -combinePreviousWithStart: %@ reduce:", self.name, [start rac_description]];
    }
combinePreviousWithStart: reduce:的實現(xiàn)完全可以類比scanWithStart:reduce:的實現(xiàn)。舉個例子來說明他們倆的不同。


  RACSequence *numbers = @[ @1, @2, @3, @4 ].rac_sequence;

  RACSignal *signalA = [numbers combinePreviousWithStart:@0 reduce:^(NSNumber *previous, NSNumber *next) {
      return @(previous.integerValue + next.integerValue);
  }].signal;

RACSignal *signalB = [numbers scanWithStart:@0 reduce:^(NSNumber *previous, NSNumber *next) {
    return @(previous.integerValue + next.integerValue);
}].signal;

signalA輸出如下：

1
3
5
7

signalB輸出如下：

1
3
6
10

現(xiàn)在應(yīng)該不同點應(yīng)該很明顯了。combinePreviousWithStart: reduce:實現(xiàn)的是兩兩之前的加和，而scanWithStart:reduce:實現(xiàn)的累加。

為什么會這樣呢，具體看看combinePreviousWithStart: reduce:的實現(xiàn)。

雖然combinePreviousWithStart: reduce:也是調(diào)用了scanWithStart:reduce:，但是初始值是RACTuplePack(start)元組，聚合reduce的過程也有所不同：

id value = reduceBlock(previousTuple[0], next);
return RACTuplePack(next, value);

依次調(diào)用reduceBlock( )閉包，傳入previousTuple[0], next，這里reduceBlock( )閉包是進行累加的操作，所以就是把前一個元組的第0位加上后面新來的信號的值。得到的值拼成新的元組，新的元組由next和value值構(gòu)成。

如果打印出上述例子中combinePreviousWithStart: reduce:的加合過程中每個信號的值，如下：

<RACTuple: 0x608000200010> (
1,
1
)

<RACTuple: 0x60000001fe70> (
2,
3
)
<RACTuple: 0x60000001fe90> (
3,
5
)
<RACTuple: 0x60000001feb0> (
4,
7
)

由于這樣拆成元組之后，下次再進行操作的時候，還可以拿到前一個信號的值，這樣就不會形成累加的效果。

13. sample:

  • (RACSignal *)sample:(RACSignal *)sampler {
    NSCParameterAssert(sampler != nil);

    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
    NSLock *lock = [[NSLock alloc] init];
    __block id lastValue;
    __block BOOL hasValue = NO;

      RACSerialDisposable *samplerDisposable = [[RACSerialDisposable alloc] init];
  RACDisposable *sourceDisposable = [self subscribeNext:^(id x) { // 暫時省略 }];

  samplerDisposable.disposable = [sampler subscribeNext:^(id _) { // 暫時省略 }];

  return [RACDisposable disposableWithBlock:^{
      [samplerDisposable dispose];
      [sourceDisposable dispose];
  }];

    }] setNameWithFormat:@"[%@] -sample: %@", self.name, sampler];
    }

sample:內(nèi)部實現(xiàn)也是對原信號和入?yún)⑿盘杝ampler分別進行訂閱。具體實現(xiàn)就是這兩個信號訂閱內(nèi)部都干了些什么。

RACSerialDisposable *samplerDisposable = [[RACSerialDisposable alloc] init];
RACDisposable *sourceDisposable = [self subscribeNext:^(id x) {
[lock lock];
hasValue = YES;
lastValue = x;
[lock unlock];
} error:^(NSError *error) {
[samplerDisposable dispose];
[subscriber sendError:error];
} completed:^{
[samplerDisposable dispose];
[subscriber sendCompleted];
}];

這是對原信號的操作，原信號的操作在subscribeNext中就記錄了兩個變量的值，hasValue記錄原信號有值，lastValue記錄了原信號的最新的值。這里加了一層NSLock鎖進行保護。

在發(fā)生error的時候，先把sampler信號取消訂閱，然后再sendError:。當(dāng)原信號完成的時候，同樣是先把sampler信號取消訂閱，然后再sendCompleted。

samplerDisposable.disposable = [sampler subscribeNext:^(id _) {
BOOL shouldSend = NO;
id value;
[lock lock];
shouldSend = hasValue;
value = lastValue;
[lock unlock];

if (shouldSend) {
    [subscriber sendNext:value];
}

} error:^(NSError *error) {
[sourceDisposable dispose];
[subscriber sendError:error];
} completed:^{
[sourceDisposable dispose];
[subscriber sendCompleted];
}];

這是對入?yún)⑿盘杝ampler的操作。shouldSend默認值是NO，這個變量控制著是否sendNext:值。只有當(dāng)原信號有值的時候，hasValue = YES，所以shouldSend = YES，這個時候才能發(fā)送原信號的值。這里我們并不關(guān)心入?yún)⑿盘杝ampler的值，從subscribeNext:^(id _)這里可以看出， _代表并不需要它的值。

在發(fā)生error的時候，先把原信號取消訂閱，然后再sendError:。當(dāng)sampler信號完成的時候，同樣是先把原信號取消訂閱，然后再sendCompleted。


經(jīng)過sample:變換就會變成這個樣子。只是把原信號的值都移動到了sampler信號發(fā)送信號的時刻，值還是和原信號的值一樣。

最后

關(guān)于RACSignal的變換操作還剩下 冷熱信號轉(zhuǎn)換操作，高階信號操作，下篇接著繼續(xù)分析。最后請大家多多指教。

轉(zhuǎn)載自:https://gold.xitu.io/post/583e096461ff4b007edddbc8
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

推薦閱讀更多精彩內(nèi)容