LPIC-1 105.1 — Shell Variables and Environment (Part 2)

Exam weight: 4 — LPIC-1 v5, Exam 102 | Part 2 of 105.1

Shell Types — Quick Reference

Bash reads different initialization files depending on two attributes: interactive vs non-interactive, and login vs non-login.

Check interactivity via $- — if the output contains i, the shell is interactive:

$ echo $-
himBHs

Check login status:

$ echo $0          # -bash means login shell
$ shopt login_shell  # on = login, off = non-login

Initialization Files

Global Files (All Users)

/etc/profile — read by any login shell. Usually sources scripts from /etc/profile.d/*.sh.

/etc/bash.bashrc — Debian/Ubuntu. Read by interactive shells.

/etc/bashrc — RHEL/CentOS equivalent of /etc/bash.bashrc.

User Files

~/.bash_profile — personal login file, highest priority.

~/.bash_login — read only if ~/.bash_profile is absent.

~/.profile — fallback, compatible with other POSIX shells. Read if neither of the above exists.

~/.bashrc — for interactive non-login shells. Often sourced from ~/.bash_profile:

if [ -f ~/.bashrc ]; then
    . ~/.bashrc
fi

~/.bash_logout — executed when a login shell exits.

Reading Order

source and the Dot Command

Apply changes to ~/.bashrc without restarting the shell:

source ~/.bashrc
. ~/.bashrc          # equivalent

Both execute the file’s commands in the current shell. Running bash file spawns a child — variables set there disappear on exit.

To fully reload the current shell process: exec bash or exec $SHELL.

Shell Variables

Assignment and Reference

$ distro=zorinos     # assignment — no spaces around =
$ echo $distro       # reference — dollar sign required
zorinos

Spaces around = break the command:

$ distro =zorinos
-bash: distro: command not found
$ distro= zorinos
-bash: zorinos: command not found

Variable Naming Rules

• May contain letters (a-z, A-Z), digits (0-9), underscore (_)
• Must start with a letter or underscore — not a digit
• No spaces in names (use _ instead)

$ distro_1=zorinos    # OK
$ _distro=zorinos     # OK
$ 1distro=zorinos     # error

Value Rules

Values may contain letters, digits, and most special characters (?, !, *, ., /).

Values with spaces must be quoted:

$ distro="zorin 12.4"

Values with redirect or pipe characters need quoting, otherwise the shell interprets them literally:

$ distro=>zorin      # creates an empty file named 'zorin'
$ distro=">zorin"    # now it is a variable value

Backslash must be escaped with another backslash:

$ win_path=C:\\path\\to\\dir\\
$ echo $win_path
C:\path\to\dir\

Quotes in Assignment Context

Single quotes — literal, no substitution:

$ lizard=uromastyx
$ animal='My $lizard'
$ echo $animal
My $lizard

Double quotes — allow variable substitution:

$ animal="My $lizard"
$ echo $animal
My uromastyx

When referencing a variable whose value contains spaces or wildcards, always use double quotes with echo:

$ lizard="    genus    |    uromastyx"
$ echo $lizard          # shell does field splitting
genus | uromastyx
$ echo "$lizard"        # spaces preserved
    genus    |    uromastyx

Local Shell Variables

By convention, local variable names are lowercase.

readonly — Immutable Variable

$ readonly reptile=tortoise

Or in two steps:

$ reptile=tortoise
$ readonly reptile

Attempt to change it fails:

$ reptile=lizard
-bash: reptile: readonly variable

List all readonly variables:

$ readonly
$ readonly -p

set — List All Variables

set without arguments prints all shell variables and functions (including unexported ones). Pipe through less or grep:

$ set | less
$ set | grep reptile
reptile=tortoise

Child Shells and Visibility

A local variable is not passed to child shells:

$ reptile=tortoise
$ bash
$ echo $reptile
                     # empty
$ exit

unset — Remove a Variable

$ unset reptile
$ echo $reptile
                     # empty

No dollar sign before the name. Works on both local and global variables.

Global Environment Variables

Environment variables are visible in the current shell and all spawned processes. By convention, names are UPPERCASE.

$ echo $SHELL
/bin/bash

Passing Values Between Variables

$ my_shell=$SHELL
$ your_shell=$my_shell
$ echo $your_shell
/bin/bash

export — Make a Variable Global

$ export reptile          # export existing local variable
$ export amphibian=frog   # create and export in one step

After export, the variable is visible in child shells:

$ bash
$ echo $amphibian
frog

export -n — Revoke Export

$ export -n reptile       # back to local

env, printenv, declare -x

All three list environment variables.

export without arguments (same as declare -x):

$ export
declare -x HOME="/home/user2"
declare -x PATH="/usr/local/bin:/usr/bin:/bin"
declare -x SHELL="/bin/bash"

env and printenv give a simpler list:

$ env
SHELL=/bin/bash
PATH=/usr/local/bin:/usr/bin:/bin
HOME=/home/user2

printenv can fetch one variable without a dollar sign:

$ printenv PWD
/home/user2

Distinction for the exam: set shows everything including local variables and functions. env/printenv show only exported variables that child processes inherit.

Running a Program in a Modified Environment

env -i — Empty Environment

Starts a program with almost no inherited variables:

$ env -i bash
$ echo $USER
                     # empty

Useful for testing that a script does not rely on accidental user variables.

env VAR=value command

Run one command with a temporarily changed variable — the shell’s own environment is unchanged:

$ env LANG=es_ES.UTF-8 date

BASH_ENV for Scripts

A non-interactive script reads no startup files, but checks BASH_ENV. If it points to a file, Bash sources that file before executing the script:

# ~/.startup_script
CROCODILIAN=caiman

$ BASH_ENV=/home/user2/.startup_script ./test_env.sh
caiman

Common Environment Variables

DISPLAY

X server address — [hostname]:display[:screen]. Empty hostname means localhost:

$ printenv DISPLAY
:0

reptilium:0:2 — X server on host reptilium, display 0, screen 2.

History Variables

HOME and Tilde

HOME holds the absolute path to the user’s home directory. Tilde ~ is a synonym:

$ echo ~; echo $HOME
/home/carol
/home/carol

Standard check in ~/.profile:

if [ -f "$HOME/.bashrc" ]; then
    . "$HOME/.bashrc"
fi

Test equality:

$ if [ ~ == "$HOME" ]; then echo "true"; fi
true

HOSTNAME and HOSTTYPE

$ echo $HOSTNAME      # TCP/IP hostname
debian
$ echo $HOSTTYPE      # CPU architecture
x86_64

LANG

System locale:

$ echo $LANG
en_UK.UTF-8

LD_LIBRARY_PATH

Colon-separated list of shared library directories:

$ echo $LD_LIBRARY_PATH
/usr/local/lib

MAIL and MAILCHECK

$ echo $MAIL          # path to mailbox
/var/mail/carol
$ echo $MAILCHECK     # check interval in seconds
60

PATH

Colon-separated list of directories searched for executables. Typical /etc/profile block:

if [ "`id -u`" -eq 0 ]; then
    PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
else
    PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
fi
export PATH

id -u returns the UID — 0 for root.

Add a directory:

$ PATH=/new/dir:$PATH     # first (searched first)
$ PATH=$PATH:/new/dir     # last (searched last)

Prompt Variables PS1–PS4

PS1 — primary prompt (# for root, $ for regular users).

PS2 — continuation prompt for multi-line commands (default > ).

PS3 — prompt for select construct.

PS4 — debug tracing prefix for set -x (default + ).

SHELL and USER

$ echo $SHELL        # absolute path to current shell
/bin/bash
$ echo $USER         # current username
carol

Aliases and Functions

Aliases

alias ll='ls -lah'
alias ..='cd ..'
alias grep='grep --color=auto'

alias             # list all
unalias ll        # remove one
unalias -a        # remove all

Bash Functions

Functions accept positional arguments via $1, $2, $@. Functions override aliases of the same name.

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

greet World
# Hello, World!

List all defined functions:

$ declare -f

Saving Aliases and Functions

Put them in ~/.bashrc for persistence. Many distros use a separate ~/.bash_aliases sourced from ~/.bashrc:

if [ -f ~/.bash_aliases ]; then
    . ~/.bash_aliases
fi

Skeleton Directory /etc/skel

/etc/skel is the template home directory. Its contents are copied into every new user’s home when the account is created with useradd -m or adduser.

$ ls -la /etc/skel
.bash_logout  .bashrc  .profile

Add a line to any file here — all future users get it automatically. Existing users are unaffected.

Change the template path: edit SKEL= in /etc/default/useradd, or use useradd -k /alternate/skel.

Quick Reference

# Check shell type
echo $0              # -bash = login
shopt login_shell    # on = login, off = non-login
echo $-              # 'i' present = interactive

# Apply config without restart
source ~/.bashrc
. ~/.bashrc
exec bash            # replace current shell process

# Variables
var=value            # local variable
export var=value     # create and export
export var           # export existing
export -n var        # revoke export
readonly var=value   # immutable
readonly             # list readonly variables
unset var            # remove variable
echo $var            # show value
printenv var         # show value (no $ needed)

# List variables
set                  # all variables and functions
env                  # environment only
printenv             # same as env
export               # environment with declare -x
declare -x           # synonym for export

# Modified environment
env -i bash                      # empty environment
env LANG=es_ES.UTF-8 date        # one variable for one command
BASH_ENV=~/.startup ./script.sh  # startup file for script

# Aliases and functions
alias ll='ls -lah'
unalias ll
alias
declare -f

# PATH
PATH=/new/dir:$PATH   # prepend (higher priority)
PATH=$PATH:/new/dir   # append

# Skel
ls -la /etc/skel
useradd -m newuser    # home created from /etc/skel

Exam Questions

1. What is the difference between ~/.bash_profile and ~/.bashrc? → bash_profile is read once by a login shell at login. bashrc is read by every interactive non-login shell.
2. Both ~/.bash_profile and ~/.profile exist — which is read? → ~/.bash_profile; ~/.profile is ignored.
3. Where does the system-wide PATH live? → /etc/profile (plus fragments in /etc/profile.d/).
4. Difference between source file and bash file? → source executes in the current shell; bash file spawns a child shell and changes are lost on exit.
5. Which command turns a local variable into a global one? → export VAR.
6. What does export -n VAR do? → Revokes export; the variable becomes local again.
7. Single vs double quotes in assignment? → Double quotes allow $variable substitution; single quotes take everything literally.
8. Which variable specifies a startup file for a non-interactive script? → BASH_ENV.
9. Which command shows only environment variables? → env, printenv, or export -p.
10. Which command shows all variables including local ones and functions? → set.
11. How to make new users receive a particular alias by default? → Add the alias line to the appropriate file in /etc/skel.
12. How to create an immutable variable? → readonly VAR=value.
13. What is ~/.bash_logout and when does it run? → A script executed when a login shell exits.
14. Difference between unset VAR and VAR=? → unset removes the variable entirely; VAR= leaves it with an empty value.
15. Which characters are forbidden at the start of a variable name? → Digits. Names must begin with a letter or underscore.
16. What is declare -x? → A synonym for export; lists or marks variables as exported.
17. What does env -i do? → Starts a command with an almost empty environment, stripping inherited variables.
18. What do HISTCONTROL=ignoreboth and HISTCONTROL=ignoredups do? → ignoreboth: skip commands starting with space AND consecutive duplicates. ignoredups: skip consecutive duplicates only.
19. What does DISPLAY=reptilium:0:2 mean? → X server on host reptilium, display number 0, screen 2.

Exercises

Exercise 1 — Shell type by launch method

For each launch method, state whether the shell is a login shell and whether it is interactive.

Exercise 2 — su and sudo for four shell types

Write the command to switch to user bob’s shell for each of the four types.

Exercise 3 — Startup files for each shell type

Which initialization files does each shell type read? Assume the user has ~/.bash_profile, ~/.bashrc, and ~/.bash_logout, and ~/.bash_profile contains the standard block that sources ~/.bashrc.

Exercise 4 — Local or global variable?

For each command sequence, decide whether the result is a local or global variable.

Exercise 5 — Decode variable values

Explain what each output means.

Exercise 6 — Fix invalid assignments

Each assignment is broken. Write the correct command and the echo call to produce the expected output.

Exercise 7 — Name the command for each task

Exercise 8 — Local variable mammal

Create a local variable mammal with value gnu.

mammal=gnu

Exercise 9 — Variable substitution in a value

Using substitution, create a local variable var_sub so that echo $var_sub outputs The value of mammal is gnu.

var_sub="The value of mammal is $mammal"

Exercise 10 — Export mammal

Make mammal a global environment variable.

export mammal

Exercise 11 — Search with set and grep

Find mammal using set and grep.

set | grep mammal

Exercise 12 — Search with env and grep

Find mammal using env and grep.

env | grep mammal

Exercise 13 — BIRD with two commands

Create an environment variable BIRD with value penguin. Use two commands.

BIRD=penguin; export BIRD

Exercise 14 — NEW_BIRD with one command

Create an environment variable NEW_BIRD with value yellow-eyed penguin. Use one command.

export NEW_BIRD="yellow-eyed penguin"

Exercise 15 — Create ~/bin

You are user2. Create a bin directory in your home directory.

mkdir ~/bin

Exercise 16 — Prepend ~/bin to PATH

Add ~/bin to PATH so Bash searches it first.

PATH="$HOME/bin:$PATH"

Exercise 17 — Persist PATH via ~/.profile

Write the if block to add ~/bin to PATH persistently via ~/.profile.

if [ -d "$HOME/bin" ] ; then
    PATH="$HOME/bin:$PATH"
fi

Exercise 18 — Hello world function and where to put it

Write a hello function that prints Hello, world!. Show how to load it with source. In which file should it go so user2 has it in every X Window terminal? In which file so root has it in any interactive shell?

hello() {
    echo "Hello, world!"
}

$ source ~/myfuncs.sh
$ hello
Hello, world!

Exercise 19 — Is a simple echo script interactive?

Script simple.sh:

#!/bin/bash
echo "Hi"

Is it interactive? What makes a script interactive?

#!/bin/bash
read -p "What is your name? " name
echo "Hello, $name!"

Exercise 20 — Apply ~/.bashrc changes without restarting

You edited ~/.bashrc. Apply the changes in the current shell without restarting it. Show two ways.

source ~/.bashrc

. ~/.bashrc

Exercise 21 — Switching to tty when GUI freezes

The GUI is frozen. You press Ctrl+Alt+F2 and log in on tty2. Which initialization files does Bash read?

Exercise 22 — Automating ~/.bash_login via /etc/skel

You want every new user to receive ~/.bash_login with a custom set of commands. How do you automate this?

$ sudo nano /etc/skel/.bash_login

Exercise 23 — let and arithmetic

Create a local variable my_val with the value 10 as the result of 5 + 5. Then create your_val with the value 5 as the result of dividing my_val by 2.

let "my_val = 5 + 5"
let "your_val = $my_val / 2"

Exercise 24 — Command substitution syntax

Which is the correct modern equivalent of:

latest_music=`ls -l1t ~/Music | head -n 6`

A. latest_music=$(ls -l1t ~/Music | head -n 6)

B. latest_music="(ls -l1t ~/Music | head -n 6)"

C. latest_music=((ls -l1t ~/Music | head -n 6))

latest_music=$(ls -l1t ~/Music | head -n 6)

LPIC-1 Study Notes | Topic 105: Shells and Shell Scripting