Variables

Caution

This section is under development. Thank you for your patience.

This chapter covers the essential aspects of variables in Unix/Linux environments. I’ll be using VS Code because I can quickly switch between shells in the Terminal window.

Unix/Linux Variables

Variables in Unix/Linux are used to store data that can be accessed and manipulated by the operating system and applications. They play a crucial role in scripting, programming, and managing system configurations. By storing values in variables, users and scripts can dynamically reference and change these values without hard-coding them, making scripts more flexible and maintainable.

In Unix/Linux, variables can hold different types of data, such as strings, integers, or file paths. They can be used for various purposes, including:

• Customizing the user environment (e.g., setting the default editor).
  
• Storing temporary data within scripts.
  
• Passing data between programs and scripts.
  
• Configuring system and application settings.

The significance of variables lies in their ability to simplify complex tasks, enhance automation, and improve the overall efficiency of the Unix/Linux environment.

Environment vs. Shell

In Unix/Linux, variables are broadly categorized into environment variables and shell variables.

Environment variables are global variables that are available system-wide and can influence the behavior of the shell and other programs. They are inherited by all child processes.

Environment variables are often used to configure the shell environment, set application settings, and pass data to child processes.

Common environment variables

Variable	Description
PATH	Specifies the directories to search for executable files.
HOME	Represents the current user’s home directory.
USER	Contains the name of the current user.
LANG	Defines the language and locale settings for applications.

Shell variables are local to the shell session in which they are defined. They are not inherited by child processes unless explicitly exported.

Shell variables are typically used for temporary data storage within scripts, customizing the shell prompt, and managing session-specific settings.

Common shell variables

Variable	Description
PS1	Defines the primary prompt string.
PS2	Defines the secondary prompt string.

Setting Variables

In the following sections we’ll cover setting shell and environment variables in your shell. These commands will work in Bash or Zsh.

Setting Shell Variables

Shell variables in Unix/Linux are defined within the context of the current shell session. To set a shell variable, simply assign a value to a variable name using the following syntax:

VARIABLE_NAME=value

Variable names are case-sensitive and traditionally use uppercase letters. When creating a new variable, there should be no spaces around the = sign. We can check the value of the new variable using echo:

MY_VAR="Hello, World"

echo $MY_VAR
# Hello, World

Zsh on macOS .

Removing Shell Variables

To remove a shell variable, use the unset command followed by the variable name:

unset MY_VAR

After running unset, the variable MY_VAR will no longer exist in the current shell session.

To list all shell variables, use the set command:

set

Setting Environment Variables

Environment variables are set similarly to shell variables but are made available to child processes by using the export command. To set an environment variable, follow these steps:

1. Assign a value to a variable.
2. Export the variable.

MY_ENV_VAR="This is an environment variable"
export MY_ENV_VAR

You can also combine these steps into a single command:

export MY_ENV_VAR="This is an environment variable"

To verify the value of an environment variable, use the echo command:

Zsh on macOS .

echo $MY_ENV_VAR
# This is an environment variable

To list all environment variables, use the printenv or env command:

printenv

or

env

Using Variables

The section below covers how to use environment and shell variables in the terminal and in shell script (.sh) files.

Using Shell Variables

Using shell variables involves referencing them within scripts or commands with a dollar sign ($) prefix and the variable. Below is an example of using a shell variable in an if/then loop:

count=5
if [ $count -gt 3 ]; then 
  echo "Count is greater than 3"; 
fi
# Count is greater than 3

The code above could be stored in a script (if_count.sh), where the shell variables could be used to store and manipulate data dynamically by calling source:

touch if_count.sh
echo "count=5
if [ $count -gt 3 ]; then 
  echo "Count is greater than 3"; 
fi" > if_count.sh

source if_count.sh
# if_count.sh: line 2: [: -gt: unary operator expected

Using Environment Variables

Environment variables can be accessed in the same way as shell variables by prefixing the variable name with a dollar sign ($). Since they are available to child processes, environment variables are particularly useful for configuring application settings and passing data to scripts and programs.

For example, PWD works similar to the pwd command, but the path is stored as a string to use in scripts or programs.

echo $PWD
# /Users/username/projects/books/fm-unix

In a script, we can use environment variables to ensure that certain settings or configurations are applied (like HOME and USER)

Assume the following is stored in my_config.sh

#!/bin/bash
echo "User's home directory: $HOME"
echo "Current user: $USER"
echo "Current language: $LANG"

These variables don’t need to be defined in the script–they can just be stored and called directly:

source my_config.sh
# User's home directory: /Users/username
# Current user: username
# Current language: en_US.UTF-8

Key Differences

Understanding the difference between environment and shell variables is essential for effective Unix/Linux system administration and scripting. It helps users manage and customize their environment efficiently, ensuring that scripts and applications work as intended.

Scope

Environment variables have a global scope and are available to all processes.

Shell variables have a local scope and are limited to the shell session.

Inheritance

Environment variables are inherited by child processes.

Shell variables need to be exported to be available to child processes.

Purpose

Environment variables are generally used for system-wide configuration and application settings.

Shell variables are used for script-specific or session-specific tasks.

Recap

By understanding and utilizing shell and environment variables effectively, you can enhance the functionality and flexibility of your Unix/Linux scripts and system configurations. We’ll touch on this topic again in the shell scripts section.