我一直在研究MVVM示例,使用ReactiveCocoa,它是集合视图中App.net帖子的简单集合,在收集集合视图的边缘之前加载更多帖子.
但是,我遇到了一个问题,我的视图模型上有一个命令.我创建了一个命令,通过AFNetworking客户端加载帖子,并在建模后回复.完成后,它会将响应发送到创建的命令的信号,并完成信号.
self.loadPostsCommand = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[[EPHTTPClient sharedClient] getGlobalTimelinePostsWithSuccess:^(NSURLSessionDataTask *task, id responseObject) {
[self.posts addObjectsFromArray:responseObject];
[subscriber sendNext:responseObject];
[subscriber sendCompleted];
} failure:^(NSURLSessionDataTask *task, NSError *error) {
[subscriber sendError:error];
}];
return nil;
}];
}];
Run Code Online (Sandbox Code Playgroud)
在我看来,我创建了一个信号来发送剩余的帖子数.
@weakify(self);
RACSignal *postsRemainingSignal = [[RACObserve(self.collectionView, contentOffset) map:^(id value) {
// The value returned from the signal will be an NSValue
CGPoint offset = [value CGPointValue];
NSNumber *postsPassed = @(floorf(offset.x/320) + 1);
return @([self.postQueue.posts count] - …Run Code Online (Sandbox Code Playgroud) 基本上,我希望能够编写如下代码:
main = do
x <- newVal (2 :: Int)
y <- newVal (3 :: Int)
z <- newFunc (x, y) (\(a,b) -> a * b)
r1 <- readVal z
print r1 -- prints 6 (2 * 3)
setVal x 5
r2 <- readVal z
print r2 -- prints 15 (5 * 3)
Run Code Online (Sandbox Code Playgroud)
有人可以从头开始或从库中提供一些示例代码,以便我能够实现上述类似的功能吗?
我正在试图弄清楚如何采用可观察的序列T并获得T我的订阅者中最近和以前的值.这是我的秒杀代码:
static void Main(string[] args)
{
var latest = new Subject<string>();
var previous = latest.SkipLast(1);
var latestWithPrevious = latest.CombineLatest(previous, (l, p) => new { Latest = l, Previous = p });
latestWithPrevious.Subscribe(x => Console.WriteLine("Latest: {0} Previous: {1}", x.Latest, x.Previous));
latest.OnNext("1");
latest.OnNext("2");
latest.OnNext("3");
Console.ReadKey();
}
Run Code Online (Sandbox Code Playgroud)
我想要以下输出:
Publishing 1
Publishing 2
Latest: 2 Previous: 1
Publishing 3
Latest: 3 Previous: 2
Run Code Online (Sandbox Code Playgroud)
但是,我得到以下内容:
Publishing 1
Publishing 2
Latest: 2 Previous: 1
Publishing 3
Latest: 3 Previous: 1
Latest: 3 …Run Code Online (Sandbox Code Playgroud) 我有一个定期发射的事件.我们假设处理事件大约需要1秒.我没有等待每个接收到的事件1,而是想累积事件直到最后一次处理完成.处理完成后,我想处理上次处理过程中收到的事件数据:
e1 e2 e3 e4 e5 e6 e7 events happening
---------------------------------------------------------------------------------------------------------------------------------------------------> time
1s 2s 3s 4s 5s 6s
p(e1) p(e2, e3) p(e4) p(e5, e6) p(e7)
[-----------------------][-----------------------] [-----------------------][-----------------------][-----------------------] processing of items
In above example, processing start as soon as e1 happens. While the processing takes places 2 more events have arrived. They should be stored so when p(e1) - which means the processing of e1 -
is finished the processing of the events e2 and e3 takes place.
This proces is …Run Code Online (Sandbox Code Playgroud) 如果我有Rx.Observable,我怎么能通过它订阅多个功能forEach?下面的代码有效,但这部分对我来说特别不干净:
Rx.Observable.from(definition).forEach(highlight);
Rx.Observable.from(definition).forEach(prefix);
Run Code Online (Sandbox Code Playgroud)
我知道我可以创建一个包装函数来调用它们中的这两个,但我喜欢将它们分开的可读性.我喜欢的是做类似的事情
Rx.Observable.from(definition).forEach(highlight, prefix)
Run Code Online (Sandbox Code Playgroud)
要么
definition = Rx.Observable.from(definition)
definition.forEach(highlight)
definition.forEach(prefix)
Run Code Online (Sandbox Code Playgroud)
要么
Rx.Observable.from(definition).forEach(highlight).forEach(prefix)
Run Code Online (Sandbox Code Playgroud)
......但这些都没有奏效.重构这个的最佳方法是什么?
JS:
(function commands() {
function highlight(node) {
node.classList.add(hoverClass);
}
function unhighlight(node) {
node.classList.remove(hoverClass);
}
function prefix(node) {
node.classList.add(prefixClass);
}
function unprefix(node) {
node.classList.remove(prefixClass);
}
function unprefixAll(nodes) {
Rx.Observable.from(nodes).forEach(unprefix);
}
var hoverClass = "hover";
var prefixClass = "prefixed";
var $commands = document.querySelector("#commands");
var definitions = Rx.Observable.from($commands.querySelectorAll("dt"))
.map(function(_, i) {
return $commands.querySelectorAll(
"dt:nth-of-type("+ (i + 1) +"), dt:nth-of-type("+ (i + 1) +") + …Run Code Online (Sandbox Code Playgroud) 我Rx.Observable从一系列事件中创建了一个:
Rx.Observable.fromEvent(recognizeStream, 'data')
Run Code Online (Sandbox Code Playgroud)
其中每个数据事件如下所示:
{ error: null, alternatives: [result1, result2, result3] }
Run Code Online (Sandbox Code Playgroud)
我想在数组中获取每个值alternatives并将它们合并到流中.我需要看哪些操作员?
据我所知,flatMap并且concatMap可以完成这项工作,但我从他们的例子中得不到这个想法.
有人可以解释我应该使用哪个运算符并向我提供一个示例吗?
对于以下TypeScript(使用rxjs):
getRegularData(): Observable<MyData> {
return WS.loadRegularData();
}
getAlternateData(): Observable<MyData> {
return WS.loadAlternateData();
}
Run Code Online (Sandbox Code Playgroud)
如何实现新方法以满足以下伪代码:
getData(): Observable<MyData> {
// try to use getRegularData, and return observable for result.
// if getRegularData returns null, get data from getAlternateData()
// instead and return observable for result.
}
Run Code Online (Sandbox Code Playgroud) 在RxJava中是否有类似于Subject适用于某个类的类Single?据推测,我会调用它onSuccess( item )或onError( Throwable )方法,输出将转发给SingleSubscriber.
我想我可以使用它Observable Subject并将其转换为a Single但看起来有点笨重.
目前使用RxJava 1但对RxJava 2的情况也很感兴趣.
Project Reactor 3.1.5.RELEASE
考虑一下:
Flux.range(0, 10)
.publishOn(Schedulers.parallel())
.subscribe(i -> LOG.info(i));
Run Code Online (Sandbox Code Playgroud)
我期望订阅者在多个线程中运行,但它只运行在一个:
2018-03-26 12:30:08.693 INFO 89770 --- [ parallel-1] d.a.Application : 0
2018-03-26 12:30:08.693 INFO 89770 --- [ parallel-1] d.a.Application : 1
2018-03-26 12:30:08.693 INFO 89770 --- [ parallel-1] d.a.Application : 2
2018-03-26 12:30:08.693 INFO 89770 --- [ parallel-1] d.a.Application : 3
2018-03-26 12:30:08.694 INFO 89770 --- [ parallel-1] d.a.Application : 4
2018-03-26 12:30:08.694 INFO 89770 --- [ parallel-1] d.a.Application : 5
2018-03-26 12:30:08.694 INFO 89770 --- [ parallel-1] d.a.Application : …Run Code Online (Sandbox Code Playgroud) 按照switchMap的定义
在每次发射时,先前的内部可观测值(您提供的功能的结果)都会被取消,并订阅新的可观测值。您可以通过切换到新的可观察到的短语来记住这一点。
现在,我有这样的代码
const source = timer(0, 5000).pipe(map(x=>`${x}`));
const example = source.pipe(switchMap((f) => interval(1000).pipe(map(y=>`f${f}-s${y}`))),take(20));
const subscribe = example.subscribe(val => console.log(val+' '+ new Date().getSeconds()));
Run Code Online (Sandbox Code Playgroud)
结果是这样
我的问题是
25秒-调用外部函数且尚未触发内部函数,因此外部函数的最新值为0,并且内部函数的默认值为0,因为它尚无值f0-s0 25
第26秒-内部函数被调用,理想情况下该值应为0,因为该函数是第一次被调用,但值为1,即。f0-s1 26
30秒-调用外部函数,它将内部函数值重置为0,即。f1-s0 30
为什么内部功能在第35秒被复位,仍然还有1秒
我觉得很难理解这个概念,谢谢
rxjs ×4
javascript ×3
.net ×2
c# ×2
java ×2
haskell ×1
ios ×1
objective-c ×1
observable ×1
rx-java ×1
rx-java2 ×1
rxjs5 ×1
rxjs6 ×1
switchmap ×1
typescript ×1