Bash Scripting – How to Reuse a Function in Multiple Scripts

bashfunctionscripting

In bash, sometimes I would like to reuse a function in several scripts.
Is it bad to repeat the definition of the function in all the scripts?
If so, what is some good practice?

Is the following way a good idea?

wrap the definition of a function myfunction in its own script define_myfunction.sh,
in any script where the function is called, source define_myfunction.sh , and then call the function myfunction arg1 arg2 ....

Thanks.

Best Answer

In bash, that is a good way of doing it, yes.

Sourcing the "library" script using source or . would be an adequate solution to your issue of wanting to share a function definition between two or more scripts. Each script that needed access to the function(s) defined in the "library" script(s) would source the needed file(s), probably at the top of the script.

This would allow you to collect related functions in a single "library" script and source it to get access to them.

Not entirely unrelated, but the bash shell also has the ability to automatically source a file upon executing a non-interactive shell (i.e. a script). This may be used to set up a specific environment for the script:

BASH_ENV="$HOME/stuff/script.env" ./myscript

... where script.env may do anything from defining functions and setting shell or environment variables, to sourcing other files etc.

Some shells, like ksh93, has an environment variable that points to a directory that may contain function definition scripts like these. In ksh93, this variable is called FPATH. A script, $FPATH/foo, would contain a function called foo, which would automatically be found when the user types foo on the command line (or in a script). The bash shell does to my knowledge not have this specific functionality.

Other shells have other forms of "auto-load" functionality.

Related Solutions

Bash Function – How to Redefine a Bash Function in Terms of Old Definition

You can print out the current definition of the function, and then include it in a function definition inside an eval clause.

current_definition=$(declare -f command_not_found_handle)
current_definition=${current_definition#*\{}
current_definition=${current_definition%\}}
prefix_to_add=$(cat <<'EOF'
  # insert code here (no special quoting required)
EOF
)
suffix_to_add=$(cat <<'EOF'
  # insert code here (no special quoting required)
EOF
)
eval "command_not_found_handle () {
  $prefix_to_add
  $current_definition
  $suffix_to_add
}"

Another approach, which I find clearer, is to define the original function under a new name, and call that from your definition. This only works if you don't need to act on the local variables of the original definition.

eval "original_$(declare -f command_not_found_handle)"
command_not_found_handle () {
  …
  original_command_not_found_handle
  …
}

Bash – ny danger to using an unset variable in a bash function definition

fn(){ printf %s\\n "${v-not set}"; }
v=value; fn; unset v; fn

value
not set

A shell function is a literal string stored in the shell's memory. At define time it is parsed, but is not evaluated for expansions (other than shell aliases) or redirections. These are only evaluated at call time.

In fact, and somewhat related, in this way it is possible to get a function to define its own input with a new temporary file at each invocation.

fn(){ ls -l /dev/fd/0; cat; } <<INFILE
$@
INFILE
fn some args; fn other args

#in dash
lr-x------ 1 mikeserv mikeserv 64 Nov 16 12:50 /dev/fd/0 -> pipe:[4076148]
some args
lr-x------ 1 mikeserv mikeserv 64 Nov 16 12:50 /dev/fd/0 -> pipe:[4077081]
other args
#bash
lr-x------ 1 mikeserv mikeserv 64 Nov 16 12:51 /dev/fd/0 -> /tmp/sh-thd-1036060995 (deleted)
some args
lr-x------ 1 mikeserv mikeserv 64 Nov 16 12:51 /dev/fd/0 -> /tmp/sh-thd-531856742 (deleted)
other args

Best Answer

Related Solutions

Bash Function – How to Redefine a Bash Function in Terms of Old Definition

Bash – ny danger to using an unset variable in a bash function definition

Related Question