3

How can I pass arrays as input to a bash function using nameref? Have not found very specific information for doing this.

For instance I have an array incl which I want to pass to a function, which then returns isufx.

## Split INCL by field separator FS
for ext in "${incl[@]}"; do

  if [[ "$ext" == "PROGL" ]]; then
    isufx+=( --include=\*.{rc,el,c,f} )
    (( vb >= 2 )) && echo " ext: $ext"
    continue
  elif [[ "$ext" == "PEXTD" ]]; then
    isufx+=( --include=\*.{rc,el,c,f} )
    isufx+=( --include=\*.{cp,cpp,f90,f95,f03,f08} )
    (( vb >= 2 )) && echo " ext: $ext"
    continue
  elif [[ "$ext" == "TYPOG" ]]; then
    isufx+=( --include=\*.{org,texi,tex} )
    (( vb >= 2 )) && echo " ext: $ext"
    continue
  fi
Improve this question
5
  • 1
    Check if this helps and fit it to your needs unix.stackexchange.com/a/732112/515538 Commented Mar 31, 2023 at 15:24
  • 1
    do you have an example of what to adjust? Commented Mar 31, 2023 at 15:30
  • I need an example that is very specific about making a function that takes arrays. Commented Mar 31, 2023 at 15:30
  • The reason you haven't found much info on doing this is because most people who need to do such things know that shell (including bash or ksh or zsh) is not a good language for complex tasks - they use more appropriate languages instead, e.g. perl or python or C or almost any language that isn't shell. Not only are other languages better suited to complex tasks, they often have functions or syntax or libraries that allow you to do things in a few lines of code that would takes dozens or hundreds of lines in shell. Commented Apr 1, 2023 at 1:35
  • e.g. most languages have one or more methods of passing a variable by reference (i.e. a pointer to the actual variable) rather than by value(s) in a variable (copies of the data). this makes it easy to pass arrays (indexed or hashed) and even complex data structures or objects to functions/subroutines....and to return them as the result of a function. pass by reference is also significantly faster than copying large blocks of data to and from functions. Commented Apr 1, 2023 at 1:40

2 Answers 2

Reset to default
4 
fill_array()
  typeset -n _in="$1" _out="$2"
  typeset _ext
  for _ext in "${_in[@]}"; do
    case $_ext in
      (PEXTD) _out+=( '--include=*.'{cp,cpp,f90,f95,f03,f08} ) ;& # fall through
      (PROGL) _out+=( '--include=*.'{rc,el,c,f} ) ;;
      (TYPOG) _out+=( '--include=*.'{org,texi,tex} ) ;;
      (*) continue
    esac
    (( vb < 2 )) || printf>&2 ' ext: %s\n' "$_ext"
  done
}

fill_array incl isufx

Here also using a case statement which seems more appropriate than an if one.

We pass the names of two variables to that function. Inside the function _in is defined as a nameref to the variable whose name is passed in the first argument, and _out for the second.

Then, when $_in or $_out are referenced in the function, they are automatically translated to the referenced function.

We prefix variable names with _ in the function to limit the risk of the function being called with variables that happen to be used in the function as in bash, contrary to ksh93 where the nameref feature comes from¹ or zsh², that wouldn't work as the implementation is much cruder.

¹ ksh is also where typeset comes from. The fact that bash copied that feature decades later but decided to call the command declare I find quite annoying. Thankfully, it also accepts typeset as an alias.

² namerefs as of writing are only available in the current development version.

Improve this answer
12
  • Then the function would actually figure out that the arguments $1, $2 are arrays. Why using typeset rather than declare? Passing arrays as input would not involve using "${incl[@]}" ? Commented Mar 31, 2023 at 16:16
  • When calling the function, are the arguments actually passed just by declaring them as incl, isufx, rather than "${incl[@]}", "${isufx[@]}" ? Commented Mar 31, 2023 at 19:17
  • Have been trying to use out=$( fill_array ary ) using printf '%s\0' "${_out[@]}", which is definitely problematic.. Commented Mar 31, 2023 at 20:43
  • @Hovlar, in fill_array incl isufx, we pass two literal strings incl and isufx to the function. typeset -n _in=incl _out=sufx in there bind / reference the _in and _out variables to the variables by those names. Commented Apr 1, 2023 at 7:57
  • If you wanted the function to return the result as a NUL delimited list, first you wouldn't define _out as a nameref, then you couldn't use printf like that as it wouldn't work for empty lists (you'd need a print0() { [ "$#" -eq 0 ] || printf '%s\0' "$@"; }), and to read the result into an array, you'd need readarray -td '' out < <(fill_array ary) for which you need bash 4.4+. Commented Apr 1, 2023 at 7:59
0

You are missing the done at the end of your loop

#!/bin/bash

function my_function() {
  declare -n myarray="$1"
  local isufx=()
  
  for ext in "${myarray[@]}"; do
    if [[ "$ext" == "PROGL" ]]; then
      isufx+=( --include=\*.{rc,el,c,f} )
      (( vb >= 2 )) && echo " ext: $ext"
      continue
    elif [[ "$ext" == "PEXTD" ]]; then
      isufx+=( --include=\*.{rc,el,c,f} )
      isufx+=( --include=\*.{cp,cpp,f90,f95,f03,f08} )
      (( vb >= 2 )) && echo " ext: $ext"
      continue
    elif [[ "$ext" == "TYPOG" ]]; then
      isufx+=( --include=\*.{org,texi,tex} )
      (( vb >= 2 )) && echo " ext: $ext"
      continue
    fi
  done
  
  echo -e "${isufx[@]}"
}

my_include=("PROGL" "EMPTY" "PEXTD" "TYPOG" "NONAME")
my_function my_include

exit
Improve this answer
13
  • Would there be any capability to input two or more arrays as input ? Commented Mar 31, 2023 at 15:50
  • You can append an array to another array and call the function or call the function x times, or do another loop and call the function with all needed arrays, don't get what you mean? Commented Mar 31, 2023 at 15:53
  • I mean this, using out=$( my_function "${this_array[@]}" "${that_array[@]}". Commented Mar 31, 2023 at 16:00
  • How would the namerefs for the two arrays look like? Commented Mar 31, 2023 at 16:09
  • ignoring bad practices like global variables, the only way to pass a value to a function in bash is via arguments. If you need to pass two arrays then you need some sort of marker (any value guaranteed not to be in either array) in between them so that you can iterate over "$@" and store the values in array "A" or array "B" (or even array "C", and so on) depending on whether they came before or after the marker. e.g. myfunc "${a1[@]}" XXXXX "${a2[@]}" XXXXX "${a3[@]}" Or just use perl, where you can pass arrays by reference rather than by value. Commented Apr 1, 2023 at 1:31

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.