RxJS是一个实例方法。必须更新/创建可观察对象的实例才能调用该方法 该方法是一种静态方法。不需要实例 为什么RxJSwithLatestFrom不是静态方法而是实例方法 withLatestFrom不同于merge，因为它有一个规范的“源”可观测值的概念，该概念由另一个可观测值的最新值扩充merge不是这样的“分层”的，可观察的对象只是作为相等的对象组合到一个流中。我认为一个很好的例子是CombineRelateTest操作符，它以静态和实例方法的形式存在。源观测值到combineLatest

当为涉及大量链接和大量异步操作的特定任务使用可观察对象时，例如列出文件夹中的所有项目并检查其中的所有文件夹以查找特定文件，我通常需要为每个任务构建复杂的链（返回可观察的（文件夹）…）或者具有某种特殊值，该值被转发到末尾，以表示批处理的结束（每个操作符以if（res==false）开始，返回Observable.of（false）） 有点像你放在杂货和收银台前的人之间的那根棍子 似乎应该有一种更好的方法，不需要通过各种回调和操作符转发停止值 那么，调用一个函数的好方法是什么呢？该函数接受文件夹路径

搜索了几个小时后。。。大多数例子都是这样的 var source = Rx.Observable.timer(0, 1000) .takeUntil(Rx.Observable.timer(5000)); var subscription = source.subscribe( function (x) { console.log('Next: ' + x); }, function (err) { console.log('Error: ' + err); },

我创建了一个服务，用于检查父组件中的更改，并向子组件发送通知 下面是简单的服务 import { Injectable } from '@angular/core'; import { ReplaySubject } from 'rxjs/ReplaySubject'; import { CloudDate } from './cloudDate'; import { Clouding } from './clouding'; @Injectable() export class Cloudi

试图了解RxJs是否可以在生产中安全使用。 任何人都知道RxJS 5中的漏洞。 以下是RxJS5已知的问题。请帮忙 **Vulnerabilities - Public Data** CVE-2017-1000048 High Risk Prototype Override Protection Bypass qs 2.4.2 CVE-2015-8855 High Risk Regular Expression Denial Of Service (ReDoS) semver 2.3.2 CVE

嗨，我是angular 5的新手，在一些博客上写了HTTP拦截器 export class AngularInterceptor implements HttpInterceptor { public http404 = false; constructor() { } intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> { console.

因此，我有一个用例，当地图移动时，我更新api请求——但它可能会生成几个带有小地图移动的快速射击请求——我想取消除最后一个请求之外的所有空中请求。我只能在延迟后使用debounce发送请求。然而，我仍然想取消任何旧的请求，如果他们碰巧仍然在处理中 const fetchNearbyStoresEpic = action$ => action$.ofType(FETCH_NEARBY_STORES) .debounceTime(500) .switchMap(action

我正在寻找可观察的操作符，它在发出值后将等待500毫秒。 如果在这段时间内发出了新值，则会采用新值并最后忘记。 如果没有发出新值，则会进一步传递该值 我试过： 延迟-它只延迟每个值 debounceTime-它会在值之间创建间隙并发出每个值。您可以尝试使用throttleTime（500）和last（）运算符。 比如说, interval(100) .pipe( take(10), throttleTime(500), last(), ) .subscribe({ next: x

我是一个后端开发人员，从我正在从事的项目的前端开发开始。前端使用Angular7和NgRx。在过去的4天里，我学习了很多，但我有一件事要做，非常感谢你的帮助 我了解到，通过返回具有多个动作的可观察数组，我们可以从NgRx中的效果中分派多个动作。我想根据条件分派数组中的一个操作 我的代码看起来像这样 @Effect() something$: Observable<Action> = this.actions$.pipe( ofType(ActionType), s

我有一个可观察的，myourceobs，以及以下代码 concurrencyFactor = 10; mySourceObs.pipe( mergeMap(data => generateAnotherObservable(data), concurrencyFactor) ).subscribe(); 一旦订阅了观察链，是否有一种方法可以动态更改concurrencyFactor？您可以这样做，但当concurrencyFactor更改时，内部观察将重新启动 concurrency

先决条件： 如果 task.snapshotChanges（）-可观察已完成 此代码段有效： task.snapshotChanges().subscribe({ complete: () => { ref.getDownloadURL().subscribe((downloadUrl) => console.log(downloadUrl)); } }); concat( task.snapshotChanges(), ref.getDownloadURL

我在组件的HTML中定义了以下内容： 重置密码 其中，[ladda]是一个自定义指令，当相应变量为true时，该指令在按钮上显示加载图标；在这种情况下，变量名为isLoading。通常我在点击服务器时会这样做，所以我会在点击服务器之前将isLoading设置为true，然后在返回响应时将其设置为false 当我尝试使用rxjs管道/最终确定模式时，这有点麻烦。如果运行以下操作，则不会检测到更改： this.passwordService.resetPassword（输入） .pipe（完成（（

我一直在使用RX-RX节点的节点扩展，但在使用特定函数writeToStream时遇到了问题 以下示例不向console process.stdout发送任何值： var Rx = require('rx'); var RxNode = require('rx-node'); var source = Rx.Observable.range(0, 5); var subscription = RxNode.writeToStream(source, process.stdout, 'utf8')

这个愚蠢的问题把我难住了。我想根据流中的数据给出不同的去BounceTime。我有： const fakeData = [{number: 1}, {number: 2}, {number: 3}]; const stream$ = Rx.Observable.from(fakeData); const delayedStream$ = stream$.concatMap(x => Rx.Observable.of(x).delay(300)); delayedStream$ .co

我正在为Stomp over WebSocket构建一个小小的RxJS包装器，它已经可以工作了 但是现在我想到了一个非常酷的特性，它可能（如果我错了，希望能纠正我的错误）很容易用RxJS实现 当前行为： 如您所见，我必须等待state==“CONNECTED”才能订阅subscribedestation（…）。否则我会从Stomp库中得到一个错误 新行为： 下一个实现应该会让用户更容易。以下是我的想象： myStompWrapper.configure("/stomp_endpoint");

在这种情况下，searchQuery$是一个RxJS可观察的。我知道当用户界面上的搜索查询字符串发生变化时，这个可观察的会发出变化 我向这个控件引入了另一个名为paging$的Observable来执行分页。此可观察发出页码。当页面更改时，我必须再次调用服务器来检索剩余的书籍 当我在用户单击页面时调用服务器时，我有页码，因为它直接来自用户界面，而不是searchQuery$Observable发出的搜索字符串 如何结合使用RxJS将searchQuery$和paging$检索搜索字符串和页码 更

我需要将回调方法链接到可观察链 private testMethod(): Rx.Observable<any> { const deferred = this.$q.defer(); let promise = deferred.promise; this.$window.fileChooser.open((results: any) => { deferred.resolve(results);

我有各种各样的方法，最近我将它们从返回承诺转换为返回可观测值。目前，这些方法通常只返回一个值。所以，在我以前调用myMethod.then（）的地方，我切换到了myMethod.first（）.subscribe（）。我这样做而不仅仅是subscribe（），因为我希望可以自动完成和清理可观察和订阅。我对这一点的理解正确吗？这是一种合理的方法吗？如果您以前的承诺现在是一个可观察的，并且在发出其值后完成，那么您不必为生命周期清理添加.first（）。这仅仅是对你的可观察对象的一个修改，以向未来的你

给定一个可观察对象中的流，我想验证/检查每个项目。如果一个被破坏，我想通过Observable.throw抛出一个错误，从而破坏所有进一步的处理 我笨拙的解决办法是 import * as Rx from 'rxjs' inputStream.mergeMap(item => (isValid(item)) ? Rx.Observable.of(item) : Rx.Observable.throw(new Error("not valid")) ) 这看起来很难看，因

在RxJava中获取种子的scan（）操作符在每次订阅时发出种子。其他RX语言，如RxJS和RxSwift，则不这样做。种子值永远不会发出 为什么会这样？假设RxJava有一个附加的特性，而其他RX语言从未预料到扫描会这样做，这是否安全 RxJs&RxSwift RxJava 我不记得为什么RxJava从一开始就这么做了。我的猜测是，通过使用skip（1），如果需要，您总是可以从扫描中省略第一项。您可以使用种子启动，但这会增加更多开销。

在存储的值为真之前，是否有一种模式可以使redux可观察到epic缓冲区 const uploadsCompleteEpic = (action$, store) => { return action$ .ofType(actionTypes.UPLOAD_SUCCESS) .bufferWhen(store => store.getState().remaining -1 === 0) .do(action => console.log(actio

我想实现一个具有3个特定属性的可观察/主体 记住最后发出的值，并能够通过getter（BehaviorSubject）将其显示出来 仅在值更改时发射 它必须有一个强类型，以便消费者知道getter是可用的（aka.BehaviorSubject.getValue（）） 我正在考虑扩展BehaviorSubject，但希望确保我没有根据新手的理解引入任何潜在的陷阱 export class DistinctUntilChangedBehaviorSubject<T, TValue> e

假设我有观测到的A，B，C。我必须听这三者的变化，并改变一个计算 i、 例如，在任何一个观测值发生变化时，我需要用当前的新值和剩余观测值的旧值重新计算 我尝试使用CombineTest，这是完美的，除了第一个行为，即所有可观察对象的值都应该有最新的/更改。在将每个源可观察对象传递到CombineTest之前，您只需在其前面加上startWith操作符： combineLatest( obsA$.pipe(startWith(null)), obsB$.pipe(startWith(nul

如何在3个流之间共享startWith（false）状态？我尝试使用with latestfrom（）但该值出现了一些奇怪的错误 const Home=componentFromStream（prop$=>{ const{handler:toggleHandler，stream:toggle$}=createEventHandler（）； const{handler:showHandler，stream:show$}=createEventHandler（）； const{handler:hid

RxJS的新功能。并且可以观察到redux 我遇到问题，我正在尝试在下面的代码中调度（takeAction（））的中游操作，然后侦听来自此的响应操作，可以是RESOLVE\u TAKE类型，也可以是REJECT\u TAKE类型。但是我的（takeAction）的没有触发，有人知道如何修复下面的代码吗 除了这个问题，还有一个额外的好处：关于如何重构代码的任何风格建议，我不确定这是否是最干净、最可读的方式。我正在进行提取，然后在不同的状态代码上切换，然后获取res（提取的响应）和reply，如果可

我使用的库使用非常常见的BehaviorSubject模式公开来自服务类的数据。实现和我自己看到/使用的唯一显著区别是添加了一个带有shareReplay1操作符的管道。我不确定是否需要shareReplay。在这种情况下，shareReplay有什么影响（如果有的话） // "rxjs": "^6.3.0" this.data = new BehaviorSubject({}); this.data$ = this.data.asObservable().pipe( shareRepla

我有一个界面： export interface Device { id: string; name: string } 我用额外的数据模拟http响应： import { Injectable } from '@angular/core'; import { Device } from './device.model'; import { Observable, timer } from 'rxjs'; import { mapTo } from 'rxjs/operators';

你好！我想实现一种方便的方法，将多个文件上传到sftp服务器，方法是将每个上传的文件回调到服务器 我已经尝试实现了一些有效的代码，但我发现存在内存泄漏，不允许在所有下载之后成功关闭与sftp服务器的连接 不断地打开和关闭连接对我来说绝对不重要 我从这里稍微调整了一下代码： 代码： 使用 如果将文件上载到sftp服务器时出错，则连接不会关闭，并且在打开自定义控制台时无法重新连接。我想将代码转换为Rxjs以提供更好的支持，我认为我可以解决关闭连接和应用程序响应性的问题 确保您使用的是最新版本的ssh

我从一个减缩器中订阅一个值，它将始终为真。当我第一次订阅它时，它工作了。但下次就不是了。根据我的研究，这个值总是真的，如果我把这个值改成false，那么它就可以正常工作了 因此，订阅或取消订阅都会给观察者带来不同的价值。目前我确实喜欢这样： this.store.dispatch(new actionsMc.CheckConcurrencySuccess(false)); this.store.dispatch(new actionsMc.CheckConcurrency(true)); 即使

我必须对API执行3个相关请求 第一次检索用户id的数组 第二种方法必须迭代用户id的数组，每次检索一个与用户相关的项目id数组 第三种方法必须迭代项目id的数组并检索与项目相关的数据 我想要这样的结果： [{'username': 'richard', projects: [{"id": 1, "name": "test"}]}, ...] 但我完全被mergeMap、forkJoin等所困扰 我尝试过的事情： getUserTeamMembers(): Observable<any&

我正在寻找一种方法来缓冲一个可观察对象的值，直到其他可观察对象发出，然后再发出所有以前的值。类似于skipUntil的东西，如果skipUntil在第二个可观察对象发出时也发出跳过的值 --a--b----c-----d---e--- (source) -----------1------------- (other1) ------------abc-d---e----(desired output) 您可以使用： 您可以使用： 这是我找到的海关接线员。不确定是否可以用更漂亮的方式来做 ex

我有无限的事件流，可以发出一些连续的事件部分，我希望每1000毫秒发生一个事件 我尝试了debounceTime/auditTime/throttleTime，但它们不包括我想要的所有事件-以演示我创建的行为，在10个事件中，每300ms触发一次事件： debounceTime（1000）将只提供事件35;10 throttleTime（1000）将给出事件1,5,9，但它将忽略10 这是必要的 auditTime（1000）将给出事件4,8 我想在这里得到的是事件1,5,9,10（每100

我有以下功能正在工作，如果鼠标向下事件是右键单击，我不想触发开关映射 this.zone.runOutsideAngular(() => { let mousedown$ = Observable.fromEvent(this.handle, 'mousedown'); let mousemove$ = Observable.fromEvent(document, 'mousemove'); let mouseup$ = Observable.fromEvent(d

嗨，我是ngrx的新手。我试图实现的是有一种方法，可以重复执行一个操作，以获取可观察对象中项目的状态更新，直到可观察对象为空。第一次 在我想重复执行动作的那一分钟，假设每5秒执行一次，然后将其减慢到10秒。但在这个过程中，我似乎无法更新延迟的持续时间。 如果能就如何实现这一目标提出任何建议，我将不胜感激 this.myObservable$ .烟斗( 延迟（pollDelay）， takeUntil（这个._销毁）， 地图（项目=>{ console.warn（新日期（））； 如果（初始轮询直到

我正在调用需要在服务器上进行身份验证的端点 /users/：userId/my/endpoint=>getData（）：可观察的 如果身份验证过期，服务器将以错误响应。然后我就可以用我邮寄的客户端密码刷新这个身份验证了 /refresh/me=>refreshAuth（）：可观察的 在那之后，我将再次发送第一个请求并获得成功响应（happy case） 我如何用一个可观察的目标来实现这一点？我知道，例如有catchError和retry getData() .pipe( catchE

一个空的可观察对象的类型签名是什么 考虑下面的例子。下面的concat中的第一个流不发出任何值，并最终完成。我如何让typescript知道emptyOf返回一个不发出任何值的可观察对象 函数清空（流$：可观察）：可观察{ 返回流$.pipe（过滤器（=>false））； } 海螺( 清空（pageLoadingStages$）， 欢迎留言$ ).subscribe（）； 我想你可以试试可观察的，从 export const EMPTY=新的可观察对象（subscriber=>subscribe

和可观察。createWithDisposable之间有什么区别？通过文档或查看源代码，我看不出有什么不同。看起来像是createWithDisposable用一个返回默认一次性值的subscribe函数包装用户提供的subscribe函数，而create需要用户提供的subscribe函数显式返回一个可丢弃的 [create]是createWithDisposable方法的别名 这两个功能可以互换createWithDisposable已被弃用。您应该使用create create函数可以返

我一直试图在Kefir drag div示例中考虑drag end stream/observeble，但没有取得任何进展。在mousedown、mousemove和mouseup组合之后触发事件似乎是有意义的，但我就是找不到一种方法来让它工作。有什么想法吗？这对我来说很好： var dragTarget = document.querySelector('#draggable'); var mouseDowns = Kefir.fromEvents(dragTarget, 'mousedow

错误被抛出并替换。但执行结束了。如何使可观察发射10个元素 const Rx = require('rxjs/Rx') Rx.Observable.interval(1000) .map((i) => { if (i === 2) throw(new Error('omg')) return i }) .take(10) .catch((err) => { return Rx.Observable.of('ok, we caught an e

在第27行中，您将看到 this.books$=store.select（fromRoot.getSearchResults） 选择器功能getSearchResults由其他选择器功能组成，它们是getSearchState和getBoosState 我的问题是 存储。选择是RxJS可观察功能还是ngrx功能 store.select函数如何传递存储上下文，以便最里面的函数可以访问它 select是一个RxJS运算符，在中定义并绑定为的方法 存储是一个可观察的对象，它在接收到一个动作并将该动

我正在为我的应用程序制作一个启动屏幕。在进入主屏幕之前，我希望它至少持续N秒 我有一个Rx变量myObservable，它从服务器或本地缓存返回数据。如何强制myObservable在至少N秒内完成 myObservable // .doStuff to make it last at least N seconds .subscribe(...) 您可以使用forkJoin等待两个观察完成： Observable.forkJoin(myObservable, Observable.ti

我使用产生大量事件的WebSocket服务，并且我希望根据存储中指定的时间，缓冲由WS-events触发的一些操作（可以禁用缓冲，因此也可以是0毫秒）。至于现在，我有一些类似的东西： const eventEpic = (action$, store) => { return action$.ofType(ACTION) ::bufferWhen((action) => { const { time } = action.payload

有人，请解释一下SwitchMap和FlatMap在Javascript方面的区别（在角度透视图中，rxjs 5） 据我理解 SwitchMap仅发出最新的可观察值，并取消先前的可观察值 flatMap收集所有单个可观测数据，并返回单个数组中的所有可观测数据，而不考虑可观测数据的顺序。异步工作 concatMap保持秩序并发出所有可观察值，同步工作 是这样吗 mergeMap与上面的工作方式有什么不同 有人，请举例说明。至少对我来说，这在开始时有点难理解 不管怎样，考虑一下： flatMap是m

使用observable，我有一个searchTextStream、一个enterKeyStream和resultStream 我有类似这样的搜索和获取结果的工具（我相信我可以通过使用cold observable进行改进） 我正在尝试获取ENTER上的数据结果，但使用最新的resultStream。需要注意的是，如果我正在键入，我不想得到旧的resultStream 三种情况 结果是令人满意的。我按下回车键，我想得到结果。这里，combinelatetest非常简单 结果显示在中，但我键入更多

我应该在RxJs 6中始终使用管道吗。即使只有一个操作员 假设我有一个带单运算符的代码 observableOf([1, 2, 3]) .pipe( map(num => num * 2) ) 我可以不用管道写作吗。代码将如下所示 observableOf([1, 2, 3]) .map(num => num * 2); 对于只有一个操作符的员工来说，这可以吗？或者这是不推荐的语法？您混合了RxJS 6和RxJS 5两种类型的操作符 因为RxJS 6始终只使用管道操

我正在尝试使用RxJS streams实现一个可切换的自动保存功能。目标是： 启用自动保存时，将更改发送到服务器 禁用自动保存时，缓冲更改并在重新启用自动保存时将其发送到服务器 以下是我遇到的情况： autoSave$=newbehaviorsubject（true）； 更改$=新主题（）； 更改$管道( 缓冲开关( autoSave$.pipe（过滤器（autoSave=>autoSave==false））， （）=>autoSave$.pipe（过滤器（autoSave=>autoSav

我试图创建一个可观测的，将发出延迟值。然而，这些值是不稳定的。我已经在这里创建了一个stackblitz。代码如下： import { of } from 'rxjs'; import { map, delay } from 'rxjs/operators'; const arr = [1,2,3,4,5]; const source = of(...arr); const source2 = source.pipe(delay(2000)); const subscribe = source

正如标题所示，我希望将iterable中的每个值延迟一段时间，同时保持对iterable的惰性评估。这是到目前为止我所得到的最接近的一个，它适用于有限可数或那些不抛出错误的可数 function* iter () { let i = 0 while (true) yield i++ } rxjs.zip( rxjs.from(iter()), rxjs.timer(500, 500), x => x ).subscribe(console.log) 另一种方法可能是

刚开始学习RxJS。对combineAll运算符感到非常困惑。如果您能解释一下这个示例代码，我将不胜感激： // emit every 1s, take 2 const source$ = interval(1000).pipe(take(2)); // map each emitted value from source to interval observable that takes 5 values const example$ = source$.pipe( map(val =&g

我写了这段代码 timer(0, 100) .pipe( windowTime(1000), take(3), flatMap( value => value.pipe(toArray()))) 我不明白为什么在订阅中我只得到2个值。无论n取什么，我总是在订阅中获得n-1值 你能解释一下为什么吗 编辑：我怀疑有一个bug，所以我 有趣的问题 因此，windowTime（1000）将每隔1000毫秒发出一个新窗口。但窗户到底是什么？一个窗口是主题实例 wi