Behaviour of Functions in Sourced Scripts

Question

In the scenario where both script1.sh and script2.sh contain a function with the same name but different definitions, and script2.sh is sourced in script1.sh, if the function is executed from script1.sh. Which function will be invoked?

I tried to simulate this case. If the function is executed from script1.sh, it is using the function defined in script1.sh only. However, is this behavior consistent across all cases?

script1.sh

#!/bin/bash
source script2.sh
execute() {
    echo "Hello"
}
execute

script2.sh

#!/bin/bash
execute() {
   echo "Something"
}

Answer 1

You can think of the function as a variable in this context: it will have the last value you assigned it. Just like if you have something like this:

var=foo
var=bar
var=baz
echo "$var"

In the case above, I hope it is obvious that echo "$var" will print out baz since every time you assign a value to a variable you overwrite whatever value it might have had before. Functions work in the same way. If you define a function with the same name multiple times, only the last definition will be relevant and the others will be lost.

Sourcing doesn't change that. If you source a function from a file and then redefine a new function with the same name, then only the new one will work. Conversely, if you define a function in your script and then source a file with a function of the same name, only the sourced one will work.

So yes, it is entirely consistent, the order of operations defines what will actually be used.

Answer 2

For completeness, if you wanted to be able to use both functions, you could switch to ksh93 (the shell bash tries to emulate anyway) where you could use namespaces.

Instead of doing:

source script2.sh

(which by the way in bash like in ksh, looks up script2.sh in $PATH which is probably not what you want), do:

namespace script2 {
  source ./script2.sh # the one in the current directory not in $PATH!
}
function execute {
  echo "Hello"
}
execute           # the one from the global namespace
.script2.execute  # the one from the script2 namespace

Note that variables also end up being namespaced.