I want to create a function in a bash script that declares a variable and value supplied to the function to be re-used later.
function format_msg {
declare "$1"="[ \033[00;32m$2 OK\033[0m ]"
}
format_msg "foo" "bar"
echo "${!foo}"
This is a returning a null value
The declare builtin declares a local variable (using dynamic scope); so the variable disappears when the function returns.
If you have a sufficiently recent version of Bash, one option is to use printf with the -v var option (which saves to a variable instead of writing to standard output):
function format_msg {
printf -v "$1" "%s" "[ \033[00;32m$2 OK\033[0m ]"
}
(That said, I do agree with CMPS's suggestion that you simply change your function so that it only handles the formatting, and lets the calling code handle the assignment. The general idea in Unix programming is "do one thing and do it well".)
Edited to add: I should also point out two other issues with your code, that you'll run into once you fix the above:
Unless your echo is defined specially (e.g. you've enabled support for backslash-escapes), it doesn't look like you're ever processing the \033 so as to get actual color formatting. So I think you probably really want
printf -v "$1" "[ \033[00;32m%s OK\033[0m ]" "$2"
with printf handling the \033.
"${!foo}" will interpret the contents of $foo as a new variable-name, and then expand to the results of that variable; I'm pretty sure that you just want
echo "$foo"
printf -v was introduced in bash 3.1, although it couldn't assign to a slot of an array until bash 4.1.Using the declare inside the function makes it local to the function.
Try this instead:
function format_msg {
echo "[ \033[00;32m$1 OK\033[0m ]"
}
foo=$(format_msg "bar")
echo $foo
declare, by default, creates a local variable. Starting with bash 4.2, you can use the -g option to create a global variable instead.
function format_msg {
declare -g "$1=[ \033[00;32m$2 OK\033[0m ]"
}
As has been said already, your code fails in this specific case because bash makes a variable (as if the command) local (has been issued) when declare is used. That is equivalent to ksh's typeset, as well as zsh's typeset, and its alternative forms declare, integer, local and readonly (but not export).
Also, you are trying to print via an indirect form echo "${!foo}". That will not print the value of $foo but the value of a variable (if it exists) which name is the value of $foo.
Using declare inside the function is possible if this form is used (for bash 4.2+):
declare -g "$1"="[ \033[00;32m$2 OK\033[0m ]"
The most basic way to make the assignment without using declare for older bash version (and in general for most shells) is the always worrisome eval (if the value of $1 or $2 has any chance of having been set by an attacker (or external user)):
eval "$1"='"[ \033[00;32m'"$2"' OK\033[0m ]"'
Of course, that will assign the string [ \033[00;32mbar OK\033[0m ] to $foo, which doesn't seem to be the intended goal.
This simple change should correctly assign the intended escaped characters to the variable:
eval "$1"=$'"[ \033[00;32m'"$2"$' OK\033[0m ]"'
Which will change to Green for bar OK and then reset the color setting.
To remove the risk of eval, we need to use something else.
For ksh 93+ and bash 4.3+ we may use namerefs (bash form used):
declare -n ref=$1
ref=$'"[ \033[00;32m'"$2"$' OK\033[0m ]"'
Or bash printf's -v option:
printf -v "$1" '"[ \033[00;32m%s OK\033[0m ]"' "$2"
In which case the interpretation of the escape codes (\033) is done by printf.
Once the variable contains the required value, is better to use printf to print it instead of echo, and no indirection is needed:
#!/bin/bash
format_msg() {
printf -v "$1" '"[ \033[00;32m%s OK\033[0m ]"' "$2"
}
format_msg "foo" "bar"
printf 'var foo=%s\n' "${foo}"