Wie man Standardwerte in Bash-Skripten setzt

Introduction

Setting default values in Bash scripts is a crucial skill for creating robust and user-friendly shell scripts. This tutorial will guide you through the process of handling missing or optional parameters by providing default values, ensuring your scripts can gracefully handle a variety of input scenarios.

By the end of this lab, you will be able to write Bash scripts that can work well even when users do not provide all the expected input parameters.

Skills Graph

Understanding Default Values in Bash

When writing Bash scripts, you often need your scripts to work even when certain input parameters are missing. Default values provide a solution by offering fallback options when variables are not explicitly set.

Why Default Values Matter

Default values in Bash scripts serve several important purposes:

• They prevent your script from failing when expected input is missing
• They make your scripts more user-friendly by reducing required parameters
• They allow your scripts to have sensible behavior in different environments
• They simplify script development and testing

Creating a Simple Script

Let's create a simple Bash script to demonstrate the need for default values. Follow these steps:

1. Open the WebIDE terminal
2. Create a new directory for our project:

mkdir -p ~/project/bash_defaults
cd ~/project/bash_defaults

3. Using the WebIDE, create a new file named greeting.sh in the bash_defaults directory with the following content:

#!/bin/bash

## A simple greeting script
NAME=$1
echo "Hello, $NAME!"

4. Make the script executable:

chmod +x greeting.sh

5. Now run the script with a name parameter:

./greeting.sh Alice

You should see the output:

Hello, Alice!

6. Now try running the script without any parameters:

./greeting.sh

You should see the output:

Hello, !

Notice that the greeting looks incomplete when no name is provided. This is a perfect scenario where default values would be helpful to make our script more robust.

In the next step, we will modify this script to use default values so it works well even when parameters are missing.

Basic Default Value Techniques

Now that we understand why default values are important, let's learn different ways to set default values in Bash scripts. We'll start with the most common techniques.

The Parameter Substitution Operator (:-)

The most common way to set default values in Bash is using the :- operator with the following syntax:

${variable:-default_value}

This means "use the value of variable if it's set and not empty, otherwise use default_value".

Let's modify our greeting script to include a default value:

1. Open the greeting.sh file in the WebIDE and update it with the following content:

#!/bin/bash

## A greeting script with default value
NAME=${1:-"World"}
echo "Hello, $NAME!"

2. Save the file and run the script with a parameter:

./greeting.sh Alice

You should see:

Hello, Alice!

3. Now run the script without any parameters:

./greeting.sh

You should see:

Hello, World!

The script now uses "World" as the default value when no name is provided, making it much more user-friendly.

Creating a More Complex Script

Let's create a more complex script that welcomes users with a customizable message and time of day. We'll use default values for both parameters:

1. Create a new file named welcome.sh in the bash_defaults directory with the following content:

#!/bin/bash

## A welcome script with multiple default values
NAME=${1:-"User"}
GREETING=${2:-"Welcome"}
TIME_OF_DAY=${3:-"today"}

echo "$GREETING, $NAME! How are you doing $TIME_OF_DAY?"

2. Make the script executable:

chmod +x welcome.sh

3. Run the script with different combinations of parameters:

./welcome.sh

Output:

Welcome, User! How are you doing today?

./welcome.sh Bob

Output:

Welcome, Bob! How are you doing today?

./welcome.sh Bob "Good morning"

Output:

Good morning, Bob! How are you doing today?

./welcome.sh Bob "Good morning" "this fine afternoon"

Output:

Good morning, Bob! How are you doing this fine afternoon?

As you can see, default values make your scripts much more flexible, working with any number of parameters provided.

Working with Environment Variables and Default Values

In many Bash scripting scenarios, you'll need to work with environment variables. Default values are especially useful when you want your script to work even if certain environment variables aren't set.

Default Values for Environment Variables

Environment variables are often used for configuration in shell scripts. Let's create a script that uses environment variables with default values:

1. Create a new file named config.sh in the bash_defaults directory with the following content:

#!/bin/bash

## Access environment variables with default values
USERNAME=${USER:-"anonymous"}
WORKING_DIR=${PWD:-"/home/labex"}
EDITOR=${VISUAL:-${EDITOR:-"nano"}}

echo "Current user: $USERNAME"
echo "Working directory: $WORKING_DIR"
echo "Preferred editor: $EDITOR"

2. Make the script executable:

chmod +x config.sh

3. Run the script:

./config.sh

You should see output similar to:

Current user: labex
Working directory: /home/labex/project/bash_defaults
Preferred editor: nano

Notice how we've nested default values for the EDITOR variable. This script first checks if the VISUAL environment variable is set, and if not, it checks the EDITOR variable. If neither is set, it defaults to "nano".

Creating a Configuration Script

Now let's create a more practical script that configures an application using environment variables with default values:

1. Create a new file named app_config.sh in the bash_defaults directory with the following content:

#!/bin/bash

## Application configuration script using default values
APP_NAME=${APP_NAME:-"MyApp"}
APP_VERSION=${APP_VERSION:-"1.0.0"}
APP_PORT=${APP_PORT:-8080}
APP_ENV=${APP_ENV:-"development"}
LOG_LEVEL=${LOG_LEVEL:-"info"}

echo "Starting $APP_NAME v$APP_VERSION"
echo "Configuration:"
echo "  Port: $APP_PORT"
echo "  Environment: $APP_ENV"
echo "  Log Level: $LOG_LEVEL"

## Create a config file with these settings
echo "Creating configuration file..."
cat > app.conf << EOF
APP_NAME=$APP_NAME
APP_VERSION=$APP_VERSION
APP_PORT=$APP_PORT
APP_ENV=$APP_ENV
LOG_LEVEL=$LOG_LEVEL
EOF

echo "Configuration file created at $(pwd)/app.conf"

2. Make the script executable:

chmod +x app_config.sh

3. Run the script with default values:

./app_config.sh

You should see output about the default configuration.

4. Now run it with some environment variables set:

APP_NAME="WebService" APP_PORT=3000 APP_ENV="production" ./app_config.sh

You should see that the script uses the values you provided for some settings and defaults for others.

5. Verify the contents of the config file:

cat app.conf

This practical example shows how default values in Bash help create flexible configuration scripts that work with or without user-specified values.

Advanced Default Value Techniques

Now that you understand the basics of setting default values in Bash, let's explore some advanced techniques that will make your scripts even more powerful and flexible.

The := Assignment Operator

The := operator not only substitutes a default value but also assigns that value to the variable if it was unset. This is useful when you want the variable to keep its default value for later use.

1. Create a new file named assign_default.sh in the bash_defaults directory with the following content:

#!/bin/bash

## Demonstrate the := assignment operator
echo "Before assignment, NAME = $NAME"

## This assigns the default value to NAME if it's unset
: ${NAME:="DefaultUser"}

echo "After assignment, NAME = $NAME"

## Now use the variable in a function
greet() {
  echo "Hello, $NAME!"
}

greet

2. Make the script executable:

chmod +x assign_default.sh

3. Run the script without setting NAME:

./assign_default.sh

You should see:

Before assignment, NAME =
After assignment, NAME = DefaultUser
Hello, DefaultUser!

4. Now set NAME before running:

NAME="Alice" ./assign_default.sh

You should see:

Before assignment, NAME = Alice
After assignment, NAME = Alice
Hello, Alice!

Chaining Default Values

Sometimes you might want to check multiple sources for a value before falling back to a hard-coded default. You can chain default values to achieve this:

1. Create a new file named chain_defaults.sh in the bash_defaults directory with the following content:

#!/bin/bash

## Read config file if it exists
if [[ -f "./user.conf" ]]; then
  source "./user.conf"
fi

## Chain default values: command line arg -> config file -> environment var -> hard-coded default
USERNAME=${1:-${CONFIG_USER:-${USER:-"guest"}}}
LANGUAGE=${2:-${CONFIG_LANG:-${LANG:-"en_US"}}}

echo "Hello, $USERNAME! Your language is set to $LANGUAGE."

2. Make the script executable:

chmod +x chain_defaults.sh

3. Create a config file for testing:

echo "CONFIG_USER=ConfigUser" > user.conf
echo "CONFIG_LANG=es_ES" >> user.conf

4. Test the script with different combinations:

## Use defaults from the config file
./chain_defaults.sh

## Override with command line arguments
./chain_defaults.sh CommandLineUser fr_FR

## Remove config file to test falling back to environment variables
rm user.conf
./chain_defaults.sh

Conditional Default Values

You can also use conditional expressions to set different default values based on conditions:

1. Create a new file named conditional_defaults.sh in the bash_defaults directory with the following content:

#!/bin/bash

## Get the current hour (24-hour format)
HOUR=$(date +%H)

## Set default greeting based on time of day
if ((HOUR < 12)); then
  DEFAULT_GREETING="Good morning"
elif ((HOUR < 18)); then
  DEFAULT_GREETING="Good afternoon"
else
  DEFAULT_GREETING="Good evening"
fi

## Use the conditional default if no greeting is provided
GREETING=${1:-"$DEFAULT_GREETING"}
NAME=${2:-"User"}

echo "$GREETING, $NAME!"
echo "The current time is $(date +%H:%M)."

2. Make the script executable:

chmod +x conditional_defaults.sh

3. Run the script to see how it chooses a default greeting based on the time of day:

./conditional_defaults.sh

4. Override the default greeting:

./conditional_defaults.sh "Hello" "World"

These advanced techniques give you more flexibility when working with default values in Bash, allowing you to create more sophisticated and user-friendly scripts.

Applying Default Values in a Real-World Script

Now that we have covered various techniques for setting default values, let's put everything together in a practical script that you might use in a real-world scenario.

We'll create a backup script that uses default values for various configuration options. This script will demonstrate how default values make your scripts more flexible and user-friendly.

Creating a Backup Script

1. Create a new file named backup.sh in the bash_defaults directory with the following content:

#!/bin/bash

## Backup script with default values for all parameters

## Source directories to backup (comma-separated) - default to current directory
SRC_DIRS=${1:-$(pwd)}

## Destination directory for backups - default to ~/backups
BACKUP_DIR=${2:-"$HOME/backups"}

## Backup filename prefix - default to "backup"
PREFIX=${3:-"backup"}

## Maximum number of backups to keep - default to 5
MAX_BACKUPS=${4:-5}

## Create destination directory if it doesn't exist
mkdir -p "$BACKUP_DIR"

## Generate timestamp for the backup filename
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_DIR/${PREFIX}_${TIMESTAMP}.tar.gz"

echo "Starting backup process..."
echo "Source: $SRC_DIRS"
echo "Destination: $BACKUP_FILE"

## Create the backup archive (we'll simulate this for the lab)
echo "Creating backup archive..."
echo "tar -czf $BACKUP_FILE $SRC_DIRS" > "$BACKUP_DIR/last_backup_command.txt"
touch "$BACKUP_FILE" ## Just create an empty file for demonstration

## Clean up old backups if we have more than MAX_BACKUPS
echo "Checking for old backups to remove..."
NUM_BACKUPS=$(ls -1 "$BACKUP_DIR"/${PREFIX}_*.tar.gz 2> /dev/null | wc -l)
if ((NUM_BACKUPS > MAX_BACKUPS)); then
  NUM_TO_DELETE=$((NUM_BACKUPS - MAX_BACKUPS))
  echo "Removing $NUM_TO_DELETE old backup(s)..."
  ls -1t "$BACKUP_DIR"/${PREFIX}_*.tar.gz | tail -n "$NUM_TO_DELETE" | while read file; do
    echo "Would delete: $file (simulation)"
  done
else
  echo "No old backups need to be removed (keeping $NUM_BACKUPS of $MAX_BACKUPS maximum)"
fi

echo "Backup process completed!"
echo "Backup saved to: $BACKUP_FILE"

2. Make the script executable:

chmod +x backup.sh

3. Create the directories needed for testing:

mkdir -p ~/backups
mkdir -p ~/test_data
echo "Test file 1" > ~/test_data/file1.txt
echo "Test file 2" > ~/test_data/file2.txt

Testing the Backup Script

Now let's test our backup script with different combinations of parameters to see how the default values work in practice:

1. Run the script with all default values:

./backup.sh

This will back up the current directory to ~/backups with the prefix "backup".

2. Run the script specifying a source directory:

./backup.sh ~/test_data

This will back up the test_data directory using the other default values.

3. Run the script with custom source and destination:

./backup.sh ~/test_data ~/project/bash_defaults/my_backups

4. Run the script with all parameters specified:

./backup.sh ~/test_data ~/project/bash_defaults/my_backups project_backup 3

This example shows how default values make your scripts flexible - users can specify as many or as few parameters as they need, and your script will still work properly.

Check the Results

After running the backup script with different parameters, you can check the results:

## Check the default backup location
ls -la ~/backups

## Check the custom backup location (if you used it)
ls -la ~/project/bash_defaults/my_backups

By using default values consistently in your scripts, you create tools that are more user-friendly and adaptable to different environments and use cases.

Summary

In this lab, you have learned how to set default values in Bash scripts, a fundamental skill for creating robust, user-friendly scripts. Throughout the lab, you have:

• Created simple scripts using basic default value techniques with the :- operator
• Worked with environment variables and default values
• Explored advanced default value techniques including the := assignment operator and conditional defaults
• Developed a practical backup script that demonstrates how default values make your scripts more flexible

These techniques allow your scripts to work well even when users do not provide all the expected parameters, making them more resilient and easier to use. Default values also simplify script development and testing by reducing the need for comprehensive input validation.

As you continue to write Bash scripts, remember to use default values liberally to improve the user experience and robustness of your scripts. This practice will make your scripts more professional and useful in a variety of environments and scenarios.