Storing Bash function parameters in variables - bash

Question

I want to define and get all the required variables that are passed to a function as parameters:
function explain_vars() {
echo "Explaining vars '$#':" >&2
for _var in "$#"; do
printf " $_var: '${!_var}'\n" >&2
done
printf "\n" >&2
}
function read_params() (
## Define local variables
_vars=(v1 v2 v3)
local ${_vars[#]}
## Read variables from input:
read ${_vars[#]} <<< "$#"
explain_vars "${_vars[#]}"
)
The read takes puts all parameters in the specified variables, default delimiter here is space. So if I pass different strings as second parameter, read will store only the first string in the second parameter, and all the rest to the following parameters:
$ read_params one "two dot one" "three" "four"
Explaining vars 'v1 v2 v3':
v1: 'one'
v2: 'two'
v3: 'dot one three four'
As we can see, variable v2 is not synchronized with given parameters anymore. Moreover, it fails at reading empty strings:
$ read_params one "" " " '' ' ' "two dot one" "three" "four"
Explaining vars 'v1 v2 v3':
v1: 'one'
v2: 'two'
v3: 'dot one three four'
By looping through the all-parameters variable $# inside the function it is possible to distinguish variables:
function raw_params() (
echo "Explaining row parameters:"
for _v in "${#}"; do
printf " '$_v'\n"
done
)
$ raw_params one "" " " '' ' ' "two dot one" "three" "four"
Explaining row parameters:
'one'
''
' '
''
' '
'two dot one'
'three'
'four'
To me the read command offers benefit and quickness at defining, controlling and checking requested parameters that are passed to functions. However this works only for single and non-empty stringed parameters. Is it possible to read all different parameters in variables like the read command does, but respecting spaces and empty parameters? Or is there a better approach maybe?

Answer 1

From the original question seems read command is not correctly understood, read is a builtin which reads one line for standard input, IFS environment variable is used as field separator and -d option allows to change record delimiter (default is newline), for more information see read in bash manual.
The function arguments are retrieved using special variable "$#", bash syntax to assign an array is just
_vars=( "$#" ) # no space between variable name and = and no space between = and (
As a space is not valid in a variable name ${!_var} expansion will fail writing an error bash: ...: bad substitution, if _var contains an expression with a space.
function keyword is useless because of (), the use of parenthesis around the body of function instead of braces { ;} starts a new sub-shell.

Answer 2

I'm not sure what you are hoping to accomplish with this code, but this would appear to solve your problem for the case of three input parameters. Perhaps it shows you a way forward even if it doesn't completely do what you want.
read_params () (
## Define local variables
_vars=(v1 v2 v3)
local ${_vars[#]}
local i
for ((i=1; i<=$#; ++i)); do
## Read variables from input:
printf -v "${_vars[i-1]}" "${!i}"
done
explain_vars "${_vars[#]}"
)

Answer 3

I rewrote my function in a script according to tripleee's answer. printf works fine except for assigning empty values ('' and "") to arrays. For that, we need to format the string we pass to printf -v with '%s'. For the example I pass an array of parameters to my function twice: once per assigning them to my regular local parameters; a second time to pass the same parameters to my last local array variable. Here is the code:
$ cat parse-local-vars.sh
#!/usr/bin/env bash
function explain_vars() {
echo "Explaining vars '$#':" >&2
for _var in "$#"; do
printf " $_var: '${!_var}'\n" >&2
done
}
function parse_params() (
#
# Stores given parameters in defined local variables _vars.
# Last variable will be treated as an array and
# remaining parameters will be stored therein.
#
## Define local variables
local _vars=(v1 v_empty_double_quote v_spaced_double_quote v_empty_single_quote v_spaced_single_quote v2_1 v3 v4 args)
local ${_vars[#]}
## Make sure we assign parameters to variables
[ ${#_vars[#]} -gt 0 ] \
|| return 1
_args_pos=$(( ${#_vars[#]}-1 ))
_args_counter=0
local p
for ((p=1; p<=$#; ++p)); do
## Read variables from input:
if [ $p -le $_args_pos ]; then
#printf -v "${_vars[p-1]}" '%s' "${!p}"
printf -v "${_vars[p-1]}" "${!p}"
else
#printf -v "${_vars[_args_pos]}[$_args_counter]" '%s' "${!p}"
printf -v "${_vars[_args_pos]}[$_args_counter]" "${!p}" # Without the '%s' assigning empty variable to an array does not work
_args_counter=$(( _args_counter+1 ))
fi
done
explain_vars "${_vars[#]}"
echo "exlaining array args[#]: '${args[#]}'"
for _v in "${args[#]}"; do
echo " >'$_v'"
done
)
params_to_test=(one "" " " '' ' ' "two dot one" "three" "four")
parse_params "${params_to_test[#]}" "${params_to_test[#]}"
As one can see, here I use printf -v without formatting the parameter string (no use of '%s'):
$ bash parse-local-vars.sh
Explaining vars 'v1 v_empty_double_quote v_spaced_double_quote v_empty_single_quote v_spaced_single_quote v2_1 v3 v4 args':
v1: 'one'
v_empty_double_quote: ''
v_spaced_double_quote: ' '
v_empty_single_quote: ''
v_spaced_single_quote: ' '
v2_1: 'two dot one'
v3: 'three'
v4: 'four'
args: 'one'
exlaining array args[#]: 'one two dot one three four' (6 values)
>'one'
>' '
>' '
>'two dot one'
>'three'
>'four'
The empty parameters "" and '' are not passed to the array (6 values).
Allowing the string formatting of printf by toggling the following comments:
printf -v "${_vars[_args_pos]}[$_args_counter]" '%s' "${!p}"
#printf -v "${_vars[_args_pos]}[$_args_counter]" "${!p}" # Without the '%s' as,signing empty variable to an array does not work
Leads to this output:
$ bash parse-local-vars.sh
Explaining vars 'v1 v_empty_double_quote v_spaced_double_quote v_empty_single_quote v_spaced_single_quote v2_1 v3 v4 args':
v1: 'one'
v_empty_double_quote: ''
v_spaced_double_quote: ' '
v_empty_single_quote: ''
v_spaced_single_quote: ' '
v2_1: 'two dot one'
v3: 'three'
v4: 'four'
args: 'one'
exlaining array args[#]: 'one two dot one three four' (8 values)
>'one'
>''
>' '
>''
>' '
>'two dot one'
>'three'
>'four'
This is the expected results, as empty strings are correctly assigned to the array (8 values). I haven't figured out what is going on with passing empty strings to an array with printf -v, but using formatted strings with printf -v seems to be the safe way to go. Any correction, explanation and improvements are welcome.