posix shell: print list of environment variable names (without values)

Question

In a posix-compatible way that works with multiple implementations, how can I print the list of currently defined environment variable without their values?

On some implementations (mksh, freebsd /bin/sh), just using export by itself will fit the bill:

$ export
FOO2
FOO

But for some other implementations (bash, zsh, dash), export also shows the value. With bash, for example:

$ export
export FOO2='as  df\
  asdk=fja:\
asd=fa\
asdf'
export FOO='sjfkasjfd  kjasdf:\
   asdkj=fkajdsf:\
       :askjfkajsf=asdfkj:\
   safdkj'
$ printenv | sed -n l
FOO2=as\tdf\$
  asdk=fja:\$
asd=fa\$
asdf$
FOO=sjfkasjfd  kjasdf:\$
   asdkj=fkajdsf:\$
\t:askjfkajsf=asdfkj:\$
   safdkj$

Other options like env or printenv don't have options to print just the variable names without values, at least not on the linux and freebsd platforms I have tried.

Piping to awk/sed/etc. or trimming the list with parameter expansion techniques (e.g., ${foo%%=*}) is acceptable, but it has to work with values that may span lines and have = and whitespace in the value (see example above).

Answers specific to particular shell implementations are interesting, but I am primarily looking for something that is compatible across implementations.

Answer 1

It's pretty easy in awk.

awk 'BEGIN{for(v in ENVIRON) print v}'

However beware some awk implementations add environment variables of their own (e.g. GNU awk adds AWKPATH and AWKLIBPATH to ENVIRON).

The output is ambiguous if the name of an environment variable contains a newline, which is extremely unusual but technically possible. A pure sh solution would be difficult. Your best bet is to start with export -p but massaging it in pure sh is difficult. You can use sed to massage the output of export -p, then use eval to get the shell to remove what it quoted. Bash and zsh print non-standard prefixes.

report () { echo "${1%%=*}"; };
eval "$(export -p | sed "s/^export /report /;
                         s/^declare -x /report /;
                         s/typeset -x /report /")"

Note that depending on the shell, export -p may or may not show variables whose name is not valid in the shell, and if it doesn't, then it may or may not quote the names properly. For example, dash, mksh and zsh omit variables whose name includes a newline, BusyBox dash and ksh93 print them raw, and bash prints them raw without their value. If you need to defend against untrusted input, don't rely on a pure POSIX solution, and definitely don't call eval on anything derived from the output of export -p.

Answer 2

Here is my solution, which nicely handles environment variables having multi-line values:

env -0 | cut -z -f1 -d= | tr '\0' '\n' | sort | column

This will print the environment using NUL to delimit variables instead of newlines (env -0).

Then we eliminate the variable values using cut -z -f1 -d=, where the -z option specifies NUL-delimited records, -f1 is the first field, and -d= says that fields are delimited by =.

tr '\0' '\n' will convert the NUL delimiters to newlines.

Then I like to sort the variable names and display them in columns.

Answer 3

I like simple things; this will work for POSIX systems:

printenv | sed 's;=.*;;' | sort
HOME
HOSTNAME
PATH
PWD
SHLVL
TERM

Answer 4

This was enough for me to get a list of all exported variable names that handled quoted and multi-lined values:

export | egrep ^declare | cut -d= -f1 | cut -d' ' -f3

As Stephane pointed out, this works in bash, and you'd be better using compgen -e which is bash-only. If you want a 1-liner that works the same in bash, dash and zsh, you can use this instead:

export | egrep '^(declare|export)' | sed -E 's/(^declare -x |export )//' | cut -d= -f1 | cut -d' ' -f2

... although this won't work for multi-line values in dash.

Answer 5

Another approach, with grep:

printenv|grep -o "^[^=]\+"

Answer 6

If you only want to print from a subset of variable names, matching a distinct pattern:

env | awk -F= '$1 ~ /^PREFIX_.*_SUFFIX$/ && /=/ { print $1 }'

Example pattern matches variables named like PREFIX_ANYTHING_SUFFIX.

Obviously test that the chosen pattern is sufficiently distinct and avoids conflict with values of any multi-line variables (such as TERM).