readable.filter(fn[, options])
¥Stability: 1 - Experimental
-
fn
<Function> | <AsyncFunction> 从流中过滤块的函数。¥
fn
<Function> | <AsyncFunction> a function to filter chunks from the stream.-
data
<any> 来自流的数据块。¥
data
<any> a chunk of data from the stream. -
options
<Object>-
signal
<AbortSignal> 如果流被销毁则中止,允许提前中止fn
调用。¥
signal
<AbortSignal> aborted if the stream is destroyed allowing to abort thefn
call early.
-
-
-
options
<Object>-
concurrency
<number> 一次调用流的fn
的最大并发调用数。默认值:1
。¥
concurrency
<number> the maximum concurrent invocation offn
to call on the stream at once. Default:1
. -
highWaterMark
<number> 在等待用户消耗已过滤项目时要缓冲多少项目。默认值:concurrency * 2 - 1
。¥
highWaterMark
<number> how many items to buffer while waiting for user consumption of the filtered items. Default:concurrency * 2 - 1
. -
signal
<AbortSignal> 如果信号中止,允许销毁流。¥
signal
<AbortSignal> allows destroying the stream if the signal is aborted.
-
-
返回:<Readable> 使用谓词
fn
过滤的流。¥Returns: <Readable> a stream filtered with the predicate
fn
.
此方法允许过滤流。对于流中的每个块,将调用 fn
函数,如果它返回真值,则该块将传递到结果流。如果 fn
函数返回一个 promise - 这个 promise 将会被 await
。
¥This method allows filtering the stream. For each chunk in the stream the fn
function will be called and if it returns a truthy value, the chunk will be
passed to the result stream. If the fn
function returns a promise - that
promise will be await
ed.
import { Readable } from 'node:stream';
import { Resolver } from 'node:dns/promises';
// With a synchronous predicate.
for await (const chunk of Readable.from([1, 2, 3, 4]).filter((x) => x > 2)) {
console.log(chunk); // 3, 4
}
// With an asynchronous predicate, making at most 2 queries at a time.
const resolver = new Resolver();
const dnsResults = Readable.from([
'nodejs.org',
'openjsf.org',
'www.linuxfoundation.org',
]).filter(async (domain) => {
const { address } = await resolver.resolve4(domain, { ttl: true });
return address.ttl > 60;
}, { concurrency: 2 });
for await (const result of dnsResults) {
// Logs domains with more than 60 seconds on the resolved dns record.
console.log(result);
}