Function libraries (sourcing scripts) in Bash Scripting - Step-by-Step Execution

Concept Flow - Function libraries (sourcing scripts)

Start script

↓

Source library script

↓

Library functions loaded

↓

Call library function

↓

Function executes

↓

Continue main script

↓

End script

The main script starts, loads functions from a library script using source, then calls those functions as needed before finishing.

Execution Sample

Bash Scripting

source ./lib.sh
say_hello() {
  echo "Hello from main script"
}
say_hello
greet

This script loads functions from lib.sh, defines its own function, then calls both its own and the sourced function.

Execution Table

Step	Action	Evaluation	Result
1	Start main script	No output	Script begins
2	source ./lib.sh	Load functions from lib.sh	Function greet() is available
3	Define say_hello()	Function defined	say_hello() ready to use
4	Call say_hello()	Runs say_hello function	Outputs: Hello from main script
5	Call greet()	Runs greet function from lib.sh	Outputs: Hello from library
6	End script	No further commands	Script ends

💡 Script ends after all commands run

Variable Tracker

Variable/Function	Start	After source	After define say_hello	After calls	Final
greet (function)	Not defined	Defined (from lib.sh)	Defined	Called once	Defined
say_hello (function)	Not defined	Not defined	Defined	Called once	Defined

Key Moments - 3 Insights

Why do we use 'source' instead of just running the library script?

Using 'source' runs the library script in the current shell, so its functions become available to the main script. Running it normally would run in a separate shell and functions wouldn't be accessible.

What happens if the library script is missing or has errors?

The 'source' command will fail, and the main script may stop or show errors when calling missing functions, as seen in step 2 of the execution table.

Can the main script override functions from the library?

Yes, functions defined after sourcing can override library functions. In this example, say_hello is unique, but if it matched greet, the main script's version would be used.

Visual Quiz - 3 Questions

Look at the execution table, what output appears when calling greet()?

A Hello from main script

B Hello from library

C No output

D Error: command not found

💡 Hint

Check step 5 in the execution_table where greet() is called

At which step does the greet function become available in the script?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the action 'source ./lib.sh' in the execution_table

If the source command is removed, what happens when greet() is called?

A It outputs 'Hello from library'

B It outputs 'Hello from main script'

C It causes an error: command not found

D It outputs nothing

💡 Hint

Without sourcing, the function greet() is not defined as shown in variable_tracker

Concept Snapshot

Function libraries in bash use 'source filename' to load functions into the current script.
This allows reuse of code without copying.
Functions in the library become available after sourcing.
Call library functions like normal functions.
If the library is missing, calls to its functions cause errors.
Functions defined later can override library functions.

Full Transcript

This visual execution shows how a bash script uses 'source' to load functions from another script called a library. The main script starts, then runs 'source ./lib.sh' which loads the greet() function into the current shell. Then the main script defines its own function say_hello(). When the script calls say_hello(), it prints 'Hello from main script'. When it calls greet(), it prints 'Hello from library'. The variable tracker shows greet() is not defined before sourcing, but is defined after. Key moments explain why sourcing is needed to share functions, what happens if the library is missing, and how function overriding works. The quiz tests understanding of when functions become available and what outputs appear. This teaches beginners how to organize reusable bash functions in separate files and use them easily.