Complete Guide to Bash Variables

Introduction to Bash Variables

Variables in Bash are fundamental containers for storing and manipulating data. They allow you to store values, reference them throughout your scripts, and perform operations on them. Understanding Bash variables is crucial for writing effective shell scripts.

Key Concepts

No Data Types: All variables are stored as strings
Case-Sensitive: $VAR and $var are different
Scope: Variables can be global or local
Special Variables: Positional parameters and system variables
Expansion: Variables are expanded with $ prefix

1. Basic Variable Declaration

Simple Variable Assignment

#!/bin/bash # Basic assignment (no spaces around =) name="John Doe" age=25 city="New York" # Accessing variables echo "$name is $age years old and lives in $city" # Output: John Doe is 25 years old and lives in New York # Variables without $ when assigning, with $ when accessing greeting="Hello" echo $greeting World echo "${greeting}, World!" # Curly braces for clarity

Variable Naming Rules

#!/bin/bash # Valid variable names name="John" NAME="John" # Different from 'name' _name="John" # Starting with underscore name123="John" # Numbers allowed after first character long_variable_name="John" # Underscores for readability # Invalid variable names # 123name="John" # Cannot start with number # my-name="John" # Hyphen not allowed # my name="John" # Space not allowed # $name="John" # $ not allowed in assignment # Best practices # Use lowercase for local variables # Use UPPERCASE for environment variables and constants local_var="value" readonly MAX_COUNT=100 export GLOBAL_CONFIG="/etc/app/config"

2. Variable Types and Usage

String Variables

#!/bin/bash # String assignment name="John Doe" empty_string="" space_string=" " # String with a space # String concatenation first="John" last="Doe" full="$first $last" echo "$full" # John Doe # Quotes matter var1=Hello World # Error: World treated as command var2="Hello World" # Correct var3='Hello World' # Correct (literal) # Single vs Double quotes name="John" echo "Hello $name" # Hello John (variable expanded) echo 'Hello $name' # Hello $name (literal) # Escaping quotes message="He said: \"Hello\"" echo "$message" # Multi-line strings multiline="Line 1 Line 2 Line 3" echo "$multiline"

Numeric Variables (All strings, but can be used in arithmetic)

#!/bin/bash # Numbers are stored as strings count="10" echo "$count" # Arithmetic expansion sum=$((5 + 3)) echo "Sum: $sum" # Sum: 8 # Different arithmetic operations a=10 b=3 echo "Addition: $((a + b))" # 13 echo "Subtraction: $((a - b))" # 7 echo "Multiplication: $((a * b))" # 30 echo "Division: $((a / b))" # 3 (integer division) echo "Modulus: $((a % b))" # 1 echo "Power: $((a ** 2))" # 100 # Using let for arithmetic let "result = a + b" echo "Result: $result" # Result: 13 # Increment/decrement counter=0 ((counter++)) echo "$counter" # 1 ((counter--)) echo "$counter" # 0 ((counter+=5)) echo "$counter" # 5

Arrays

#!/bin/bash # Indexed arrays fruits=("apple" "banana" "orange") numbers=(1 2 3 4 5) mixed=("hello" 42 "world" 3.14) # Accessing array elements echo "${fruits[0]}" # apple echo "${fruits[1]}" # banana echo "${fruits[@]}" # all elements echo "${#fruits[@]}" # array length # Adding elements fruits[3]="grape" fruits+=("kiwi" "mango") # Iterating over array for fruit in "${fruits[@]}"; do echo "Fruit: $fruit" done # Associative arrays (Bash 4+) declare -A capitals capitals["USA"]="Washington" capitals["France"]="Paris" capitals["Japan"]="Tokyo" echo "${capitals["France"]}" # Paris echo "${!capitals[@]}" # all keys echo "${capitals[@]}" # all values # Iterate over associative array for country in "${!capitals[@]}"; do echo "$country: ${capitals[$country]}" done

3. Special Variables

Positional Parameters

#!/bin/bash # script.sh echo "Script name: $0" echo "First argument: $1" echo "Second argument: $2" echo "Third argument: $3" echo "All arguments: $@" echo "Number of arguments: $#" echo "All arguments (as single string): $*" # Shift through arguments echo "Processing arguments:" while [ $# -gt 0 ]; do echo "Argument: $1" shift done # Example usage # ./script.sh arg1 arg2 arg3

Special Shell Variables

#!/bin/bash # Process ID echo "Current shell PID: $$" echo "Last background process PID: $!" # Exit status echo "Last command exit status: $?" # Shell options echo "Shell options: $-" # Previous working directory cd /tmp cd ~ echo "Previous directory: $OLDPWD" # Current working directory echo "Current directory: $PWD" # Random number echo "Random number: $RANDOM" echo "Another random: $RANDOM" # Line number echo "Current line number: $LINENO"

Environment Variables

#!/bin/bash # Common environment variables echo "Home directory: $HOME" echo "User: $USER" echo "Username: $LOGNAME" echo "Shell: $SHELL" echo "Path: $PATH" echo "Terminal: $TERM" echo "Language: $LANG" echo "Hostname: $HOSTNAME" echo "Display: $DISPLAY" # Setting environment variables export MY_APP_CONFIG="/etc/myapp/config" export DATABASE_URL="postgresql://localhost/mydb" # Environment for a single command PATH="/custom/bin:$PATH" command_name # Listing all environment variables env printenv declare -p # Show all variables

4. Variable Operations

String Operations

#!/bin/bash # String length str="Hello World" echo "Length: ${#str}" # 11 # Substring extraction echo "${str:6}" # World (from position 6) echo "${str:6:3}" # Wor (3 chars from position 6) echo "${str: -5}" # World (last 5 chars) echo "${str: -5:2}" # Wo (2 chars from 5 from end) # Pattern removal filename="document.txt" echo "${filename%.txt}" # document (remove suffix) echo "${filename%.*}" # document (remove shortest suffix) echo "${filename%%.*}" # document (remove longest suffix) path="/home/user/file.txt" echo "${path#*/}" # home/user/file.txt (remove shortest prefix) echo "${path##*/}" # file.txt (remove longest prefix) # Search and replace text="Hello Hello World" echo "${text/Hello/Hi}" # Hi Hello World (first match) echo "${text//Hello/Hi}" # Hi Hi World (all matches) echo "${text/#Hello/Hi}" # Hi Hello World (match at start) echo "${text/%World/All}" # Hello Hello All (match at end) # Default values unset var echo "${var:-default}" # default (if unset or empty) echo "${var-default}" # default (only if unset) echo "${var:=default}" # assign default and return echo "$var" # default (now assigned) # Error if unset echo "${var:?Error message}" # prints error if unset or empty

Case Modification (Bash 4+)

#!/bin/bash # Uppercase/lowercase name="john DOE" echo "${name^}" # John DOE (first letter uppercase) echo "${name^^}" # JOHN DOE (all uppercase) echo "${name,}" # john DOE (first letter lowercase) echo "${name,,}" # john doe (all lowercase) # Case transformation with patterns text="hello-world" echo "${text^}" # Hello-world echo "${text^^}" # HELLO-WORLD echo "${text^^[a-z]}" # HELLO-WORLD echo "${text^^[a]}" # hello-world (only a)

5. Variable Scope

Local vs Global Variables

#!/bin/bash # Global variable global_var="I'm global" function test_scope() { # Local variable local local_var="I'm local" echo "Inside function: $global_var" echo "Inside function: $local_var" # Modify global global_var="Modified global" # Create new global inside function new_global="Created in function" } test_scope echo "Outside: $global_var" # Modified global echo "Outside: $local_var" # Empty (not accessible) echo "Outside: $new_global" # Created in function # Function with local variables only function calculate() { local result=$(( $1 + $2 )) echo "$result" } sum=$(calculate 5 3) echo "Sum: $sum"

Exporting Variables

#!/bin/bash # Export variable to child processes export CONFIG_FILE="/etc/myapp/config" export DEBUG=true # Export after assignment DATABASE_URL="postgresql://localhost/db" export DATABASE_URL # Export multiple variables export VAR1="value1" VAR2="value2" VAR3="value3" # Child script (child.sh) cat > child.sh << 'EOF' #!/bin/bash echo "Config file: $CONFIG_FILE" echo "Debug mode: $DEBUG" EOF chmod +x child.sh ./child.sh # Unset variable unset DATABASE_URL unset VAR1 VAR2 VAR3

6. Advanced Variable Techniques

Indirect Expansion

#!/bin/bash # Variable indirection fruit_apple="Apple is red" fruit_banana="Banana is yellow" fruit="apple" echo "${fruit_$fruit}" # Error echo "${fruit_apple}" # Apple is red # Using indirection chosen="apple" ref="fruit_$chosen" echo "${!ref}" # Apple is red (indirect expansion) # Practical example config_user="admin" config_pass="secret" config_host="localhost" for setting in user pass host; do ref="config_$setting" echo "Setting $setting: ${!ref}" done

Variable Attributes

#!/bin/bash # Readonly variables readonly PI=3.14159 PI=3.14 # Error: cannot modify readonly # Integer attribute declare -i number number=10 number="5" # Works (string converted to integer) number="hello" # Becomes 0 echo "$number" # Array attributes declare -a indexed_array declare -A associative_array # Lowercase/Uppercase attributes declare -l lowercase="HELLO" # Automatically lowercase echo "$lowercase" # hello declare -u uppercase="hello" # Automatically uppercase echo "$uppercase" # HELLO # Read from file declare -a lines mapfile -t lines < file.txt echo "${lines[0]}"

Dynamic Variable Names

#!/bin/bash # Creating dynamic variable names for i in {1..5}; do declare "var_$i=$i" done echo "$var_1" # 1 echo "$var_5" # 5 # Using eval (be careful!) name="value" eval "$name='Hello World'" echo "$value" # Hello World # Better: using declare for i in {1..3}; do declare "fruit_$i=$(echo "fruit$i")" done # List variables with pattern echo "${!fruit_@}" # fruit_1 fruit_2 fruit_3 echo "${!fruit_*}" # fruit_1 fruit_2 fruit_3

7. Variable Expansion and Quoting

Quote Types

#!/bin/bash # Double quotes (allow expansion) name="John" echo "Hello $name" # Hello John echo "Hello \$name" # Hello $name (escaped) # Single quotes (literal) echo 'Hello $name' # Hello $name echo 'Hello "World"' # Hello "World" # No quotes (word splitting, globbing) echo Hello World # Hello World (multiple spaces collapsed) echo * # Lists files in current directory # ANSI-C quoting ($'...') echo $'Hello\nWorld' # Newline interpretation echo $'Tab\there' # Tab character echo $'Bell\a' # Bell character echo $'Quote: \'' # Single quote

Word Splitting

#!/bin/bash # IFS (Internal Field Separator) data="apple:banana:orange" # Default IFS (space, tab, newline) for item in $data; do echo "$item" # Splits by spaces (none here) - whole string done # Change IFS IFS=":" for item in $data; do echo "$item" # Splits by colon: apple, banana, orange done # Reset IFS unset IFS # Preserve spaces with IFS IFS=$'\n' # Newline only # Word splitting examples list="one two three" set -- $list # Split into positional parameters echo "$1" # one echo "$2" # two echo "$3" # three # Prevent word splitting list="one two three" set -- "$list" # No splitting echo "$1" # one two three

8. Command Substitution

Basic Command Substitution

#!/bin/bash # Old style (backticks) files=`ls` echo "Files: $files" # Modern style ($()) files=$(ls) echo "Files: $files" # Nesting command substitution output=$(echo "Date: $(date)") echo "$output" # Complex examples current_date=$(date +%Y-%m-%d) echo "Today: $current_date" lines=$(wc -l < file.txt) echo "Lines: $lines" # Using in arithmetic count=$(grep -c "pattern" file.txt) echo "Matches: $((count * 2))" # Multi-line output files_list=$(ls -la) echo "$files_list" # Quotes preserve newlines

Process Substitution

#!/bin/bash # Process substitution (Bash 4+) diff <(ls dir1) <(ls dir2) # Compare files while read line; do echo "Processed: $line" done < <(grep "pattern" file.txt) # Multiple process substitutions paste <(cut -f1 file1) <(cut -f2 file2) # Complex example while IFS= read -r line1 && IFS= read -r line2 <&3; do echo "Line1: $line1, Line2: $line2" done < <(command1) 3< <(command2)

9. Variable Attributes and Declare

Using declare/typeset

#!/bin/bash # Declare variable with attributes declare -r READONLY_VAR="Cannot change" declare -i INTEGER=10 declare -a ARRAY=(1 2 3) declare -A ASSOC=([key]=value) declare -x EXPORTED_VAR="Visible to child processes" declare -l LOWERCASE="HELLO" declare -u UPPERCASE="hello" # List variables declare -p # Show all variables with attributes declare -p PATH # Show PATH variable details # Function-local variables function test() { declare -i local_int=5 echo "$local_int" } # Read-only array declare -ra COLORS=("red" "green" "blue") # COLORS[0]="yellow" # Error: readonly # Export array (not directly possible) # Workaround using string declare -ax MY_ARRAY=(1 2 3) # Still won't export

Variable Attributes Examples

#!/bin/bash # Integer arithmetic with declare -i declare -i count count=10 count+=5 # Addition, not concatenation echo "$count" # 15 count="2 * 3" echo "$count" # 6 # Lowercase/Uppercase with assignment declare -l name="JOHN DOE" echo "$name" # john doe name="JANE SMITH" echo "$name" # jane smith declare -u code="abc123" echo "$code" # ABC123 # Trace function calls declare -t TRACE_VAR="track this" set -o functrace # Array attributes declare -a numbers numbers[5]=10 echo "${#numbers[@]}" # 1 (sparse array) echo "${!numbers[@]}" # 5 (indexes)

10. Practical Examples

Configuration File Parser

#!/bin/bash # Simple config parser parse_config() { local config_file="$1" while IFS='=' read -r key value; do # Skip comments and empty lines [[ "$key" =~ ^#.*$ || -z "$key" ]] && continue # Trim whitespace key=$(echo "$key" | xargs) value=$(echo "$value" | xargs) # Remove quotes if present value="${value%\"}" value="${value#\"}" value="${value%\'}" value="${value#\'}" # Export as variable export "$key=$value" done < "$config_file" } # Example config file cat > app.conf << 'EOF' # Application configuration DB_HOST=localhost DB_PORT=5432 DB_NAME=myapp DEBUG=true MAX_CONNECTIONS=100 EOF # Parse and use parse_config app.conf echo "Database: $DB_NAME on $DB_HOST:$DB_PORT" echo "Debug mode: $DEBUG"

Safe Variable Handling

#!/bin/bash # Safe variable access with defaults get_env() { local var_name="$1" local default="${2:-}" if [ -n "${!var_name}" ]; then echo "${!var_name}" else echo "$default" fi } # Validate variable is set require_var() { local var_name="$1" local message="${2:-Required variable $var_name is not set}" if [ -z "${!var_name}" ]; then echo "ERROR: $message" >&2 exit 1 fi } # Use defaults DB_HOST=$(get_env "DB_HOST" "localhost") DB_PORT=$(get_env "DB_PORT" "5432") # Require critical variables require_var "API_KEY" "API key must be set" # Safe array handling safe_array_get() { local array_name="$1" local index="$2" local default="${3:-}" eval "value=\"\${${array_name}[$index]:-}\"" if [ -n "$value" ]; then echo "$value" else echo "$default" fi }

Variable Scope Manager

#!/bin/bash # Save and restore variable states save_vars() { local save_file="${1:-/tmp/vars_save}" declare -p | grep -v "^declare -[aA]" > "$save_file" } restore_vars() { local save_file="${1:-/tmp/vars_save}" if [ -f "$save_file" ]; then source "$save_file" rm "$save_file" fi } # Temporary variable changes with_vars() { local vars_file="/tmp/vars_$$" save_vars "$vars_file" # Set temporary variables eval "$1" # Run command eval "${@:2}" # Restore restore_vars "$vars_file" } # Usage with_vars "PATH=/custom/bin:\$PATH; DEBUG=1" "my_command --verbose"

Environment Manager

#!/bin/bash # Environment setup/teardown setup_environment() { local env_file="$1" # Save current environment declare -p > "/tmp/env_before_$$" # Load new environment while IFS= read -r line; do [[ "$line" =~ ^#.*$ || -z "$line" ]] && continue export "$line" done < "$env_file" } teardown_environment() { # Restore previous environment while IFS= read -r line; do if [[ "$line" =~ ^declare\ -x\ ([^=]+)= ]]; then var="${BASH_REMATCH[1]}" unset "$var" fi done < "/tmp/env_before_$$" # Reload saved variables source "/tmp/env_before_$$" rm "/tmp/env_before_$$" } # Environment profiles profile_dev() { export DB_HOST="localhost" export DB_NAME="dev_db" export DEBUG=1 } profile_prod() { export DB_HOST="prod.db.example.com" export DB_NAME="prod_db" export DEBUG=0 } # Switch profile use_profile() { local profile="$1" "profile_$profile" }

11. Error Handling with Variables

Variable Validation

#!/bin/bash # Validate variable types validate_integer() { local var_name="$1" local value="${!var_name}" if [[ ! "$value" =~ ^-?[0-9]+$ ]]; then echo "Error: $var_name must be an integer" >&2 return 1 fi } validate_positive() { local var_name="$1" local value="${!var_name}" if [[ ! "$value" =~ ^[0-9]+$ ]] || [ "$value" -le 0 ]; then echo "Error: $var_name must be positive integer" >&2 return 1 fi } validate_email() { local var_name="$1" local value="${!var_name}" if [[ ! "$value" =~ ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then echo "Error: $var_name must be valid email" >&2 return 1 fi } validate_ip() { local var_name="$1" local value="${!var_name}" if [[ ! "$value" =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then echo "Error: $var_name must be valid IP" >&2 return 1 fi # Validate each octet IFS='.' read -r a b c d <<< "$value" if [ "$a" -gt 255 ] || [ "$b" -gt 255 ] || [ "$c" -gt 255 ] || [ "$d" -gt 255 ]; then echo "Error: $var_name contains invalid octet" >&2 return 1 fi }

Defensive Programming

#!/bin/bash # Set strict mode set -euo pipefail # Check required variables required_vars=("DB_HOST" "DB_USER" "DB_PASS") for var in "${required_vars[@]}"; do if [ -z "${!var:-}" ]; then echo "Error: $var is not set" >&2 exit 1 fi done # Use default values safely : "${MAX_RETRIES:=3}" : "${TIMEOUT:=30}" # Prevent unset variable errors set -u echo "$UNDEFINED_VAR" # This will error # Safer alternative echo "${UNDEFINED_VAR:-}" # Empty string if unset # Check if variable is set if [ -n "${SOME_VAR+set}" ]; then echo "SOME_VAR is set" else echo "SOME_VAR is not set" fi

12. Performance and Best Practices

Variable Performance Tips

#!/bin/bash # Use local variables in functions (faster) function slow() { for i in {1..1000}; do global_var=$i # Global variable (slower) done } function fast() { local local_var for i in {1..1000}; do local_var=$i # Local variable (faster) done } # Avoid unnecessary command substitution # Slow for i in $(seq 1 1000); do # ... done # Fast for ((i=1; i<=1000; i++)); do # ... done # Use built-in operations instead of external commands # Slow len=$(echo -n "$string" | wc -c) # Fast len=${#string} # Use arrays instead of string parsing # Better files=("$@") for file in "${files[@]}"; do echo "$file" done # Avoid eval when possible # Dangerous eval "var_$i='value'" # Safer declare "var_$i=value"

Best Practices

#!/bin/bash # 1. Always quote variables file="my file.txt" cat "$file" # Good cat $file # Bad (breaks with spaces) # 2. Use descriptive names user_input="data" # Good ui="data" # Bad (too short) path_to_config_file="/etc/app/config" # Good p="/etc/app/config" # Bad (not descriptive) # 3. Use readonly for constants readonly MAX_CONNECTIONS=100 readonly PI=3.14159 # 4. Initialize variables local var="" # Good local var # Bad (may inherit previous value) # 5. Use lowercase for local variables local user_name="John" # Good local USER_NAME="John" # Bad (looks like environment) # 6. Use uppercase for exported variables export APP_HOME="/opt/myapp" # Good export app_home="/opt/myapp" # Bad (convention) # 7. Check variables before use if [ -n "${filename:-}" ]; then process "$filename" fi # 8. Use default values timeout=${TIMEOUT:-30} debug=${DEBUG:-false} # 9. Clean up sensitive variables secret_key="supersecret" process_data "$secret_key" unset secret_key # 10. Use arrays for lists # Instead of: fruits="apple banana orange" fruits=("apple" "banana" "orange") for fruit in "${fruits[@]}"; do echo "$fruit" done

13. Common Pitfalls and Solutions

Variable Pitfalls

#!/bin/bash # Pitfall 1: Spaces in assignments # Wrong name = "John" # Error: name command not found # Correct name="John" # Pitfall 2: Forgetting $ when reading count=5 echo count # prints "count", not 5 echo "$count" # prints 5 # Pitfall 3: Word splitting files="file1 file2 file3" for file in $files; do # Works but fragile echo "$file" done # Better files=("file1" "file2" "file3") for file in "${files[@]}"; do echo "$file" done # Pitfall 4: Globbing with unquoted variables pattern="*" echo $pattern # Lists files in directory echo "$pattern" # Prints * # Pitfall 5: Environment inheritance export VAR="value" (export VAR="child"; echo "$VAR") # Prints "child" echo "$VAR" # Prints "value" (unchanged) # Pitfall 6: Array vs string array=(1 2 3) echo "$array" # Prints "1" (only first element) echo "${array[@]}" # Prints "1 2 3" # Pitfall 7: Unset variables in strict mode set -u echo "$UNDEFINED" # Error # Safer echo "${UNDEFINED:-}" # Pitfall 8: Exporting arrays export myarray=(1 2 3) # Doesn't work # Workaround: export as string export myarray="1 2 3" # Pitfall 9: Variable scope in pipelines count=0 echo -e "1\n2\n3" | while read line; do ((count++)) done echo "$count" # Still 0 (subshell issue) # Fix with process substitution count=0 while read line; do ((count++)) done < <(echo -e "1\n2\n3") echo "$count" # 3 # Pitfall 10: Using echo with flags var="-n" echo "$var" # Prints nothing (interpreted as echo flag) printf "%s\n" "$var" # Safe alternative

14. Command Summary and Cheat Sheet

Variable Operations Quick Reference

# Assignment name="value" readonly constant="value" export global="value" declare -i integer=5 declare -a array=(1 2 3) declare -A dict=([key]="value") # Access $name ${name} ${#name} # Length ${name:offset:length} # Substring ${name#pattern} # Remove shortest prefix ${name##pattern} # Remove longest prefix ${name%pattern} # Remove shortest suffix ${name%%pattern} # Remove longest suffix ${name/pattern/replacement} # Replace first ${name//pattern/replacement} # Replace all ${name^} # First character uppercase ${name^^} # All uppercase ${name,} # First character lowercase ${name,,} # All lowercase # Default values ${var:-default} # Use default if unset/empty ${var-default} # Use default if unset ${var:=default} # Assign default if unset/empty ${var:=default} # Assign default if unset ${var:?error} # Error if unset/empty ${var?error} # Error if unset # Indirect expansion ${!var} # Indirect reference # Array operations ${array[@]} # All elements ${!array[@]} # Array indices ${#array[@]} # Array length array+=("new") # Append unset array[2] # Remove element # Special variables $0 # Script name $1, $2... # Positional parameters $@ # All arguments $* # All arguments (as string) $# # Number of arguments $? # Exit status $$ # Process ID $! # Last background PID $- # Shell options

Common Patterns

# Safe variable access : "${VAR:=default}" # Set default if unset : "${VAR:?Required}" # Error if unset # Variable testing [ -n "$VAR" ] # Not empty [ -z "$VAR" ] # Empty [ "${VAR+set}" = "set" ] # Is set (even if empty) # Variable transformation lower=$(echo "$VAR" | tr '[:upper:]' '[:lower:]') upper=$(echo "$VAR" | tr '[:lower:]' '[:upper:]') trimmed=$(echo "$VAR" | xargs) # Loops with variables for var in "${list[@]}"; do echo "$var" done while IFS= read -r line; do echo "$line" done < file.txt

Conclusion

Bash variables are essential for effective shell scripting:

Key Takeaways

No types - all variables are strings, but can be used numerically with arithmetic
Case-sensitive - naming conventions matter
Scope - understand local vs global vs environment
Expansion - ${} provides powerful manipulation
Arrays - indexed and associative for complex data
Special variables - positional parameters and system info

Best Practices Summary

Practice	Example
Quote variables	`"$var"`
Use local in functions	`local var`
Use uppercase for constants	`readonly MAX=100`
Use lowercase for locals	`local count`
Use arrays for lists	`files=("$@")`
Check variables before use	`[ -n "$var" ]`
Set defaults	`: "${var:=default}"`
Clean sensitive data	`unset password`

Common Commands Summary

# Variable operations declare # Set attributes export # Make available to children local # Function-local readonly # Make read-only unset # Remove variable set # Show all variables/env # Information env # Show environment printenv # Print environment echo # Display values printf # Formatted output

Mastering Bash variables is fundamental to writing robust, maintainable shell scripts. They provide the foundation for data manipulation, configuration management, and program flow control in the Unix/Linux environment.

Complete Bash Exercises with Solutions

Practice Bash scripting with solved exercises to improve your command-line and scripting skills.
Link: https://macronepal.com/complete-bash-exercises-with-solutions/

Complete Guide to Bash Crontab Command

Learn how to schedule and automate tasks efficiently using the Bash crontab command.
Link: https://macronepal.com/complete-guide-to-bash-crontab-command-schedule-tasks/

Complete Guide to Bash Arrays

Understand how to create, manage, and use arrays in Bash scripting.
Link: https://macronepal.com/complete-guide-to-bash-arrays/

Bash Quiz: Test Your Knowledge

Test your Bash scripting knowledge with quizzes and practical questions.
Link: https://macronepal.com/bash-quiz-test-your-knowledge/

Complete Guide to Bash Functions

Learn how to write reusable Bash functions for cleaner and efficient scripts.
Link: https://macronepal.com/complete-guide-to-bash-functions/

Complete Guide to Bash Loops

Master loops in Bash for repetitive tasks and automation.
Link: https://macronepal.com/complete-guide-to-bash-loops/

Complete Guide to Bash If-Else Statements

Learn decision-making in Bash using conditional statements.
Link: https://macronepal.com/complete-guide-to-bash-ifelse-statements/

Complete Guide to Bash Operators

Explore arithmetic, logical, and comparison operators in Bash.
Link: https://macronepal.com/complete-guide-to-bash-operators/

Complete Guide to Bash Data Types

Understand variables and different data types used in Bash scripting.
Link: https://macronepal.com/complete-guide-to-bash-data-types/