Functions

Functions allow you to encapsulate a set of actions within a reusable block of code. To create a function in Bash, you use the "function" keyword followed by the name of the function and the set of actions that it performs. For example:

function say_hello {
    echo "hello world"
}

say_hello

This creates a function called "say_hello" that simply prints the message "hello world" to the console. The function is then called using the function name "say_hello".

Understanding command arguments

In Bash scripting, every command receives arguments that can affect its behavior. Command arguments are simply additional pieces of information you provide to a command to help it perform a specific task. Understanding how these arguments work is essential to master Bash scripting.

What are Command Arguments?

Command arguments refer to the variables or values that are passed to a command script when it is executed. You can supply arguments to a command by typing them after the command name, separated by spaces. For example, the cp command uses its first argument as the source file to copy, while the second argument is the target file.

How are Command Arguments Used?

With command arguments, you can customize or refine a command’s behavior by adding specific options, values, or variables. For instance, if you want to list all files that end with .txt in a particular directory, you’d use the -l flag to show file details and pass the string *.txt as an argument to the ls command.

Positional Parameters for Command Arguments

To access command arguments from within a Bash script, you can make use of positional parameters. Positional parameters refer to the arguments passed to the script, and they are accessible via special variables like $1, $2, $3, and so on. For instance, the variable $1 holds the first positional parameter, $2 the second, $3 the third, and so on.

Using Default Values in Command Arguments

In Bash scripting, you can set default values for command arguments to avoid errors or unexpected behavior when no argument is given. To set default values, you can use conditionals and the ${var:-default} syntax to check if a variable exists and fallback to a default value if not.

Conclusion

Command arguments are an essential part of Bash scripting and can make your life much easier when working with different command scripts. Understanding how to use and manipulate command arguments in bash can help streamline your workflow and make you a more efficient developer.

Skipping the last argument in Bash

In Bash, the last argument of a command is often used as a file name, directory or other type of argument. However, there are situations where you want to skip the last argument and pass it to another command. Here are some easy code examples for you to try:

Using the shell parameter expansion

#!/bin/bash

args=("$@")
last_arg=${args[-1]}

some_command "${args[@]:0:${#args[@]}-1}"

other_command "${last_arg}"

This code sets up the list of arguments, saves the last argument to a variable, and finally passes all but the last argument to the first command, and the last argument to the second command.

Using shift

#!/bin/bash

some_command() {
    shift "$(($#-1))"
}

other_command() {
    last_arg="$1"
}

some_command "$@"
other_command "${@: -1}"

This code defines two functions, one that removes the last argument and one that retrieves the last argument.

Using xargs

#!/bin/bash

last_arg="$(echo $@ | rev | cut -d" " -f1 | rev)"
args="$(echo $@ | rev | cut -d" " -f2- | rev)"

echo $args | xargs -L 1 some_command
other_command "$last_arg"

This code uses xargs to create a new command line argument list with all but the last argument sent to some_command and the last argument sent to other_command.

By following these methods, you can save time and avoid repeating commands as well as avoid errors that might be caused by repeating arguments.

Example 1: Deleting files using wildcard

Deleting files manually can be time-consuming and tedious, especially when you have a large number of files to remove. Fortunately, Bash provides a quick and easy way to delete files using the wildcard (*).

Here's an example of how to delete all .txt files in a directory:

$ rm *.txt

This command tells Bash to delete all files in the current directory that have the .txt extension. The wildcard (*) matches any string of characters, which means that it will match any filename that ends with .txt.

Here are a few things to keep in mind when using the rm command with wildcards:

• Be careful! The rm command permanently deletes files, so make sure you're deleting the files you really want to get rid of.
• Always double-check your command before running it. It's easy to accidentally delete the wrong files if you're not paying attention.
• You can use other wildcards to match different types of filenames. For example, the question mark (?) matches any single character, and the square brackets ([ ]) can match a range of characters or a specific character.
  

  Example 2: Creating directories with default permissions

Creating directories with default permissions is a common task for bash scripts. With the use of the mkdir function in bash, it is possible to create directories and set default permissions for them. The permission settings can be specified using the octal notation, as three digits (rwx), or as a single digit (0-7).

To create directories with default permissions, use the following code:

mkdir -m <permissions> <directory>

Where <permissions> is the permission settings expressed in octal notation, and <directory> is the name of the directory you want to create.

For example, to create a directory with permission settings of 755:

$ mkdir -m 755 mydirectory

This creates a directory named mydirectory with permission settings of rwxr-xr-x.

Alternatively, you can specify the permission settings using the three-digit notation, as in:

$ mkdir -m u=rwx,g=rx,o=rx mydirectory

This creates a directory named mydirectory with permission settings of rwxr-xr-x.

In this example, u=rwx sets permissions for the user who creates the file, g=rx sets permissions for the group that the user belongs to, and o=rx sets permissions for all other users.

Creating directories with default permissions can be useful if you want to automate the process of creating directories with specific permission settings. It can also help to ensure that the directories you create are secure and accessible only to authorized users.

Example 3: Listing file sizes in human-readable format

In Bash, it's possible to list the sizes of files in a directory using the ls command and the --human-readable option. This option allows you to view the size of files in a readable format instead of the default bytes format. Here's an example:

ls -lh

This command will list the files in the current directory along with their sizes in human-readable format. The output will look something like this:

-rw-r--r-- 1 user user 171K Apr 10 16:45 example.txt
-rw-r--r-- 1 user user  32K Apr 10 16:46 anotherexample.txt

In this example, the files "example.txt" and "anotherexample.txt" are displayed along with their sizes in kilobytes (K). The sizes of the files are much easier to read and understand than they would be in the default bytes format.

Here's a breakdown of the different options used in the ls command:

• -l: This option displays the output in long format, which includes additional information such as the file permissions, owner, and modification date.
• -h: This option displays the file sizes in human-readable format, using units like kilobytes (K), megabytes (M), and gigabytes (G) instead of the default bytes format.

Using the ls command with the --human-readable option can be a useful way to quickly see the sizes of files in a directory without having to manually convert the sizes from bytes to a more readable format.

Conclusion

Skipping the last argument in Bash is a valuable skill for any developer to have in their toolkit. By using the examples and techniques outlined in this article, you can streamline your workflow and save valuable time on routine tasks.

Remember, the key to success is practice. Experiment with different commands and experiment with different parameters to see what works best for you. With continued practice and a solid understanding of Bash syntax, you'll be able to master this powerful scripting language and take your development skills to the next level. So get started today and see what Bash can do for you!