Storing Bash function parameters in variables

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?

When you check man bash, Here Strings it says: "<<<word: The word undergoes brace expansion, tilde expansion, parameter and variable expansion, command substitution, arithmetic expansion, and quote removal." (emphasis me). In other words you lose the quotes and with that parameter "grouping" you've expected and needed. — Ondrej K.
– Ondrej K., Commented Feb 5, 2018 at 16:17
So read cannot be used in my case? Reading from stdin will also remove quotes. — kaligne
– kaligne, Commented Feb 5, 2018 at 16:31

Nahuel Fouilleul · Accepted Answer · 2018-02-06 13:41:02Z

2

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.

answered Feb 6, 2018 at 13:41

Nahuel Fouilleul

19.5k2 gold badges36 silver badges37 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

kaligne Over a year ago

Ah I got it for the array assignment. However in my loop case I cannot directly declare and update the array without using eval statement. (` printf -v "${_vars[p-1]}" "${!p}"`). Should I avoid the use of parenthesis for my subshell functions in my case?

Nahuel Fouilleul Over a year ago

@kaligne, i'm not sure to understand your need, i can't answer if subshell is needed but i don't think so why do you think it's needed? what is your intention with _vars?

kaligne Over a year ago

I was just wondering if your take on that was just informative or an advise to use / not use the parenthesis. Here I used them to not declare _var as local, I thought it would (relatively) save time . But the thing here is the variables that _var contains have to be declared local anyway. So in the end I didn't use the parenthesis for any particular need

tripleee · Accepted Answer · 2018-02-05 17:13:29Z

1

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[@]}"
)

answered Feb 5, 2018 at 17:13

tripleee

192k37 gold badges317 silver badges367 bronze badges

2 Comments

kaligne Over a year ago

Thanks that seems to be a nice lead. printf -v correctly assigns parameters to variables. However it fails at assigning empty parameters in arrays. I found a workaround as explained in my answer below.

tripleee Over a year ago

(There is no "above" or "below"; these posts are shown in different order depending on votes, age, etc.)

kaligne · Accepted Answer · 2018-02-06 13:22:33Z

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.

Collectives™ on Stack Overflow

Storing Bash function parameters in variables

3 Answers 3

3 Comments

2 Comments

Comments

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

2 Comments

Comments

Related