标签: reactive-programming

在ReactiveCocoa中,subscribeError:方法与catch:？之间的区别是什么？你为什么要回信号catch:？

我正在使用React JS来渲染HTML内容.问题是我无法理解代码的特定部分它的作用.

如果您可以从以下链接http://facebook.github.io/react/看到Todo列表的基本示例

<script type='text/jsx'>
        /** @jsx React.DOM */ 

        var TodoList = React.createClass({
                render: function(){ 
                        var createItem = function(itemText) {
                          return <li>{itemText}</li>;
                        };
                        return <ul>{this.props.items.map(createItem)}</ul>;
                    }
            });

        var TodoApp = React.createClass({
                getInitialState: function(){
                    return {items:[], text: ''}
                },
                onChange: function(e)
                {
                    this.setState({text: e.target.value});
                },
                handleSubmit: function(e)
                {
                    e.preventDefault();
                    var nextItems = this.state.items.concat([this.state.text]);
                    var nextText = ''
                    this.setState({items: nextItems, text: nextText});
                },
                render:function(){
                    return (
                        <div>
                            <h3>ToDo List</h3>
                            <TodoList items={this.state.items}/>
                            <form onSubmit={this.handleSubmit}>
                                <input type="text" onChange={this.onChange} value={this.state.text}/>
                                <button>Add #{this.state.items.length+1}</button>
                            </form> …

我真的看不出它们之间的区别.它们都是关于流经指令的数据和输入数据中的变化传播.我读过这本书(由Matt Carcki撰写),它清楚地表明两者都是一样的.另一方面,维基百科建立了反应式编程作为数据流编程的一种形式,这种堆栈溢出的答案也是如此.

那么,Reactive编程和Dataflow编程之间的概念差异是什么？

我一直在研究并尝试使用Reactor和RxJava进行编码的Reactive Style.我确实理解,与单线程执行相比,反应式编码可以更好地利用CPU.

在基于Web的应用程序中,反应式编程与命令式编程之间是否有任何具体比较？

通过对非反应式编程使用反应式编程,我实现了多少性能提升和吞吐量？

还原反应编程有哪些优缺点？

有没有统计基准？

问题

我有两个Apis.Api 1给了我一个项目列表,Api 2给了我更多关于我从Api获得的每个项目的详细信息.到目前为止,我解决它的方式导致性能不佳.

问题

在Retrofit和RxJava的帮助下,快速,快速地解决了这个问题.

我的方法

在片刻我的解决方案看起来像这样:

第1步:Single<ArrayList<Information>>从Api 1 执行Retrofit .

第2步:我遍历这些项目并向Api 2发出请求.

第3步:改造退货按顺序执行Single<ExtendedInformation>每个项目

步骤4:在完成Api 2的所有调用完成后,我为组合信息和扩展信息的所有项创建一个新对象.

我的守则

 public void addExtendedInformations(final Information[] informations) {
        final ArrayList<InformationDetail> informationDetailArrayList = new ArrayList<>();
        final JSONRequestRatingHelper.RatingRequestListener ratingRequestListener = new JSONRequestRatingHelper.RatingRequestListener() {
            @Override
            public void onDownloadFinished(Information baseInformation, ExtendedInformation extendedInformation) {
                informationDetailArrayList.add(new InformationDetail(baseInformation, extendedInformation));
                if (informationDetailArrayList.size() >= informations.length){
                    listener.onAllExtendedInformationLoadedAndCombined(informationDetailArrayList);
                }
            }
        };

        for (Information information : informations) {
            getExtendedInformation(ratingRequestListener, information);
        }
    }

    public void getRatingsByTitle(final JSONRequestRatingHelper.RatingRequestListener ratingRequestListener, final Information information) {
        Single<ExtendedInformation> …

为什么我们需要将RxAndroid与RxJava一起使用？它们与RxAndroid和RxJava的实际使用之间有什么功能差异？我找不到合适的答案.

在使用 Android Room 时我应该考虑哪些例外情况。从我的研究中，我发现只有一种例外情况可能发生。

房间例外

这也是当你有Single<T>一个返回类型并且你有一个空的回报时。除此之外，我找不到任何其他可能引发异常的情况。

当然，如果你有一些逻辑上不正确的实现，可能会有一些例外，比如

• 编辑方案，但未实施 Migration
• OnConflictStrategy插入时不执行
• 在主线程上运行房间，但不允许它 allowMainThreadQueries()

我做了一些研究并尝试了几乎所有可能的情况，主要是 RxJava 返回类型，我看到了上面提到的一个异常，就是这样。

这是我运行的测试

我想确保我对每个可能的场景都有实现，并且没有一些异常和意外崩溃。我在想SQLite可能会发生异常的情况，但我相信它已经包裹在 Room 中并且会处理。（没有把握）

你能给出可能发生的任何其他可能的例外吗？

我最近开始WebClient在我的Spring boot项目中使用。有人可以扔之间的差异/用法一些轻exchange和retrieve方法WebClient。

我明白exchange返回Mono<ClientResponse>和retrieve返回ResponseSpec，我只想知道何时/为什么我应该使用它们中的每一个。

非常感谢。

我已经定义:

let currentHours:Variable<Float> = Variable(0.0)
let currentRate:Variable<Float>  = Variable(0.0)

我想用combineLatest制作一个Observable来总结这两个值:

Observable.combineLatest(currentHours, currentRate, { (h, r) -> Float in
    return Float(h+r)
})

我也尝试:

let c =  Observable.combineLatest(currentHours, currentRate) { $0 + $1 }

我总是遇到编译错误.谢谢

在每一篇技术讲座中,或者在每篇博文中,我都读过有关IEnumerable和IObservable的内容,我读过, IEnumerable是基于拉式的结构, IObservable是基于推送的结构.

我已经读过IObservable,我们有异步调用,没有任何东西被阻止,一切都是基于推送的.

但是,但是,但是...

它到底意味着什么？推动基础和拉基于

因为在我看来IEnumerable中我们也可以将数据推送到结构中并从中提取数据,我真的迷失在那些技术术语和想法中.

请以正常和人性的方式向我解释这两种结构之间的区别以及基于推进和基于拉的结构之间的区别.

谢谢.