rxjs与Array.some（）的等价物是什么？

如果要迭代数组以查看某些元素是否通过条件，请执行以下操作：

let result = [1, 34, 65, 3, 7].some(entry => entry > 10)
// result => true

rxjs的等效功能是什么？ 我想是这样的（这并不完全正确）：

//函数返回可观察的
来自（[fn1，fn2，fn2]）管道(
映射（fn=>fn（）），
takeUntil（数据>100）
).subscribe（数据=>console.log（`result:${data}`）

---

（来自fn的返回值始终是异步的）

等效值将与以下相反：

from（[1,34,65,3,7]）管道(
每个（（项目）=>项目<10），
映射（（isEvery）=>！isEvery）
).subscribe（（e）=>console.log（e））//true

我认为没有原生的

some

，但是您可以通过使用这两个管道自己创建它

如果要迭代数组以查看是否所有元素都通过一个条件，可以执行以下操作：让result=[1,34,65,3,7].some（entry=>entry>10）//返回true

错误。您需要使用

every

检查所有元素是否都通过条件 如果任何元素序列满足一个条件，则使用一些

对于RX.js来说也是一样的

from([1, 34, 65, 3, 7]).pipe(
  every((item) => item < 10),
  .... //rest of the operations
)

from（[1,34,65,3,7]）管道(
每个（（项目）=>项目<10），
..//其余的操作
)

在RxJs中，至少在afaik中，没有与某些操作符直接等价的东西。同时，可以实现类似的东西

const fn1 = () => of(100).pipe(delay(100))
const fn2 = () => of(200).pipe(delay(200))
const fn3 = () => of(300).pipe(delay(300))

from([fn1,fn2,fn3]).pipe( // where functions return Observable<number>
        concatMap(fn=>fn()),
        filter(d => d > 100),
        toArray()
    ).subscribe({
      next: data => console.log(`Are there elements grearer than 100?`, data.length > 0)
    })

---

相当于

数组。有些

，也就是说，为了检查是否至少有一个元素通过了条件，我认为它应该是

find

const some = (predicate) => source$ =>
  source$.pipe(
    find(predicate),
    mapTo(true),
    defaultIfEmpty(false)
  );

这样，只要有一个元素满足谓词，您就会收到一个true（可观察的将完成，因为不会有更多的值出现）。如果它们都不匹配，那么一旦源完成，您就会收到一个false

使用它而不是否定每个的好处是，只要它与谓词匹配，就可以得到

真

，而不必等待整个可观察对象完成

额外：注意，

find

是一个现有的操作符，但它只是

过滤器（谓词）

+

take（1）

编辑：哦！我没有看到你没有一个数字的可观测值，而是一个返回数字可观测值的函数的可观测值

在这种情况下，您需要将其展平-并使用上面描述的

some

操作符：

from([fn1,fn2,fn2]).pipe( // where functions return Observable<number>
  mergeMap(fn => fn()),
  some(data => data > 100)
).subscribe(data => console.log(`result:${data}`)

---

请注意，有两个可能的操作符用于展平观察值：

concatMap

将逐个订阅每个观察值，等待前一个操作完成，然后再订阅下一个操作（保留解析值的顺序），而

mergeMap

将订阅所有不断出现的观察值（但是，如果后面的观测比前面的观测快，则发出的值的顺序将不同）。

100%rxjs运算符相当于：

const{of}=rxjs；
const{map}=rxjs.operators；
const some=cb=>source=>source.pipe(
映射（src=>src.some（cb））
)
常量偶数=元素=>元素%2===0；
（[1,2,3,4]）管道的(
有些（甚至）
).subscribe（console.log）

---

这个数组有一个区别-

数组。一些

会在找到与谓词匹配的元素后立即停止迭代数组。另一方面，对每个求反总是需要遍历整个元素列表。@olivarra1是的，这确实是一个区别。如果这是一个n问题！如果您想创建

some

作为可管道操作符，并让typescript跟随键入，我认为函数签名应该是这样的：

functionsome（fn：（v:T）=>boolean）：OperatorFunction

const fn1 = () => of(100).pipe(delay(100))
const fn2 = () => of(200).pipe(delay(200))
const fn3 = () => of(300).pipe(delay(300))

let found = false;

from([fn1,fn2,fn3]).pipe( // where functions return Observable<number>
        concatMap(fn=>fn()),
        first(d => d > 100),
        tap(() => found = true)
    ).subscribe({
      error: (e) => {
        if (e.name === "EmptyError") {
          console.log(`Are there elements grearer than 100?`, found)
        }
        else {
          console.error(e)
        }
        },
      complete: () => console.log(`Are there elements grearer than 100?`, found),
    })

const some = (predicate) => source$ =>
  source$.pipe(
    find(predicate),
    mapTo(true),
    defaultIfEmpty(false)
  );

from([fn1,fn2,fn2]).pipe( // where functions return Observable<number>
  mergeMap(fn => fn()),
  some(data => data > 100)
).subscribe(data => console.log(`result:${data}`)

from([fn1,fn2,fn2]).pipe( // where functions return Observable<number>
  mergeMap(fn => fn()),
  find(data => data > 100),
  mapTo(true),
  defaultIfEmpty(false)
).subscribe(data => console.log(`result:${data}`)