Jawk CLI Quickstart

Run an Inline Script

$ echo "hello world" | jawk '{ print $2 ", " $1 "!" }'
world, hello!

C:\> echo hello world | jawk "{ print $2 "", "" $1 ""!"" }"
world, hello!

If you do not pass -f or -L, Jawk expects the next non-option argument to be the AWK program itself.

Run a Script File

Store the AWK program in a file:

totals.awk:

BEGIN {
  total = 0
}
{
  total += $2
}
END {
  print total
}

And point Jawk at it with -f:

$ jawk -f totals.awk values.txt

You can repeat -f to combine multiple script sources before execution.

Read from stdin

If you do not provide input filenames after the script, Jawk reads from standard input:

$ printf "alpha\nbeta\n" | jawk '{ print NR ":" $0 }'
1:alpha
2:beta

You can also request standard input explicitly with the - operand, which makes it possible to interleave it with regular input files. FILENAME is - while standard input is being read:

$ echo "from stdin" | jawk '{ print FILENAME ":" $0 }' before.txt - after.txt

Inside a script, getline < "/dev/stdin" reads the same standard input, and print > "/dev/stdout" and print > "/dev/stderr" write to the standard output and standard error of the process, as they do in gawk. print > "/dev/null" discards its output on every platform, Windows included, and /dev/null may be passed as an operand to read an empty input file. See special filenames^[2] for details.

Read Input Files

Input filenames passed after the script become runtime operands and are processed as AWK input files:

$ jawk -F : '{ print FILENAME ":" FNR ":" $1 }' /etc/passwd /etc/group

Jawk follows the usual AWK distinction between the script itself and the remaining operands. Files and name=value operands after the script are visible through ARGV and ARGC.

Use -- to mark the end of options when the script or the first operand could otherwise be mistaken for an option:

$ jawk -f totals.awk -- values.txt

As in gawk, once the program text has been supplied with -f or -L, an unknown option also ends option processing and is passed on to the AWK program through ARGV, which is useful for #! interpreter scripts.

$ jawk '
    BEGINFILE { if (ERRNO != "") { printf "skipping %s (%s)\n", FILENAME, ERRNO; nextfile } }
    { print FILENAME ":" FNR ":" $0 }' good.txt missing.txt
good.txt:1:hello
skipping missing.txt (No such file or directory)

Pass Variables

Use -v for variables that must exist before BEGIN runs:

$ jawk -v prefix=hello 'BEGIN { print prefix }'
hello

Use name=value operands after the script for AWK-style file-list assignments that take effect before the next input file is consumed:

$ jawk '{ print mode ":" $0 }' mode=csv data.txt

Set the field separator with -F when you want Jawk to split text records differently:

$ jawk -F : '{ print $1 "," $6 }' /etc/passwd

Use --posix when you want POSIX-oriented compile-time behavior from the CLI. In particular, it disables gawk-style nested arrays, so classic multi-dimensional subscripts such as a[i, j] remain valid while a[i][j] is rejected:

$ jawk --posix 'BEGIN { a[1,2] = 42; print a[1,2] }'
42

Because -L loads an already compiled program, Jawk rejects --posix together with -L instead of pretending that it can re-apply compile-time restrictions after the fact.

Load Extensions

List the currently registered extension identifiers:

$ jawk --list-ext

Then load one explicitly:

$ jawk -l GawkExtension -f script.awk

Jawk accepts the registered extension name, the simple class name, or the fully qualified class name; an extension class that is not registered yet resolves by its fully qualified class name only. Additional extension classes can be placed on the JVM classpath before launching Jawk: set JAWK_CLASSPATH when using the jawk launcher, or use java -cp with the io.jawk.Cli main class when running the standalone jar (see Using Extensions^[4]).

When no -l option is given, Jawk enables the built-in GNU Awk compatibility extension^[5], which provides asort(), typeof(), and the other gawk builtins. Passing -l replaces that default set, so add -l GawkExtension when the script still needs the gawk functions:

$ jawk -l GawkExtension -l com.company.my.SampleExtension -f script.awk

Enable Sandbox Mode

Use -S or --sandbox to compile and run the script with sandbox restrictions:

$ jawk -S -f script.awk input.txt

Sandbox mode disables system(), input and output redirection, command pipelines, @include source inclusion, and related features that are intentionally unsafe in a restricted host environment. Every redirection is rejected, whatever the target: the /dev/stdin, /dev/stdout, and /dev/stderr special filenames^[2] are no more reachable from a sandboxed script than a regular file is.

See Also

• CLI Reference^[6] for the full list of options and flags
• Java Quickstart^[7] if you want to embed AWK in a JVM application
• Using Extensions^[4]
• Compatibility and Compliance^[8]