Variables, Environment Variables, and Command Substitution

1. Declaring and Using Variables

A variable is simply a named piece of storage that holds information you can use later in your script. Think of it as a labeled box where you can put a piece of data.

Let's watch a video that provides an excellent introduction to variables in Bash, covering how to create them, reference them, and why they are so useful.

Key Syntax Rules

As you saw in the video, the syntax is specific and important. Let's summarize the key rules:

• Assignment: To assign a value, use VARIABLE_NAME="value".

  • There must be no spaces on either side of the equals sign. MYVAR = "hello" will cause an error.
  • Variable names are case-sensitive (myvar is different from MYVAR).
  • By convention, user-defined variable names are often lowercase or snake_case to distinguish them from system environment variables.

• Reference: To get the value of a variable, use the dollar sign: $VARIABLE_NAME.

• Quoting:
  • Double quotes ("): Allow variable substitution. echo "Hello, $USER" will print "Hello, [your_username]". This is generally what you want.
  • Single quotes ('): Treat all characters literally. echo 'Hello, $USER' will print the literal string "Hello, $USER".

It's a best practice to always enclose your variable references in double quotes (e.g., echo "$myvar"). This prevents unexpected behavior if your variable's value contains spaces or special characters.

2. Command Substitution: Capturing Command Output

In our very first script, we used $(date) to print the current date. This is called command substitution. It allows you to run a command and "capture" its output, which you can then use as part of another command or assign to a variable.

Let's continue with the same video to see this in action.

There are two syntaxes for command substitution:

1. $(command): The modern, preferred syntax. It's easy to read and can be nested (e.g., $(echo "Today is $(date)")).
2. `command` (backticks): The older syntax. It is less readable and cannot be easily nested. You should recognize it, but prefer using the $(...) form in your own scripts.

Let's try it in your terminal. Create a variable that holds the path to your current directory:

CURRENT_DIR=$(pwd)
echo "My current directory is: $CURRENT_DIR"

This is incredibly useful for creating dynamic filenames, logging information, or feeding the result of one tool into another.

3. Environment Variables: Accessing System Information

Your shell environment already contains a set of pre-defined variables called environment variables. These variables hold useful system-wide information, such as your username, your home directory, and the search path for commands.

By convention, environment variables are named in all uppercase.

Let's watch the final segment of the video to learn about them.

Here are some of the most common environment variables you'll use:

• $USER: Your current logged-in username.
• $HOME: The absolute path to your home directory (e.g., /home/your_username).
• $HOSTNAME: The hostname of your machine.
• $PATH: A colon-separated list of directories where the shell looks for executable commands.
• $SHELL: The path to your default shell program (e.g., /bin/bash).

You can see all the environment variables in your current session by running the env command. Since the list can be long, it's helpful to pipe it into less:

env | less

(Press q to exit less.)

For a handy text reference of these concepts, including a list of other special system variables, the following page is a great resource.

Do-It-Yourself: Project Setup Script

Time to apply what you've learned! Your task is to create a script that automates setting up a basic directory structure for a new web project. This is a practical task directly related to your full-stack development goals.

Your script, project_setup.sh, must:

1. Start with the correct shebang line (#!/usr/bin/env bash).
2. Define a variable, for example PROJECT_DIR, and assign it a name for your project (e.g., "my_django_project").
3. Use echo to print a message indicating which project it is setting up, using the variable.
4. Create a main project directory using the name stored in your variable.
5. Inside that new directory, create three subdirectories: static, templates, and src.
6. Print status messages using echo as it creates the directories.
7. As a final confirmation, print a success message that includes the username (from an environment variable) and the current date/time (from command substitution) when the setup was completed.
8. Make the script executable and run it from your terminal.

This exercise combines all three concepts: a user-defined variable, command substitution, and an environment variable.

#!/usr/bin/env bash




# 1. Define the project directory name
PROJECT_DIR="my_django_project"




# 2. Print what's happening
echo "--- Setting up project: $PROJECT_DIR ---"
echo ""




# 3. Create the directories
#    Remember to use quotes around variables in commands!
mkdir "$PROJECT_DIR"
echo "Created main directory: $PROJECT_DIR"

mkdir "$PROJECT_DIR/static"
mkdir "$PROJECT_DIR/templates"
mkdir "$PROJECT_DIR/src"
echo "Created subdirectories: static, templates, src"
echo ""




# 4. Print a final confirmation message
echo "Setup complete!"
echo "Run by user: $USER on $(date)"

# First, create and open the file with nano
nano project_setup.sh




# Add the script content (from the hint or your own version), then save and exit nano
# (Ctrl+X, then Y, then Enter)




# Make the script executable
chmod +x project_setup.sh




# Run the script
./project_setup.sh




# Verify the result
ls -l my_django_project

Conclusion

Excellent work! You've just taken a massive step forward in your scripting abilities. By using variables, your scripts are no longer static and rigid but can adapt to different inputs and situations.

Key Takeaways:

• User-defined variables store data for reuse (VAR="value", accessed with $VAR).
• Quotes matter: Double quotes " expand variables, while single quotes ' do not. Always quoting your variables ("$VAR") is a safe habit.
• Command substitution captures the output of commands for use in your script (OUTPUT=$(command)).
• Environment variables ($USER, $HOME, etc.) provide useful information about the system and are conventionally uppercase.

In our next lesson, we will make our scripts even more intelligent. Now that we can store and manipulate data, the next logical step is to make decisions. You'll learn how to use if/elif/else statements to add conditional logic, allowing your script to perform different actions based on the data it has.