A German Bash Scripting Tutorial/Workshop (deutsch)#

Anyone working with Linux will hardly avoid Bash scripts, yet few take the time to learn it properly.

After writing a small article on extending the Nautilus file commander, I realized how useful a small tutorial could be.

The topic overview:

Introduction to Linux and the Bash Shell
Basics of Bash Programming
- Introduction to the command line
Basic commands and navigation
- Working with files and directories
Creating, reading and editing files
Navigation in directories
Creating Bash scripts
- Basic structure of a Bash script
Writing executable scripts
Variables and data flow
- Variable types and declaration
Reading and writing data
Control structures
- Conditions and decisions
- Loop constructs
Functions and modularity
- Defining and using functions
- Building scripts modularly
Error handling and debugging
- Identifying error sources
- Debugging scripts effectively
Advanced topics
- Regular Expressions
- Scripting for system administration
Useful tools and resources

1. Introduction to Linux and the Bash Shell

Linux is a widely used operating system known for its stability, security and flexibility. The Bash shell is one of the most common shells on Linux and allows interaction with the operating system through a command-line interface.

2. Basics of Bash Programming

Introduction to the command line

I’ll show you how to use the command line, an essential tool on Linux. You’ll learn how to enter commands to interact with your system.

Learn the basic commands:

pwd: Shows your current directory. ls: Lists files and directories. cd: Changes the directory. touch: Creates a new file. mkdir: Creates a new directory.

3. Working with Files and Directories

Creating, reading and editing files Here you’ll learn how to create files, display their contents and edit them.
Navigation in directories I’ll show you how to navigate through directories and efficiently organize your file structure.

4. Creating Bash Scripts

Basic structure of a Bash script

Every Bash script starts with #!/bin/bash__. This line is crucial because it specifies which interpreter should be used.

**Creating a Bash script *Open a terminal: Start your terminal in Linux. *Create a new file: Use the touch command to create a new script file. For example: touch my_script.sh. Edit the file: Open the file in a text editor. You can use a simple editor like nano: nano my_script.sh .

Writing a Bash script In the editor, insert the following code:

#!/bin/bash
#Define a simple function
output() {
  echo "Hello, I am a function!"
}

#Call the function
output

#Simple output
echo "This is my first Bash script!"

In this example, we started right away with a function. Saving and closing the Bash script Save the script in nano by pressing Ctrl+O, then Enter. Exit the editor with Ctrl+X.

Writing executable scripts

You’ll learn how to write a script and make it executable so you can run it directly from the command line. To execute the script, you need to make it executable:

Run the command chmod +x my_script.sh.

Running the Bash script

Run the script with ./my_script.sh.

What happens in the script?

#!/bin/bash: This is the shebang line, which specifies that this script should be executed with Bash.
output() { ... }: Here you define a function named output that outputs a message.
output: You call the output function.
echo "This is my first Bash script!": With echo you output a message on the screen.
This script shows you the basics of script creation, function definition and calls, as well as text output in Bash. Feel free to experiment with the code to add more functions and commands!

However, make sure to back up first, in case you accidentally delete or modify data.

5. Variables and Data Flow

Variable types and declaration

In Bash you can use different types of variables. I’ll explain how to declare and assign them. For example: my_variable=“Hello World”.

Tutorial: Working with variables in Bash

In this part of the tutorial, we focus on how to store, declare and read variables in Bash. Variables are fundamental to writing effective scripts because they allow you to store and manipulate values.

Declaring and assigning variables

Declaring variables In Bash you declare a variable by simply assigning it a value. For example:

my_variable=“Hello World”

Here you’ve created a variable named my_variable and assigned it the value “Hello World”.

Variable names

Variable names should be meaningful. They can contain letters, numbers and underscores, but must not start with a number.

Reading variables

Outputting variable values To output the value of a variable, you use the echo command with the $ sign before the variable name. For example:

echo $my_variable

This will output “Hello World” on the console.

Working with variables

Embedding variables in text

You can also embed variables in strings. If you use double quotes, the value of the variable will be inserted into the string:

echo "The message is: $my_variable"

Using variables in calculations

For numerical calculations, you use the $(( )) construct. For example:

a=5
b=3
sum=$((a + b))
echo "The sum is $sum"

This will output “The sum is 8”.

Environment variables

Environment variables: Bash also has environment variables that are available system-wide. For example, echo $HOME outputs the path to your home directory.

Setting your own environment variables: You can set your own environment variables with export, for example:

export MY_VAR="A value"

This variable is then available in all subordinate shell sessions.

Variables and quotation marks

Double quotes

When you use double quotes, variables and certain special characters like \n (for a line break) are interpreted.

Single quotes

If you use single quotes, the text is output exactly as it is written. Variables are not interpreted.

echo 'My variable: $my_variable'

This will be output exactly as is, without replacing the value of my_variable.

Tips to avoid beginner mistakes

Capitalize names

It’s a common convention to write environment variables in uppercase to distinguish them from local variables.

Be careful with spaces

Make sure you don’t put spaces around the equals sign when declaring variables. With this knowledge you are well equipped to use variables effectively in your Bash scripts!__

Reading and writing data

Here you’ll learn how to store data in variables and read them back. This is particularly useful when you want to process information in your script.

Control structures

Conditions and decisions You’ll learn how to use if, else and elif to set conditions and make decisions in your scripts.

Loop constructs

Loops are essential for automating repetitive tasks. I’ll show you how to use for and while loops in your scripts.

7. Functions and modularity

Defining and using functions

Functions help you make your code more efficient and readable. You’ll learn how to define and call your own functions.

Building scripts modularly

I’ll explain how to divide your scripts into modules to make them reusable and clear.

8. Error handling and debugging

Identifying error sources

Errors happen, but don’t worry! I’ll show you how to identify and fix common error sources.

Debugging scripts effectively

You’ll learn techniques to debug your scripts and find and fix errors quickly.

9. Advanced topics

Regular Expressions

Regular Expressions (RegEx) are a powerful tool for text processing. I’ll introduce you to the basics and show you how to use them in Bash.

Scripting for system administration

Bash scripts are ideal for system administration tasks. You’ll learn advanced techniques to manage your system effectively.

10. Useful tools and resources

External tools and helper programs

There are many tools that make life easier as a Bash programmer. I’ll introduce you to some of the best.