Bash – How to Loop Through Arguments in a Bash Script

argumentsbashshell

I would like to write a bash script with unknown amount of arguments.

How can I walk through these arguments and do something with them?

A wrong attempt would look like this:

#!/bin/bash
for i in $args; do 
    echo $i
done

Best Answer

There's a special syntax for this:

for i do
  printf '%s\n' "$i"
done

More generally, the list of parameters of the current script or function is available through the special variable $@.

for i in "$@"; do
  printf '%s\n' "$i"
done

Note that you need the double quotes around $@, otherwise the parameters undergo wildcard expansion and field splitting. "$@" is magic: despite the double quotes, it expands into as many fields as there are parameters.

print_arguments () {
  for i in "$@"; do printf '%s\n' "$i"; done
}
print_arguments 'hello world' '*' 'special  !\characters' '-n' # prints 4 lines
print_arguments ''                                             # prints one empty line
print_arguments                                                # prints nothing

Related Solutions

bash – Passing Braces as Arguments to Bash Function

When you run findinfiles {*.js,*.html,} {release,dev,} "span", here is what happens:

Bash parses quotes and splits the command into words: findinfiles, {*.js,*.html,} {release,dev,} span.
Bash expands the braces, resulting in the list of words findinfiles, *.js, *.html, release, dev, span.
Bash expands the wildcard patterns *.js and *.html to the list of matching file names. If no file name matches either pattern, it is left alone.
Bash looks up the name findinfiles, finds out that it's a function, and executes the function with the supplied parameters.

You can prevent the braces and wildcards from being expanded at the function call, but then the braces will appear literally in the arguments, which isn't particularly useful.

I suggest changing the format of your function call. Instead of using braces, use only commas, and manually split the arguments at commas inside the function.

findinfiles () {
  local patterns="$1" excludes="$2" pattern="$3"
  shift 3
  typeset -a cmd dirs
  if [[ $# -eq 0 ]]; then dirs=(.); else dirs=("$@"); fi
  cmd=(grep --color=auto -iRnHr)
  local IFS=,
  for x in $patterns; do
    cmd+=("--include=$x")
  done
  for x in $excludes; do
    cmd+=("--exclude-dir=$x")
  done
  "${cmd[@]}" "${dirs}"
}

Explanations:

Store the first three parameters in local variables. Any extra parameters are directories to search in.
Set dirs to the list of extra parameters. If there are none, use . (current directory) instead.
Set IFS to a comma. When a script contains an unquoted variable expansion like $patterns and $excludes above, the shell performs the following:
1. Replace the variable by its value.
2. Split the variable into separate words wherever it contains a character that is present in IFS. By default, IFS contains whitespace characters (space, tab and newline).
3. Treat each word as a wildcard pattern and expand it to the list of matching files. If there is no matching file, leave the pattern alone.
(To avoid these expansion steps, use double quotes around the variable substitution, as in patterns="$1" and so on in the script above.)
The function builds the command line to execute incrementally in the array variable cmd. At the end, the command is executed.

Alternatively, you could build on the following settings:

shopt -s extglob globstar
fif_excludes='release dev'
alias fif='grep --color=auto -inH $fif_excludes'

Run commands like

fif span **/*.@(js|html)

Explanations:

shopt -s extglob activates the @(js|html) form of wildcard pattern, which matches either js or html. (This option activates other pattern forms, see the manual for details.)
shopt -s globstar actives the pattern **/ which matches subdirectories at any depth (i.e. it performs a recursive traversal).
To change the exclude list (which I expect doesn't happen often), modify the fif_excludes variable.

Bash Scripting – Use Filename Arguments or Default to stdin/stdout

I'd make heavier use of I/O redirection:

#!/bin/bash
[[ $1 ]] && [[ ! -f $1 ]] && echo "file $1 dne" && exit 1
[[ $1 ]] && exec 3<$1 || exec 3<&0
[[ $2 ]] && exec 4>$2 || exec 4>&1
fgrep -v "stuff" <&3 >&4

Explanation

[[ $1 ]] && [[ ! -f $1 ]] && echo "file $1 dne" && exit 1

Test if an input file has been specified as a command line argument and if the file exists.
[[ $1 ]] && exec 3<$1 || exec 3<&0

If $1 is set, i.e. an input file has been specified, the specified file is opened at file descriptor 3, otherwise stdin is duplicated at file descriptor 3.
[[ $2 ]] && exec 4>$2 || exec 4>&1

Similarly if the $2 is set, i.e. an output file has been specified, the specified file is opened at file descriptor 4, otherwise stdout is duplicated at file descriptor 4.
fgrep -v "stuff" <&3 >&4

Lastly fgrep is invoked, redirecting its stdin and stdout to the previously set file descriptors 3 and 4 respectively.

Reopening standard input and output

If you'd prefer not to open intermediate file descriptors, an alternative is to replace the file descriptors corresponding to stdin and stdout directly with the specified input and output files:

#!/bin/bash
[[ $1 ]] && [[ ! -f $1 ]] && echo "file $1 dne" && exit 1
[[ $1 ]] && exec 0<$1
[[ $2 ]] && exec 1>$2
fgrep -v "stuff"

A drawback with this approach is that you loose the ability to differentiate output from the script itself from the output of the command which is the target for the redirection. In the original approach, you can direct script output to the unmodified stdin and stdout, which in turn might have been redirected by the caller of the script. The specified input and output files could still be accessed via the corresponding file descriptors, which are distinct from the script stdin and stdout.

Best Answer

Related Solutions

bash – Passing Braces as Arguments to Bash Function

Bash Scripting – Use Filename Arguments or Default to stdin/stdout

Related Question