Table of Contents•Quick Answer: What Are Bash Variables?◦Quick Comparison: Variable Storage Methods•Table of Contents•Variable Basics◦Creating Variables◦Accessing Variables◦Variable Naming Rules◦When to Use Simple Variables•Variable Assignment◦Basic Assignment◦Assignment from User Input◦Assignment from Command Output•Data Types◦Strings◦Numbers◦Boolean (True/False)◦Type Checking◦When to Use Each Type•Special Variables◦Script Arguments◦Exit Status◦Process IDs◦Shell Info◦When to Use Special Variables•Parameter Expansion◦Length◦Substring Extraction◦String Replacement◦Default Values◦Case Conversion (Bash 4)◦When to Use Parameter Expansion•Variable Scope◦Local Variables◦Global Variables◦Environment Variables•Variable Validation◦Check if Variable Exists◦Validate Numeric◦Validate Path•Arrays and Associative Arrays◦Indexed Arrays◦Associative Arrays (Bash 4)•Best Practices◦1. Always Quote Variables◦2. Use Meaningful Names◦3. Use Local Variables in Functions◦4. Validate Input◦5. Use Readonly for Constants•Frequently Asked Questions◦Q: What’s the difference between $var and ${var}?◦Q: Should I use $ or $*?◦Q: How do I make a variable readonly?◦Q: What’s the difference between local and global variables?◦Q: Can I have variables with special characters?•Next StepsQuick Answer: What Are Bash Variables?Bash variables are named containers that store data values, allowing you to reuse information throughout your scripts. The simplest way to create one isnamevalue, then access it with$name.Quick Comparison: Variable Storage MethodsMethodSpeedBest ForComplexitySimple variablesFastestString/number storageVery simpleArraysVery fastMultiple valuesSimpleAssociative arraysVery fastKey-value pairsModerateParameter expansionFastestManipulation extractionSimpleEnvironment variablesFastCross-process sharingSimpleBottom line:Start with simple variables. Use arrays when storing multiple values, and associative arrays when you need key-value pairs.Bash variables are the foundation of scripting, storing data and controlling script behavior. This guide covers variable assignment, data types, scoping rules, special variables, and parameter expansion techniques.Understanding variables is critical for writing effective Bash scripts that manipulate data, make decisions, and communicate with other programs.Table of ContentsVariable BasicsVariable AssignmentData TypesSpecial VariablesParameter ExpansionVariable ScopeVariable ValidationArrays and Associative ArraysBest PracticesFrequently Asked QuestionsVariable BasicsCreating VariablesCreating a variable in Bash is straightforward—you just assign a value to a name. There’s no fancy declaration needed; Bash figures out what you’re storing based on context. This flexibility is one of Bash’s strengths, though it requires care since variables aren’t strongly typed.In Bash, variables are created simply by assignment:nameJohn age30 emailjohnexample.comNotice there are no spaces around the equals sign—name Johnwould fail because Bash would interpretnameas a command. This is a common gotcha for beginners coming from other languages where spacing is forgiving.Accessing VariablesOnce you’ve created a variable, retrieve its value by prefixing the name with$. This tells Bash you want thevaluestored in that variable, not the variable name itself. There are three syntaxes that all work the same way:Use the$prefix to access variable values:nameAlice echo $name # Output: Alice echo $name # Output: Alice (safer - use quotes) echo ${name} # Output: Alice (explicit syntax)Here’s an important distinction:echo $nameworks, butecho $nameis safer. If your variable contains spaces or special characters, unquoted variables can break your script. For example, ifnameAlice Boband you useecho $name, it might behave unexpectedly in some contexts. Always quote variables:$nameshould be your default habit.The${name}syntax might look verbose, but it’s invaluable when the variable name is ambiguous—like when you want to echo a variable followed by text:echo ${name}suffixis different fromecho $namesuffix(which tries to access a variable called$namesuffix).Variable Naming RulesBash has specific rules about what you can name your variables. They’re fairly intuitive, but knowing them prevents frustration:Must start with a letter or underscoreCan contain letters, numbers, underscoresCase-sensitive (Name,name,NAMEare different)Convention: UseUPPERCASEfor constants,lowercasefor regular variables# Valid my_var10 _private20 VAR_NAMEtest # Invalid 2var10 # Starts with number my-var10 # Contains hyphen my var10 # Contains spaceWhy these rules? The first character must be a letter or underscore because Bash needs to distinguish variable names from numbers. Hyphens look like operators to Bash (think of subtraction), so they’re forbidden. Spaces end the variable name entirely—Bash would interpretmy var10as trying to run a command calledmywith argumentsvar10.When to Use Simple VariablesSimple variables work best when:You’re storing a single value (string or number)The value won’t change frequently during script executionYou need the fastest, most readable codeYou’re new to Bash and want to keep things simpleSkip simple variables when:You need to store multiple related values (use arrays instead)You need key-value pairs (use associative arrays)You’re working with very large amounts of data (consider files)Variable AssignmentVariables can receive values from three primary sources: direct assignment, user input, or command output. Each approach solves different problems, and understanding when to use each makes your scripts more efficient and readable.Basic AssignmentThe simplest way to create a variable is direct assignment. You decide what value goes in, and it stays there for the rest of your script (unless you change it). This is predictable and fast—Bash doesn’t need to wait for external commands or user input.# String greetingHello, World! # Number count42 # Command output (Command Substitution) current_date$(date) # or current_datedate # Older syntax, avoid # Arithmetic total$((10 5))Notice the$(command)syntax for running commands—this is modern Bash and preferred over backticks. The$((expression))syntax evaluates arithmetic without needing an external calculator. Both store results directly in variables, making them very efficient.Assignment from User InputSometimes your script needs to ask the user for information. Thereadcommand pauses execution and waits for the user to type something, then stores it in a variable. This is essential for interactive scripts.# Read from stdin read name echo Hello, $name # Read with prompt read -p Enter your name: name # Read multiple values read first last echo Name: $first $lastThe-pflag shows a prompt before waiting for input—much better than leaving users confused about why the script is hanging. When you useread first last, Bash splits the input by whitespace, putting the first word infirstand the second word inlast. If you read only one variable with multiple inputs, everything gets stored in that one variable.Assignment from Command OutputMany Bash scripts need to capture the output of other programs. Command substitution with$(command)captures what a program writes to the screen and stores it in a variable. This is how you integrate your scripts with existing Unix tools.# Get all files in directory files$(ls /home/user/*.txt) # Count lines in file line_count$(wc -l file.txt) # Get current user current_user$(whoami)This technique is incredibly powerful—you can use any command (ls, grep, curl, custom scripts) and capture its output. Just remember that$(command)captures stdout but not stderr, and it strips the trailing newline from the output. If you need stderr too, redirect it:$(command 21).Data TypesHere’s something important to understand about Bash: it’s dynamically typed and weakly typed. That means Bash doesn’t enforce strict data types like Python or Java. Everything is technically a string, but Bash is smart enough to treat it like a number when you use it in arithmetic. This flexibility is powerful but requires care—you can accidentally do string operations on what you thought were numbers.StringsStrings are the most common data type in Bash. You can use single quotes or double quotes, and they behave differently—a crucial distinction many beginners miss.# String variables nameJohn messageSingle quotes preserve literals phraseDouble quotes allow $variable expansion echo $name # Output: John echo $phrase # Output: Double quotes allow JohnSingle quotes treat everything literally—variables won’t expand inside them. Double quotes allow variable expansion and command substitution. If you want the literal character$without variable expansion, single quotes are your answer. This is especially important when working with file paths or URLs that might contain$.NumbersBash treats numbers as strings until you do arithmetic with them. You can store a number in a variable, but Bash only knows it’s a number when you use it in an arithmetic context.# Integer count42 result$((10 5)) # Float (requires bc for calculations) pi3.14159 area$(echo scale2; 3.14159 * 5 * 5 | bc)Notice the$((10 5))syntax for arithmetic—Bash evaluates it and stores the result. For decimal numbers, Bash’s built-in math is limited to integers, so you need thebccalculator for floats. This is a common gotcha:echo $((10 / 3))returns3, not3.33, because Bash does integer division.Boolean (True/False)Bash doesn’t have a true boolean type. Instead, it uses return codes: 0 for success/true, and non-zero (usually 1) for failure/false. This can feel backwards if you’re from other languages, but it’s consistent with Unix philosophy.# True is_admin0 # False is_readonly1 if [ $is_admin -eq 0 ]; then echo Admin user fiThe-eqoperator compares numeric values. If you’re checking a variable that acts as a boolean, you’re technically comparing numbers, not true/false values. This is why many Bash scripts useif command; thensyntax—it directly checks the command’s exit code, which is more elegant than storing the result in a variable.Type CheckingSince Bash doesn’t enforce types, you sometimes need to verify what kind of data you’re working with. This is especially important when accepting input from users or other scripts.# Check if variable is empty if [ -z $var ]; then echo Variable is empty fi # Check if variable is not empty if [ -n $var ]; then echo Variable has value fi # Check if variable is numeric if [ $var -eq $var ] 2/dev/null; then echo Variable is numeric fiThe-zflag checks if a string is zero-length (empty). The-nflag checks if it has content. For numeric checking, the trick[ $var -eq $var ]works because arithmetic comparison will fail if the variable isn’t a number. The2/dev/nullredirects error messages so they don’t clutter your output.When to Use Each TypeStrings:Default for everything; use when content is text or mixedNumbers:Use in arithmetic operations; store age, counts, IDsBooleans:Use for flags that are either on/off; explicitly store as 0 or 1 for claritySpecial VariablesBash automatically sets certain variables that contain useful information about your script’s execution environment. These aren’t variables you create—Bash maintains them for you. Learning these special variables is essential because they’re how your script receives information from its caller and the system.Script ArgumentsWhen you run a script with arguments, Bash automatically breaks them apart and stores them in special variables. This is how your script knows what it’s supposed to do.$0 # Script name $1-$9 # First through ninth argument $ # All arguments (as separate strings) $* # All arguments (as one string) $# # Number of arguments # Example: ./script.sh arg1 arg2 arg3 # Inside script: # $0 ./script.sh # $1 arg1 # $2 arg2 # $3 arg3 # $# 3 # $ arg1 arg2 arg3$0is useful for error messages—you can display your script’s name without hardcoding it.$1,$2, etc. are the positional parameters. If you have more than 9 arguments (and you might), use${10},${11}with braces to access them. The$and$*difference matters more than you’d think:$preserves word boundaries (better for arguments with spaces), while$*concatenates into one string. Use$when passing arguments to other commands.Exit Status$? # Exit code of last command (0 success, 1-255 error) ls /nonexistent 2/dev/null if [ $? -ne 0 ]; then echo ls command failed fiProcess IDs$$ # Current process ID $! # Process ID of last background job PPID # Parent process ID echo My PID: $$ background_command echo Background PID: $!Shell InfoYour environment variables tell you about the system and user. These are set by the system when your shell starts, and you can reference them in your scripts for system-aware behavior.$SHELL # Current shell (/bin/bash) $HOME # Home directory $USER # Current user $PWD # Current directory $OLDPWD # Previous directory echo User: $USER echo Home: $HOME echo Current dir: $PWDThese environment variables are incredibly useful for writing portable scripts. Instead of hardcoding/home/john, use$HOME. Instead of assuming you’re running as a specific user, check$USER. This makes your scripts work across different systems and user accounts.When to Use Special VariablesUse special variables when:You need to access script arguments ($1,$2,$)You want to know your script’s name for logging ($0)You need system information like home directory or usernameYou want to check if a previous command succeeded ($?)Don’t use special variables when:You’re creating temporary storage (use regular variables instead)You want to modify values permanently (they’re read-only for most)Parameter ExpansionParameter expansion is the Swiss Army knife of Bash variable manipulation. These special syntaxes let you extract parts of variables, provide fallback values, and transform content without spawning external commands. They’re pure Bash, which means they’re fast and portable.LengthSometimes you need to know how long a variable’s content is. The${#variable}syntax gives you the string length instantly. This is useful for validation (is the password long enough?) or formatting.textBash echo ${#text} # Output: 4 array(a b c) echo ${#array[]} # Output: 3 (array length)Thesyntax means “all elements”—that’s how you get an array’s length. Without it, you’d just get the length of the first element.Substring ExtractionExtracting part of a string is essential for parsing filenames, URLs, or formatted data. The syntax${text:start:length}extractslengthcharacters starting from positionstart.textHello, World! echo ${text:0:5} # Output: Hello (5 chars from position 0) echo ${text:7} # Output: World! (from position 7 to end) echo ${text: -6} # Output: World! (last 6 chars)Notice the space before the minus sign in${text: -6}—without it, Bash might misinterpret it. Positions start at 0, so${text:0:5}gets the first 5 characters. Negative indices count from the end:-6means “6 characters from the end.”String ReplacementParameter expansion allows simple text replacement without external tools. This is faster and cleaner than piping tosedfor straightforward substitutions.textcat cat cat # Replace first occurrence echo ${text/cat/dog} # Output: dog cat cat # Replace all occurrences echo ${text//cat/dog} # Output: dog dog dog # Remove all occurrences echo ${text//cat} # Output: (empty, with spaces)Single slash replaces the first match; double slash replaces all occurrences. This pattern is perfect for simple literal text replacement on strings you’ve already loaded into variables. For regex patterns or file-in-place editing, you’d usesedinstead.Default ValuesDefault values handle missing data gracefully. If a variable isn’t set or is empty, you can provide a fallback. This pattern prevents “undefined variable” errors and makes scripts more robust.# Use default if unset name${username:-guest} # Use default and set variable if unset name${username:guest} username$name # Use alternate if set greeting${name:Hello, $name} # Display error if unset config_file${1:?Config file required}The:-operator gives you a default;:sets the variable to the default if it wasn’t already set;:uses a value only if the variable is already set;:?throws an error message if the variable is unset. These patterns make your scripts fail fast with clear error messages when they’re missing required data.Case Conversion (Bash 4)Bash 4 introduced simple case conversion without external commands. The^^syntax converts to uppercase,,,to lowercase, and^capitalizes the first character.textBash Programming # Uppercase echo ${text^^} # Output: BASH PROGRAMMING # Lowercase echo ${text,,} # Output: bash programming # Capitalize first character echo ${text^} # Output: Bash programmingThis is much faster than piping totrorsedfor simple case changes. However, it only works in Bash 4—check your version if these don’t work.When to Use Parameter ExpansionUse parameter expansion when:You need string length, extraction, or simple replacementYou want fast, built-in operations (no external commands)You’re working with variables you’ve already storedYou need default values for missing variablesUse external tools (sed, tr) when:You need regex patterns or complex transformationsYou’re editing files directlyYou’re working with streams or pipesVariable ScopeLocal Variables#!/bin/bash global_varIm global function my_function() { local local_varIm local global_varChanged globally echo Inside: $local_var echo Global: $global_var } my_function echo Outside: $local_var # Empty (local not accessible) echo Global: $global_var # Output: Changed globallyGlobal Variables#!/bin/bash MY_VARAvailable everywhere function print_var() { echo In function: $MY_VAR } print_var echo In main: $MY_VAREnvironment VariablesVariables exported to child processes:# Define and export export MY_ENV_VARvalue # Or define then export MY_VARvalue export MY_VAR # Access in subshell or other programs bash -c echo $MY_ENV_VARVariable ValidationCheck if Variable Exists# Check if set if [ -z ${varx} ]; then echo Variable is unset fi # Check if set and not empty if [ -n $var ]; then echo Variable has value fiValidate Numericvalidate_number() { if [ $1 -eq $1 ] 2/dev/null; then echo Valid number return 0 else echo Not a number return 1 fi } validate_number 42 # Valid validate_number abc # InvalidValidate Pathif [ -f $file ]; then echo File exists fi if [ -d $dir ]; then echo Directory exists fi if [ -e $path ]; then echo Path exists (file or directory) fiArrays and Associative ArraysIndexed Arrays# Define array fruits(apple banana orange) # Access elements echo ${fruits[0]} # Output: apple echo ${fruits[1]} # Output: banana echo ${fruits[]} # Output: apple banana orange # Array length echo ${#fruits[]} # Output: 3 # Loop through array for fruit in ${fruits[]}; do echo $fruit doneAssociative Arrays (Bash 4)# Declare associative array declare -A person # Set values person[name]John person[age]30 person[city]New York # Access values echo ${person[name]} # Output: John # All keys echo ${!person[]} # Output: name age city # All values echo ${person[]} # Output: John 30 New YorkBest Practices1. Always Quote Variables# Good echo Hello, $name [ -f $file ] cat $file # Bad (breaks with spaces) echo Hello, $name [ -f $file ] cat $file2. Use Meaningful Names# Good user_count10 backup_directory/home/backups # Poor uc10 bd/home/backups3. Use Local Variables in Functionsgood_function() { local temp_varlocal global_varaccessible outside } bad_function() { temp_varaffects global scope }4. Validate Inputprocess_file() { local file$1 if [ -z $file ]; then echo ERROR: File not provided 2 return 1 fi if [ ! -f $file ]; then echo ERROR: File not found: $file 2 return 1 fi # Process file... }5. Use Readonly for Constantsreadonly CONFIG_DIR/etc/myapp readonly MAX_RETRIES3 readonly VERSION1.0.0 # Prevents accidental modification CONFIG_DIR/tmp # Error: CONFIG_DIR: readonly variableFrequently Asked QuestionsQ: What’s the difference between$varand${var}?A:They’re equivalent;${var}is explicit syntax, useful when the variable name is ambiguous. Example:echo ${var}namevsecho $varname(different meanings).Q: Should I use$or$*?A:Use$(with quotes:$). It preserves arguments with spaces.$*concatenates them together.Q: How do I make a variable readonly?A:Usereadonly VARvalueordeclare -r VARvalue. Prevents modification.Q: What’s the difference between local and global variables?A:Local variables (declared withlocal) are accessible only within a function. Global variables are accessible everywhere.Q: Can I have variables with special characters?A:No, variable names can only contain letters, numbers, and underscores. Use associative arrays for flexible key names.Next StepsExplore related topics:Bash Complete Guide- Overview of all Bash featuresBash Arrays- Deep dive into indexed and associative arraysBash Control Structures- Use variables in conditionalsBash Functions- Variables within function scope