How to list variables declared in script in bash?

Question

In my script in bash, there are lot of variables, and I have to make something to save them to file. My question is how to list all variables declared in my script and get list like this:

VARIABLE1=abc
VARIABLE2=def
VARIABLE3=ghi

Answer 1

set will output the variables, unfortunately it will also output the functions defines as well.

Luckily POSIX mode only outputs the variables:

( set -o posix ; set ) | less

Piping to less, or redirect to where you want the options.

So to get the variables declared in just the script:

( set -o posix ; set ) >/tmp/variables.before
source script
( set -o posix ; set ) >/tmp/variables.after
diff /tmp/variables.before /tmp/variables.after
rm /tmp/variables.before /tmp/variables.after

(Or at least something based on that :-) )

Answer 2

compgen -v

It lists all variables including local ones. I learned it from Get list of variables whose name matches a certain pattern, and used it in my script.

Answer 3

for i in _ {a..z} {A..Z}; do eval "echo \${!$i@}" ; done | xargs printf "%s\n"

This must print all shell variable names. You can get a list before and after sourcing your file, just like with set. Then you can diff which variables are new (as explained in the other answers). However, keep in mind that filtering with diff can miss some variables that were changed, because they were present both - before and after sourcing your file.

In your case, if you know that your variables' names start with "VARIABLE", then you can source your script and do:

for var in ${!VARIABLE@}; do
   printf "%s%q\n" "$var=" "${!var}"
done

UPDATE: For pure BASH solution (no external commands used):

for i in _ {a..z} {A..Z}; do
   for var in `eval echo "\\${!$i@}"`; do
      echo $var
      # you can test if $var matches some criteria and put it in the file or ignore
   done 
done

Answer 4

Based on some of the above answers, this worked for me:

before=$(set -o posix; set | sort);

source file:

comm -13 <(printf %s "$before") <(set -o posix; set | sort | uniq) 

Answer 5

If you can post-process, (as already mentioned) you might just place a set call at the beginning and end of your script (each to a different file) and do a diff on the two files. Realize that this will still contain some noise.

You can also do this programatically. To limit the output to just your current scope, you would have to implement a wrapper to variable creation. For example

store() {
    export ${1}="${*:2}"
    [[ ${STORED} =~ "(^| )${1}($| )" ]] || STORED="${STORED} ${1}"
}

store VAR1 abc
store VAR2 bcd
store VAR3 cde

for i in ${STORED}; do
    echo "${i}=${!i}"
done

Which yields

VAR1=abc
VAR2=bcd
VAR3=cde

Answer 6

A little late to the party, but here's another suggestion:

#!/bin/bash

set_before=$( set -o posix; set | sed -e '/^_=*/d' )

# create/set some variables
VARIABLE1=a
VARIABLE2=b
VARIABLE3=c

set_after=$( set -o posix; unset set_before; set | sed -e '/^_=/d' )
diff  <(echo "$set_before") <(echo "$set_after") | sed -e 's/^> //' -e '/^[[:digit:]].*/d'

The diff+sed pipeline command line outputs all script-defined variables in the desired format (as specified in the OP's post):

VARIABLE1=a
VARIABLE2=b
VARIABLE3=c

Answer 7

Here's something similar to the @GinkgoFr answer, but without the problems identified by @Tino or @DejayClayton, and is more robust than @DouglasLeeder's clever set -o posix bit:

+ function SOLUTION() { (set +o posix; set) | sed -ne '/^\w\+=/!q; p;'; }

The difference is that this solution STOPS after the first non-variable report, e.g. the first function reported by set

BTW: The "Tino" problem is solved. Even though POSIX is turned off and functions are reported by set, the sed ... portion of the solution only allows variable reports through (e.g. VAR=VALUE lines). In particular, the A2 does not spuriously make it into the output.

+ function a() { echo $'\nA2=B'; }; A0=000; A9=999; 
+ SOLUTION | grep '^A[0-9]='
A0=000
A9=999

AND: The "DejayClayton" problem is solved (embedded newlines in variable values do not disrupt the output - each VAR=VALUE get a single output line):

+ A1=$'111\nA2=222'; A0=000; A9=999; 
+ SOLUTION | grep '^A[0-9]='
A0=000
A1=$'111\nA2=222'
A9=999

NOTE: The solution provided by @DouglasLeeder suffers from the "DejayClayton" problem (values with embedded newlines). Below, the A1 is wrong and A2 should not show at all.

$ A1=$'111\nA2=222'; A0=000; A9=999; (set -o posix; set) | grep '^A[0-9]='
A0=000
A1='111
A2=222'
A9=999

FINALLY: I don't think the version of bash matters, but it might. I did my testing / developing on this one:

$ bash --version
GNU bash, version 4.4.12(1)-release (x86_64-pc-msys)

POST-SCRIPT: Given some of the other responses to the OP, I'm left < 100% sure that set always converts newlines within the value to \n, which this solution relies upon to avoid the "DejayClayton" problem. Perhaps that's a modern behavior? Or a compile-time variation? Or a set -o or shopt option setting? If you know of such variations, please add a comment...

Answer 8

If you're only concerned with printing a list of variables with static values (i.e. expansion doesn't work in this case) then another option would be to add start and end markers to your file that tell you where your block of static variable definitions is, e.g.

#!/bin/bash

# some code

# region variables
VAR1=FOO
VAR2=BAR
# endregion

# more code

Then you can just print that part of the file.

Here's something I whipped up for that:

function show_configuration() {
   local START_LINE=$(( $(< "$0" grep -m 1 -n "region variables" | cut -d: -f1) + 1 ))
   local END_LINE=$(( $(< "$0" grep -m 1 -n "endregion" | cut -d: -f1) - 1 ))
   < "$0" awk "${START_LINE} <= NR && NR <= ${END_LINE}"
}

First, note that the block of variables resides in the same file this function is in, so I can use $0 to access the contents of the file.

I use "region" markers to separate different regions of code. So I simply grep for the "variable" region marker (first match: grep -m 1) and let grep prefix the line number (grep -n). Then I have to cut the line number from the match output (splitting on :). Lastly, add or subtract 1 because I don't want the markers to be part of the output.

Now, to print that range of the file I use awk with line number conditions.

Answer 9

The printenv command:

printenv prints all environment variables along with their values.

Good Luck...

Answer 10

Try using a script (lets call it "ls_vars"):

  #!/bin/bash
  set -a
  env > /tmp/a
  source $1
  env > /tmp/b
  diff /tmp/{a,b} | sed -ne 's/^> //p'

chmod +x it, and:

  ls_vars your-script.sh > vars.files.save

Answer 11

From a security perspective, either @akostadinov's answer or @JuvenXu's answer is preferable to relying upon the unstructured output of the set command, due to the following potential security flaw:

#!/bin/bash

function doLogic()
{
    local COMMAND="${1}"
    if ( set -o posix; set | grep -q '^PS1=' )
    then
        echo 'Script is interactive'
    else
        echo 'Script is NOT interactive'
    fi
}

doLogic 'hello'   # Script is NOT interactive
doLogic $'\nPS1=' # Script is interactive

The above function doLogic uses set to check for the presence of variable PS1 to determine if the script is interactive or not (never mind if this is the best way to accomplish that goal; this is just an example.)

However, the output of set is unstructured, which means that any variable that contains a newline can totally contaminate the results.

This, of course, is a potential security risk. Instead, use either Bash's support for indirect variable name expansion, or compgen -v.

Answer 12

Try this : set | egrep "^\w+=" (with or without the | less piping)

The first proposed solution, ( set -o posix ; set ) | less, works but has a drawback: it transmits control codes to the terminal, so they are not displayed properly. So for example, if there is (likely) a IFS=$' \t\n' variable, we can see:

IFS='
'

…instead.

My egrep solution displays this (and eventually other similars ones) properly.

Answer 13

I probably have stolen the answer while ago ... anyway slightly different as a func:

    ##
    # usage source bin/nps-bash-util-funcs
    # doEchoVars
    doEchoVars(){

        # if the tmp dir does not exist
        test -z ${tmp_dir} && \
        export tmp_dir="$(cd "$(dirname $0)/../../.."; pwd)""/dat/log/.tmp.$$" && \
        mkdir -p "$tmp_dir" && \
        ( set -o posix ; set )| sort >"$tmp_dir/.vars.before"


        ( set -o posix ; set ) | sort >"$tmp_dir/.vars.after"
        cmd="$(comm -3 $tmp_dir/.vars.before $tmp_dir/.vars.after | perl -ne 's#\s+##g;print "\n $_ "' )"
        echo -e "$cmd"
    } 

Answer 14

Simple way to do this is to use bash strict mode by setting system environment variables before running your script and to use diff to only sort the ones of your script :

# Add this line at the top of your script :
set > /tmp/old_vars.log

# Add this line at the end of your script :
set > /tmp/new_vars.log

# Alternatively you can remove unwanted variables with grep (e.g., passwords) :
set | grep -v "PASSWORD1=\|PASSWORD2=\|PASSWORD3=" > /tmp/new_vars.log

# Now you can compare to sort variables of your script :
diff /tmp/old_vars.log /tmp/new_vars.log | grep "^>" > /tmp/script_vars.log

You can now retrieve variables of your script in /tmp/script_vars.log. Or at least something based on that!

Answer 15

set | awk '/[[:alnum:]_]+ \(\)/ {exit} {print}'

set shows variables first, so I am looking for the first function with regexp which looks like "^funcname ()"

Answer 16

TL;DR

With: typeset -m <GLOBPATH>

$ VARIABLE1=abc
$ VARIABLE2=def
$ VARIABLE3=ghi
$ noglob typeset -m VARIABLE*
VARIABLE1=abc
VARIABLE2=def
VARIABLE3=ghi

---

¹ documentation for typeset can be found in man zshbuiltins, or man zshall.