1

据我了解，RACSubjectReactiveCocoa 4 的等价物是Observer类。我希望将信号和观察者链接在一起，以便信号发送事件，将映射操作应用于发送给观察者的事件。在 Obj-C 中，它看起来像这样：

// ViewModel.h

@interface ViewModel

@property (readonly) RACSubject *someAction; //expects e.g. int values
@property (readonly) RACSignal *someSignal; //sends e.g. string values

@end

// ViewModel.m

//redeclaring the signal and action as readwrite

@implementation

- (id)init {
  _someAction = [RACSubject subject];
  _someSignal = [_someAction map:^id(NSNumber *index) {
     return "Some string based on index passed in";
  }];
}

@end

现在，当有人将一个值推送到 上someAction时，someSignal将触发一个包含派生值的事件。如何在 Swift 中实现相同的效果？

到目前为止我能做的是这样的：

public class ViewModel: NSObject {
    public let (internalSignal, someAction) = Signal<Int, NoError>.pipe()
    public var someSignal: Signal<String, NoError> {
        get {
            return self.internalSignal.map({ [unowned self](index: Int) -> String in
                return "Some string value based on \(self.someArray[index])"
            })
        }
    }
    public let someArray = [1, 2, 3, 4, 5]
}

这看起来像一个糟糕的解决方案，因为

  1. internalSignal应该是私有的，但需要声明为公共的，以便将其与 Signal 的管道相匹配
  2. someSignal因此，每次需要时都会计算它，即使相同的信号可以一遍又一遍地重复使用。也不能声明为let常量。
4

1 回答 1

2

您可以init像 ObjC 一样初始化成员...

public class ViewModel: NSObject {
    private let internalSignal: Signal<Int, NoError>
    public let someAction: Observer<Int, NoError>
    public let someSignal: Signal<String, NoError>

    override init() {
        (internalSignal, someAction) = Signal<Int, NoError>.pipe()
        someSignal = internalSignal.map { index in
            "Some string value based on \(index)"
        }
        super.init()
    }
}

因为someSignal你也可以使用延迟初始化，它允许成员引用self：

public class ViewModel: NSObject {
    private let internalSignal: Signal<Int, NoError>
    public let someAction: Observer<Int, NoError>
    public private(set) lazy var someSignal: Signal<String, NoError> =
        self.internalSignal.map { [unowned self] index in
            "Some string value based on \(self.someArray[index])"
        }

    override init() {
        (internalSignal, someAction) = Signal<Int, NoError>.pipe()
        super.init()
    }
}

与第一段代码不同，lazy-var 仅在someSignal使用之前进行初始化，而不是在 ViewModel 的初始化时。

此外，由于它是一个var，Swift 允许你使用 mutate 它的值（没有这样的东西lazy let）。我们可以使用 来限制权限private(set)，但这不会阻止您在self.someSignal = ...某处意外写入。

或者，您可以创建someSignal一个隐式展开的可选并手动初始化：

public class ViewModel: NSObject {
    private let internalSignal: Signal<Int, NoError>
    public let someAction: Observer<Int, NoError>
    public private(set) var someSignal: Signal<String, NoError>!

    override init() {
        (internalSignal, someAction) = Signal<Int, NoError>.pipe()
        super.init()
        someSignal = internalSignal.map { [unowned self] index in
            "Some string value based on \(self.someArray[index])"
        }
    }
}
于 2016-05-19T13:05:04.570 回答