Passing parameters to a Bash function

Question

I am trying to search how to pass parameters in a Bash function  but what comes up is always how to pass parameter from the command line  I would like to pass parameters within my script  I tried  myBackupFunction  quot    quot    quot     quot    quot xx quot    function myBackupFunction  directory   options   rootPassword                But the syntax is not correct  How can I pass a parameter to my function

User · Answer

Knowledge of high level programming languages (C/C++, Java, PHP, Python, Perl, etc.) would suggest to the layman that Bourne Again Shell (Bash) functions should work like they do in those other languages.

Instead, Bash functions work like shell commands and expect arguments to be passed to them in the same way one might pass an option to a shell command (e.g. ls -l). In effect, function arguments in Bash are treated as positional parameters ($1, $2..$9, ${10}, ${11}, and so on). This is no surprise considering how getopts works. Do not use parentheses to call a function in Bash.

(Note: I happen to be working on OpenSolaris at the moment.)

# Bash style declaration for all you PHP/JavaScript junkies. :-)
# $1 is the directory to archive
# $2 is the name of the tar and zipped file when all is done.
function backupWebRoot ()
{
    tar -cvf - "$1" | zip -n .jpg:.gif:.png "$2" - 2>> $errorlog &&
        echo -e "\nTarball created!\n"
}


# sh style declaration for the purist in you. ;-)
# $1 is the directory to archive
# $2 is the name of the tar and zipped file when all is done.
backupWebRoot ()
{
    tar -cvf - "$1" | zip -n .jpg:.gif:.png "$2" - 2>> $errorlog &&
        echo -e "\nTarball created!\n"
}


# In the actual shell script
# $0               $1            $2

backupWebRoot ~/public/www/ webSite.tar.zip

Want to use names for variables? Just do something this.

local filename=$1 # The keyword declare can be used, but local is semantically more specific.

Be careful, though. If an argument to a function has a space in it, you may want to do this instead! Otherwise, $1 might not be what you think it is.

local filename="$1" # Just to be on the safe side. Although, if $1 was an integer, then what? Is that even possible? Humm.

Want to pass an array to a function?

callingSomeFunction "${someArray[@]}" # Expands to all array elements.

Inside the function, handle the arguments like this.

function callingSomeFunction ()
{
    for value in "$@" # You want to use "$@" here, not "$*" !!!!!
    do
        :
    done
}

Need to pass a value and an array, but still use "$@" inside the function?

function linearSearch ()
{
    local myVar="$1"

    shift 1 # Removes $1 from the parameter list

    for value in "$@" # Represents the remaining parameters.
    do
        if [[ $value == $myVar ]]
        then
            echo -e "Found it!\t... after a while."
            return 0
        fi
    done

    return 1
}

linearSearch $someStringValue "${someArray[@]}"

User · Answer

Another way to pass named parameters to Bash    is passing by reference  This is supported as of Bash 4 0    bin bash function myBackupFunction      directory options destination filename local directory  quot  1 quot  options  quot  2 quot  destination  quot  3 quot  filename  quot  4 quot     echo  quot tar cz    options     directory    ssh root backupserver   quot cat  gt   mnt    destination     filename  tgz  quot  quot      declare -A backup   directory   quot    quot   options   quot     quot   destination   quot backups quot   filename   quot backup quot      myBackupFunction backup directory  backup options  backup destination  backup filename    An alternative syntax for Bash 4 3 is using a nameref  Although the nameref is a lot more convenient in that it seamlessly dereferences  some older supported distros still ship an older version  so I won t recommend it quite yet

User · Answer

Drop the parentheses and commas   myBackupFunction  quot    quot   quot     quot   quot xx quot   And the function should look like this  function myBackupFunction           Here  1 is the first parameter   2 the second  etc

User · Answer

If you prefer named parameters  it s possible  with a few tricks  to actually pass named parameters to functions  also makes it possible to pass arrays and references   The method I developed allows you to define named parameters passed to a function like this  function example   args   string firstName   string lastName   integer age       echo  quot My name is   firstName    lastName  and I am   age  years old  quot     You can also annotate arguments as  required or  readonly  create    rest arguments  create arrays from sequential arguments  using e g  string 4   and optionally list the arguments in multiple lines  function example     args        required string firstName       string lastName       integer age       string      favoriteHobbies    echo  quot My name is   firstName    lastName  and I am   age  years old  quot    echo  quot My favorite hobbies include    favoriteHobbies     quot     In other words  not only you can call your parameters by their names  which makes up for a more readable core   you can actually pass arrays  and references to variables - this feature works only in Bash 4 3 though   Plus  the mapped variables are all in the local scope  just as  1  and others   The code that makes this work is pretty light and works both in Bash 3 and Bash 4  these are the only versions I ve tested it with   If you re interested in more tricks like this that make developing with bash much nicer and easier  you can take a look at my Bash Infinity Framework  the code below is available as one of its functionalities  shopt -s expand aliases  function assignTrap     local evalString   local -i paramIndex     paramIndex-0    local initialCommand  quot   1-  quot     if     quot  initialCommand quot      quot   quot       then     echo  quot trap - DEBUG  eval   quot     previousTrap   quot   unset   previousTrap  unset   paramIndex  quot      return   fi    while     quot   1-  quot      quot   quot      quot   1-  quot      quot   initialCommand  quot            quot       quot  -gt 0  amp  amp   quot  paramIndex quot  -eq 0      do     shift   First colon  quot   quot  or next parameter s comma  quot   quot      paramIndex  1     local -a decorators        while     quot   1-  quot      quot   quot          do       decorators     quot  1 quot          shift     done      local declaration      local wrapLeft   quot       local wrapRight   quot       local nextType  quot  1 quot      local length 1      case   nextType  in       string   boolean  declaration  quot local  quot           integer  declaration  quot local -i quot           reference  declaration  quot local -n quot           arrayDeclaration  declaration  quot local -a quot   wrapLeft    wrapRight           assocDeclaration  declaration  quot local -A quot   wrapLeft    wrapRight            quot string  quot   quot   quot   declaration  quot local -a quot   length  quot   nextType   a-z       quot            quot integer  quot   quot   quot   declaration  quot local -ai quot   length  quot   nextType   a-z       quot         esac      if     quot   declaration  quot      quot  quot         then       shift       local nextName  quot  1 quot         for decorator in  quot   decorators     quot        do         case   decorator  in            readonly  declaration   quot r quot                required  evalString   quot      -z     paramIndex        echo   quot Parameter   nextName    nextType  is marked as required by    FUNCNAME 1    function   quot    quot   gt  amp 2               global  declaration   quot g quot             esac       done        local paramRange  quot  paramIndex quot         if    -z  quot  length quot           then              rest         paramRange  quot     paramIndex  quot            trim leading             nextName  quot   nextName       quot          if     quot       quot  -gt 1            then           echo  quot Unexpected arguments after a rest array   nextName  in    FUNCNAME 1    function  quot   gt  amp 2         fi       elif     quot  length quot  -gt 1          then         paramRange  quot     paramIndex  length  quot          paramIndex     length - 1         fi        evalString   quot   declaration    nextName    wrapLeft     paramRange   wrapRight    quot           Continue to the next parameter        shift     fi   done   echo  quot   evalString  local -i   paramIndex   paramIndex   quot     alias args  local   previousTrap   trap -p DEBUG   trap  quot eval   quot    assignTrap   BASH COMMAND   quot   quot  DEBUG

User · Answer

A simple example that will clear both during executing script or inside script while calling a function     bin bash echo  quot parameterized function example quot  function print param value        value1  quot   1  quot     1 represent first argument     value2  quot   2  quot     2 represent second argument     echo  quot param 1 is    value1  quot    As string     echo  quot param 2 is   value2  quot      sum     value1  value2     Process them as number     echo  quot The sum of two value is   sum  quot    print param value  quot 6 quot   quot 4 quot    Space-separated value   You can also pass parameters during executing the script print param value  quot  1 quot   quot  2 quot    Parameter  1 and  2 during execution    Suppose our script name is  quot param example quot     Call it like this        param example 5 5     Now the parameters will be  1 5 and  2 5

User · Answer

It takes two numbers from the user  feeds them to the function called add  in the very last line of the code   and add will sum them up and print them     bin bash  read -p  quot Enter the first  value   quot  x read -p  quot Enter the second value   quot  y  add        arg1  1   arg1 gets to be the first  assigned argument  note there are no spaces        arg2  2   arg2 gets to be the second assigned argument  note there are no spaces       echo     arg1    arg2      add x y   Feeding the arguments

User · Answer

There are two typical ways of declaring a function  I prefer the second approach  function function name      command        or function name         command        To call a function with arguments  function name  quot  arg1 quot   quot  arg2 quot   The function refers to passed arguments by their position  not by name   that is  1   2  and so forth   0 is the name of the script itself  Example  function name         echo  quot Parameter  1 is  1 quot     Also  you need to call your function after it is declared     usr bin env sh  foo 1    this will fail because foo has not been declared yet   foo         echo  quot Parameter  1 is  1 quot     foo 2   this will work   Output    myScript sh  line 2  foo  command not found Parameter  1 is 2  Reference  Advanced Bash-Scripting Guide

[bash] Passing parameters to a Bash function

Examples related to bash

Examples related to parameters

Examples related to arguments