$ cat test2.txt | norl -B 'total=0' -ane 'total+=parseInt($F[1])' -PE '$_=total:${total}'
total:15

-ne : same as -pe but doesn't print $\_ each line.

-B /-E : executs at begining(-B) / end(-E) of stream. works with -n/-p option.

$ cat test2.txt|norl -a -pe '$_=$F[1]'
12
30

-a option: automatic split. $F=$\_.split(',') before -e , you can change separator by -F option




$3

$ export NORL_MODULES="request-promise fs"
$ cat urls.txt | norl -ne 'return request_promise($_)' -E 'for(i in $_){fs.writeFileSync(robots-${i}.txt,$_[i]) }'
robots-0.txt:contains google.com's robots.txt
robots-1.txt:contains yahoo.com's robots.txt

if Promise is returned by each -pe / -ne program, norl prints(-pe) or collects(-ne) it and Promise.all() to wait before -E program. if -ne, then pass the result array into -E program via $\_

$3

$ cat waits.txt | norl -ane 'return ((name,timeout,cb)=>{console.log(${name}:${timeout}secs);setTimeout(()=>{cb(null,name+":OK");},timeout*1000)}).bind(null,$F[0],Number($F[1]));'
A:5secs
B:1secs (<-after 5secs from 1st line)
C:3secs (<-after 1secs from 2nd line)

returned function from each -ne / -pe program will be queued and waits for all callbacks then prints(-pe) or collects(-ne) before running -E program.if -ne, then pass the result array into -E via $\_

the function must be async.js style like '(cb)=>cb(null,"OK")' , if you specify -c or -C ,you must return array like '(cb)=>cb(null,[1,2,3])'

you can pass parameters via .bind() like this example. by default, execution is sequential. you can control it by -L [] option. try to append -L 2 to the example above to check behavior. 2 is a number of executables in parallel. if you omit , 16 will be used.

-B / -E function also supports async callback. result of -E will be printed if -P or -J is specified. result of -B function is alwasys dropped.

$3

$ cat test.txt | norl -axpe '$_=echo ${$F[0]}|tr "o" "O"'
HellO
GOOdnight

-x option: execute $\_ as shell command after each -pe then print stdout of the command, works only with -p. you can use norl like xargs

note that don't forget to assign $\_. -x option executes $\_ string not your -pe program itself.

tips: process stops at error condition ($?!=0) at LAST command. you can ignore error code by appending '|cat' at end of shell command like $\_='wc -l noexists | cat'

$ echo -e "README.md\nnotexists.txt\npackage.json"|norl -Xpe '$_=test -e ${$_}'
README.md
package.json

-X option: same as x but pass-through input line instead of printing stdout of shell command. checks $? result code each execution then print input line if $?==0. unlike -x, -X DOESNT stop execution when $!=0

you can easy to create filter program with 'test' or 'grep'.

tips: all data(code/stdin/stdout/cmd) from each shell command will be collected and passed to -E via $\_. appending -E "console.error(JSON.stringify($\_,null,2))" is useful for debugging.

$3

$ if cat README.md|norl -ae 'return $F.length<15?false:true';then echo "README.md is too short";fi
README.md is too short (if number of lines of README.md are under 15)

if you return a boolean(true/false) at the final (-e or -E) program. the number will be norl's shell result code ($?),true=0/false=1. You can use norl like 'test' command inside bash if.

$3

$ norl -pe '$_=stream:${$S} ${$_}' file1.txt file2.txt
stream:0 file1's 1st line
stream:0 file1's 2nd line
stream:1 file2's 1nd line
stream:2 file2's 2nd line

with (-p / -n), same -e program will be called with every file's line. -e program is able to know the file number (0,1,..) by special value $S.

$3

$ norl -Pe '$\_=$\_.replace(/\_VERSION\_/g,"1.2.0")' -O destDir/ package.json README.md LICENSE.txt
destDir/package.json
destDir/README.json
destDir/LICENSE.json (All files "\_VERSION\_" strings were replaced by 1.2.0)

Similar to Multi-Input Mode, but MIMO mode is very simpler than Multi-Input (single out) mode.

if you specify destination dir by -O option with multiple input files. program will be execute file by file. MIMO mode is just a short hand of

$ for f in file1 file2;do cat $f | norl -Pe 'program' >destdir/$f; done.

unlike Multi-Input(single out) mode, you can't join each file. but MIMO mode is very useful when embed something to template file like example above.

$3

if you return a string from the program. it will be copied to $\_ automatically.
special abbriviation function '=>..' is short hand for '($\_,$F,$S)=>..' . you can make the program shorter.

$ echo "Hello" | norl -pe 'return $\_+"World"'
#can be
$ echo "Hello" | norl -pe '=>$_+" World"'
Hello World

$3

all variable names which start from $.. (except $\_ / $F / $S) and \_(for lodash) are preserved.but you can use some of preserved functions.

$P and $E are predefined to console.log and console.error
this means you can rewrite console.log/console.error by $P / $E e.g.

$ echo "Hello" | norl -e 'console.log($_);console.error("warning")'
#can be
$ echo "Hello" | norl -e '$P($_);$E("warning")'

additinally, $s / $m (lower case) are useful to write String.replace()/String.match() shorter.(only works in -e not for -B -E)

$ echo "Hello World" | norl -pe '=>$_.replace(/world/i,"Norl")'
#can be
$ echo "Hello World" | norl -pe '=>$s(/world/i,"Norl")'
Hello Norl #definition:$s=(regex,replacement)=>$\_.replace(regex,replacement)

$ echo "Hello World" | norl -pe '=>($_.match(/Hello (W.+)/) || [])[1]'
#can be
$ echo "Hello World" | norl -pe '=>$m(/Hello (W.+1)/)[1]'
World #definition:$m=(regex)=>($\_.match(regex)||[])

$e is shorthand for process.env. definition is $e=(name)=>process.env[env]

Use as Module

norl provides module interface. you can write your own CLI filter program easier.

`
npm install norl

echo '{"s":"Hello World"}'| node -e 'require("norl").e(($G,$_)=>{console.log(JSON.parse($_).s);})'


Hello World

echo -e "Hello\nWorld"| node -e 'require("norl").ne(($G,$_)=>{console.log($_.replace(/Hello/,"Hi!"))})'


Hi!

echo -e "Hello\nWorld"| node -e 'require("norl").ne(($G,$_)=>{$G.count+=$_.length},($G)=>{$G.count=0},($G)=>{console.log(Chars:${$G.count})})'


Chars:10

require.("norl").r()

require.("norl").e()

Change Log

- 3.1.x: adds $e(name) (shorthand for process.env[name]) / able to use => with -xpe -Xpe like =>'echo hello'
- 3.0.x: adds $s / $m shorthands for $_.replace()/ $_.match()
- 3.0.x: -pe 'return "FOO"' prints "FOO" instead of $_. adds special abbriviation '=>...'
- 3.0.x: Breaking change: returning Number will print out the number instead of return code. if you return code like test command, use Boolean.
- 2.4.x: -m './foo/bar' style module path support/-S search node\_modules before NODE\_PATH/async func at -B suppport/automatic => detection/automatic print for async func on -pe
- 2.3.x: added Multi-Input-Multi-Out mode (-O)
- 2.2.x: supports file input and multi-input mode.
- 2.1.x: controling process.exit(n) code by returning number at final function.(-P -J will be cancelled)
- 2.0.x: -x/-X option, async.js style callback support. -L option
- 1.1.x: adds -c option/able to omit -a when -F is specified
- 1.0.x: first release