Shell Scripts 2

LHT
  2023-01-17 04:04 2023-01-17 04:04 Created      3.4k Words  20 Mins  

read Console Input

Syntax

1
read [options] [arguments]

Options:

  • -p: Specifies the prompt to display when reading input.
  • -t: Specifies the time (in seconds) to wait for input. If -t is not added, it waits indefinitely.

Arguments:

  • Variable: Specifies the name of the variable where the input will be stored.

Below is an example demonstrating how to use the read command to read user input and store it in a variable:

1
2
3
4
5
6
7
#!/bin/bash

read -p "Please enter your name: " name
read -t 5 -p "Please enter your age (enter within 5 seconds): " age

echo "Your name is: $name"
echo "Your age is: $age"

In the example above, the read command is used to read the user’s name and age. The -p option specifies the prompt, and the -t option sets the timeout. After entering the name and age in the command line, the program stores the input values in the respective variables and outputs them. If the user does not input the age within the specified time, the age value will be empty.

Output after running the script:

1
2
3
4
Please enter your name: John
Please enter your age (enter within 5 seconds): 25
Your name is: John
Your age is: 25

If the user does not enter the age within 5 seconds, the output will be:

1
2
3
Please enter your name: John
Your name is: John
Your age is:

Functions

System Functions

basename

basename is a command used to get the base file name of a given path.

Here is the syntax of basename:

1
basename [path] [suffix]

Parameter Explanation:

  • path: The path from which to extract the base file name. This can be a file or directory path.
  • suffix: An optional parameter specifying the suffix to remove. If provided, basename will remove the suffix from the path.

Note that the basename command returns the base file name of the given path without the path information.

Example usage:

1
basename /path/to/file.txt

Output:

1
file.txt
1
basename /path/to/file.txt .txt

Output:

1
file

In the example, the first command returns the base file name file.txt from the path /path/to/file.txt, and the second command removes the .txt suffix, returning file.

dirname

dirname is a command used to get the directory name of a given path.

Here is the syntax of dirname:

1
dirname [path]

Parameter Explanation:

  • path: The path from which to extract the directory name. This can be a file or directory path.

Note that the dirname command returns the directory name of the given path, excluding the file name or the last path component.

Example usage:

1
dirname /path/to/file.txt

Output:

1
/path/to

In the example, the command returns the directory name /path/to from the file path /path/to/file.txt.

Custom Functions

Here is the syntax for defining custom functions:

1
2
3
4
5
6
7
[function] function_name[()]
{
    # Function code block
    # May contain a series of commands and logic

    [return return_value;]
}

The parts enclosed in square brackets in the syntax represent optional items.

  • function (optional): A keyword used to declare a function. In most cases, the keyword can be omitted, and the function can be declared directly using the function name and parentheses.
  • function_name: The name you assign to the function, which can be customized.
  • () : Parentheses around the function’s parameter list. If the function does not accept any parameters, the parentheses can be omitted.
  • function_code_block: The actual code of the function, which includes a series of commands and logic.
  • return return_value (optional): Specifies the return value of the function. The return keyword can be followed by an integer value, which represents the status code returned after the function executes. If the return statement is omitted, the function defaults to returning the execution status of the last command.

Note: To ensure proper execution of functions in the script, it is recommended to place the function definitions at the top of the script or before they are called.

Here is an example demonstrating how to define a function that calculates the sum of two input parameters:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/bin/bash

# Define the function to calculate the sum of two numbers
sum_numbers() {
    local num1=$1
    local num2=$2
    local sum=$((num1 + num2))
    echo "The sum of the two numbers is: $sum"
}

# Receive two numbers as input from the user
read -p "Please enter the first number: " input1
read -p "Please enter the second number: " input2

# Call the function and pass the user input as parameters
sum_numbers $input1 $input2

In the example script, we define a function called sum_numbers that calculates the sum of two input parameters. The read command is used to accept two numbers from the user and store them in the variables input1 and input2. Then, we call the sum_numbers function and pass the user input as parameters to calculate and output the result.

Example execution result:

1
2
3
Please enter the first number: 5
Please enter the second number: 3
The sum of the two numbers is: 8

Note that the read command is used to receive user input, and the -p option is used to specify the prompt. The user input is then passed to the function through $input1 and $input2.

Additional Explanation

local is a keyword used to declare local variables within a function. In Bash scripts, the local keyword restricts the scope of a variable to the current function, preventing it from affecting variables with the same name outside the function.

Here is the syntax for the local keyword:

1
local variable_name

Where variable_name is the name of the local variable you wish to declare within the function.

Variables declared with the local keyword are only visible inside the function and do not affect variables with the same name outside the function. This helps prevent conflicts between local and global variables and avoids polluting the namespace.

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/bin/bash

my_function() {
    local my_var="Local Variable"
    echo "Inside function variable: $my_var"
}

my_var="Global Variable"
echo "Outside function variable: $my_var"

my_function

echo "Outside function variable: $my_var"

Output when executing the above script:

1
2
3
Outside function variable: Global Variable
Inside function variable: Local Variable
Outside function variable: Global Variable

As seen in the example, the variable my_var declared with the local keyword is only visible inside the function and does not affect the same-named variable outside the function.

Introduction to Regular Expressions

Regular expressions are patterns made up of characters and special symbols, used to describe and match strings that follow a specific rule. They can be used to search, filter, and manipulate text that matches a particular pattern.

By using tools like grep, sed, and awk in Linux, along with regular expressions, you can easily search for, match, and replace text that meets specific patterns, providing powerful text processing and filtering capabilities.

Here are some common uses and patterns:

  1. Character Matching:

    • .: Matches any single character.
    • [abc]: Matches any one character from the character set, such as a, b, or c.
    • [^abc]: Negates the character set, matching any character except those in the set.
    • [0-9]: Matches any digit from 0 to 9.

  2. Repetition Matching:

    • *: Matches the preceding character zero or more times.
    • +: Matches the preceding character one or more times.
    • ?: Matches the preceding character zero or one time.
    • {n}: Matches the preceding character exactly n times.
    • {n,}: Matches the preceding character at least n times.
    • {n,m}: Matches the preceding character between n and m times.

  3. Boundary Matching:

    • ^: Matches the start of a line.
    • $: Matches the end of a line.
    • \b: Matches the boundary of a word.

  4. Grouping and Referencing:

    • (pattern): Groups patterns together.
    • \n: References the nth matched group.

  5. Special Character Matching:

    • \d: Matches a digit character.
    • \w: Matches a word character (alphanumeric + underscore).
    • \s: Matches a whitespace character.
    • \S: Matches a non-whitespace character.

  6. Escaping Special Characters:

    • Use the backslash \ to escape special characters and match them literally.
    • Example: \. matches a literal dot . rather than any character.

  7. Logical Operations:

    • |: Logical OR, matches any one of the patterns.

Here are some common regular expression usage examples:

  1. Match Numbers: \d+

    • Example: 123, 4567, 9
    • Description: Matches one or more consecutive digits.

  2. Match Letters: [a-zA-Z]+

    • Example: abc, Hello, World
    • Description: Matches one or more consecutive letters (both uppercase and lowercase).

  3. Match Words: \b\w+\b

    • Example: Hello, world, 123
    • Description: Matches a word composed of one or more alphanumeric characters, where \b indicates the word boundary.

  4. Match Email Addresses: \b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b

  5. Match Dates: \b\d{4}-\d{2}-\d{2}\b

    • Example: 2021-05-20, 1990-12-31
    • Description: Matches dates in the format YYYY-MM-DD.

  6. Match URLs: \bhttps?://\S+\b

    • Example: https://www.example.com, http://google.com
    • Description: Matches URLs starting with http:// or https://.

These examples only showcase a small portion of regular expression applications. In practice, regular expressions are incredibly powerful and can be used for more complex pattern matching, such as matching repeated characters or characters within specific ranges.

When using regular expressions, you can adjust and combine them based on the specific needs and text content you are working with. Additionally, different text processing tools may have slightly different support for regular expressions, so it’s advisable to consult the relevant tool’s documentation for more details and advanced usage.

Text Processing Tools

cut

cut is a commonly used command-line tool in Linux and other Unix-like operating systems for extracting fields (columns) from text files or standard input.

The basic syntax of the cut command is as follows:

1
cut [options] file

Common options include:

  • -c: Specifies the character range to extract, which can be individual character positions, character ranges, or multiple character ranges. For example, -c 1-5,7 extracts the 1st through 5th characters and the 7th character.
  • -f: Specifies the range of fields (columns) to extract, separated by a delimiter. For example, -f 1,3 extracts the 1st and 3rd columns.
  • -d: Specifies the delimiter for fields. The default delimiter is a tab.
  • --complement: Inverts the extraction, meaning it extracts everything except the specified character range or fields.

Here are some examples:

  1. Extract specific characters from a file:

    1
    cut -c 1-5,8 file.txt

    This extracts the 1st through 5th characters and the 8th character from each line in the file file.txt.

  2. Extract specific fields from a file:

    1
    cut -f 1,3 -d "," file.csv

    This extracts the 1st and 3rd columns from a CSV file file.csv, where fields are separated by commas.

  3. Extract a range of fields from a file:

    1
    cut -f 2-4 -d " " file.txt

    This extracts columns 2 through 4 from a space-separated file file.txt.

The cut command also supports additional options and features such as -s (which prevents displaying lines with missing specified fields) and -b (which extracts by byte positions). You can view the full documentation for cut by using the man cut command in the terminal.

awk

awk is a powerful text processing tool based on pattern matching and action rules to process text. Below is the basic usage of awk, options, examples, and commonly used built-in variables:

Basic Usage:

1
awk 'pattern { action }' file
  • pattern is the pattern used to match lines to process.
  • action is the operation executed on the matched lines.

Options:

  • -F <char>: Specifies the field separator, with the default being space.
  • -v var=value: Defines a variable and assigns a value to it.
  • -f <script file>: Specifies a file containing awk script.

Examples:

  1. Print each line of a file:

    1
    awk '{ print }' file.txt

  2. Print the 1st and 3rd columns of a file:

    1
    awk '{ print $1, $3 }' file.txt

  3. Filter and print based on a condition:

    1
    awk '$2 > 10 { print }' file.txt

  4. Calculate the sum of the 1st column:

    1
    awk '{ sum += $1 } END { print sum }' file.txt

Common Built-in Variables:

  • NR: The number of the current processed line.

    1
    awk '{ print NR, $0 }' file.txt

  • NF: The number of fields in the current line.

    1
    awk '{ print NF, $0 }' file.txt

  • FNR: The number of the current line in the current file.

    1
    awk '{ print FNR, $0 }' file1.txt file2.txt

  • FS: The field separator.

    1
    awk 'BEGIN { FS = ":" } { print $1, $3 }' file.txt

  • OFS: The output field separator.

    1
    awk 'BEGIN { OFS = "," } { print $1, $2 }' file.txt

This is just the basic usage of awk along with some common built-in variables. awk offers much more functionality and flexibility for more complex text processing and data manipulation. You can use the man awk command to view the full documentation and more detailed usage instructions.

BEGIN and END Blocks:

BEGIN and END are special patterns in awk used to perform actions before or after processing text.

  • BEGIN Block: The BEGIN block runs before processing any input. It is typically used for initializing variables, setting parameters, or performing other pre-processing tasks. The BEGIN block is executed only once.

    Example:

    1
    awk 'BEGIN { print "Processing started" } { print $0 }' file.txt

  • END Block: The END block runs after all input has been processed. It is typically used to summarize, compute results, or output summary information. The END block is executed only once.

    Example:

    1
    awk '{ sum += $1 } END { print "Total:", sum }' file.txt

In the above example, the BEGIN block prints a starting message before input is processed, and the END block prints the total after processing all input.

Note that the BEGIN and END blocks are optional and can be used as needed, providing flexibility for performing operations before and after text processing.

Comprehensive Application Example

Archive Files

In practical production applications, it is often necessary to archive and back up important data.

Here is an example of a script that performs daily archive backups of a specified directory:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/bin/bash

# Input directory name (without trailing /)
read -p "Please enter the directory name to back up: " dir_name

# Archive date
archive_date=$(date +%Y%m%d)

# Archive file name
archive_file="/root/archive/${dir_name}_${archive_date}.tar.gz"

# Perform archive backup
tar -czf "$archive_file" "$dir_name"

# Output backup completion information
echo "Directory $dir_name has been successfully archived as $archive_file"

Script explanation:

  1. The user inputs the directory name to be backed up.
  2. The current date is obtained and used as the archive date.
  3. The archive file name is constructed using the directory name and the archive date.
  4. The tar command is used to archive and back up the specified directory, with the -czf option to compress the archive file and save it as a .tar.gz format.
  5. Output the backup completion message, including the archived directory and file name.

Although the above script can already achieve the required functionality, improvements are needed in input and output checks and feedback. For example, before running the script, it is necessary to ensure that the /root/archive directory exists and has appropriate write permissions.

Here is an improved version of the script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#!/bin/bash

# Input directory name (without trailing /)
read -p "Please enter the directory name to back up: " dir_name

# Check if the directory exists
if [ ! -d "$dir_name" ]; then
  echo "Error: Directory $dir_name does not exist!"
  exit 1
fi

# Check if the directory is empty
if [ -z "$(ls -A "$dir_name")" ]; then
  echo "Error: Directory $dir_name is empty!"
  exit 1
fi

# Create archive directory (if it doesn't exist)
archive_dir="/root/archive"
mkdir -p "$archive_dir"

# Archive date
archive_date=$(date +%Y%m%d)

# Archive file name
archive_file="${archive_dir}/${dir_name}_${archive_date}.tar.gz"

# Perform archive backup
tar -czf "$archive_file" "$dir_name"

# Check if archiving was successful
if [ $? -ne 0 ]; then
  echo "Error: Backup of directory $dir_name failed!"
  exit 1
fi

# Output backup completion information
echo "Directory $dir_name has been successfully archived as $archive_file"

Improvement explanation:

  1. Added checks for directory existence and non-emptiness to prevent backing up non-existent or empty directories.
  2. Used the -p option to create the archive directory, and it will not report an error if the directory already exists.
  3. Checked the return value of the archiving command to ensure that no errors occurred during the backup process.
  4. Error messages are output to the standard error stream, and the script exits using exit 1.
  5. Used the variable $? to check the return value of the previous command.

Send Message to a User Quickly

Here is an example of a script that sends a message quickly to a specified user:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#!/bin/bash

# Check the number of arguments
if [ $# -lt 2 ]; then
  echo "Error: Please provide a username and message to send!"
  exit 1
fi

# Get the username and message content
user_name=$1
message="${*:2}"

# Check if the user is logged in
if ! who | grep -wq "$user_name"; then
  echo "Error: User $user_name is not logged in!"
  exit 1
fi

# Check if the user has messaging enabled
if ! grep -wq "^$user_name" /etc/messaging_enabled_users.txt; then
  echo "Error: User $user_name has not enabled messaging!"
  exit 1
fi

# Check if the message content is empty
if [ -z "$message" ]; then
  echo "Error: The message content is empty!"
  exit 1
fi

# Send the message
echo "Sending message to user $user_name: $message"
# ... perform the actual sending operation, such as using a messaging command or sending an email, etc.

# Output message sent confirmation
echo "Message successfully sent to user $user_name"

Script explanation:

  1. Checks the number of arguments to ensure that both a username and a message are provided.
  2. Retrieves the username and message content.
  3. Checks if the user is logged in by using the who command to check the list of logged-in users and using grep for matching.
  4. Checks if the user has messaging enabled by checking the /etc/messaging_enabled_users.txt file. This file path can be adjusted according to actual needs.
  5. Checks if the message content is empty using -z to check if the message variable is empty.
  6. The message sending section can be implemented based on specific needs, such as using a messaging command or sending an email.
  7. Outputs a message sent confirmation.

Here is an improved version of the script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#!/bin/bash

# Check the number of arguments
if [ $# -lt 2 ]; then
  echo "Error: Please provide a username and message to send!"
  exit 1
fi

# Get the username and message content
user_name=$1
message="${*:2}"

# Check if the user is logged in
if ! who | grep -wq "$user_name"; then
  echo "Error: User $user_name is not logged in!"
  exit 1
fi

# Check if the user has messaging enabled
enabled_users_file="/etc/messaging_enabled_users.txt"
if ! grep -wq "^$user_name" "$enabled_users_file"; then
  echo "Error: User $user_name has not enabled messaging!"
  exit 1
fi

# Check if the message content is empty
if [ -z "$message" ]; then
  echo "Error: The message content is empty!"
  exit 1
fi

# Send the message
send_message_command="echo \"$message\" | wall"
eval "$send_message_command"

# Check if the message sending was successful
if [ $? -ne 0 ]; then
  echo "Error: Failed to send the message to user $user_name!"
  exit 1
fi

# Output message sent confirmation
echo "Message successfully sent to user $user_name"

Improvement explanation:

  1. Provides more detailed error messages to inform users of the specific cause of errors.
  2. Stores the message functionality enabled status in a variable to avoid reading the file each time.
  3. Stores the enabled users file path in the $enabled_users_file variable for easier modification.
  4. Uses the eval command to execute the message sending command, supporting variables in the message content.
  5. Checks the return value of the message sending command to ensure the sending process was successful.
  6. Error messages are output to the standard error stream, and the script exits using exit 1.
  • Title: Shell Scripts 2
  • Author: LHT
  • Created at : 2023-01-17 04:04:00
  • Link: https://blog.327774.xyz/2023/01/16/linux/shell/Shell Scripts 2/
  • License: This work is licensed under CC BY-NC-SA 4.0.
On this page
Shell Scripts 2
  1. read Console Input
  2. Functions
    1. System Functions
      1. basename
      2. dirname
    2. Custom Functions
    3. Additional Explanation
  3. Introduction to Regular Expressions
  4. Text Processing Tools
    1. cut
    2. awk
  5. Comprehensive Application Example
    1. Archive Files
    2. Send Message to a User Quickly