each for filters

Command Type

built-in

Signature

> each {flags} (closure)

Flags

• --keep-empty, -k: Keep empty result cells.
• --flatten, -f: Combine outputs into a single stream instead of collecting them to separate values.

Parameters

• closure: The closure to run.

Input/output types:

Examples

Multiplies elements in the list.

> [1 2 3] | each {|e| 2 * $e }
╭───┬───╮
│ 0 │ 2 │
│ 1 │ 4 │
│ 2 │ 6 │
╰───┴───╯

Produce a list of values in the record, converted to string.

> {major:2, minor:1, patch:4} | values | each {|| into string }
╭───┬───╮
│ 0 │ 2 │
│ 1 │ 1 │
│ 2 │ 4 │
╰───┴───╯

'null' items will be dropped from the result list. It has the same effect as 'filter_map' in other languages.

> [1 2 3 2] | each {|e| if $e == 2 { "two" } }
╭───┬─────╮
│ 0 │ two │
│ 1 │ two │
╰───┴─────╯

Iterate over each element, producing a list showing indexes of any 2s.

> [1 2 3] | enumerate | each {|e| if $e.item == 2 { $"found 2 at ($e.index)!"} }
╭───┬───────────────╮
│ 0 │ found 2 at 1! │
╰───┴───────────────╯

Iterate over each element, keeping null results.

> [1 2 3] | each --keep-empty {|e| if $e == 2 { "found 2!"} }
╭───┬──────────╮
│ 0 │          │
│ 1 │ found 2! │
│ 2 │          │
╰───┴──────────╯

Return "hello $name" for each name in the list of names $env.name, or return "bye" if $env.name does not exist.

> $env.name? | each { $"hello ($in)" } | default "bye"

Scan through multiple files without pause.

> ls *.txt | each --flatten {|f| open $f.name | lines } | find -i 'note: ' | str join "\n"

Print chunks of data from an external command as soon as they become available.

> ^$nu.current-exe -c 'print hello; sleep 0.5sec; print world' | each { print $in } | ignore

Notes

Since tables are lists of records, passing a table into 'each' will iterate over each record, not necessarily each cell within it.

Avoid passing single records to this command. Since a record is a one-row structure, 'each' will only run once, behaving similar to 'do'. To iterate over a record's values, use 'items' or try converting it to a table with 'transpose' first.

By default, for each input there is a single output value. If the closure returns a stream rather than value, the stream is collected completely, and the resulting value becomes one of the items in each's output.

To receive items from those streams without waiting for the whole stream to be collected, each --flatten can be used. Instead of waiting for the stream to be collected before returning the result as a single item, each --flatten will return each item as soon as they are received.

This "flattens" the output, turning an output that would otherwise be a list of lists like list<list<string>> into a flat list like list<string>.

String or byte streams, empty pipelines, null values, ranges, and some custom values can also be used as inputs to 'each'. A stream of bytes or strings (usually from external commands) will be treated as though it was a list of chunks of the stream, where the size of the chunks are determined arbitrarily. Empty pipelines and null values are both returned unchanged from 'each' without calling the provided closure. Ranges and custom values which can be iterated will be treated as lists of the values they represent.

Subcommands: