//1.创建信号
    RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
       
        //3.发送信号
        [subscriber sendNext:@"发送信号"];
        /**
         如果不在发送数据，最好发送信号完成，内部会自动调用[RACDisposable disposable]取消订阅信号
         */
        [subscriber sendCompleted];
        
        //取消订阅方法
        return [RACDisposable disposableWithBlock:^{
            //block调用时刻：当信号发送完成或者发送错误，就会自动执行这个block,取消订阅信号
            // 执行完Block后，当前信号就不在被订阅了。
            NSLog(@"信号销毁了");
        }];
    }];
    
    //2.订阅信号
    [signal subscribeNext:^(id x) {
        NSLog(@"订阅信号:%@",x);
    }];

RACSignal *signal1 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
       
        /**
         有一个全局变量保存值就不会走下面取消订阅方法
         */
        _subscriber = subscriber;
        
        [subscriber sendNext:@"123"];
        [subscriber sendCompleted];
        
        return [RACDisposable disposableWithBlock:^{
            NSLog(@"走销毁这个方法了");
        }];
    }];

    //订阅信号返回RACDisposable
    RACDisposable *disposable = [signal1 subscribeNext:^(id x) {
        NSLog(@"接收打印的值:%@",x);
    }];
    
    // 默认一个信号发送数据完毕们就会主动取消订阅.
    // 只要订阅者在,就不会自动取消信号订阅
    // 手动取消订阅者
    [disposable dispose];

 //1.创建信号
    RACSubject *subject = [RACSubject subject];
    //2.订阅信号
    [subject subscribeNext:^(id x) {
       //当信号发出新值，就会调用.
        NSLog(@"第一个订阅者%@",x);
    }];
    
    [subject subscribeNext:^(id x) {
        NSLog(@"第二个订阅者%@",x);
    }];
    
    //3.发送信号
    [subject sendNext:@"123456"];
    //4.发送信号完成,内部会自动取消订阅者
    [subject sendCompleted];
    
    //输出:
    // 第一个订阅者123456
    // 第二个订阅者123456

    //1.
    RACReplaySubject *replaySubject = [RACReplaySubject subject];
    //2.发送信号
    [replaySubject sendNext:@"1"];
    [replaySubject sendNext:@"2"];
    //3.订阅信号
    [replaySubject subscribeNext:^(id x) {
        NSLog(@"第一个订阅者接收到的数据%@",x);
    }];
    
    [replaySubject subscribeNext:^(id x) {

        NSLog(@"第二个订阅者接收到的数据%@",x);
    }];
    
    //输出:
    //第一个订阅者接收到的数据1
    //第一个订阅者接收到的数据2
    //第二个订阅者接收到的数据1
    //第二个订阅者接收到的数据2

 /**
     RACTuple:元组类,类似NSArray,用来包装值.
     */
    //元组
    RACTuple *tuple = [RACTuple tupleWithObjectsFromArray:@[@"123",@"345",@1]];
    NSString *first = tuple[0];
    NSLog(@"%@",first);
    
    //输出:
    //123

   NSArray *arr = @[@"213",@"321",@1];
    //RAC 集合
//    RACSequence *sequence = arr.rac_sequence;
//    // 把集合转换成信号
//    RACSignal *signal = sequence.signal;
//    //订阅集合信号,内部会自动遍历所有的元素发出来
//    [signal subscribeNext:^(id x) {
//        NSLog(@"遍历数组%@",x);
//    }];
    //输出:
    /**
     遍历数组213
     遍历数组321
     遍历数组1
     */
    
    //高级写法
    [arr.rac_sequence.signal subscribeNext:^(id x) {
        NSLog(@"高级写法遍历数组打印%@",x);
    }];
    
    //输出:
    /**
     高级写法遍历数组打印213
     高级写法遍历数组打印321
     高级写法遍历数组打印1
     */

 NSDictionary *dict = @{@"sex":@"女",@"name":@"苍老师",@"age":@18};
    
    //转换成集合
    [dict.rac_sequence.signal subscribeNext:^(RACTuple *x) {
//        NSString *key = x[0];
//        NSString *value = http://www.mamicode.com/x[1];>//        NSLog(@"%@ %@",key,value);
        // RACTupleUnpack:用来解析元组
        // 宏里面的参数,传需要解析出来的变量名
        //= 右边,放需要解析的元组
        RACTupleUnpack(NSString *key, NSString *value) = x;
        NSLog(@"%@ %@",key,value);
     
    }];
    //输出:
    /**
     sex 女
     name 苍老师
     age 18
     */

//1.创建信号
    RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        NSLog(@"发送请求");
        
        [subscriber sendNext:@"1"];
        return [RACDisposable disposableWithBlock:^{
            
        }];
    }];
    //2.订阅信号
    [signal subscribeNext:^(id x) {
       
        NSLog(@"接收数据");
    }];
    [signal subscribeNext:^(id x) {
        
        NSLog(@"接收数据");
    }];
    
    // 3.运行结果，会执行两遍发送请求，也就是每次订阅都会发送一次请求
    
    // RACMulticastConnection:解决重复请求问题
    // 1.创建信号
    RACSignal *connectionSignal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        NSLog(@"发送请求--");
        [subscriber sendNext:@1];
        
        return [RACDisposable disposableWithBlock:^{
            
        }];
    }];
    
    //2.创建连接
    RACMulticastConnection *connect = [connectionSignal publish];
    
    //3.订阅信号
    // 注意：订阅信号，也不能激活信号，只是保存订阅者到数组，必须通过连接,当调用连接，就会一次性调用所有订阅者的sendNext:
    [connect.signal subscribeNext:^(id x) {
        NSLog(@"订阅者一信号--");
    }];
    [connect.signal subscribeNext:^(id x) {
        
        NSLog(@"订阅者二信号--");
        
    }];
    //4.连接,激活信号
    [connect connect];
    
    //输出:
    /**
     发送请求--
     订阅者一信号--
     订阅者二信号--
     */

//1.创建命令
    RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
       
        NSLog(@"执行命令");
        //创建空信号,必须返回信号
        //return [RACSignal empty];
        
        //2.创建信号,用来传递数据
        return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
           
            [subscriber sendNext:@"请求数据"];
            
            //注意:数据传递完，最好调用sendCompleted，这时命令才执行完毕。
            [subscriber sendCompleted];
            
            return [RACDisposable disposableWithBlock:^{
                NSLog(@"数据销毁");
            }];
        }];
    }];
    
    //强引用命令，不要被销毁，否则接收不到数据
    _command = command;
    
    //监听事件有咩有完成
    [command.executing subscribeNext:^(id x) {
        if ([x boolValue] == YES) { // 当前正在执行
            NSLog(@"当前正在执行");
        }else{
            // 执行完成/没有执行
            NSLog(@"执行完成/没有执行");
        }

    }];
    
    //执行命令
    [self.command execute:@1];

    //创建信号中信号
    RACSubject *signalOfSignals = [RACSubject subject];
    RACSubject *signalA = [RACSubject subject];
    RACSubject *signalB = [RACSubject subject];
    // 订阅信号
//        [signalOfSignals subscribeNext:^(RACSignal *x) {
//            [x subscribeNext:^(id x) {
//                NSLog(@"%@",x);
//            }];
//        }];
//     switchToLatest:获取信号中信号发送的最新信号
    [signalOfSignals.switchToLatest subscribeNext:^(id x) {
        
        NSLog(@"%@",x);
    }];
    
    // 发送信号
    [signalOfSignals sendNext:signalA];
    
    [signalA sendNext:@1];
    [signalB sendNext:@"BB"];
    [signalA sendNext:@"11"];

  // 1.创建命令
    RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
        // input:执行命令传入参数
        // Block调用:执行命令的时候就会调用
        NSLog(@"%@",input);
        
        return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
            
            // 发送数据
            [subscriber sendNext:@"执行命令产生的数据"];
            
            return nil;
        }];
    }];
    
    // 如何拿到执行命令中产生的数据
    // 订阅命令内部的信号
    // 1.方式一:直接订阅执行命令返回的信号
    // 2.方式二:
    
    // 2.执行命令
    RACSignal *signal = [command execute:@1];
    
    // 3.订阅信号
    [signal subscribeNext:^(id x) {
        NSLog(@"%@",x);
    }];