UNIVERSITY OF LUCKNOW
BACHELOR OF COMPUTER APPLICATION
YEAR: THIRD,
SEMESTER –V
BCA-504
Unix and Shell Programming
Unit 4:The Shell
Overview of the Shell: Interpretive Cycle, Shell Offerings, Pattern Matching,
Escaping and Quoting, Redirection, Pipes, Tee, Command Substitution,
Shell Variables, and Essential Shell Programming
The shell is an integral part of Unix/Linux systems, providing both an interactive interface for
users and a programming environment for automating tasks. It is a command-line interpreter
that processes user commands, executes programs, and provides powerful scripting
capabilities. This guide provides a detailed explanation of the core shell concepts, including the
interpretive cycle, pattern matching, escaping and quoting, redirection, pipes, tee, command
substitution, shell variables, and essential shell programming.
1. The Shell’s Interpretive Cycle
The shell follows a cycle for interpreting and executing commands, which can be broken down
into the following steps:
1. Command Input: The user enters a command at the shell prompt.
2. Tokenization: The shell splits the input into tokens, breaking down the command into its
constituent components, such as the command name, arguments, operators, and
special symbols.
3. Expansion: The shell performs various expansions:
○ Variable expansion: Substituting the value of environment variables.
○ Command substitution: Replacing a command with its output.
○ Wildcard expansion: Expanding wildcards like *, ?, and [] to match files.
○ Tilde expansion: Expanding ~ to the user’s home directory.
4. Parsing: The shell checks the syntax of the command to ensure that it is valid and
prepares it for execution.
5. Redirection/Piping: If redirection or pipes are present, the shell sets up the appropriate
file descriptors and connects commands through pipes.
6. Execution: The shell executes the command, either by invoking a program or running a
script.
7. Output/Return: The command produces output (if any), which is printed to the terminal
or redirected to a file. The shell then returns to waiting for input.
2. Shell Offerings
The shell provides a variety of features that allow for efficient interaction with the system. Some
key offerings include:
a. Job Control
● Allows users to manage background and foreground processes.
○ Background (bg): Resume a suspended job in the background.
○ Foreground (fg): Bring a job to the foreground.
○ Jobs (jobs): List the current jobs and their statuses.
b. Alias
● Alias allows you to define custom shortcuts for frequently used commands.
○ Example: alias ll='ls -l' creates an alias ll for ls -l.
c. History
● The shell keeps a history of commands, enabling users to reuse commands with the
history command.
○ Pressing the up arrow allows users to scroll through previous commands.
d. Globbing/Pattern Matching
● The shell supports file matching using wildcards, enabling pattern-based file selection.
e. Shell Functions
You can define functions to group commands for reuse:
bash
my_function() {
echo "Hello, $1"
}
f. Control Structures
● The shell provides structures for decision-making and looping:
○ if, else for conditional execution.
○ for, while, until for looping.
○ case for pattern matching.
3. Pattern Matching in the Shell
Pattern matching (also called globbing) allows you to match files or strings based on patterns.
This enables more flexible file management and searching.
Common Wildcards:
● * (Asterisk): Matches any sequence of characters (including no characters).
○ Example: *.txt matches all .txt files in a directory.
● ? (Question Mark): Matches exactly one character.
○ Example: file?.txt matches file1.txt, fileA.txt, etc.
● [] (Square Brackets): Matches any one character inside the brackets.
○ Example: file[1-3].txt matches file1.txt, file2.txt, and
file3.txt.
● {} (Curly Braces): Used for creating lists of strings.
○ Example: file{1,2,3}.txt matches file1.txt, file2.txt, and
file3.txt.
4. Escaping and Quoting
Escaping and quoting are crucial for controlling how special characters are interpreted by the
shell.
Types of Quoting:
● Single Quotes ('): Prevent the shell from interpreting special characters inside the
quotes. Everything inside single quotes is treated literally.
○ Example: echo '$HOME' prints $HOME, not the value of the variable.
● Double Quotes ("): Allows for variable expansion and command substitution, but
prevents interpretation of certain special characters like spaces.
○ Example: echo "$HOME" prints the value of the HOME environment variable.
● Backslashes (\): Escape individual characters.
○ Example: echo "I\'m a student" prints I'm a student.
5. Redirection in the Shell
Redirection allows you to control where input and output of commands go (either to files or other
streams).
Common Redirection Operators:
● Input Redirection (<): Redirects input to a command from a file.
○ Example: sort < file.txt sorts the contents of file.txt.
● Output Redirection (>): Redirects output to a file (overwrites the file).
○ Example: echo "Hello" > output.txt writes "Hello" to output.txt.
● Append Output (>>): Appends output to a file.
○ Example: echo "Goodbye" >> output.txt appends "Goodbye" to
output.txt.
● Error Redirection (2>): Redirects error output to a file.
○ Example: command 2> error.txt redirects error messages to error.txt.
● Redirecting Both Output and Error (&>): Redirects both standard output and error
output to the same file.
○ Example: command &> output.txt writes both output and errors to
output.txt.
6. Pipes in the Shell
Pipes (|) are used to connect the output of one command to the input of another command.
This allows for creating powerful command pipelines.
Example:
bash
cat file.txt | grep "pattern" # Filters the contents of file.txt to
show only lines containing 'pattern'
Multiple pipes can be chained together:
bash
cat file.txt | sort | uniq # Sorts file.txt and removes duplicate
lines
7. Tee Command
The tee command is used to read from the standard input and write to both standard output
and one or more files. This is useful when you want to view the output of a command and save
it simultaneously.
Syntax:
bash
command | tee file.txt
Example:
bash
echo "Hello, World" | tee output.txt # Writes "Hello, World" to both
the terminal and output.txt
Appending to a File:
You can append to a file using the -a option:
bash
echo "More text" | tee -a output.txt # Appends "More text" to
output.txt
8. Command Substitution
Command substitution allows the output of a command to be used as an argument in another
command.
Syntax:
bash
$(command) # Preferred method (modern)
or
bash
`command` # Older syntax (deprecated but still widely used)
Example:
bash
echo "The current date is $(date)" # Uses the output of the date
command
This is useful for dynamically passing values in commands and scripts.
9. Shell Variables
Variables are used to store data (such as strings, numbers, or command outputs) in the shell.
They can be used to simplify commands and improve script readability.
Setting Variables:
bash
variable_name=value # No spaces around the equal sign
Example:
bash
name="Alice"
echo $name # Prints 'Alice'
Special Variables:
● $HOME: Represents the user’s home directory.
● $USER: Represents the current user’s username.
● $PWD: Represents the current working directory.
● $?: Represents the exit status of the last command.
● $0: Represents the script’s name.
● $$: Represents the process ID of the current shell.
Exporting Variables:
Variables can be exported to become environment variables, which are accessible by
subprocesses.
bash
export PATH=$PATH:/new/directory # Adds a new directory to the PATH
10. Essential Shell Programming
Shell scripting allows you to automate repetitive tasks by writing sequences of commands in a
file.
Key Concepts:
● Control Structures:
If-else Statements:
bash
if [ condition ]; then
command1
else
command2
fi
○
○ Loops:
For loop:
bash
for i in {1..5}; do
echo $i
done
■
While loop:
bash
while [ condition ]; do
command
done
Functions: Functions allow you to group a set of commands and reuse them.
bash
greet() {
echo "Hello, $1"
}
greet "Alice" # Outputs: Hello, Alice
●
● Scripts: Shell scripts are plain text files containing shell commands. They can be
executed by making them executable (chmod +x script.sh) and running them
(./script.sh).
