Applies to openSUSE Leap 42.2

14 Bash and Bash Scripts


These days many people use computers with a graphical user interface (GUI) like GNOME. Although they offer lots of features, their use is limited when it comes to the execution of automated tasks. Shells are a good addition to GUIs and this chapter gives you an overview of some aspects of shells, in this case Bash.

14.1 What is The Shell?

Traditionally, the shell is Bash (Bourne again Shell). When this chapter speaks about the shell it means Bash. There are actually more available shells than Bash (ash, csh, ksh, zsh, …), each employing different features and characteristics. If you need further information about other shells, search for shell in YaST.

14.1.1 Knowing the Bash Configuration Files

A shell can be invoked as an:

  1. Interactive login shell.  This is used when logging in to a machine, invoking Bash with the --login option or when logging in to a remote machine with SSH.

  2. Ordinary interactive shell.  This is normally the case when starting xterm, konsole, gnome-terminal or similar tools.

  3. Non-interactive shell.  This is used when invoking a shell script at the command line.

Depending on which type of shell you use, different configuration files are being read. The following tables show the login and non-login shell configuration files.

Table 14.1: Bash Configuration Files for Login Shells




Do not modify this file, otherwise your modifications can be destroyed during your next update!


Use this file if you extend /etc/profile


Contains system-wide configuration files for specific programs


Insert user specific configuration for login shells here

Table 14.2: Bash Configuration Files for Non-Login Shells


Do not modify this file, otherwise your modifications can be destroyed during your next update!


Use this file to insert your system-wide modifications for Bash only


Insert user specific configuration here

Additionally, Bash uses some more files:

Table 14.3: Special Files for Bash




Contains a list of all commands you have been typing


Executed when logging out

14.1.2 The Directory Structure

The following table provides a short overview of the most important higher-level directories that you find on a Linux system. Find more detailed information about the directories and important subdirectories in the following list.

Table 14.4: Overview of a Standard Directory Tree




Root directory—the starting point of the directory tree.


Essential binary files, such as commands that are needed by both the system administrator and normal users. Usually also contains the shells, such as Bash.


Static files of the boot loader.


Files needed to access host-specific devices.


Host-specific system configuration files.


Holds the home directories of all users who have accounts on the system. However, root's home directory is not located in /home but in /root.


Essential shared libraries and kernel modules.


Mount points for removable media.


Mount point for temporarily mounting a file system.


Add-on application software packages.


Home directory for the superuser root.


Essential system binaries.


Data for services provided by the system.


Temporary files.


Secondary hierarchy with read-only data.


Variable data such as log files.


Only available if you have both Microsoft Windows* and Linux installed on your system. Contains the Windows data.

The following list provides more detailed information and gives some examples of which files and subdirectories can be found in the directories:


Contains the basic shell commands that may be used both by root and by other users. These commands include ls, mkdir, cp, mv, rm and rmdir. /bin also contains Bash, the default shell in openSUSE Leap.


Contains data required for booting, such as the boot loader, the kernel, and other data that is used before the kernel begins executing user-mode programs.


Holds device files that represent hardware components.


Contains local configuration files that control the operation of programs like the X Window System. The /etc/init.d subdirectory contains LSB init scripts that can be executed during the boot process.


Holds the private data of every user who has an account on the system. The files located here can only be modified by their owner or by the system administrator. By default, your e-mail directory and personal desktop configuration are located here in the form of hidden files and directories, such as .gconf/ and .config.

Note: Home Directory in a Network Environment

If you are working in a network environment, your home directory may be mapped to a directory in the file system other than /home.


Contains the essential shared libraries needed to boot the system and to run the commands in the root file system. The Windows equivalent for shared libraries are DLL files.


Contains mount points for removable media, such as CD-ROMs, flash disks, and digital cameras (if they use USB). /media generally holds any type of drive except the hard disk of your system. When your removable medium has been inserted or connected to the system and has been mounted, you can access it from here.


This directory provides a mount point for a temporarily mounted file system. root may mount file systems here.


Reserved for the installation of third-party software. Optional software and larger add-on program packages can be found here.


Home directory for the root user. The personal data of root is located here.


A tmpfs directory used by systemd and various components. /var/run is a symbolic link to /run.


As the s indicates, this directory holds utilities for the superuser. /sbin contains the binaries essential for booting, restoring and recovering the system in addition to the binaries in /bin.


Holds data for services provided by the system, such as FTP and HTTP.


This directory is used by programs that require temporary storage of files.

Important: Cleaning up /tmp at Boot Time

Data stored in /tmp are not guaranteed to survive a system reboot. It depends, for example, on settings in /etc/sysconfig/cron.


/usr has nothing to do with users, but is the acronym for Unix system resources. The data in /usr is static, read-only data that can be shared among various hosts compliant with the Filesystem Hierarchy Standard (FHS). This directory contains all application programs including the graphical desktops such as GNOME and establishes a secondary hierarchy in the file system. /usr holds several subdirectories, such as /usr/bin, /usr/sbin, /usr/local, and /usr/share/doc.


Contains generally accessible programs.


Contains programs reserved for the system administrator, such as repair functions.


In this directory the system administrator can install local, distribution-independent extensions.


Holds various documentation files and the release notes for your system. In the manual subdirectory find an online version of this manual. If more than one language is installed, this directory may contain versions of the manuals for different languages.

Under packages find the documentation included in the software packages installed on your system. For every package, a subdirectory /usr/share/doc/packages/packagename is created that often holds README files for the package and sometimes examples, configuration files or additional scripts.

If HOWTOs are installed on your system /usr/share/doc also holds the howto subdirectory in which to find additional documentation on many tasks related to the setup and operation of Linux software.


Whereas /usr holds static, read-only data, /var is for data which is written during system operation and thus is variable data, such as log files or spooling data. For an overview of the most important log files you can find under /var/log/, refer to Table 16.1, “Log Files”.


Only available if you have both Microsoft Windows and Linux installed on your system. Contains the Windows data available on the Windows partition of your system. Whether you can edit the data in this directory depends on the file system your Windows partition uses. If it is FAT32, you can open and edit the files in this directory. For NTFS, openSUSE Leap also includes write access support. However, the driver for the NTFS-3g file system has limited functionality.

14.2 Writing Shell Scripts

Shell scripts are a convenient way of doing all sorts of tasks: collecting data, searching for a word or phrase in a text and many other useful things. The following example shows a small shell script that prints a text:

Example 14.1: A Shell Script Printing a Text
#!/bin/sh 1
# Output the following line: 2
echo "Hello World" 3


The first line begins with the Shebang characters (#!) which is an indicator that this file is a script. The script is executed with the specified interpreter after the Shebang, in this case /bin/sh.


The second line is a comment beginning with the hash sign. It is recommended to comment difficult lines to remember what they do.


The third line uses the built-in command echo to print the corresponding text.

Before you can run this script you need some prerequisites:

  1. Every script should contain a Shebang line (this is already the case with our example above.) If a script does not have this line, you need to call the interpreter manually.

  2. You can save the script wherever you want. However, it is a good idea to save it in a directory where the shell can find it. The search path in a shell is determined by the environment variable PATH. Usually a normal user does not have write access to /usr/bin. Therefore it is recommended to save your scripts in the users' directory ~/bin/. The above example gets the name

  3. The script needs executable permissions. Set the permissions with the following command:

    chmod +x ~/bin/

If you have fulfilled all of the above prerequisites, you can execute the script in the following ways:

  1. As Absolute Path.  The script can be executed with an absolute path. In our case, it is ~/bin/

  2. Everywhere.  If the PATH environment variable contains the directory where the script is located, you can execute the script with

14.3 Redirecting Command Events

Each command can use three channels, either for input or output:

  • Standard Output.  This is the default output channel. Whenever a command prints something, it uses the standard output channel.

  • Standard Input.  If a command needs input from users or other commands, it uses this channel.

  • Standard Error.  Commands use this channel for error reporting.

To redirect these channels, there are the following possibilities:

Command > File

Saves the output of the command into a file, an existing file will be deleted. For example, the ls command writes its output into the file listing.txt:

ls > listing.txt
Command >> File

Appends the output of the command to a file. For example, the ls command appends its output to the file listing.txt:

ls >> listing.txt
Command < File

Reads the file as input for the given command. For example, the read command reads in the content of the file into the variable:

read a < foo
Command1 | Command2

Redirects the output of the left command as input for the right command. For example, the cat command outputs the content of the /proc/cpuinfo file. This output is used by grep to filter only those lines which contain cpu:

cat /proc/cpuinfo | grep cpu

Every channel has a file descriptor: 0 (zero) for standard input, 1 for standard output and 2 for standard error. It is allowed to insert this file descriptor before a < or > character. For example, the following line searches for a file starting with foo, but suppresses its errors by redirecting it to /dev/null:

find / -name "foo*" 2>/dev/null

14.4 Using Aliases

An alias is a shortcut definition of one or more commands. The syntax for an alias is:


For example, the following line defines an alias lt which outputs a long listing (option -l), sorts it by modification time (-t) and prints it in reverse order while sorting (-r):

alias lt='ls -ltr'

To view all alias definitions, use alias. Remove your alias with unalias and the corresponding alias name.

14.5 Using Variables in Bash

A shell variable can be global or local. Global variables, or environment variables, can be accessed in all shells. In contrast, local variables are visible in the current shell only.

To view all environment variables, use the printenv command. If you need to know the value of a variable, insert the name of your variable as an argument:

printenv PATH

A variable, be it global or local, can also be viewed with echo:

echo $PATH

To set a local variable, use a variable name followed by the equal sign, followed by the value:


Do not insert spaces around the equal sign, otherwise you get an error. To set an environment variable, use export:

export NAME="tux"

To remove a variable, use unset:

unset NAME

The following table contains some common environment variables which can be used in you shell scripts:

Table 14.5: Useful Environment Variables


the home directory of the current user


the current host name


when a tool is localized, it uses the language from this environment variable. English can also be set to C


the search path of the shell, a list of directories separated by colon


specifies the normal prompt printed before each command


specifies the secondary prompt printed when you execute a multi-line command


current working directory


the current user

14.5.1 Using Argument Variables

For example, if you have the script you can execute it like this: "Tux Penguin" 2000

To access all the arguments which are passed to your script, you need positional parameters. These are $1 for the first argument, $2 for the second, and so on. You can have up to nine parameters. To get the script name, use $0.

The following script prints all arguments from 1 to 4:

echo \"$1\" \"$2\" \"$3\" \"$4\"

If you execute this script with the above arguments, you get:

"Tux Penguin" "2000" "" ""

14.5.2 Using Variable Substitution

Variable substitutions apply a pattern to the content of a variable either from the left or right side. The following list contains the possible syntax forms:


removes the shortest possible match from the left:

echo ${file#*/}

removes the longest possible match from the left:

echo ${file##*/}

removes the shortest possible match from the right:

echo ${file%.*}

removes the longest possible match from the right:

echo ${file%%.*}

substitutes the content of VAR from the pattern_1 with pattern_2:

echo ${file/tux/wilber}

14.6 Grouping and Combining Commands

Shells allow you to concatenate and group commands for conditional execution. Each command returns an exit code which determines the success or failure of its operation. If it is 0 (zero) the command was successful, everything else marks an error which is specific to the command.

The following list shows, how commands can be grouped:

Command1 ; Command2

executes the commands in sequential order. The exit code is not checked. The following line displays the content of the file with cat and then prints its file properties with ls regardless of their exit codes:

cat filelist.txt ; ls -l filelist.txt
Command1 && Command2

runs the right command, if the left command was successful (logical AND). The following line displays the content of the file and prints its file properties only, when the previous command was successful (compare it with the previous entry in this list):

cat filelist.txt && ls -l filelist.txt
Command1 || Command2

runs the right command, when the left command has failed (logical OR). The following line creates only a directory in /home/wilber/bar when the creation of the directory in /home/tux/foo has failed:

mkdir /home/tux/foo || mkdir /home/wilber/bar
funcname(){ ... }

creates a shell function. You can use the positional parameters to access its arguments. The following line defines the function hello to print a short message:

hello() { echo "Hello $1"; }

You can call this function like this:

hello Tux

which prints:

Hello Tux

14.7 Working with Common Flow Constructs

To control the flow of your script, a shell has while, if, for and case constructs.

14.7.1 The if Control Command

The if command is used to check expressions. For example, the following code tests whether the current user is Tux:

if test $USER = "tux"; then
  echo "Hello Tux."
  echo "You are not Tux."

The test expression can be as complex or simple as possible. The following expression checks if the file foo.txt exists:

if test -e /tmp/foo.txt ; then
  echo "Found foo.txt"

The test expression can also be abbreviated in angled brackets:

if [ -e /tmp/foo.txt ] ; then
  echo "Found foo.txt"

Find more useful expressions at

14.7.2 Creating Loops With the for Command

The for loop allows you to execute commands to a list of entries. For example, the following code prints some information about PNG files in the current directory:

for i in *.png; do
 ls -l $i

14.8 For More Information

Important information about Bash is provided in the man pages man bash. More about this topic can be found in the following list:

Print this page