📘 Functions — Core Customization Technique in Bash

🎯 What You Will Learn

Understand what functions are in Bash and how they differ from aliases.
Learn how to define, use, and persist functions for automation.
Explore function scopes, arguments, and return values.
Locate where function definitions are stored — in user-level and system-level files (with tree view).
Implement real WordPress VPS functions for maintenance, backup, and service control.
Follow best practices for organization, testing, and reliability.

1. What is a Bash Function

A function in Bash is a named group of commands that can be executed as a unit. It allows reusable logic, parameter handling, and condition checks — far more flexible than an alias. Basic syntax:

function_name () {
    commands
}

or:

function function_name {
    commands
}

Example:

greet() {
    echo "Hello, $(whoami)!"
}

When you type `greet`, the shell executes the block inside the braces.

2. Why Functions Are Important

Purpose	Description
Automation	Combines multiple tasks into one reusable command.
Parameterization	Accepts arguments for flexible command execution.
Maintainability	Keeps scripts and repetitive commands organized.
Consistency	Defines standard logic across multiple WordPress servers.
Logic Handling	Supports conditionals (`if`, `for`, `while`) unlike aliases.

3. Where Functions Are Stored

Functions can be defined temporarily in a shell session or persistently in configuration files.

Scope	File	Applies To	Loaded When
User-level	`~/.bashrc` or `~/.bash_functions`	One user	On every interactive shell start
System-wide	`/etc/profile.d/*.sh` or `/etc/bash.bashrc`	All users	On every login or interactive session

Directory Structure (Tree View)

User-level configuration

/home/
└── donnyariw/
    ├── .bashrc
    ├── .bash_functions
    ├── .bash_aliases
    ├── .bash_profile
    └── scripts/
        └── wpbackup.sh

System-wide configuration

/etc/
├── profile
├── bash.bashrc
└── profile.d/
    ├── lang.sh
    ├── vim.sh
    └── custom-functions.sh

Each file type plays a specific role:

~/.bash_functions → custom user functions.
/etc/profile.d/custom-functions.sh → global functions for all users.

4. Function vs Alias

Feature	Alias	Function
Purpose	Command shortcut	Full logic routine
Can take arguments	❌ No	✅ Yes
Supports logic (if, loop)	❌ No	✅ Yes
Defined in	`.bashrc`, `.bash_aliases`	`.bashrc`, `.bash_functions`, `/etc/profile.d/`
Used for	Simple shortcuts	Multi-step or parameterized automation

Example comparison:

# Alias
alias wpstatus='wp plugin list --allow-root'

# Function
wpstatus() {
  site=$1
  wp plugin list --allow-root --path=/home/$site/public_html
}

Usage:

wpstatus dev-wpstrategist

5. Defining Functions

a. Basic Function

sayhello() {
  echo "Hello from Bash!"
}

Usage:

sayhello

Output:

Hello from Bash!

b. Function with Argument

greet() {
  echo "Hello, $1!"
}

Usage:

greet Donny

Output:

Hello, Donny!

c. Return Values

checkfile() {
  if [ -f "$1" ]; then
    echo "File exists: $1"
    return 0
  else
    echo "File not found."
    return 1
  fi
}

Usage:

checkfile /etc/passwd
echo $?

6. Persistent Function Storage

a. User-Level Persistent Functions

Inside ~/.bashrc or ~/.bash_functions:

wpbackupsite() {
  site=$1
  wp db export /root/wpbackup/${site}-$(date +%F).sql \
  --path=/home/$site/public_html --allow-root
}

Then reload:

source ~/.bashrc

Now:

wpbackupsite dev-wpstrategist

b. System-Wide Persistent Functions

Create a file inside /etc/profile.d/:

sudo nano /etc/profile.d/custom-functions.sh

Example content:

# /etc/profile.d/custom-functions.sh

restartservices() {
  echo "Restarting Redis, PHP, and LiteSpeed..."
  systemctl restart redis
  systemctl restart lsws
  echo "Services restarted successfully."
}

Make executable:

chmod +x /etc/profile.d/custom-functions.sh

All users can now use:

restartservices

7. WordPress VPS Practical Use Cases

Function Name	Example Definition	Description
`wpbackupsite`	`wp db export /root/wpbackup/...`	Backup per WordPress site
`wpupdateall`	Loops over `/home///public_html`	Updates plugins across all sites
`redisflush`	`redis-cli flushall`	Clears Redis cache
`restartservices`	Restart PHP, Redis, LiteSpeed	Reloads services efficiently
`wpcleancache`	Delete LSCache + Redis flush	Clears both caching layers

Example 1: Backup Function

wpbackupsite() {
  site=$1
  if [ -d "/home/$site/public_html" ]; then
    echo "Backing up $site..."
    wp db export /root/wpbackup/${site}-$(date +%F).sql \
      --path=/home/$site/public_html --allow-root
    echo "Backup complete."
  else
    echo "Error: $site not found!"
  fi
}

Example 2: Global Plugin Updater

wpupdateall() {
  for dir in /home/*/*/public_html; do
    if [ -f "$dir/wp-config.php" ]; then
      echo "→ Updating plugins in $dir"
      wp plugin update --all --path="$dir" --allow-root
    fi
  done
  echo "All WordPress sites updated."
}

Example 3: Combined Cache Cleaner

wpcleancache() {
  echo "Flushing Redis cache..."
  redis-cli flushall
  echo "Clearing LSCache..."
  rm -rf /home/*/*/public_html/wp-content/lscache/*
  echo "Cache cleared."
}

8. Organizing Functions

To maintain structure:

Create a dedicated file:

touch ~/.bash_functions

Add your functions there.
Load them automatically from .bashrc:

if [ -f ~/.bash_functions ]; then
    source ~/.bash_functions
fi

Example Tree View of Integration

/home/donnyariw/
├── .bashrc
├── .bash_functions
└── .bash_aliases

Flow of execution:

bash startup → .bashrc → .bash_functions → functions available globally

9. Best Practices

Use descriptive names: wpbackupsite is clearer than bkpwp.
Validate input: Always check if $1 or files exist.
Use absolute paths: Prevents dependency on environment variables.
Return proper exit codes: Use return 0 (success) or return 1 (failure).
Keep logic short: For long tasks, place them in scripts under /root/scripts/.
Avoid re-defining system commands: Use command keyword to call the original binary.
Test in a sandbox first: Before deploying to production VPS.

10. Troubleshooting

Problem	Cause	Fix
Function not found	File not sourced	Run `source ~/.bashrc` or restart terminal
Wrong directory reference	`$1` undefined	Use argument validation (`if [ -z "$1" ]; then`)
Command error	Missing absolute path	Use `/usr/bin/wp`, `/usr/bin/systemctl`, etc.
Function overrides	Duplicate name	Rename or `unset -f function_name`

11. Quick Lab

Objective: Automate backups and plugin updates for all WordPress sites.

Open your function file:

nano ~/.bash_functions

Add:

wpbackupsite() {
  site=$1
  wp db export /root/wpbackup/${site}-$(date +%F).sql \
    --path=/home/$site/public_html --allow-root
}

wpupdateall() {
  for dir in /home/*/*/public_html; do
    if [ -f "$dir/wp-config.php" ]; then
      echo "Updating: $dir"
      wp plugin update --all --path="$dir" --allow-root
    fi
  done
}

Load functions:

source ~/.bash_functions

Test:

wpbackupsite dev-wpstrategist
wpupdateall

Expected output:

Backing up dev-wpstrategist...
→ Updating plugins in /home/dev-wpstrategist/public_html
All WordPress sites updated.

12. Glossary

Term	Definition
Function	A reusable Bash code block that executes multiple commands.
Positional Parameter	`$1`, `$2`, etc., arguments passed to a function.
Return Code	Numeric result of function execution (`0`=success).
Sourcing	Executing the contents of a file in the current shell.
Scope	Visibility of functions or variables within the environment.

13. Mini-Quiz

Where are user-level Bash functions typically stored?
Which command makes your new function available immediately?
How do you pass arguments to a function?
What’s the main advantage of a function over an alias?
Which directory is best for defining global (system-wide) functions?

14. Summary

Functions are reusable automation blocks in Bash — more powerful than aliases.
They accept parameters, can include loops, and return exit codes.
User functions belong in ~/.bash_functions or ~/.bashrc; global ones in /etc/profile.d/*.sh.
Ideal for WordPress VPS automation such as backups, cache clearing, or updates.
Keep them modular, descriptive, and validated for safe and predictable automation.
Always maintain clear documentation and backup before deploying on production systems.

Would you like me to continue next with “Core Customization Technique: Environment Variables” (next in your curriculum sequence), including file location mapping and VPS examples? About function. how to call and check all function that is registered in terminal? for alias we can simply type alias
Excellent question — this shows you’re diving into the declarative layer of Bash configuration. Let’s break it down step-by-step, just like we did with aliases, and clarify how to list, inspect, and call functions inside your Bash terminal.

1. How to Call (Run) a Bash Function

Once a function is defined (either interactively or via your .bashrc / .bash_functions), you call it just like a regular command:

function_name

Example:

greet() {
  echo "Hello, $(whoami)!"
}

Then call it:

greet

Output:

Hello, root!

If your function accepts parameters:

wpbackupsite dev-wpstrategist

(where `$1` inside the function receives `dev-wpstrategist`).

📜 2. How to List All Registered Functions

Unlike aliases (where you type alias), Bash functions can be listed with the following commands:

Command	Description
`declare -F`	Lists only the names of currently defined functions.
`declare -f`	Lists all functions with their full body definitions.
`typeset -F`	Same as `declare -F` (POSIX-compliant equivalent).
`compgen -A function`	Lists function names (useful in scripts).

Examples

a. List function names only

declare -F

Output:

declare -f wpbackupsite
declare -f wpupdateall
declare -f restartservices

b. List function bodies

declare -f

Output:

wpbackupsite ()
{
    site=$1
    wp db export /root/wpbackup/${site}-$(date +%F).sql --path=/home/$site/public_html --allow-root
}

c. Quick names only (clean output)

compgen -A function

Output:

wpbackupsite
wpupdateall
restartservices

🔍 3. How to Check a Specific Function Definition

To see what a specific function does:

declare -f function_name

Example:

declare -f wpbackupsite

Output:

wpbackupsite ()
{
    site=$1
    wp db export /root/wpbackup/${site}-$(date +%F).sql --path=/home/$site/public_html --allow-root
}

This is the function’s “source code” — useful for debugging or verifying changes.

🧠 4. How to Check if a Function Exists

Use:

type function_name

Example:

type wpbackupsite

Output:

wpbackupsite is a function
wpbackupsite ()
{
    site=$1
    wp db export /root/wpbackup/${site}-$(date +%F).sql --path=/home/$site/public_html --allow-root
}

⚙️ 5. How to Remove a Function from Memory

If you’ve redefined or no longer need a function:

unset -f function_name

Example:

unset -f wpbackupsite

Now check:

type wpbackupsite

Output:

bash: type: wpbackupsite: not found

🧩 6. Useful Variations

Task	Command	Purpose
List all functions	`declare -F`	Shows all function names
Show all definitions	`declare -f`	Displays entire code body
Show one definition	`declare -f wpbackupsite`	Inspects one function
Search function by name	`declare -F	grep wp`
Check if exists	`type wpupdateall`	Returns info if defined
Remove function	`unset -f wpupdateall`	Deletes from session
Export function to subshell	`export -f wpbackupsite`	Makes available to child shells

🧰 7. Practical Example

Let’s combine everything into a mini workflow.

# Define a function
wpcleancache() {
  redis-cli flushall
  rm -rf /home/*/*/public_html/wp-content/lscache/*
  echo "Cache cleared for all sites!"
}

# Verify it’s registered
declare -F | grep wpcleancache

# Test the function
wpcleancache

# View the function code
declare -f wpcleancache

# Remove if no longer needed
unset -f wpcleancache

🧭 8. Summary Table

Purpose	Command
List all function names	`declare -F` or `compgen -A function`
List all functions with definitions	`declare -f`
Show specific function definition	`declare -f function_name`
Check if name refers to function	`type function_name`
Remove function	`unset -f function_name`
Export to subshell	`export -f function_name`
Execute a function	`function_name [arguments]`

✅ Quick Recap

To call a function → just type its name.
To see all available functions → use declare -F.
To inspect full definitions → use declare -f.
To check specific function → type function_name.
To remove a function → unset -f function_name.
To make global (subshell) → export -f function_name.

🎯 What You Will Learn​

1. What is a Bash Function​

When you type greet, the shell executes the block inside the braces.​

2. Why Functions Are Important​

3. Where Functions Are Stored​

Directory Structure (Tree View)​

4. Function vs Alias​

5. Defining Functions​

a. Basic Function​

b. Function with Argument​

c. Return Values​

6. Persistent Function Storage​

a. User-Level Persistent Functions​

b. System-Wide Persistent Functions​

7. WordPress VPS Practical Use Cases​

Example 1: Backup Function​

Example 2: Global Plugin Updater​

Example 3: Combined Cache Cleaner​

8. Organizing Functions​

Example Tree View of Integration​

9. Best Practices​

10. Troubleshooting​

11. Quick Lab​

12. Glossary​

13. Mini-Quiz​

14. Summary​

1. How to Call (Run) a Bash Function​

(where $1 inside the function receives dev-wpstrategist).​

📜 2. How to List All Registered Functions​

Examples​

🔍 3. How to Check a Specific Function Definition​

This is the function’s “source code” — useful for debugging or verifying changes.​

🧠 4. How to Check if a Function Exists​

⚙️ 5. How to Remove a Function from Memory​

🧩 6. Useful Variations​

🧰 7. Practical Example​

🧭 8. Summary Table​

✅ Quick Recap​

🎯 What You Will Learn

1. What is a Bash Function

When you type `greet`, the shell executes the block inside the braces.

2. Why Functions Are Important

3. Where Functions Are Stored

Directory Structure (Tree View)

4. Function vs Alias

5. Defining Functions

a. Basic Function

b. Function with Argument

c. Return Values

6. Persistent Function Storage

a. User-Level Persistent Functions

b. System-Wide Persistent Functions

7. WordPress VPS Practical Use Cases

Example 1: Backup Function

Example 2: Global Plugin Updater

Example 3: Combined Cache Cleaner

8. Organizing Functions

Example Tree View of Integration

9. Best Practices

10. Troubleshooting

11. Quick Lab

12. Glossary

13. Mini-Quiz

14. Summary

1. How to Call (Run) a Bash Function

(where `$1` inside the function receives `dev-wpstrategist`).

📜 2. How to List All Registered Functions

Examples

🔍 3. How to Check a Specific Function Definition

This is the function’s “source code” — useful for debugging or verifying changes.

🧠 4. How to Check if a Function Exists

⚙️ 5. How to Remove a Function from Memory

🧩 6. Useful Variations

🧰 7. Practical Example

🧭 8. Summary Table

✅ Quick Recap