Don`t Waste Time Learn How to Skip the Last Argument in Bash with These Easy Code Examples

Table of content

  1. Introduction
  2. Bash scripting basics
  3. Understanding command arguments
  4. Skipping the last argument in Bash
  5. Example 1: Deleting files using wildcard
  6. Example 2: Creating directories with default permissions
  7. Example 3: Listing file sizes in human-readable format
  8. Conclusion


When it comes to writing scripts in Bash, sometimes you need to skip the last argument. This can be useful if you want to ignore certain options or if you only want to work with a subset of the arguments passed to your script. Fortunately, there are a few simple ways to do this in Bash, and in this article, we'll explore some code examples to show you how it's done.

If you're new to Bash scripting, it can be a bit overwhelming at first. The syntax and structure of Bash scripts can be quite different from other programming languages, and there are a lot of different functions and commands to learn. However, with a little bit of practice, you'll be able to master the basics of Bash scripting and start writing your own scripts in no time.

In this article, we assume that you have some basic knowledge of Bash scripting, including how to define and call functions, how to pass arguments to your scripts, and how to work with arrays. If you're not familiar with these concepts, you may want to review some introductory resources before diving into this article. But if you're ready to learn how to skip the last argument in Bash, read on!

Bash scripting basics

Bash scripting is a popular method of automating tasks on Linux and Unix systems. It allows developers to create executable scripts that can perform a wide range of functions, from simple data processing tasks to complex system management tasks.

In order to start writing Bash scripts, you first need to become familiar with some basic concepts.


Variables are used to store data that can be referenced later in the script. To create a variable in Bash, you simply assign a value to it using the "=" operator. For example:

foo="hello world"

This creates a variable called "foo" with the value "hello world". You can then reference this variable later in the script using "$foo".

Conditional Statements

Conditional statements allow you to control the flow of your script based on certain conditions. The most commonly used conditional statement in Bash is the "if" statement. For example:

if [ "$foo" == "hello world" ]; then
    echo "foo is set to hello world"

This checks whether the variable "foo" is set to the value "hello world". If it is, then the message "foo is set to hello world" is printed to the console.


Loops allow you to perform a set of actions repeatedly. There are two main types of loops in Bash: "for" loops and "while" loops. For example:

for i in {1..5}; do
    echo "This is iteration $i"

This creates a "for" loop that will iterate through the numbers 1 to 5. On each iteration, the message "This is iteration " is printed to the console.


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"


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.


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



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


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

other_command() {

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


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.


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!

Cloud Computing and DevOps Engineering have always been my driving passions, energizing me with enthusiasm and a desire to stay at the forefront of technological innovation. I take great pleasure in innovating and devising workarounds for complex problems. Drawing on over 8 years of professional experience in the IT industry, with a focus on Cloud Computing and DevOps Engineering, I have a track record of success in designing and implementing complex infrastructure projects from diverse perspectives, and devising strategies that have significantly increased revenue. I am currently seeking a challenging position where I can leverage my competencies in a professional manner that maximizes productivity and exceeds expectations.
Posts created 3193

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Posts

Begin typing your search term above and press enter to search. Press ESC to cancel.

Back To Top