2.1 Lesson 1

Certificate:

Linux Essentials

Version:

1.6

Topic:

2 Finding Your Way on a Linux System

Objective:

2.1 Command Line Basics

Lesson:

1 of 2

Introduction

Modern Linux distributions have a wide range of graphical user interfaces but an administrator will always need to know how to work with the command line, or shell as it is called. The shell is a program that enables text based communication between the operating system and the user. It is usually a text mode program that reads the user’s input and interprets it as commands to the system.

There are several different shells on Linux, these are just a few:

Bourne-again shell (Bash)
C shell (csh or tcsh, the enhanced csh)
Korn shell (ksh)
Z shell (zsh)

On Linux the most common one is the Bash shell. This is also the one that will be used in examples or exercises here.

When using an interactive shell, the user inputs commands at a so-called prompt. For each Linux distribution, the default prompt may look a little different, but it usually follows this structure:

username@hostname current_directory shell_type

On Ubuntu or Debian GNU/Linux, the prompt for a regular user will likely look like this:

carol@mycomputer:~$

The superuser’s prompt will look like this:

root@mycomputer:~#

On CentOS or Red Hat Linux, the prompt for a regular user will instead look like this:

[dave@mycomputer ~]$

And the superuser’s prompt will look like this:

[root@mycomputer ~]#

Let’s explain each component of the structure:

username: Name of the user that runs the shell
hostname: Name of the host on which the shell runs
current_directory: The directory that the shell is currently in. A ~ means that the shell is in the current user’s home directory.
shell_type: $ indicates the shell is run by a regular user.

# indicates the shell is run by the superuser root.

As we do not need any special privileges, we will use an unprivileged prompt in the following examples. For brevity, we will just use the $ as prompt.

Command Line Structure

Most commands at the command line follow the same basic structure:

command  [option(s)/parameter(s)...]  [argument(s)...]

Take the following command as an example:

$ ls -l /home

Let’s explain the purpose of each component:

Command

Program that the user will run – ls in the above example.

Option(s)/Parameter(s)

A “switch” that modifies the behavior of the command in some way, such as -l in the above example. Options can be accessed in a short and in a long form. For example, -l is identical to --format=long.

Multiple options can be combined as well and for the short form, the letters can usually be typed together. For example, the following commands all do the same:

$ ls -al
$ ls -a -l
$ ls --all --long

Argument(s)

Additional data that is required by the program, like a filename or path, such as /home in the above example.

The only mandatory part of this structure is the command itself. In general, all other elements are optional, but a program may require certain options, parameters or arguments to be specified.

Note	Most commands display a short overview of available commands when they are run with the `-h` parameter. We will learn additional ways to learn more about Linux commands soon.

Command Behavior Types

The shell supports two types of commands:

Internal: These commands are part of the shell itself and are not separate programs. There are around 30 such commands. Their main purpose is executing tasks inside the shell (e.g. cd, set, export).
External: These commands reside in individual files. These files are usually binary programs or scripts. When a command which is not a shell builtin is run, the shell uses the PATH variable to search for an executable file with same name as the command. In addition to programs which are installed with the distribution’s package manager, users can create their own external commands as well.

The command type shows what type a specific command is:

$ type echo
echo is a shell builtin
$ type man
man is /usr/bin/man

Using Globbing to Manipulate Files and Directories

The shell has a lot of features that make working with files easier for the user. One of them is globbing. Globbing uses wildcards, which are characters or groups of characters that facilitate patterns or grouping of filenames. The most used wildcards are:

*: Zero, one or more occurrences of an arbitrary character
?: A single occurrence of an arbitrary character
[a-z]: A single occurrence of a character included in the specified range
[!a-z] or [^a-z]: A single occurrence of a character not included in the specified range

Let’s see some examples of files matched by wildcards:

*: Matches all files and directories in the current directory.

Examples: ssh-b, paranormal
a*: Matches all files and directories whose name starts with a.

Examples: alien, anna
f*.txt: Matches all files and directories whose name starts with f and ending in .txt.

Examples: file.txt, freddy.txt
p??: Matches all files and directories whose name starts with p followed by exactly two characters.

Examples: pie, pi4
f[a-z][0-9]: Matches any file whose name starts with f, followed by one lower case letter, followed one number.

Examples: fa0, fb8
g[!a-z]: Matches any file whose name starts with g, followed by one character that is not a lower case letter.

Examples: gF, g6

Quoting

As a Linux user, you will have to create or manipulate files or variables in various ways. This is easy when working with short filenames and single values, but it becomes more complicated when, for example, spaces, special characters and variables are involved. Shells provide a feature called quoting which encapsulates such data using various kinds of quotes (" ", ' ', ` `). In Bash, there are three types of quotes:

Double quotes
Single quotes

For example, the following commands don’t act in the same way due to quoting:

$ touch $USER
$ touch "$USER"
$ touch '$USER'

Note	Don’t be confused by `$USER` in the above example. It is a variable which, by default, is set to the current username. We will introduce variables later. For now, just remember that `$USER` might be replaced with the current user’s name.

Double Quotes

Double quotes tell the shell to take the text in between the quote marks ("...") as regular characters. All special characters lose their meaning, except the $ (dollar sign), \ (backslash) and ` (backquote). This means that variables, command substitution and arithmetic functions can still be used.

For example, the substitution of the $USER variable is not affected by the double quotes:

$ echo I am $USER
I am tom
$ echo "I am $USER"
I am tom

A space character, on the other hand, looses its meaning as an argument separator:

$ touch new file
$ ls -l
-rw-rw-r-- 1 tom students 0 Oct 8 15:18 file
-rw-rw-r-- 1 tom students 0 Oct 8 15:18 new
$ touch "new file"
$ ls -l
-rw-rw-r-- 1 tom students 0 Oct 8 15:19 new file

As you can see, in the first example, the touch command creates two individual files, the command interprets the two strings as individual arguments. In the second example, the command interprets both strings as one argument, therefore it only creates one file. It is, however, best practice to avoid the space character in filenames. Instead, an underscore (_) or a dot (.) could be used.

Single Quotes

Single quotes don’t have the exceptions of the double quotes. They revoke any special meaning from each character. Let’s take one of the first examples from above:

$ echo I am $USER
I am tom

When applying the single quotes you see a different result:

$ echo 'I am $USER'
I am $USER

The command now displays the exact string without substituting the variable.

Guided Exercises

Split the lines below into the components of command, option(s)/parameter(s) and argument(s):
- Example: cat -n /etc/passwd
  
  Command:
  
  cat
  
  Option:
  
  -n
  
  Argument:
  
  /etc/passwd
- ls -l /etc
  
  Command:
  
  Option:
  
  Argument:
- ls -l -a
  
  Command:
  
  Option:
  
  Argument:
- cd /home/user
  
  Command:
  
  Option:
  
  Argument:
Find what type the following commands are:

Example:

pwd

Shell builtin

mv

External command

cd

cat

exit
Provide at least three examples for each pattern:

Example:

*e

file, line, locale

h*

j???

br[a-z][a-z]d

h[!a-g]*
Find a globbing expression to the following strings:

Example:

UserA, GroupA, FileA

*A

Wind, windy, cindy

file1, file5, file8

Ana, Amy, Ali

tree5, tie8, tiling2
Resolve the following commands that use quotes:

Example:

echo "$HOME is my home directory"

echo /home/user is my home directory

touch "$USER"

touch 'touch'

Explorational Exercises

Give at least three examples for the following pattern:

A[a-Z]?[elmo]?
With one command and using globbing wildcards, create 5 files numbered 1 to 5 with the prefix game (game1, game2, …).
Delete all 5 files that you just created with just one command, using a different globbing wildcard.
What do you think is the practical application for globbing?
Where would you think would quotation marks be mostly useful with globbing?
Is there any other way to make two commands interact with each other? What are those?

Summary

In this lab you learned:

Concepts of the Linux shell
What is the Bash shell
The structure of the command line
Globbing and its wide usefulness
An introduction to quoting

Commands used in the exercises:

bash: The most popular shell on Linux computers.
echo: Output text on the terminal.
ls: List the contents of a directory.
type: Show how a specific command is executed.
touch: Create an empty file or update an existing file’s modification date.
hostname: Show or change a system’s hostname.

Answers to Guided Exercises

Split the lines below into the components of command, option(s)/parameter(s) and argument(s):
- ls -l /etc
  
  Command:
  
  ls
  
  Option:
  
  -l
  
  Argument:
  
  /etc
- ls -l -a
  
  Command:
  
  ls
  
  Option:
  
  -l -a
  
  Argument:
- cd /home/user
  
  Command:
  
  cd
  
  Option:
  
  Argument:
  
  /home/user
Find what type the following commands are:

cd

Shell builtin

cat

External command

exit

Shell builtin
Provide at least three examples for each pattern:

h*

hay, hello, hy

j???

jade, jace, joly

br[a-z][a-z]d

bread, braid, brand

h[!a-g]*

hide, history, humid
Find a globbing expression to the following strings:

Wind, windy, cindy

?ind*

file1, file5, file8

file[1-9]

Ana, Amy, Ali

A??

tree5, tie8, tiling2

t*[0-9]
Resolve the following commands that use quotes:

touch "$USER"

tom

touch 'touch'

Creates a file named touch

Answers to Explorational Exercises

Give at least three examples for the following pattern:

A[a-Z]?[elmo]?

Adele, Adela, Aston, Angel, Adams
With one command and using globbing wildcards, create 5 files numbered 1 to 5 with the prefix game (game1, game2, …).

Ranges can be used to express the numbers from 1 to 5 within one command:
```
$ touch game[1-5]
```
Delete all 5 files that you just created with just one command, using a different globbing wildcard.

Since all files start with game and end in a single character (a number from 1 to 5 in this case), ? can be used as a wildcard for the last character in the filename:
```
$ rm game?
```
What do you think is the practical application for globbing?

Globbing is mainly used to manipulate a group of files that have similar names.
Where would you think would quotation marks be mostly useful with globbing?

They are very useful in scripts or automation methods, because at the time a script is written, the naming convention for the files processed by the script might be unknown. Whenever working with files whose names are automatically collected, it is best practice to use correct quoting to ensure spaces and special characters do not lead to unwanted side effects.
Is there any other way to make two commands interact with each other? What are those?

Yes, one command could, for example, write data to a file which is then processed by another command. Linux can also collect the output of one command and use it as input for another command. This is called piping and we will learn more about it in a future lesson.