Declaring global variable inside a function

declare inside a function doesn't work as expected. I needed read-only global variables declared in a function. I tried this inside a function but it didn't work:

declare -r MY_VAR=1 

But this didn't work. Using the readonly command did:

func() { readonly MY_VAR=1 } func echo $MY_VAR MY_VAR=2 

This will print 1 and give the error "MY_VAR: readonly variable" for the second assignment.

I think you need the printf builtin with its -v switch:

func() { printf -v "$var" '5' } var=var_name func echo "$var_name" 

will output 5.

Since this is tagged shell, it is important to note that declare is a valid keyword only in a limited set of shells, so whether it supports -g is moot. To do this sort of thing in a generic Bourne shell, you can just use eval:

eval ${arg}=5 

The existence of the local and declare builtin commands may render it counter-intuitive that the wanted functionality is actually available from the export builtin, at least on Bash.

According to the Bash manual, the export command has an -n option, which "causes the export property to be removed from each name". This also applies while declaring variables with values right ahead.

The following snippet demonstrates the usage:

VAR=old-value function func () { export -n "$1=$2" } func VAR new-value echo "VAR=$VAR" # prints VAR=new-value 

One may create one own's global function, and use it inside other functions:

VAR=old-value function global () { export -n "$1=$2" } function main () { global VAR "$1" } main main-value echo "VAR=$VAR" # prints VAR=main-value 

This is verified working on

• an old Bash 2.03.0(1) running on a (modern) OS/390 z/OS
• on a Bash 3.2.57(1) on macOS 10.15
• on a Bash 4.1.2(2) on CentOS 6

I used this to inspect the various possibilities:

#!env bash export LANG=C LC_ALL=C A=a0 B=b0 C=c0 D=d0 E=e0 export F=f0 function testfunc () { local "$1=$2" ; shift 2 declare "$1=$2" ; shift 2 declare -g "$1=$2" ; shift 2 export -n "$1=$2" ; shift 2 export "$1=$2" } echo "$A/$B/$C/$D/$E" testfunc A a1 B b1 C c1 D d1 E e1 echo "$A/$B/$C/$D/$E" export -p | grep -E '^declare -x [ABCDEF]=' 

In case of macOS 10.15 this shows an output similar to this:

$ bash test.sh a0/b0/c0/d0/e0 test.sh: line 15: declare: -g: invalid option declare: usage: declare [-afFirtx] [-p] [name[=value] ...] a0/b0/c0/d1/e1 declare -x E="e1" declare -x F="f0" 

The output shows that the local and declare commands used in the testfunc function effectively do not apply the variables in the global context (as documented) and that the declare -g option is not widely supported yet. It also shows that the variables D and E have been changed in the global context from inside the testfunc function (as hoped for), while only the E variable has been marked for export as a side effect by the export command, showing that the export -n option is effective. The variable F is there just to verify the grep command worked as expected.

Using "eval" (or any direct assignment) can give you headaches with special characters (or issues with value injection etc).

I've had great success just using "read"

$ function assign_global() { > local arg="$1" > IFS="" read -d "" $arg <<<"$2" >} $ assign_global MYVAR 23 echo $MYVAR 23 $ assign_global MYVAR "\"'" "' 

If you want something a little less hackish, try using export in place of declare -g. It has the added benefit of being an environment variable now.

func() { # # Here happens something that ultimately makes $arg="var_name" # export ${arg}=5 } func echo ${var_name}; # Prints out "5" 

Unfortunately, this still does not work for arrays.

In Bash for declaring array variables inside a function definition you can use the local command in combination with the eval command like in the following example:

#!/bin/bash function test { local -g $1 local array=( AA BB 'C C' DD) eval ${1}='("${array[@]}")' } test VAR echo VAR=${VAR[@]:1:2} 

the output will be:

$./test.sh VAR=BB C C 

works with: GNU bash, Version 4.4.18

Eval will work with Array variables...I just had to single quote the local Array variable inside the eval statement.

The below reads in a file (1st arg) a line at a time and then copies it to the variable name passed to the 2nd arg of the get_file.

get_file () { declare -a Array=(); while read line; do Array=("${Array[@]}" "($line)") done < ${1} eval ${2}='("${Array[@]}")' unset Array } declare -a my_array=(); get_file /etc/myfile.conf my_array echo ${#my_array[@]}

Maybe your could use the following functions to dynamically assign your global variable in bash(< 4.2). If > 2 args passed, then the value will be array type. E.G

_set2globals variable_name arg1 [arg2] [arg3] [...] 

Source:

# dynamically set $variable_name($1)=$values($2...) to globals scope function _set2globals() { if (( $# < 2 )); then printf "$FUNCNAME: expect at least 2 argument, but %d you given.\n" $# >&2 exit 1 fi local ___pattern_='^[_a-zA-Z][_0-9a-zA-Z]*$' if [[ ! $1 =~ $___pattern_ ]]; then printf "$FUNCNAME: invalid variable name: %s.\n" "$1" >&2 exit 1 fi local __variable__name__=$1 shift local ___v_ local ___values_=() while (($# > 0)); do ___v_=\'${1//"'"/"'\''"}\' ___values_=("${___values_[@]}" "$___v_") # push to array shift done eval $__variable__name__=\("${___values_[@]}"\) } 

-g -r does the job. My bash version is: 5.1.16. Here is an example:

function setup() { declare -g -r VERSION="${1:-2.0}" } function main() { setup "$@" VERSION="2.3" # error } main "$@"