Bash Scripting Fundamentals on Linuxize

Shebang Explained: #! in Bash and Shell Scripts

hello@linuxize.com (Linuxize) — Tue, 23 Jul 2019 20:31:47 +0100

When you run a script as an executable file, the operating system needs to know which program should read it. That instruction is usually written on the first line of the file as a shebang, which starts with #! followed by an interpreter path.

A shebang can point to Bash, a POSIX shell, Python, Perl, Node.js, AWK, or another interpreter. This guide explains how shebang lines work in general, then shows how to choose the right Bash shebang for shell scripts.

What Is a Shebang?

A shebang is the interpreter directive at the top of an executable script. It tells the kernel which program to use when you run the file directly, such as ./script.sh.

For example, this shebang tells the system to run the script with Bash:

sh
#!/bin/bash

The #! characters are sometimes called hashbang, sharp-bang, or pound-bang. In day-to-day shell scripting, shebang is the most common name.

If the script is not executable and you run it by passing it to an interpreter, the shebang is not used:

Terminal
bash script.sh

In that case, bash is already the interpreter.

Shebang Syntax

The shebang line takes the following form:

sh
#!interpreter [arguments]

The shebang must be the first line in the script.
It must start with #!.
Whitespace after #! is optional, but most scripts omit it.
The interpreter is usually an absolute path, such as /bin/sh or /bin/bash.
Interpreter arguments are optional.

Common examples include:

#!/bin/bash - Uses bash to parse the file.
#!/usr/bin/env perl - Uses the env command to find the path to the perl executable.
#!/usr/bin/env python3 - Executes the file using the python3 binary.

Common Shebang Lines

Shebang	Interpreter
`#!/bin/sh`	POSIX shell
`#!/bin/bash`	Bash using an absolute path
`#!/usr/bin/env bash`	Bash found through `$PATH`
`#!/usr/bin/env python3`	Python 3
`#!/usr/bin/env node`	Node.js
`#!/usr/bin/env perl`	Perl
`#!/usr/bin/env ruby`	Ruby
`#!/usr/bin/awk -f`	AWK

Use the shebang that matches the language and syntax used in the file. A script that uses Bash arrays, [[ ]], or brace expansion should not use #!/bin/sh.

Bash Shebang: /bin/bash vs /usr/bin/env bash

If a shebang is not specified and you run the script with ./script.sh, the kernel’s execve() call fails to find an interpreter and the calling shell attempts to run it as a shell script. In practice, this means the script is interpreted by /bin/sh, which may not support Bash-specific features. To ensure that your script is always interpreted with Bash, you need to specify the executable path using a shebang.

There are two ways to set the interpreter:

Using the absolute path to the bash binary:
sh
```
#!/bin/bash
```
Using the env utility:
sh
```
#!/usr/bin/env bash
```

The advantage of the second approach is that it searches for the bash executable in the user’s $PATH environment variable. If there is more than one path to bash, the first one found will be used. This makes scripts more portable across systems where Bash may not be installed at /bin/bash (such as FreeBSD or NixOS).

Passing Options to the Interpreter

When using the absolute path, you can pass options directly to the interpreter. For example, to run the script in debug mode:

sh
#!/bin/bash -x

When using env, you cannot pass options on the shebang line in the traditional way. Instead, use set inside the script:

sh
#!/usr/bin/env bash
set -x

On systems with coreutils 8.30+ (2018), you can use env -S to split arguments:

sh
#!/usr/bin/env -S bash -x

#!/bin/sh vs #!/bin/bash

These two shebangs are not interchangeable:

#!/bin/sh invokes the system’s POSIX-compliant shell. On Debian and Ubuntu, this is typically dash, a lightweight shell that lacks many Bash features.
#!/bin/bash invokes Bash specifically, giving you access to arrays, [[ ]] tests, {1..10} brace expansion, and other Bash-only features.

Use #!/bin/sh when your script only uses POSIX syntax and you want maximum portability. Use #!/bin/bash when your script relies on Bash-specific features.

Example Script

Create a simple script that uses a shebang and prints “Hello, World”. Open your text editor and create a file called hello_world:

Terminal
nano hello_world

hello_worldsh
#!/bin/bash

echo "Hello, World"

To be able to run the script without specifying the interpreter from the command line, you need to make the file executable :

Terminal
chmod +x hello_world

Now you can run the script by typing ./ followed by the script name:

Terminal
./hello_world

output

Hello, World

Overriding the Shebang

If for some reason you want to override the interpreter set in the shebang line, run the script by explicitly specifying the desired shell.

For example, to run a script that has #!/bin/sh specified in the shebang line using the bash shell, you would type:

Terminal
bash hello_world

Note that overriding the shell interpreter is not recommended, as it may lead to unexpected behavior.

Troubleshooting

bad interpreter: No such file or directory
The interpreter path in the shebang does not exist, or the file uses Windows CRLF line endings. Check the first line with head -n 1 script.sh, then verify the interpreter with command -v bash or ls -l /bin/bash.

/bin/bash^M: bad interpreter
The script was saved with Windows line endings, so Linux reads the carriage return as part of the interpreter path. Convert the file to Unix line endings with dos2unix script.sh or sed -i 's/\r$//' script.sh.

The script uses the wrong Bash path
Some systems use /bin/bash, while others may have Bash in another location. Check the path with command -v bash. If you need a more portable Bash shebang, use #!/usr/bin/env bash.

Bash syntax fails when the script runs with sh
If the script uses Bash-only syntax such as arrays, [[ ]], or brace expansion, use #!/bin/bash or #!/usr/bin/env bash. Running the same file with sh script.sh overrides the shebang and may fail.

Permission denied when running ./script.sh
The file is not executable. Add execute permission with chmod +x script.sh, then run it again with ./script.sh.

Quick Reference

Task	Command / Syntax
Shebang syntax	`#!interpreter [arguments]`
Bash shebang (absolute)	`#!/bin/bash`
Bash shebang (portable)	`#!/usr/bin/env bash`
POSIX shell shebang	`#!/bin/sh`
Python 3 shebang	`#!/usr/bin/env python3`
Pass options (absolute)	`#!/bin/bash -x`
Pass options (env)	`#!/usr/bin/env -S bash -x`
Make script executable	`chmod +x script.sh`
Run script	`./script.sh`
Override interpreter	`bash script.sh`
Find Bash path	`command -v bash`

FAQ

What does a shebang mean?
A shebang tells the operating system which interpreter should run an executable script. It starts with #! and is followed by the interpreter path.

What does #!/bin/bash mean?
It tells the operating system to use the Bash interpreter at /bin/bash to execute the script.

Should I use #!/bin/bash or #!/usr/bin/env bash?
Use #!/usr/bin/env bash for portability. It searches $PATH for Bash, which works across systems where Bash is not at /bin/bash. Use the absolute path when you need to pass interpreter options directly on the shebang line.

What happens if I omit the shebang?
The kernel cannot determine the interpreter, so the calling shell attempts to run the script itself. This typically results in the script being interpreted by /bin/sh, which may not support Bash-specific syntax.

Can I use a shebang with Python or other languages?
Yes. Use #!/usr/bin/env python3 for Python, #!/usr/bin/env node for Node.js, #!/usr/bin/env perl for Perl, and so on.

Conclusion

The shebang (#!) tells the operating system which interpreter to use when executing a script. Use #!/bin/bash or #!/usr/bin/env bash for Bash scripts, and choose a different interpreter when the script is written for another language. To learn all the ways to execute scripts, see our guide on how to run a Bash script .

How to Run a Bash Script in Linux

hello@linuxize.com (Linuxize) — Mon, 12 Jan 2026 20:10:10 +0100

If you use Linux, learning to run bash scripts is an important skill. Bash scripts help you automate tasks, manage your system, and make your work easier. There are several ways to execute a bash script, and the best method depends on what you need.

This article explains the different methods for running and executing bash scripts in Linux and how to resolve common issues. If you are new to Linux, start with our guide on basic Linux commands .

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Method	Command	When to use
Executable	`./script.sh`	Standard run after `chmod +x`
Bash interpreter	`bash script.sh`	No permission change needed
Source	`source script.sh` or `. script.sh`	Apply variables and functions to current shell
Background	`./script.sh &` or `nohup ./script.sh &`	Long-running tasks
Debug	`bash -x script.sh`	Trace each command before it runs

Making a Script Executable

The most common way to run a bash script is to make it executable and run it directly.

First, at the top of your script, add a shebang line that tells the system which interpreter to use:

script.shsh
#!/bin/bash

echo "Hello, World!"

Warning

The shebang must be on the first line of the file.

Use chmod to make the script executable:

Terminal
chmod +x script.sh

Now run the script by typing ./ followed by the script name:

Terminal
./script.sh

output

Hello, World!

The ./ tells the shell to look for the script in the current directory.

Running a Script with the Bash Interpreter

You can run a script by explicitly calling the bash interpreter. This method does not require the script to be executable:

Terminal
bash script.sh

This is handy if you cannot change file permissions or want to test a script quickly.

You can also use sh for POSIX-compatible scripts:

Terminal
sh script.sh

Sourcing a Script (Run in the Current Shell)

Sourcing a script runs it in the current shell session, not in a subshell. Use the source command or its shorthand .:

Terminal
source script.sh

Or:

Terminal
. script.sh

This is useful when the script sets environment variables or defines functions that you want to use in your current shell.

For example, if you have a script that sets a variable:

setenv.shsh
#!/bin/bash
export MY_VAR="Hello"

When running normally, the variable is not available in the current shell:

Terminal
./setenv.sh
echo $MY_VAR

The command prints no output because the variable is set only inside the child process.

When sourcing, the variable persists:

Terminal
source setenv.sh
echo $MY_VAR

output

Hello

Running Scripts in the Background

To run a script in the background , append & to the command:

Terminal
./script.sh &

For long-running scripts that should continue after you log out, use nohup :

Terminal
nohup ./script.sh &

Running Scripts with Debug Mode

To debug a script and see each command before it executes, use the -x flag:

Terminal
bash -x script.sh

output

+ echo 'Hello, World!'
Hello, World!

Other useful Bash flags include:

bash -n script.sh - Check syntax without running
bash -v script.sh - Print lines as they are read
bash -e script.sh - Exit immediately on error

Running Scripts from Anywhere

To run a script from any directory, you can either specify the full path or add the script to a directory in your $PATH .

A common approach is to create a ~/bin directory:

Terminal
mkdir -p ~/bin

Add it to your ~/.bashrc:

Terminal
export PATH="$HOME/bin:$PATH"

Move your script there and make it executable:

Terminal
mv script.sh ~/bin/
chmod +x ~/bin/script.sh

After reloading your shell or running source ~/.bashrc, you can run the script from anywhere:

Terminal
script.sh

Using /usr/bin/env in the Shebang

Instead of hardcoding the Bash path, you can use:

script.shsh
#!/usr/bin/env bash

echo "Hello, World!"

This approach is considered best practice because it works across different systems and respects the user’s environment.

Troubleshooting

Permission Denied

output

bash: ./script.sh: Permission denied

Make the script executable:

Terminal
chmod +x script.sh

Command Not Found

output

bash: script.sh: command not found

Use ./ prefix or provide the full path:

Terminal
./script.sh

Bad Interpreter

output

bash: ./script.sh: /bin/bash^M: bad interpreter

The file has Windows line endings. Convert it using:

Terminal
sed -i 's/\r$//' script.sh

Security Considerations

If you downloaded a script from the Internet, always check its contents before running it.
Be extra careful when running scripts as root.
Use restrictive permissions when you can.
Do not add the current directory (.) to $PATH.
Do not run a script unless you are sure it is safe.

Conclusion

A practical workflow is to keep your scripts in ~/bin, make them executable with chmod +x, and start each one with #!/usr/bin/env bash. Reach for source only when a script needs to set variables or define functions in your current shell.

Next, learn how to write your own with our guide on bash functions .

Bash Comments: Single-Line, Multiline, and Best Practices

hello@linuxize.com (Linuxize) — Wed, 02 Oct 2019 21:31:47 +1110

When writing Bash scripts, it is always a good practice to keep your code clean and easy to understand, which is essential for maintainability. You can achieve this by organizing code into logical blocks, using proper indentation, and choosing descriptive names for variables and functions.

One of the most effective ways to make your scripts understandable is to add meaningful comments. A comment is a human-readable explanation or annotation written within the shell script that Bash ignores during execution.

Why Comments Matter

Adding comments to your Bash scripts will save you a lot of time and effort when you look at your code in the future. If you want to modify a script you wrote months or years ago, you may not remember why you wrote a particular piece of code unless you added a comment.

Comments also help your teammates, collaborators, and system administrators quickly grasp the script’s purpose and logic without having to trace through every line.

When you have a complex regex or parameter substitution inside your script, a short comment describing what the code does is far more useful than a long explanation. Keep comments short and to the point; avoid explaining something that is already clear and straightforward to the reader.

How Bash Handles Comments

Bash treats everything from a # symbol (hash mark) to the end of the line as a comment and ignores it during execution.

The only exception is when the first line of the script starts with the #! characters. This sequence is called a shebang and tells the operating system which interpreter to use to parse the rest of the file.

The # comment syntax works the same way in other POSIX-compatible shells such as sh and zsh, so everything in this guide applies to shell scripts in general.

Single-Line Comments

Comments can be added at the beginning of a line or inline with other code:

sh
# This is a Bash comment.
echo "This is Code" # This is an inline Bash comment.

The blank space after the hash mark is not mandatory, but it improves readability.

If your text editor supports syntax highlighting, comments are usually displayed in green or grey.

Comments are also useful when testing a script. Instead of deleting lines or blocks, you can comment them out:

sh
# if [[ $VAR -gt 10 ]]; then
# echo "Variable is greater than 10."
# fi

Multiline and Block Comments in Bash

Unlike most programming languages, Bash has no built-in multiline or block comment syntax. There are two common approaches.

Multiple Single-Line Comments (Recommended)

The simplest and most portable way to write a multiline comment is to prefix each line with #:

sh
# This is the first line.
# This is the second line.

This is the recommended approach. It is clear, works in every shell, and editors with syntax highlighting will color each line as a comment.

HereDoc Block Comment

Another option is to use a HereDoc block that is not redirected to any command. Because nothing reads the input, it acts as a block comment placeholder:

sh
<< 'MULTILINE-COMMENT'
 Everything inside the
 HereDoc body is
 ignored by Bash
MULTILINE-COMMENT

This is a workaround, not a real built-in feature. The single quotes around the delimiter ('MULTILINE-COMMENT') are important: they prevent Bash from expanding variables and commands inside the block. To avoid unexpected behavior, prefer single-line comments for all normal commenting needs.

Best Practices

Use # followed by a space for readability: # comment, not #comment.
Write comments that explain why, not what; the code already shows what it does.
Add a header comment at the top of every script describing its purpose, author, and usage.
Comment out code during debugging rather than deleting it, so you can restore it easily.
Keep comments up to date; an outdated comment is worse than no comment.

Quick Reference

Syntax	Use case
`# comment`	Single-line or end-of-line comment
`echo "code" # comment`	Inline comment after a command
`# line1` / `# line2`	Multiline comment (recommended)
`<< 'EOF' ... EOF`	HereDoc block comment (workaround)
`#!` on line 1	Shebang: not a comment, sets the interpreter

For a printable quick reference, see the Bash cheatsheet .

FAQ

What is the correct syntax for a Bash comment?
Use the # character. Everything from # to the end of the line is ignored by Bash. Example: # This is a comment.

Does Bash support block comments?
Not natively. The most reliable way to write a block comment is to use multiple single-line comments, each starting with #. The HereDoc trick (<< 'EOF' ... EOF) works but is not a real language feature.

Can I comment out multiple lines at once?
Most text editors support block-comment shortcuts (for example, select lines and press Ctrl+/ in VS Code). In the terminal, prefix each line manually with #.

What is the difference between # and #!?
# starts a comment anywhere in a script. #! on the very first line is a shebang: it tells the operating system which interpreter to run the script with (for example, #!/bin/bash). The shebang is not treated as a comment by the OS.

Should I use HereDoc for block comments?
Only if you need to temporarily disable a large block and your editor does not support multi-line comment shortcuts. Always quote the delimiter ('EOF') to prevent variable expansion inside the block. For normal commenting, stick to #.

Conclusion

In Bash, the # character marks everything that follows it on the same line as a comment. For multiline blocks, use consecutive single-line comments; they are the clearest and most compatible approach. Well-commented scripts save time, reduce bugs, and make maintenance easier for everyone who works with them.

.bashrc vs .bash_profile: What is the Difference?

hello@linuxize.com (Linuxize) — Sun, 10 May 2020 20:21:42 +0100

When you open a terminal or log in to a Linux system, Bash reads and executes commands from a set of startup files. These files let you customize your shell environment: creating aliases , adding directories to $PATH , setting environment variables , and changing the shell prompt.

Which startup file Bash reads depends on whether the shell is a login or non-login shell. This guide explains the difference between .bashrc and .bash_profile, when each file is loaded, and where to put your customizations.

Interactive vs Non-Interactive Shells

A shell can be either interactive or non-interactive:

Interactive shell - A shell that reads input from the user and writes output to the terminal. This is what you use when you type commands at a prompt.
Non-interactive shell - A shell that runs without user interaction, such as when executing a Bash script . Non-interactive shells do not read .bashrc or .bash_profile.

An interactive shell can be either a login or a non-login shell:

Login shell - Invoked when you log in to the system. This includes logging in via SSH , logging in at a local console, or starting Bash with the --login option.
Non-login shell - Invoked when you open a new terminal window or tab in a graphical desktop, or when you type bash inside an existing shell.

You can check whether your current shell is a login shell by running:

Terminal
shopt login_shell

If the output is login_shell on, it is a login shell. If it is login_shell off, it is a non-login shell.

Startup File Loading Order

When Bash starts as an interactive login shell, it reads the following files in order:

/etc/profile - System-wide settings. This file usually sources scripts from /etc/profile.d/.
~/.bash_profile - User-specific login settings. If this file does not exist, Bash looks for ~/.bash_login, then ~/.profile, and executes commands from the first one it finds.

When Bash starts as an interactive non-login shell, it reads only:

~/.bashrc - User-specific shell settings.

The following table summarizes which files are read in each scenario:

Shell Type	Files Read
Interactive login (SSH, console, `bash --login`)	`/etc/profile` → `~/.bash_profile` (or `~/.bash_login` or `~/.profile`)
Interactive non-login (new terminal tab, typing `bash`)	`~/.bashrc`
Non-interactive (scripts)	None (unless `BASH_ENV` is set)

Difference Between .bashrc and .bash_profile

.bash_profile is executed once when you log in. .bashrc is executed every time you open a new interactive shell.

In practice, most users want their customizations to be available in every shell - both login and non-login. The standard approach is to put all your customizations in ~/.bashrc and have ~/.bash_profile source it:

~/.bash_profilesh
if [ -f ~/.bashrc ]; then
 . ~/.bashrc
fi

With this setup, both login and non-login shells load the same configuration.

Where to Put What

Customization	File	Reason
Aliases	`~/.bashrc`	Available in every interactive shell
Shell functions	`~/.bashrc`	Available in every interactive shell
Prompt customization (`PS1`)	`~/.bashrc`	Applied to every new shell
`$PATH` modifications	`~/.bashrc`	Loaded in every shell (when `.bash_profile` sources `.bashrc`)
Environment variables (`export`)	`~/.bashrc`	Available everywhere if sourced from `.bash_profile`
Commands to run once at login	`~/.bash_profile`	Run only during login (e.g., `ssh-agent`, startup messages)

.profile vs .bash_profile

Many Linux distributions use ~/.profile instead of ~/.bash_profile. The difference is:

~/.bash_profile - Read only by Bash.
~/.profile - Read by Bash and other POSIX-compatible shells (sh, dash).

If both ~/.bash_profile and ~/.profile exist, Bash reads only ~/.bash_profile and ignores ~/.profile. If you want ~/.profile to be read, either remove ~/.bash_profile or source ~/.profile from within it.

Ubuntu and Debian create ~/.profile by default and do not create ~/.bash_profile. Fedora and RHEL create ~/.bash_profile.

macOS Note

On macOS, Terminal.app and iTerm2 open login shells by default, which is the opposite of most Linux terminal emulators. This means ~/.bash_profile (or ~/.zprofile for zsh) is read every time you open a terminal window on macOS.

Since macOS Catalina (2019), the default shell on macOS is zsh, not Bash. The zsh equivalents are:

Bash File	Zsh Equivalent
`~/.bash_profile`	`~/.zprofile`
`~/.bashrc`	`~/.zshrc`

If any of these startup files do not exist on your system, you can create them .

Quick Reference

File	When Loaded	Use For
`/etc/profile`	Login shells	System-wide environment settings
`~/.bash_profile`	Login shells	User login settings, sourcing `.bashrc`
`~/.profile`	Login shells (if no `.bash_profile`)	Portable user login settings
`~/.bashrc`	Non-login interactive shells	Aliases, functions, prompt, PATH
`/etc/bash.bashrc` (Debian/Ubuntu) or `/etc/bashrc` (Fedora/RHEL)	Non-login interactive shells	System-wide shell settings

Troubleshooting

Aliases do not work when connecting via SSH
SSH opens a login shell, which reads ~/.bash_profile but not ~/.bashrc. Add . ~/.bashrc inside your ~/.bash_profile so that aliases are loaded in login shells as well.

PATH changes in .bashrc are not applied
Make sure ~/.bash_profile sources ~/.bashrc. Without this, login shells do not read ~/.bashrc and your PATH changes are ignored.

Changes to .bashrc do not take effect
After editing ~/.bashrc, either open a new terminal or run source ~/.bashrc to apply the changes in the current shell.

Both .bash_profile and .profile exist but only one is used
If ~/.bash_profile exists, Bash ignores ~/.profile. Either consolidate your settings into one file or have ~/.bash_profile source ~/.profile.

FAQ

Which file should I edit to add an alias?
Add aliases to ~/.bashrc. As long as ~/.bash_profile sources ~/.bashrc, your aliases will be available in both login and non-login shells.

Why does my terminal not read .bash_profile?
Most Linux terminal emulators (GNOME Terminal, Konsole, xfce4-terminal) open non-login shells, which read ~/.bashrc instead of ~/.bash_profile. Only SSH sessions, console logins, and bash --login trigger a login shell.

What is the difference between source and .?
They are equivalent. Both execute commands from a file in the current shell. . ~/.bashrc and source ~/.bashrc do the same thing. The . syntax is POSIX-compatible, while source is a Bash extension.

Does .bashrc run when I execute a script?
No. Scripts run in a non-interactive shell, which does not read ~/.bashrc unless the script explicitly sources it or the BASH_ENV variable is set to point to it.

Where should I put environment variables for GUI applications?
GUI applications do not read .bashrc or .bash_profile. On systemd-based systems, put environment variables in ~/.config/environment.d/*.conf or set them in your desktop environment settings.

Conclusion

.bash_profile is read by login shells and .bashrc is read by non-login interactive shells. The simplest setup is to put all your customizations in ~/.bashrc and have ~/.bash_profile source it. This way, your aliases, PATH, and environment variables are available in every interactive shell.

Bash Positional Arguments: How to Use $1, $2, $@, and shift

hello@linuxize.com (Linuxize) — Wed, 28 Jan 2026 09:20:00 +0100

Positional parameters are Bash variables that store the arguments given to a script or function. They help you to write flexible and convenient scripts that can accept input from the command line.

Understanding positional arguments is essential for writing useful Bash scripts. In this guide, you will learn how to access and work with command-line arguments in your scripts. If you are new to the command line, start with our guide on basic Linux commands .

What Are Bash Positional Arguments?

In Bash documentation, these values are called positional parameters, while many users refer to them as positional arguments because they hold the arguments passed by position.

When you run a script with arguments, Bash assigns each argument to a numbered variable called a positional parameter:

Terminal
./script.sh arg1 arg2 arg3

In this example:

$0 contains the script name (./script.sh)
$1 contains the first argument (arg1)
$2 contains the second argument (arg2)
$3 contains the third argument (arg3)

Accessing Positional Parameters

Basic Parameters ($1, $2, $3, …)

The most common way to access arguments is through $1, $2, $3, and so on:

~/greet.shsh
#!/bin/bash

echo "Hello, $1!"
echo "You are from $2."

Run the script:

Terminal
./greet.sh Leah Seattle

output

Hello, Leah!
You are from Seattle.

Parameters Beyond $9

For parameters beyond $9, use curly braces:

sh
echo "The tenth argument is: ${10}"
echo "The eleventh argument is: ${11}"

If you do not use braces, $10 would be interpreted as $1 followed by a literal 0.

Special Parameter Variables

Bash provides several special variables for working with positional parameters:

Variable	Description
`$0`	The name of the script
`$1` - `$9`	The first 9 arguments
`${10}` …	Arguments 10 and beyond
`$#`	The number of arguments
`$@`	All arguments as separate words
`$*`	All arguments as a single word

The Script Name ($0)

The $0 variable contains the name of the script as it was called:

~/showname.shsh
#!/bin/bash

echo "This script is called: $0"

Terminal
./showname.sh

output

This script is called: ./showname.sh

Counting Arguments ($#)

The $# variable holds the number of arguments passed to the script:

~/count.shsh
#!/bin/bash

echo "You provided $# arguments."

Terminal
./count.sh one two three

output

You provided 3 arguments.

This is helpful when you want to check if the right number of arguments was given:

~/validate.shsh
#!/bin/bash

if [ $# -lt 2 ]; then
 echo "Usage: $0 <source> <destination>"
 exit 1
fi

echo "Copying from $1 to $2"

All Arguments ($@ and $*)

Both $@ and $* represent all arguments, but they behave differently when quoted.

Without quotes, they are identical:

sh
for arg in $@; do echo "$arg"; done
for arg in $*; do echo "$arg"; done

With quotes, they behave differently:

"$@" expands to "$1" "$2" "$3" (separate strings)
"$*" expands to "$1 $2 $3" (single string)

~/compare.shsh
#!/bin/bash

echo "Using \"\$@\":"
for arg in "$@"; do
 echo " - $arg"
done

echo ""
echo "Using \"\$*\":"
for arg in "$*"; do
 echo " - $arg"
done

Terminal
./compare.sh "hello world" foo bar

output

Using "$@":
- hello world
- foo bar
Using "$*":
- hello world foo bar

Notice that "$@" preserved “hello world” as a single argument, while "$*" joined everything into one string.

Best practice: Use "$@" when you need to pass arguments to another command or iterate over them individually.

The `shift` Command

The shift built-in command removes the first positional parameter and shifts all others down by one:

$2 becomes $1
$3 becomes $2
And so on…

~/shift_example.shsh
#!/bin/bash

echo "Before shift:"
echo " \$1 = $1"
echo " \$2 = $2"
echo " \$3 = $3"

shift

echo ""
echo "After shift:"
echo " \$1 = $1"
echo " \$2 = $2"
echo " \$3 = $3"

Terminal
./shift_example.sh apple banana cherry

output

Before shift:
$1 = apple
$2 = banana
$3 = cherry
After shift:
$1 = banana
$2 = cherry
$3 =

Shifting Multiple Positions

You can also use shift to move the positional parameters by more than one position at a time:

sh
shift 3

Processing All Arguments with shift

The shift command is useful for processing arguments one at a time:

~/process_all.shsh
#!/bin/bash

while [ $# -gt 0 ]; do
 echo "Processing: $1"
 shift
done

echo "Done. All arguments processed."

Terminal
./process_all.sh file1.txt file2.txt file3.txt

output

Processing: file1.txt
Processing: file2.txt
Processing: file3.txt
Done. All arguments processed.

Practical Examples

Example 1: File Backup Script

Here is a script that backs up a file to a directory you choose:

~/backup.shsh
#!/bin/bash

# Check for required arguments
if [ $# -ne 2 ]; then
 echo "Usage: $0 <file> <backup_dir>"
 exit 1
fi

SOURCE="$1"
BACKUP_DIR="$2"

# Check if the source file exists
if [ ! -f "$SOURCE" ]; then
 echo "Error: File '$SOURCE' not found."
 exit 1
fi

# Create a backup directory if it does not exist
mkdir -p "$BACKUP_DIR"

# Create backup with timestamp
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
FILENAME=$(basename "$SOURCE")
cp "$SOURCE" "$BACKUP_DIR/${FILENAME}.${TIMESTAMP}.bak"

echo "Backup created: $BACKUP_DIR/${FILENAME}.${TIMESTAMP}.bak"

Create a test file and run the script:

Terminal
echo "example" > report.txt
./backup.sh report.txt backups

output

Backup created: backups/report.txt.20260429_092000.bak

Example 2: Simple Calculator

This script does simple arithmetic calculations:

~/calc.shsh
#!/bin/bash

if [ $# -ne 3 ]; then
 echo "Usage: $0 <number1> <operator> <number2>"
 echo "Operators: + - x /"
 exit 1
fi

NUM1=$1
OP=$2
NUM2=$3

case $OP in
 +) RESULT=$((NUM1 + NUM2)) ;;
 -) RESULT=$((NUM1 - NUM2)) ;;
 x) RESULT=$((NUM1 * NUM2)) ;;
 /) RESULT=$((NUM1 / NUM2)) ;;
 *) echo "Unknown operator: $OP"; exit 1 ;;
esac

echo "$NUM1 $OP $NUM2 = $RESULT"

Terminal
./calc.sh 10 + 5
./calc.sh 20 x 3

output

10 + 5 = 15
20 x 3 = 60

Example 3: Processing Command-Line Options

This script shows how to handle flags and arguments:

~/options.shsh
#!/bin/bash

VERBOSE=false
OUTPUT=""

while [ $# -gt 0 ]; do
 case $1 in
 -v|--verbose)
 VERBOSE=true
 shift
 ;;
 -o|--output)
 if [ -z "$2" ]; then
 echo "Error: --output requires a file name"
 exit 1
 fi
 OUTPUT="$2"
 shift 2
 ;;
 -h|--help)
 echo "Usage: $0 [-v] [-o output_file] [files...]"
 exit 0
 ;;
 -*)
 echo "Unknown option: $1"
 exit 1
 ;;
 *)
 break
 ;;
 esac
done

# The remaining arguments are files
if [ "$VERBOSE" = true ]; then
 echo "Verbose mode enabled"
 echo "Output file: ${OUTPUT:-stdout}"
 echo "Files to process: $@"
fi

for file in "$@"; do
 echo "Processing: $file"
done

Positional Parameters in Functions

You can use positional parameters inside functions, too. Each function gets its own set of these parameters:

~/func_params.shsh
#!/bin/bash

greet() {
 echo "Hello, $1! You are $2 years old."
}

# Script arguments
echo "Script name: $0"
echo "Script argument 1: $1"

# Function arguments (separate from script arguments)
greet "Zoe" 30
greet "Luca" 25

Terminal
./func_params.sh test_arg

output

Script name: ./func_params.sh
Script argument 1: test_arg
Hello, Zoe! You are 30 years old.
Hello, Luca! You are 25 years old.

Default Values for Parameters

You can set default values for parameters if they are not provided:

~/defaults.shsh
#!/bin/bash

NAME="${1:-Guest}"
GREETING="${2:-Hello}"

echo "$GREETING, $NAME!"

Terminal
./defaults.sh
./defaults.sh Leah
./defaults.sh Leah "Good morning"

output

Hello, Guest!
Hello, Leah!
Good morning, Leah!

The syntax ${VAR:-default} returns default if VAR is unset or empty.

Conclusion

Positional parameters let Bash scripts read command-line arguments through variables such as $1, $2, $#, and "$@". Use shift when you need to process arguments one at a time, and always validate the expected arguments before using them. For more details on executing scripts, see our guide on how to run a bash script .

echo Command in Linux: Print Text and Variables

hello@linuxize.com (Linuxize) — Wed, 17 Apr 2019 20:31:47 +0100

The echo command is one of the most basic and frequently used commands in Linux. It prints its arguments to the standard output.

echo is commonly used in shell scripts to display messages or output the results of other commands. This guide covers the Bash builtin version of echo with practical examples.

Syntax

txt
echo [OPTIONS] [ARGUMENTS]

echo is a shell builtin in Bash and most other popular shells like Zsh and Ksh. There is also a standalone /usr/bin/echo utility, but the shell builtin version takes precedence.

The available options are:

-n - Do not output a trailing newline.
-e - Enable interpretation of backslash escape sequences.
-E - Disable interpretation of escape sequences (this is the default).

When -e is used, the following escape sequences are recognized:

\\ - Backslash.
\a - Alert (BEL).
\b - Backspace.
\c - Suppress further output.
\e - Escape character.
\f - Form feed.
\n - New line.
\r - Carriage return.
\t - Horizontal tab.
\v - Vertical tab.

Display a String

To display a simple line of text, pass it as an argument to echo:

Terminal
echo Hello, World!

output

Hello, World!

The command prints the text exactly as it was passed to echo and adds a newline at the end.

Although not required, it is a good practice to enclose arguments in double or single quotes. When using single quotes '', the literal value of each character is preserved and variables are not expanded.

Display Strings with Quotes

To print a double quote, enclose the text within single quotes or escape it with a backslash:

Terminal
echo 'Hello "Linuxize"'
echo "Hello \"Linuxize\""

output

Hello "Linuxize"
Hello "Linuxize"

Both commands print the same text. The first one uses single quotes around the full string, and the second one escapes the double quotes with backslashes.

To print a single quote, enclose the text within double quotes:

Terminal
echo "I'm a Linux user."

output

I'm a Linux user.

Because the string is enclosed in double quotes, the single quote is printed as a regular character.

Use Escape Characters

Use the -e option to enable interpretation of escape sequences. In the following example, we are using \n for a new line and \t for a horizontal tab:

Terminal
echo -e "You know nothing, Jon Snow.\n\t- Ygritte"

output

You know nothing, Jon Snow.
- Ygritte

The \n sequence moves the second part of the text to a new line, and \t adds a tab before the attribution.

Suppress the Trailing Newline

By default, echo appends a newline character at the end of the output. Use the -n option to suppress it:

Terminal
echo -n "Hello, " && echo "World!"

output

Hello, World!

This is useful when building prompts or combining multiple outputs on a single line inside a script.

Display Variables

echo can display shell variables . In the following example, we are printing the name of the currently logged-in user:

Terminal
echo "Current user: $USER"

output

Current user: linuxize

The shell expands $USER before running echo, so the command prints the value of the current user’s login name.

Display Command Output

Use the $(command) expression to include command output in the echo argument. The following command displays the current date :

Terminal
echo "The date is: $(date +%D)"

output

The date is: 04/17/19

The command substitution runs date +%D first, then echo prints the returned date as part of the string.

Use Pattern Matching

The shell expands wildcard characters before passing arguments to echo. For example, the following command returns the names of all .php files in the current directory:

Terminal
echo The PHP files are: *.php

output

The PHP files are: index.php contact.php functions.php

The shell expands *.php to matching filenames before echo receives the arguments.

Redirect Output to a File

Instead of displaying the output on the screen, you can redirect it to a file using the > or >> operators:

Terminal
echo "First line" > /tmp/file.txt
echo "Second line" >> /tmp/file.txt

When using >, the file is overwritten. The >> operator appends the output to the file . If the file does not exist, both operators create it.

Use the cat command to verify the contents:

Terminal
cat /tmp/file.txt

output

First line
Second line

The output confirms that the first command created the file and the second command appended a new line to it.

Write to Standard Error

To send output to standard error instead of standard output, redirect file descriptor 1 to 2:

Terminal
echo "Error: something went wrong" >&2

This is useful in scripts where you need to separate error messages from normal output. For more details, see how to redirect stderr to stdout in Bash .

Display Colored Output

Use ANSI escape sequences to change the foreground and background colors or set text properties such as bold and underline:

Terminal
echo -e "\033[1;37mWHITE"
echo -e "\033[0;30mBLACK"
echo -e "\033[0;34mBLUE"
echo -e "\033[0;32mGREEN"
echo -e "\033[0;36mCYAN"
echo -e "\033[0;31mRED"
echo -e "\033[0;35mPURPLE"
echo -e "\033[0;33mYELLOW"
echo -e "\033[1;30mGRAY"

Quick Reference

Task	Command
Print a string	`echo "text"`
Print without trailing newline	`echo -n "text"`
Print with escape sequences	`echo -e "line1\nline2"`
Print a variable	`echo "$VAR"`
Print command output	`echo "$(command)"`
Write to a file (overwrite)	`echo "text" > file.txt`
Append to a file	`echo "text" >> file.txt`
Write to stderr	`echo "error" >&2`

FAQ

What does the echo command do in Linux?
The echo command prints its arguments to standard output. It is most commonly used in shell scripts to display messages, show the value of a variable, or write a line of text to a file. By default, echo also adds a newline at the end of the output.

What is the difference between echo and printf?
echo automatically adds a trailing newline and has limited formatting options. printf supports format specifiers (like %s, %d) and does not add a newline unless you include \n. Use printf when you need precise control over output formatting.

How do I print a newline with echo?
Use the -e option with the \n escape sequence: echo -e "line1\nline2". Without -e, the backslash sequence is printed literally.

How do I echo without a newline?
Use the -n option: echo -n "text". This suppresses the trailing newline character.

Why does echo behave differently on macOS?
echo options and escape handling are not fully portable across shells and systems. Use printf when you need consistent behavior across Linux, macOS, and other Unix-like systems.

Conclusion

The echo command prints text to the terminal and is one of the most commonly used commands in Bash scripts. Use -n to suppress the trailing newline and -e to interpret escape sequences. For more advanced formatting, consider using printf .

In scripts that need predictable formatting, use echo for simple messages and printf when spacing, newlines, or escape handling must be exact.

Bash printf Command

hello@linuxize.com (Linuxize) — Sun, 31 May 2020 20:11:34 +0100

When writing Bash scripts, echo is commonly used for printing to standard output. While simple and convenient, echo is limited in its capabilities and formatting control.

To have more control over the output formatting, use the printf command instead.

The printf command behaves similarly to the C printf() function and gives you more control over formatting.

The `printf` Command

printf is a shell builtin in Bash and in other popular shells like Zsh and Ksh. There is also a standalone /usr/bin/printf binary, but the shell built-in version takes precedence.

We will cover the Bash builtin version of printf.

The syntax for the printf command is as follows:

txt
printf [-v var] format [arguments...]

The -v option tells printf not to print the output but to assign it to the variable (var).

The format is a string that may contain three different types of objects:

Regular characters are printed to the output as-is.
Backslash-escaped characters are interpreted and then printed.
Conversion specifiers that describe the format and are replaced by the values of respective arguments that follow the format string.

arguments are values that replace the specifiers in the format string.

The command accepts any number of arguments.

If more arguments than format specifiers are provided, the format string is reused to consume all of the arguments.
If fewer arguments than format specifiers are supplied, the extra numeric-format specifiers are set to zero value, while string-format specifiers are set to a null string.

Below are a few points to consider when passing arguments to the printf command:

The shell will expand all variables, perform wildcard matching, and handle special characters before passing the arguments to the printf command.
When using single quotes '', the literal value of each character enclosed within the quotes will be preserved. Variables and commands will not be expanded.

Unlike echo, the printf command does not automatically add a newline character (\n) at the end of the line. You must include \n explicitly.

A typical example of using printf looks like:

Terminal
printf "Open issues: %s\nClosed issues: %s\n" "34" "65"

output

Open issues: 34
Closed issues: 65

The string Open issues: %s\nClosed issues: %s\n is the format, while “34” and “65” are arguments. The format string contains two newline characters (\n) and two format specifiers (%s) that are replaced with the arguments.

Backslash Escapes

The backslash-escaped characters are interpreted when used in the format string or in an argument corresponding to a %b conversion specifier. Here is a list of the most common escape characters:

\\ - Displays a backslash character.
\b - Displays a backspace character.
\n - Displays a new line.
\r - Displays a carriage return.
\t - Displays a horizontal tab.
\v - Displays a vertical tab.

Conversion Specifiers

A conversion specification takes the following form:

txt
%[flags][width][.precision]specifier

Each conversion specification starts with the percent sign (%), includes optional modifiers, and ends with one of the following letters that represent the data type (specifier) of the corresponding argument: aAbcdeEfgGioqsuxX.

Type conversion specifier

The type conversion specifier is a character that specifies how to interpret the corresponding argument. This character is required and is placed after the optional fields.

Below is a list showing all type conversions and what they do:

%b - Print the argument while expanding backslash escape sequences.
%q - Print the argument shell-quoted, reusable as input.
%d, %i - Print the argument as a signed decimal integer.
%u - Print the argument as an unsigned decimal integer.
%o - Print the argument as an unsigned octal integer.
%x, %X - Print the argument as an unsigned hexadecimal integer. %x prints lower-case letters and %X prints upper-case.
%e, %E - Print the argument as a floating-point number in exponential notation. %e prints lower-case letters and %E prints upper-case.
%a, %A - Print the argument as a floating-point number in hexadecimal fractional notation. %a prints lower-case letters and %A prints upper-case.
%g, %G - Print the argument as a floating-point number in normal or exponential notation, whichever is more appropriate for the given value and precision. %g prints lower-case letters and %G prints upper-case.
%c - Print the argument as a single character.
%f - Print the argument as a floating-point number.
%s - Print the argument as a string.
%% - Print a literal % symbol.

An unsigned number represents zero and positive numbers, while a signed number represents negative, zero, and positive numbers.

The following command prints the number 100 in three different numeral systems (Multiple bases):

Terminal
printf "Decimal: %d\nHex: %x\nOctal: %o\n" 100 100 100

output

Decimal: 100
Hex: 64
Octal: 144

Flags directive

Flags are the first optional modifiers and are used to set the justification, leading zeros, prefixes, etc.

Here are the most common ones:

- - Left-align the printed text within the field. By default, the text is right-aligned.
+ - Prefix the numbers with a + or - sign. By default, only negative numbers are prefixed with a negative sign.
0 - Pads numbers with leading zeros rather than spaces.
blank - Prefix the positive numbers with a blank space and negative numbers with a minus (-).
# - An alternative format for numbers.

Width directive

The width directive field, placed after any flag characters, specifies the minimum number of characters the conversion should produce.

If the output text width is less than the specified width, it is padded with spaces. The width can be specified as a non-negative decimal integer or an asterisk (*).

Here is an example:

Terminal
printf "%20s %d\n" Mark 305

%20s means set the field to at least 20 characters long. Blanks are added before the text because, by default, the output is right-justified. To align the text to the left, use the - flag (%-20s).

output

 Mark 305

When an asterisk (*) is used as a width directive, then the width of the conversion field is set by a width argument that precedes the argument that’s being formatted.

In the example below, we’re setting the width to 10:

Terminal
printf "%0*d" 10 5

0 is a flag that pads the number with leading zeros instead of blanks. The output text will have at least 10 characters:

output

0000000005

Precision directive

The .precision modifier consists of a dot (.) followed by a positive integer or asterisk (*) which, depending on the specifier type, sets the number of string or digit characters or the number of decimal places to be printed.

The precision has the following effect:

If the conversion type is an integer, the precision specifies the minimum number of digits to be printed. If the number of digits in the argument is less than the precision, leading zeros are printed.
If the conversion type is floating-point, the precision specifies the number of digits after the decimal point. The default precision is 6.
If the conversion type is a string, the precision specifies the maximum number of characters to be printed. If the number of characters in the argument is greater than the precision, the excess characters are truncated.

Here is an example showing how to round a floating-point number to 3 decimals:

Terminal
printf "%.3f" 1.61803398

output

1.618

When precision is set to an asterisk (*), its value is set by the precision argument that precedes the argument being formatted.

Terminal
printf "%.*f" 3 1.61803398

output

1.618

Practical Tips

Always quote the format string to prevent unwanted globbing or variable expansion.
Prefer single quotes for literal formats unless you need variable expansion inside the format string itself.
Use printf -v var format args to store formatted output in a variable instead of printing it.
Use \n explicitly to end lines — unlike echo, printf does not add a newline automatically.
To print a literal %, use %%.

Quick Reference

Format / Option	Description
`%s`	String
`%d` / `%i`	Signed decimal integer
`%f`	Floating-point number
`%e` / `%E`	Floating-point in exponential notation
`%o`	Octal integer
`%x` / `%X`	Hexadecimal integer
`%c`	Single character
`%%`	Literal `%`
`%b`	String with backslash escapes expanded
`%Ns`	Right-align string in field of width N
`%-Ns`	Left-align string in field of width N
`%.Nf`	Float with N decimal places
`%0Nd`	Integer padded with leading zeros to width N
`-v var`	Store output in variable instead of printing

FAQ

What is the difference between printf and echo in Bash? echo is simpler but inconsistent across shells — its handling of escape sequences and the -e flag varies. printf behaves consistently, supports precise formatting with conversion specifiers, does not add a trailing newline unless you include \n, and works the same way across Bash, Zsh, and Ksh.

Why does my printf output appear on one line with no newlines? printf does not add a newline at the end of output automatically. Add \n in the format string wherever you need a line break: printf "line one\nline two\n".

How do I store printf output in a variable? Use the -v flag: printf -v myvar "Hello, %s" "$name". This assigns the formatted string to myvar without printing it. It is faster than using a subshell with myvar=$(printf ...).

Can printf repeat a format string for multiple arguments? Yes. If you provide more arguments than format specifiers, printf reuses the format string until all arguments are consumed. For example, printf "%s\n" one two three prints each word on its own line.

Conclusion

printf is the reliable choice when output formatting matters in a Bash script. Use %s for strings, %d for integers, %f for floats, and width and precision modifiers to align tabular output. For a broader look at printing in Bash, see the echo command guide .

Bash String Concatenation: Combine Variables and Strings

hello@linuxize.com (Linuxize) — Fri, 22 Mar 2019 23:31:47 +0100

One of the most commonly used string operations in Bash is concatenation — joining two or more strings together by placing one after another.

This article covers the main ways to concatenate strings in Bash with practical examples.

Concatenating Strings with Juxtaposition

The simplest way to concatenate strings is to place variables next to one another:

sh
VAR1="Hello,"
VAR2=" World"
VAR3="$VAR1$VAR2"
echo "$VAR3"

output

Hello, World

You can also mix variables with literal strings:

sh
VAR1="Hello,"
VAR2="${VAR1} World"
echo "$VAR2"

output

Hello, World

In the example above, VAR1 is enclosed in curly braces. This is required when a variable is immediately followed by a character that could be part of a valid variable name. Without the braces, Bash tries to expand the entire token as a single variable:

sh
VAR="Hello"
echo "$VARWorld" # expands $VARWorld, which is empty
echo "${VAR}World" # expands $VAR, then appends World

output


HelloWorld

Always quote variables in double quotes to prevent word splitting and glob expansion. Use single quotes when you want to suppress variable expansion entirely — characters inside single quotes are treated as literals.

Bash does not distinguish variable types; variables are treated as integers or strings depending on context. Concatenating a variable that contains only digits works the same way:

sh
VAR1="Hello, "
VAR2=2
VAR3=" Worlds"
VAR4="$VAR1$VAR2$VAR3"
echo "$VAR4"

output

Hello, 2 Worlds

Appending Strings with the `+=` Operator

The += operator appends a string to the end of an existing variable:

sh
VAR1="Hello,"
VAR1+=" World"
echo "$VAR1"

output

Hello, World

The += operator is particularly useful in loops for building up a string incrementally. The following example uses it in a bash for loop to join a list of words:

languages.shsh
VAR=""
for ELEMENT in 'Hydrogen' 'Helium' 'Lithium' 'Beryllium'; do
 VAR+="${ELEMENT} "
done

echo "$VAR"

output

Hydrogen Helium Lithium Beryllium

Concatenating Strings with printf

The printf command with -v formats and assigns a string directly to a variable without spawning a subshell:

sh
VAR1="Hello,"
VAR2=" World"
printf -v VAR3 '%s%s' "$VAR1" "$VAR2"
echo "$VAR3"

output

Hello, World

This approach is especially useful when you need to include a separator or control the format precisely:

sh
printf -v RESULT '%s, %s' "Hello" "World"
echo "$RESULT"

output

Hello, World

Unlike a command substitution such as VAR=$(printf ...), printf -v does not fork a subshell, making it slightly more efficient in tight loops.

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Method	Example
Juxtaposition	`VAR3="$VAR1$VAR2"`
Curly brace delimiters	`VAR3="${VAR1}suffix"`
`+=` operator	`VAR1+=" World"`
`printf -v`	`printf -v VAR3 '%s%s' "$VAR1" "$VAR2"`
With separator	`printf -v VAR3 '%s, %s' "$VAR1" "$VAR2"`

Troubleshooting

Variable value does not appear in the concatenated string You are likely using single quotes. Single quotes suppress all variable expansion. Change '$VAR1$VAR2' to "$VAR1$VAR2" to allow expansion.

Concatenated string breaks on spaces The variable is not quoted when used. Always use double quotes around variables: echo "$VAR". Without quotes, Bash performs word splitting on spaces, which can break the value into separate arguments.

${VAR}text does not expand as expected Use braces when appending literal text directly after a variable name. Write "${VAR}text" instead of "$VARtext" so Bash does not treat it as a different variable name. Also verify the variable is set with echo "${VAR}" before concatenating.

FAQ

How do I concatenate strings with a custom separator? Use printf -v: printf -v RESULT '%s-%s' "$VAR1" "$VAR2" produces value1-value2. For a comma-separated list built in a loop, append ${ELEMENT}, inside the loop and trim the trailing comma afterwards.

How do I include a newline between two strings? Use $'\n' as the separator: VAR3="$VAR1"$'\n'"$VAR2". Alternatively, use printf -v VAR3 '%s\n%s' "$VAR1" "$VAR2".

Can I concatenate command output with a string? Yes. Use command substitution: VAR="Today is $(date +%F)". The output of the command replaces $(...) and is joined with the surrounding string.

What is the difference between double and single quotes in concatenation? Double quotes allow variable expansion and command substitution. Single quotes treat everything literally. "$VAR World" expands $VAR, while '$VAR World' outputs the literal text $VAR World.

Conclusion

Bash offers three main ways to concatenate strings: placing variables side by side, using the += operator to append, and using printf -v for formatted joins. For comparing strings in Bash , see the linked guide.

If you have any questions, feel free to leave a comment below.

Bash String Manipulation: Substring, Replace, Length, and More

hello@linuxize.com (Linuxize) — Mon, 18 May 2026 10:30:00 +0200

When you write Bash scripts, many small text tasks do not need sed, awk, or another external command. Parameter expansion can extract part of a string, replace text, strip a prefix, or change case directly inside ${}.

This guide covers the most useful string operations with practical examples for each one.

String Length

Get the number of characters in a variable using ${#variable}:

Terminal
filename="backup-2026-04-14.tar.gz"
echo "${#filename}"

output

This returns the character count. For strings that contain only ASCII characters, the character count and byte count are the same.

Extracting a Substring

Use ${variable:offset:length} to extract part of a string:

Terminal
str="Hello, World"
echo "${str:7:5}"

output

World

The offset is zero-based, so 7 starts at the eighth character. 5 is how many characters to return.

Omit the length to extract from the offset to the end of the string:

Terminal
echo "${str:7}"

output

World

Negative offsets count from the end of the string. Note the space before the minus sign; it is required to avoid being interpreted as the :- default value syntax:

Terminal
echo "${str: -5}"

output

World

Replacing a Substring

Use ${variable/pattern/replacement} to replace the first match of a pattern:

Terminal
path="/var/log/app/error.log"
echo "${path/log/logs}"

output

/var/logs/app/error.log

Only the first occurrence is replaced. To replace every occurrence, double the forward slash:

Terminal
echo "${path//log/logs}"

output

/var/logs/app/error.logs

Leave the replacement empty to delete a substring:

Terminal
version="v1.2.3"
echo "${version/v/}"

output

1.2.3

The pattern supports glob characters: * matches any sequence of characters, ? matches a single character, and [...] matches a character class.

Removing a Prefix

Use # to remove a prefix from the beginning of a string. The shortest matching prefix is removed:

Terminal
file="photo.backup.tar.gz"
echo "${file#*.}"

output

backup.tar.gz

Use ## to remove the longest possible matching prefix:

Terminal
echo "${file##*.}"

output

gz

A common use is stripping a directory path to get just the filename:

Terminal
filepath="/home/user/documents/report.pdf"
echo "${filepath##*/}"

output

report.pdf

Removing a Suffix

Use % to strip a suffix from the end of a string. The shortest match is removed:

Terminal
file="photo.backup.tar.gz"
echo "${file%.*}"

output

photo.backup.tar

Use %% for the longest match:

Terminal
echo "${file%%.*}"

output

photo

Combining prefix and suffix removal is a clean way to extract a bare filename from a path:

Terminal
filepath="/home/user/documents/report.pdf"
base="${filepath##*/}"
name="${base%.*}"
echo "$name"

output

report

Changing Case

Convert a string to uppercase with ^^:

Terminal
greeting="hello, world"
echo "${greeting^^}"

output

HELLO, WORLD

Convert to lowercase with ,,:

Terminal
input="Hello World"
echo "${input,,}"

output

hello world

To capitalize only the first character, use a single ^:

Terminal
word="linux"
echo "${word^}"

output

Linux

To lowercase only the first character, use a single ,:

Terminal
word="LINUX"
echo "${word,}"

output

lINUX

Case conversion requires Bash 4.0 or newer. The default shell on older macOS systems ships with Bash 3.2 and does not support these operators. As a portable alternative, use tr:

Terminal
echo "$greeting" | tr '[:lower:]' '[:upper:]'

Checking if a String Contains a Substring

Use a glob pattern inside [[ ]] to test whether a string contains another string:

Terminal
str="Running on Linux kernel 6.8"
if [[ "$str" == *"Linux"* ]]; then
 echo "Linux detected"
fi

output

Linux detected

The * wildcards match anything before and after the search pattern. The comparison is case-sensitive. To check case-insensitively, convert both sides to the same case first using ,, before comparing.

For a more detailed walkthrough of substring detection, including case-insensitive matching and edge cases, see How to Check if a String Contains a Substring in Bash . For more on [[ ]] conditionals and string comparison operators, see the guide on Bash comparison operators .

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Operation	Syntax
String length	`${#var}`
Substring from offset	`${var:offset}`
Substring with length	`${var:offset:length}`
Replace first match	`${var/pattern/replacement}`
Replace all matches	`${var//pattern/replacement}`
Delete substring	`${var/pattern/}`
Remove shortest prefix	`${var#pattern}`
Remove longest prefix	`${var##pattern}`
Remove shortest suffix	`${var%pattern}`
Remove longest suffix	`${var%%pattern}`
Uppercase all	`${var^^}`
Lowercase all	`${var,,}`
Uppercase first char	`${var^}`
Lowercase first char	`${var,}`

Conclusion

Bash parameter expansion handles most day-to-day string operations without extra commands, which keeps scripts shorter and faster. For more on working with strings, see the guides on Bash string concatenation and splitting strings by delimiter .

Bash Split String: Split a String by Delimiter

hello@linuxize.com (Linuxize) — Tue, 05 May 2026 15:30:00 +0200

When a script reads a CSV row, a colon-separated config line, or a piece of user input, one of the first things you usually need to do is break that string into its individual fields. Bash does not have a dedicated split function, but the shell gives you several ways to do the job with nothing more than built-ins and common core utilities.

This guide explains how to split a string by a delimiter in Bash using read, the IFS variable, tr, awk, and parameter expansion, with safe examples you can drop straight into a script.

The IFS Variable

Word splitting in Bash is controlled by the internal field separator, stored in the IFS variable. By default, IFS contains a space, a tab, and a newline, which is why unquoted expansions split on whitespace. When you set IFS to a single character such as a comma or a colon, Bash uses that character to decide where one field ends and the next begins.

Most of the techniques below work by changing IFS for one command only, so the rest of the script keeps the default behavior.

Splitting a String with read

The cleanest way to split a string into named variables is the read built-in combined with a temporary IFS:

sh
#!/bin/bash

STR="ubuntu:debian:fedora:arch"
IFS=":" read -r first second third fourth <<< "$STR"

echo "$first"
echo "$second"
echo "$third"
echo "$fourth"

Running the script produces one field per line:

output

ubuntu
debian
fedora
arch

The IFS=":" assignment applies only to the read command that follows it, so the global IFS stays untouched. The here-string (<<<) feeds the string into read on standard input, and -r keeps backslashes literal so they are not treated as escape characters.

Splitting Into a Bash Array

When the number of fields is not known ahead of time, split the string into an array instead of a fixed list of variables. Pass -a to read to tell it the target is an array:

sh
#!/bin/bash

STR="1,2,3,4,5"
IFS="," read -r -a numbers <<< "$STR"

for n in "${numbers[@]}"; do
 echo "$n"
done

The numbers array now holds one value per comma-separated field, and the loop prints each one on its own line. Always expand arrays with "${numbers[@]}" inside double quotes so elements that contain spaces stay intact.

For a deeper look at what else arrays can do, see our guide on Bash arrays .

Splitting With a Multi-Character Delimiter

IFS treats each character in its value as a separate delimiter, so setting IFS="::" will still split on single colons. For a multi-character delimiter such as :: or -, convert it to a single character first with sed or use parameter expansion:

sh
#!/bin/bash

STR="alpha::beta::gamma"
IFS="|" read -r -a parts <<< "${STR//::/|}"

for p in "${parts[@]}"; do
 echo "$p"
done

The ${STR//::/|} expansion replaces every occurrence of :: with a pipe character, and then read splits the resulting string on the pipe. Pick a placeholder character that you are sure the input does not contain.

Splitting With tr

When you only need the fields printed one per line, tr is often enough. It translates the delimiter into a newline:

Terminal
printf '%s\n' "red,green,blue" | tr ',' '\n'

output

red
green
blue

This approach pairs well with pipelines. For example, you can count the number of fields by piping the output into wc -l, or loop over the values with a while read block:

sh
#!/bin/bash

STR="red,green,blue"

while IFS= read -r color; do
 echo "Color: $color"
done < <(printf '%s\n' "$STR" | tr ',' '\n')

The process substitution <(...) sends the output of the pipeline into the loop without using a subshell for the loop body, so any variables you set inside the loop remain available after it ends.

Splitting With awk

For more structured splitting, awk is the right tool. It reads input one record at a time and exposes each field as $1, $2, and so on. Use -F to set the field separator:

Terminal
echo "jane:x:1001:1001:Jane Doe:/home/jane:/bin/bash" | awk -F':' '{ print $1, $5 }'

output

jane Jane Doe

awk is also a good pick when the delimiter is a regular expression, when you need to skip a header line, or when you want to act on a specific field without touching the rest. For more patterns, see our awk command guide .

Splitting With Parameter Expansion

Bash parameter expansion can pull a prefix or a suffix off a string without calling any external command. This is the fastest option when you only need one part, not all of them:

sh
#!/bin/bash

PATH_LINE="/usr/local/bin/script.sh"

BASE="${PATH_LINE##*/}"
DIR="${PATH_LINE%/*}"

echo "Directory: $DIR"
echo "Basename: $BASE"

output

Directory: /usr/local/bin
Basename: script.sh

##*/ strips the longest match of */ from the start of the string, leaving the basename. %/* strips the shortest match of /* from the end, leaving the directory. The same pattern works for any delimiter, not only the slash.

For full coverage of these expansions, see our guide on Bash string manipulation .

Preserving Empty Fields

A common surprise with read is that trailing empty fields can be dropped. Consider the string a,,b,:

sh
#!/bin/bash

STR="a,,b,"
IFS="," read -r -a fields <<< "${STR},"

echo "Count: ${#fields[@]}"
printf '[%s]\n' "${fields[@]}"

output

Count: 4
[a]
[]
[b]
[]

Bash keeps empty fields in the middle, but read -a drops a trailing empty field when the delimiter is the last character. Appending one extra delimiter before reading gives read a final empty value to assign, which preserves the trailing field from the original string.

Quick Reference

The table below summarizes which technique to reach for based on what the script needs to do.

Goal	Technique
Split into named variables	`IFS=":" read -r a b c <<< "$STR"`
Split into an array	`IFS="," read -r -a arr <<< "$STR"`
Multi-character delimiter	Replace with `${STR//::/\|}` first, then split
Print one field per line	`printf '%s\n' "$STR" \| tr ',' '\n'`
Select specific fields	`awk -F',' '{ print $2 }'`
Take prefix or suffix only	`${STR%%...}` / `${STR##...}`

For a printable quick reference, see the bash cheatsheet .

FAQ

How do I split a string by whitespace in Bash?
Leave IFS at its default and use read -r -a arr <<< "$STR". Any run of spaces, tabs, or newlines will act as a separator.

Why does my array lose the last empty field?
If the delimiter is at the very end of the string, read -a can drop the trailing empty element. Append one extra delimiter before reading, for example IFS=',' read -r -a arr <<< "${STR},", when the trailing empty field matters.

Can I split on a newline?
Yes. For line-based strings, use mapfile -t lines <<< "$STR" so each input line becomes one array element. Plain read stops at the first newline unless you change how it reads the input.

Is there a built-in split function in Bash?
No. Word splitting driven by IFS plus the read built-in is the idiomatic replacement for a dedicated split function.

Conclusion

Splitting strings in Bash comes down to picking the right tool for the shape of the input: read with IFS for structured parsing, tr or awk for pipelines, and parameter expansion for quick prefix or suffix work. When the input is untrusted, quote every expansion and handle empty fields on purpose rather than by accident.

How to Increment and Decrement a Variable in Bash: Counter Examples

hello@linuxize.com (Linuxize) — Sun, 11 Aug 2019 21:11:27 +0100

One of the most common arithmetic operations when writing Bash scripts is incrementing and decrementing variables. This is most often used in loops as a counter, but it can occur elsewhere in the script as well.

Incrementing and decrementing means adding or subtracting a value (usually 1), respectively, from the value of a numeric variable. The arithmetic expansion can be performed using the double parentheses ((...)) and $((...)) or with the let built-in command.

This guide explains the most common ways to increment and decrement a variable in Bash.

Using the `+` and `-` Operators

The simplest way to increment or decrement a variable is by using the + and - operators.

sh
i=$((i+1))
((i=i+1))
let "i=i+1"

sh
i=$((i-1))
((i=i-1))
let "i=i-1"

This method allows you to increment or decrement the variable by any value you want.

Here is an example of incrementing a counter variable within an until loop:

sh
i=0

until [ $i -gt 3 ]
do
 echo i: $i
 ((i=i+1))
done

output

i: 0
i: 1
i: 2
i: 3

The `+=` and `-=` Operators

In addition to the basic operators explained above, Bash also provides the assignment operators += and -=. These operators are used to increment or decrement the value of the left operand by the value specified after the operator.

sh
((i+=1))
let "i+=1"

sh
((i-=1))
let "i-=1"

In the following while loop, we are decrementing the value of the i variable by 5.

sh
i=20

while [ $i -ge 5 ]
do
 echo Number: $i
 let "i-=5"
done

output

Number: 20
Number: 15
Number: 10
Number: 5

Using the `++` and `--` Operators

The ++ and -- operators increment and decrement, respectively, their operand by 1 and return the value.

sh
((i++))
((++i))
let "i++"
let "++i"

sh
((i--))
((--i))
let "i--"
let "--i"

The operators can be used before or after the operand. They are also known as:

prefix increment: ++i
prefix decrement: --i
postfix increment: i++
postfix decrement: i--

The prefix operators first increment or decrement the operand by 1 and then return the new value of the operand. The postfix operators return the operand’s value before it has been incremented or decremented.

If you only want to increment or decrement the variable, there is no difference between the prefix and postfix operator. The distinction matters only when the result is used in another operation or assigned to another variable.

The following examples demonstrate how the ++ operator works when used before and after its operand:

sh
x=5
y=$((x++))
echo x: $x
echo y: $y

output

x: 6
y: 5

sh
x=5
y=$((++x))
echo x: $x
echo y: $y

output

x: 6
y: 6

Below is an example of how to use the postfix increment operator in a Bash script:

~/counter.shsh
#!/bin/bash
i=0
while true; do
 if [[ "$i" -gt 3 ]]; then
 exit 1
 fi
 echo i: $i
 ((i++))
done

The disadvantage of using ++ and -- is that the variable can only be incremented or decremented by 1. For stepping by a larger value, use += or -= instead.

Quick Reference

Method	Increment	Decrement
Basic operators	`i=$((i+1))`	`i=$((i-1))`
Arithmetic context	`((i=i+1))`	`((i=i-1))`
`let` built-in	`let "i=i+1"`	`let "i=i-1"`
Assignment operators	`((i+=1))`	`((i-=1))`
`let` assignment	`let "i+=1"`	`let "i-=1"`
Postfix shorthand	`((i++))`	`((i--))`
Prefix shorthand	`((++i))`	`((--i))`

For a printable quick reference, see the bash cheatsheet .

Troubleshooting

integer expression expected error
This usually means the variable is empty or contains non-numeric text. Initialize counters before arithmetic operations, for example i=0.

i++ fails with command not found
Use increment and decrement operators only in arithmetic contexts such as ((i++)) or $((i+1)). Writing i++ as a standalone command is not valid shell syntax.

Script works in Bash but fails in sh
Some arithmetic forms are Bash-specific. If the script uses Bash features like (( )), run it with Bash (#!/bin/bash) instead of sh.

FAQ

What is the difference between prefix and postfix increment?
Both change the variable by 1, but they differ when the result is used in an expression. y=$((x++)) assigns the original value to y, then increments x. y=$((++x)) increments x first, then assigns the new value to y. When you only need to increment the variable and do not use the result, there is no practical difference.

Can I increment by a value other than 1?
Yes. Use ((i+=5)) or let "i+=5" to increment by any value. The ++ and -- shorthand only step by 1.

Why does i++ not work outside of (( ))?
The ++ and -- operators only work inside arithmetic contexts such as ((i++)) or $((i++)). Using i++ directly in a command or condition will cause an error.

Where are counters most commonly used?
Counters are most often used inside for , while , and until loops to track iterations or build a step-based sequence.

Can I decrement below zero?
Yes. Bash arithmetic treats variables as signed integers, so a counter can go negative without any special handling.

Conclusion

Incrementing and decrementing variables in Bash can be performed in several ways. For simple counters, the ++ and -- shorthand is the most concise. For stepping by larger values, use += or -=. To learn more about running your scripts, see our guide on how to run a Bash script .

If you have any questions, feel free to leave a comment below.

Bash Arithmetic: Integer and Floating-Point Math

hello@linuxize.com (Linuxize) — Fri, 22 May 2026 14:41:00 +0200

Bash treats everything as a string by default, which catches many people out the first time they write total=$count+1 and end up with the literal text 5+1 instead of 6. The shell has dedicated arithmetic forms that evaluate numeric expressions properly, but they only handle integers; for floating-point math you reach for bc or awk. Once you know which form to use where, the math is short and predictable.

This guide explains how Bash arithmetic works, the differences between (( )), $(( )), and let, and how to combine them with external tools when you need decimals.

Why Plain Assignment Does Not Add

A first attempt at incrementing a variable usually looks like this:

sh
count=5
total=$count+1
echo "$total"

output

5+1

The shell sees $count as the string 5, joins it with +1, and assigns the result. To force numeric evaluation, use one of the arithmetic forms below.

The (( )) Compound Command

Wrap an expression in double parentheses to evaluate it as integer math:

sh
count=5
(( count = count + 1 ))
echo "$count"

output

Inside (( )), variable names work without $, the C-style operators are available (+, -, *, /, %, **, ++, --, <<, >>, &, |, ^, &&, ||), and the exit status of the whole expression is non-zero when the result is 0, which means you can use arithmetic in if:

sh
if (( count > 5 )); then
 echo "count is above 5"
fi

output

count is above 5

The shortcut increment and decrement operators read cleanly in loops:

sh
for (( i = 0; i < 3; i++ )); do
 echo "i=$i"
done

output

i=0
i=1
i=2

(( )) is the right form when you assign back to a variable or use the result for control flow. It does not print anything to standard output.

The $(( )) Expansion

When you want the value of an expression rather than the side effect, use the $(( )) arithmetic expansion. The result is substituted into the surrounding command like any other expansion:

sh
count=5
echo "Next: $(( count + 1 ))"

output

Next: 6

$(( )) is the right form for inline math inside echo, assignments to other variables, command arguments, and printf:

sh
files=42
echo "Average: $(( files / 7 )) per day"

output

Average: 6 per day

Notice that the division truncates: 42 / 7 happens to be exact, but 43 / 7 would yield 6, not 6.14. Bash arithmetic is integer-only; the decimal part is silently discarded.

The let Builtin

let is the older builtin for arithmetic. It evaluates each argument as an expression:

sh
let "count = 5 + 1"
echo "$count"

output

let is mostly historical at this point. (( )) does the same work without the quoting trap (let count=* would expand the * as a glob unless quoted) and reads more cleanly. New scripts should prefer (( )); let is worth recognizing in code you inherit.

Operators You Will Actually Use

Bash supports a wide list of arithmetic operators. These are the ones that come up in everyday scripts:

+, -, *, /, % - Standard arithmetic and remainder.
** - Exponentiation.
++, -- - Increment and decrement, prefix or postfix.
+=, -=, *=, /=, %= - Compound assignment.
==, !=, <, <=, >, >= - Numeric comparison (inside (( ))).
&&, ||, ! - Logical AND, OR, NOT.
<<, >>, &, |, ^, ~ - Bitwise shifts and operations.

A small example that uses several:

sh
size=1024
if (( size > 0 && size % 2 == 0 )); then
 echo "Power of two? $(( (size & (size - 1)) == 0 ? 1 : 0 ))"
fi

output

Power of two? 1

The ternary operator (? :) works inside arithmetic contexts, which keeps short branches readable without nesting if.

Number Bases

Bash arithmetic supports several integer bases. Prefix a number to declare its base:

0xNN for hexadecimal.
0NN for octal.
BASE#NNN for any base from 2 to 64.

Examples:

sh
echo "$(( 0xff ))"
echo "$(( 0755 ))"
echo "$(( 2#1010 ))"

output

255
493
10

Watch out for leading zeros: 08 is interpreted as octal and rejected because 8 is not a valid octal digit. If user input may include leading zeros (HTTP status codes parsed from a string, timestamps), strip them before arithmetic with ${var#0} or use the explicit 10# base prefix:

sh
value="08"
echo "$(( 10#$value ))"

output

Floating-Point Math with bc

Bash itself cannot do decimal math, but it is happy to call out to a tool that can. bc is the arbitrary-precision calculator that ships with most distributions:

sh
echo "scale=2; 43 / 7" | bc

output

6.14

The scale=2 directive sets two decimal places of precision. Without it, bc truncates the division the same way Bash does. Use a higher scale for currency or scientific work:

sh
echo "scale=10; 4*a(1)" | bc -l

output

3.1415926532

The -l flag loads the math library, which gives you s (sine), c (cosine), a (arctangent), l (natural log), e (exponential), and sqrt. The expression above computes pi from 4 * arctan(1).

To capture the result into a variable:

sh
pi=$(echo "scale=4; 4*a(1)" | bc -l)
echo "pi = $pi"

output

pi = 3.1415

bc is the right tool when you need genuine decimals and do not want a heavyweight dependency. For one-off interactive calculations, run bc -l and type expressions at its prompt.

Floating-Point Math with awk

awk is the other obvious choice and is often faster because it does not start a separate calculator process. Use awk for inline expressions inside scripts:

sh
rate=$(awk 'BEGIN { printf "%.2f\n", 43 / 7 }')
echo "rate = $rate"

output

rate = 6.14

printf inside awk works the same way as the C function, with %.2f controlling the number of decimal places. For a percentage:

sh
pct=$(awk -v a=23 -v b=89 'BEGIN { printf "%.1f%%\n", (a / b) * 100 }')
echo "pct = $pct"

output

pct = 25.8%

Pass values into awk with -v name=value rather than building the expression by string concatenation; the -v form avoids quoting headaches and shell-injection issues when the inputs come from user data.

Increment Counters in a Loop

Counter loops are the bread and butter of arithmetic in scripts, and they lean on the increment and decrement operators . Two equivalent forms work; pick the one that reads best:

sh
count=0
while IFS= read -r line; do
 (( count++ ))
done < input.txt
echo "Lines: $count"

sh
count=0
while IFS= read -r line; do
 count=$(( count + 1 ))
done < input.txt
echo "Lines: $count"

The (( count++ )) form is shorter and is what most authors prefer. Both produce the same result and run at the same speed.

If the script uses set -e, avoid (( count++ )) when count may start at zero. The arithmetic command returns a failure status when the expression evaluates to 0, so the first increment can stop the script. Use pre-increment or assignment instead:

sh
(( ++count ))
(( count += 1 ))

Troubleshooting

syntax error in expression
A variable that should hold a number contains non-numeric characters (often a leading or trailing space from read, or a stray letter). Inside (( )) and $(( )), Bash reports a syntax error on the offending token. Trim the input with ${var//[[:space:]]/} or validate it before the arithmetic line.

division by 0
A divisor evaluated to zero, often because the variable was empty and Bash treated it as 0. Quote the expansion in your check (if [ -n "$divisor" ]) before the divide, and either skip the operation or substitute a default with ${divisor:-1}.

Result is 0 when it should be a fraction
Bash arithmetic is integer-only. Switch to bc with an explicit scale= or to awk with %.Nf formatting for decimal output.

FAQ

When should I use (( )) versus $(( ))?
Use (( )) for assignments and control flow (if, while, for). Use $(( )) when you want the value substituted into a surrounding command. They share the same expression syntax.

Can I do floating-point math without an external tool?
Not in Bash. ksh93 and zsh support floating-point in their arithmetic contexts; Bash does not. For Bash, route decimals through bc or awk.

Is there a performance difference between bc and awk?
awk is usually faster because it runs entirely inside a single process and does not communicate over a pipe. For one-off calculations the difference is negligible; in a tight loop, prefer awk or precompute the values with a single awk call instead of running bc per iteration.

Conclusion

Reach for (( )) and $(( )) whenever a script needs counters, conditions, or quick integer math, and switch to bc or awk the moment decimals enter the picture. Pair that habit with Bash strict mode and the patterns in our Bash best practices guide so numeric code keeps working even when the inputs do not.

How to Set Environment Variables in Linux

hello@linuxize.com (Linuxize) — Wed, 10 Apr 2019 10:55:47 +0100

In Linux and Unix-based systems, environment variables are dynamic named values stored within the system that are used by applications launched in shells or subshells. In simple terms, an environment variable is a variable with a name and an associated value.

Environment variables allow you to customize how the system works and the behavior of the applications on the system. For example, the environment variable can store information about the default text editor or browser, the path to executable files, or the system locale and keyboard layout settings.

In this guide, we will explain how to read and set environment and shell variables.

Quick Reference

For a printable quick reference, see the env cheatsheet .

Task	Command
List all environment variables	`printenv` or `env`
Print a specific variable	`printenv HOME` or `echo $HOME`
Set a shell variable	`MY_VAR="value"`
Set an environment variable	`export MY_VAR="value"`
Remove a variable	`unset MY_VAR`
Add to PATH	`export PATH="$HOME/bin:$PATH"`
List all variables and functions	`set`
Make variable persistent	Add it to your shell startup file such as `~/.bashrc`, `~/.zshrc`, or `~/.profile`
Reload config after changes	`source ~/.bashrc` or `source ~/.zshrc`

Environment Variables and Shell Variables

Variables have the following format:

txt
KEY=value
KEY="Some other value"
KEY=value1:value2

The names of the variables are case-sensitive. By convention, environment variables should have UPPER CASE names.
When assigning multiple values to the variable, they must be separated by the colon : character.
There is no space around the equals = symbol.

Variables can be classified into two main categories: environment variables and shell variables.

Environment variables are variables that are available system-wide and are inherited by all spawned child processes and shells.

Shell variables are variables that apply only to the current shell instance. Each shell such as zsh and bash, has its own set of internal shell variables.

There are several commands available that allow you to list and set environment variables in Linux:

env – The command allows you to run another program in a custom environment without modifying the current one. When used without an argument it will print a list of the current environment variables.
printenv – The command prints all or the specified environment variables.
set – The command sets or unsets shell variables. When used without an argument it will print a list of all variables including environment and shell variables, and shell functions.
unset – The command deletes shell and environment variables.
export – The command sets environment variables.

List Environment Variables

The most commonly used command to display environment variables is printenv. If the name of the variable is passed as an argument to the command, only the value of that variable is displayed. If no argument is specified, printenv prints a list of all environment variables, one variable per line.

For example, to display the value of the HOME environment variable you would run:

Terminal
printenv HOME

The output will print the path of the currently logged in user:

output

/home/linuxize

You can also pass more than one argument to the printenv command:

Terminal
printenv LANG PWD

output

en_US.UTF-8
/home/linuxize

If you run the printenv or env command without any arguments, it will show a list of all environment variables:

Terminal
printenv

The output will look something like this:

output

SHELL=/bin/bash
USER=linuxize
HOME=/home/linuxize
LANG=en_US.UTF-8
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
TERM=xterm-256color
XDG_SESSION_TYPE=tty
XDG_RUNTIME_DIR=/run/user/1000
MAIL=/var/mail/linuxize
LOGNAME=linuxize

Below are some of the most common environment variables:

USER - The current logged-in user.
HOME - The home directory of the current user.
EDITOR - The default file editor to be used. Programs such as crontab -e, git commit, and visudo open this editor when they need text input.
SHELL - The path of the current user’s shell, such as bash or zsh.
LOGNAME - The name of the current user.
PATH - A list of directories to be searched when executing commands. When you run a command the system will search those directories in this order and use the first found executable.
LANG - The current locales settings.
TERM - The current terminal emulation.
MAIL - Location of where the current user’s mail is stored.
XDG_SESSION_TYPE - The type of session (e.g., tty, x11, wayland).

The printenv and env commands print only the environment variables. If you want to get a list of all variables, including environment, shell variables, and shell functions , you can use the set command:

Terminal
set

output

BASH=/bin/bash
BASHOPTS=checkwinsize:cmdhist:complete_fullquote:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:login_shell:progcomp:promptvars:sourcepath
BASH_ALIASES=()
BASH_ARGC=()
BASH_ARGV=()

The command will display a large list of all variables so you probably want to pipe the output to the less command.

Terminal
set | less

You can also use the echo command to print a shell variable. For example, to print the value of the BASH_VERSION variable you would run:

Terminal
echo $BASH_VERSION

output

5.2.21(1)-release

Setting Environment Variables

To better illustrate the difference between the Shell and Environment variables we’ll start with setting Shell Variables and then move on to the Environment variables.

To create a new shell variable with the name MY_VAR and value Linuxize simply type:

Terminal
MY_VAR='Linuxize'

You can verify that the variable is set by using either echo $MY_VAR or filtering the output of the set command with grep set | grep MY_VAR:

Terminal
echo $MY_VAR

output

Linuxize

Use the printenv command to check whether this variable is an environment variable or not:

Terminal
printenv MY_VAR

The output will be empty which tells us that the variable is not an environment variable.

You can also try to print the variable in a new shell and you will get an empty output.

Terminal
bash -c 'echo $MY_VAR'

The export command is used to set Environment variables.

To create an environment variable simply export the shell variable as an environment variable:

Terminal
export MY_VAR

You can check this by running:

Terminal
printenv MY_VAR

output

Linuxize

If you try to print the variable in a new shell this time you will get the variable value printed on your terminal:

Terminal
bash -c 'echo $MY_VAR'

output

Linuxize

You can also set environment variables in a single line:

Terminal
export MY_NEW_VAR="My New Var"

Environment variables created in this way are available only in the current session. If you open a new shell or if you log out, all variables will be lost.

Set a Variable for a Single Command

You can set a variable for a single command without exporting it globally:

Terminal
DEBUG=1 myapp --verbose

This is useful for testing or for commands that need temporary values.

Unsetting Variables

To remove an environment or shell variable, use the unset command:

Terminal
unset MY_VAR

You can verify that the variable has been removed:

Terminal
echo $MY_VAR

The output will be empty, confirming the variable no longer exists.

Info

The unset command works for both shell and environment variables.

Working with the PATH Variable

The PATH variable is one of the most important environment variables. It specifies a list of directories where the shell looks for executable files.

To view your current PATH:

Terminal
echo $PATH

output

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

Each directory is separated by a colon :. When you type a command, the shell searches these directories from left to right and runs the first matching executable.

To add a new directory to PATH:

Terminal
export PATH="$HOME/bin:$PATH"

This prepends $HOME/bin to the beginning of PATH, so executables in that directory will take priority.

To append a directory to the end of PATH:

Terminal
export PATH="$PATH:/opt/myapp/bin"

Info

Changes made to PATH in the current session are temporary. To make them permanent, add the export line to your shell configuration file (see the next section).

Persistent Environment Variables

To make environment variables persistent, define them in shell startup files. In most Linux distributions, when you start a new session, environment variables are read from the following files:

/etc/environment - Use this file to set up system-wide environment variables. This file accepts only simple KEY=value pairs and does not support export, variable expansion, or shell syntax. Variables in this file are set in the following format:
sh
```
FOO=bar
VAR_TEST="Test Var"
```
/etc/profile - Variables set in this file are loaded whenever a bash login shell is entered. When declaring environment variables in this file, you need to use the export command:
sh
```
export JAVA_HOME="/path/to/java/home"
export PATH=$PATH:$JAVA_HOME/bin
```
Per-user shell-specific configuration files. For example, if you are using Bash, you can declare the variables in ~/.bashrc. If you are using Zsh, use ~/.zshrc:
sh
```
export PATH="$HOME/bin:$PATH"
```
/etc/profile.d/*.sh - System-wide shell scripts sourced by /etc/profile. This is a common place to drop app-specific export statements.
~/.config/environment.d/*.conf - On systemd-based systems, you can define user environment variables here using KEY=value lines.

Understanding Shell Configuration Files

Different configuration files are loaded depending on how the shell is started:

~/.bash_profile or ~/.profile - Loaded for login shells (when you log in via SSH or a console). This is where you should set environment variables that apply to your entire session.
~/.bashrc - Loaded for interactive non-login shells (when you open a new terminal window). This is where you should set aliases, functions, and shell-specific settings.
~/.zshrc - The equivalent of ~/.bashrc for Zsh users.

Info

On most Linux distributions, ~/.bash_profile sources ~/.bashrc, so variables set in ~/.bashrc are available in login shells too.

To load the new environment variables into the current shell session use the source command:

Terminal
source ~/.bashrc

FAQ

How do I check if an environment variable is set?
Use printenv VAR >/dev/null and check the exit code. If you need to distinguish between unset and set-but-empty in a shell script, use ${VAR+x} or, in Bash, [ -v VAR ].

How do I set an environment variable for a single command?
Use VAR=value command, for example: DEBUG=1 my_command.

Where should I put persistent variables in Bash or Zsh?
Use the startup file that matches how your shell is launched. ~/.bashrc is common for interactive Bash shells, ~/.profile or ~/.bash_profile is used for Bash login shells, and ~/.zshrc is used for Zsh. For system-wide variables, use /etc/profile, /etc/profile.d/*.sh, or /etc/environment depending on the type of variable.

What is the difference between shell and environment variables?
Shell variables exist only in the current shell. Environment variables are exported and inherited by child processes.

Conclusion

Environment variables control how your shell and applications behave. For a deeper look at shell startup files and scripting patterns, see the export command reference.

How to Use the Export Command in Linux

hello@linuxize.com (Linuxize) — Fri, 09 Jan 2026 16:10:00 +0100

The export command is an essential part of the Bash shell in Linux. It allows you to share variables or functions you create so that they can be used by other programs or new shells started from your current terminal.

By default, variables exist only in the shell where they are created. When you use export, the variable becomes an environment variable, meaning it is passed to child processes.

In this article, we will show you how to use the export command to create, list, and manage environment variables and functions.

What Is an Environment Variable?

Environment variables are system-wide variables that are inherited by all spawned child processes and shells.

Environment variables allow you to customize how the system works and the behavior of the applications on the system. For example, environment variables can store information about the default text editor or browser, the paths to executable files, or the system locale and keyboard layout settings.

Common examples include:

PATH – Defines where the shell looks for executable files.
HOME – Your home directory.
USER – Your username.
LANG - The current locales settings.
SHELL - The path of the current user’s shell, such as bash or zsh.

Syntax Overview

The syntax of the export command is:

txt
export [-f] [-n] [name[=value] …]

Or to list exported variables:

txt
export -p

Where:

name - the shell variable or function to export.
-p - lists all exported variables in the current shell.
-n - removes the export property from the specified variable(s) (they remain defined in the current shell but won’t be inherited by child processes).
-f - treats the specified name(s) as functions instead of variables.

To see why export matters, compare a regular shell variable with an exported one:

Terminal
NAME="linuxize"
bash -c 'echo "$NAME"'

export NAME="linuxize"
bash -c 'echo "$NAME"'

The first command does not pass NAME to the child shell. After export, the child shell can read it.

List All Exported Variables

To see all exported variables in your current shell, type:

sh
export -p

Example output:

output

declare -x PATH="/usr/local/bin:/usr/bin:/bin"
declare -x HOME="/home/user"
declare -x LANG="en_US.UTF-8"

These are variables that any child process will inherit.

You can also use printenv or env to see all currently active environment variables.

Creating and Exporting Environment Variables

To create a new environment variable , use the following form:

sh
export VARIABLE=VALUE

Variable names are case-sensitive. By convention, environment variables should have UPPER CASE names.

Example:

sh
export COUNT=2024

Check its value:

sh
echo $COUNT

output

Variables defined without export are local to the current shell and won’t be inherited by child processes.

You can also first define a variable and export it separately:

sh
COUNT=2024
export COUNT

Exporting Functions

Functions can be exported to child shells using the -f option. Example:

sh
greet() {
echo "Hello World!"
}

Terminal
export -f greet

Info

Without -f, export assumes you’re exporting a variable, not a function.

This works in Bash. Function export is not portable across all shells.

Then, start a new child shell by typing bash, and enter the function name:

Terminal
greet

output

Hello World!

If you haven’t exported the function, it will not be available in the child shell, and there will be no output.

Remove Export Property

To stop exporting a variable while retaining it in the current shell:

Terminal
export -n VARIABLE

To remove a variable completely from both current and child processes:

Terminal
unset VARIABLE

Make Environment Variables Permanent

Exported variables are not permanent and last only for the current session.

To make environment variables persistent across sessions, add export VARIABLE=value to your shell configuration file. Common places include:

/etc/profile
~/.bashrc
~/.bash_profile
/etc/environment (typically uses plain VARIABLE=value, not export VARIABLE=value)

Example:

sh
export JAVA_HOME="/path/to/java/home"
export PATH=$PATH:$JAVA_HOME/bin

Conclusion

The export command is important for managing environment variables and functions in Linux.

Important aspects to remember:

Child processes inherit exported variables/functions.
Use export -f for functions.
Remove exports with export -n or completely delete with unset.
Persistent exports require adding them to the shell configuration files.

Mastering export will make your shell scripts and session management much more powerful.

How to Add a Directory to PATH in Linux

hello@linuxize.com (Linuxize) — Mon, 29 Jul 2019 18:30:40 +0100

The $PATH variable tells your shell which directories to search for executable files when you type a command. Without the right directories in $PATH, the shell cannot find your programs and returns a command not found error.

This guide explains how to temporarily and permanently add a directory to $PATH in Linux, covering user-level and system-wide methods.

What is PATH in Linux

The $PATH environment variable is a colon-delimited list of directories that tells the shell where to search for executable files. Common directories in the default $PATH include /bin, /sbin, /usr/bin, /usr/local/bin, and /usr/local/sbin. All files with executable permissions stored in these directories can be run from any location.

To check the directories currently in your $PATH, use the echo or printenv command:

Terminal
echo $PATH

output

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

If two directories contain an executable with the same name, the shell runs the one found in whichever directory appears first in $PATH.

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Goal	Method
Temporary (current session)	`export PATH="$HOME/bin:$PATH"`
Permanent for current user	Add export to `~/.bashrc` and source it from your login shell file
Permanent for all users	Create a file in `/etc/profile.d/`

Add a Directory to PATH Temporarily

To add a directory to $PATH for the current shell session only, use the export command:

Terminal
export PATH="$HOME/bin:$PATH"

The export command makes the updated variable available to child processes spawned from the current shell. The change is lost when the session ends or the terminal is closed.

You can now run executables stored in $HOME/bin by name, without specifying their full path.

Add a Directory to PATH Permanently

To make a PATH change permanent, add the export statement to your shell configuration files.

There are two shell startup files to be aware of:

~/.bashrc - read for interactive non-login shells, such as most terminal emulator windows in a desktop environment.
~/.profile or ~/.bash_profile - read for login shells, such as SSH sessions and TTY logins.

To cover both cases, add the export to ~/.bashrc and ensure your login shell file sources it. Open ~/.bashrc with your text editor :

Terminal
nano ~/.bashrc

Add the following line at the end of the file:

~/.bashrcsh
export PATH="$HOME/bin:$PATH"

Save the file and load the new $PATH into the current session using the source command:

Terminal
source ~/.bashrc

To confirm the directory was added, print the value of $PATH:

Terminal
echo $PATH

If your login shell is Zsh, add the same export line to ~/.zshrc instead of ~/.bashrc. For a full walkthrough, see how to install and use Zsh .

Tip

On most modern distributions, ~/.local/bin is the conventional directory for per-user executables, and tools like pip install --user and pipx place scripts there. If a command installed this way returns command not found, add ~/.local/bin to $PATH:

~/.bashrcsh
export PATH="$HOME/.local/bin:$PATH"

Many distributions add this directory automatically when it exists at login, so logging out and back in may be enough.

If you log in via SSH, ensure your existing login shell file sources ~/.bashrc so the same PATH change applies to login shells. Use ~/.bash_profile only if it already exists. Otherwise, prefer ~/.profile:

Terminal
nano ~/.profile

~/.profilesh
if [ -f ~/.bashrc ]; then
 . ~/.bashrc
fi

System-Wide: /etc/profile.d/

To add a directory to $PATH for all users on the system, the recommended approach is to create a new file with a .sh extension in the /etc/profile.d/ directory. Files in this directory are sourced automatically for all users at login.

For example, to add /opt/myapp/bin to the system PATH, create the file:

Terminal
sudo nano /etc/profile.d/myapp.sh

Add the following line:

/etc/profile.d/myapp.shsh
export PATH="/opt/myapp/bin:$PATH"

The change takes effect for all users on the next login.

Info

/etc/environment is another system-wide configuration file, but it is a plain key=value file parsed by PAM, not a shell script. It does not support variable expansion, so you cannot use $PATH or $HOME inside it. Use /etc/profile.d/ for system-wide PATH additions instead.

Prepend vs Append

The examples above prepend the new directory ("$HOME/bin:$PATH"), placing it at the beginning of $PATH. This gives your directory higher priority. If a directory contains an executable with the same name as a system binary, your version runs first.

To append instead, place the new directory at the end:

Terminal
export PATH="$PATH:$HOME/bin"

Appending gives lower priority to your directory. System binaries take precedence over any executable with the same name in your custom directory. For personal scripts, prepending is usually the right choice.

Remove a Directory from PATH

To permanently remove a directory from $PATH, open the configuration file where it was added and delete or comment out the export line. The change takes effect in new shell sessions. If you are unsure which startup file controls your shell type, see .bashrc vs .bash_profile .

To remove a directory from $PATH for the current session only, use sed to filter it out:

Terminal
PATH=$(echo ":$PATH:" | sed 's|:/home/user/bin:||' | sed 's/^://;s/:$//')

In the command above, we are wrapping $PATH with colons on both sides so the target directory can be matched regardless of its position, then passing the result through sed to strip the entry and clean up any leading or trailing colons.

For a directory that was added only for the current session, the simplest approach is to open a new terminal. Temporary PATH changes do not persist across sessions.

Troubleshooting

Command not found after adding to PATH
You likely forgot to reload the configuration file. Run source ~/.bashrc to apply the changes in the current terminal, or log out and back in for login shells.

PATH changes apply in the terminal but not in SSH sessions
~/.bashrc is not read directly by login shells. Ensure your login shell file, usually ~/.profile or an existing ~/.bash_profile, sources ~/.bashrc, then log out and back in.

PATH variable appears broken or commands stop working
You likely used export PATH="/your/dir" without including $PATH, which overwrites the entire variable. Open a new terminal to restore the default PATH, then correct the export line to export PATH="/your/dir:$PATH".

FAQ

How do I check if a specific directory is already in PATH?
Run echo $PATH | tr ':' '\n' to print each directory on its own line, then scan the output for the directory you are looking for.

What is the difference between ~/.bashrc and ~/.bash_profile for PATH?
~/.bashrc is read for interactive non-login shells (most terminal windows). Login shells read files such as ~/.profile or ~/.bash_profile. Put the export in ~/.bashrc and have your existing login shell file source it so the PATH change applies in all contexts.

How do I add a directory to PATH for all users?
Create a file with a .sh extension in /etc/profile.d/ containing the export statement. The file is sourced for all users at login. Do not edit /etc/environment for this purpose; it does not support variable expansion.

Does PATH order matter?
Yes. The shell searches directories in order from left to right and runs the first matching executable it finds. Directories listed earlier have higher priority.

Conclusion

The quickest way to add a directory to $PATH is export PATH="$HOME/bin:$PATH" in the current session. To make the change permanent, add that line to ~/.bashrc and have your login shell file source it when needed. For system-wide changes, drop a .sh file in /etc/profile.d/.

Bash Arrays

hello@linuxize.com (Linuxize) — Mon, 27 May 2019 20:31:47 +0100

Arrays are one of the most commonly used and fundamental data structures. You can think of an array as a variable that stores multiple values, allowing you to represent and manipulate a group of related data as a single entity.

Bash supports two types of arrays: numerically indexed arrays referenced by integers, and associative arrays referenced by strings (keys). Unlike most programming languages, Bash array elements do not have to be the same data type; an array can contain both strings and numbers. Bash does not support multidimensional arrays.

Numerically indexed arrays can be accessed from the end using negative indices. The index -1 references the last element. Indices do not have to be contiguous.

Info

Some array features are not available in very old Bash versions (for example, the default Bash 3.2 on older macOS systems). Associative arrays and negative indexing require a newer Bash version.

Creating Arrays

Numerically Indexed Arrays

Bash variables are untyped, so any variable can be used as an indexed array without declaring it. To explicitly declare one, use the declare builtin:

sh
declare -a array_name

You can assign elements individually by index:

sh
array_name[0]=value_1
array_name[1]=value_2
array_name[2]=value_3

Or initialize the whole array at once using parentheses, with elements separated by spaces:

sh
array_name=( element_1 element_2 element_3 )

When using this form, indexing starts at zero.

Associative Arrays

Associative arrays use strings as keys instead of integers. Unlike indexed arrays, they must be declared before use:

sh
declare -A array_name

Assign elements individually:

sh
declare -A array_name

array_name[key_foo]=value_foo
array_name[key_bar]=value_bar
array_name[key_xyz]=value_xyz

Or use the inline form:

sh
declare -A array_name=(
 [key_foo]=value_foo
 [key_bar]=value_bar
 [key_xyz]=value_xyz
)

Access Elements

To reference a single element, use the following syntax:

sh
${array_name[index]}

Info

The curly braces ${} delimit the variable name and index expression so Bash parses it correctly.

For example, to print the element at index 1:

sh
declare -a my_array=( "Hydrogen" "Helium" "Lithium" "Beryllium" )

echo ${my_array[1]}

output

Helium

To access all elements, use @ or * as the index:

sh
declare -a my_array=( "Hydrogen" "Helium" "Lithium" "Beryllium" )

echo "${my_array[@]}"

output

Hydrogen Helium Lithium Beryllium

The difference between @ and * matters when the expression is inside double quotes. "${my_array[*]}" expands to a single word with elements separated by spaces. "${my_array[@]}" expands each element as a separate word. Use @ when iterating over array elements to handle values that contain spaces correctly.

To print all keys (indices), add ! before the array name:

sh
declare -a my_array=( "Hydrogen" "Helium" "Lithium" "Beryllium" )

echo "${!my_array[@]}"

output

0 1 2 3

Array Length

To get the number of elements in an array, prefix the array name with #:

sh
${#array_name[@]}

Here is an example:

sh
declare -a my_array=( "Hydrogen" "Helium" "Lithium" "Beryllium" )

echo ${#my_array[@]}

output

Loop Through an Array

The for loop is the most common way to iterate over array elements:

sh
declare -a my_array=( "Hydrogen" "Helium" "Lithium" "Beryllium" )

for i in "${my_array[@]}"
do
 echo "$i"
done

output

Hydrogen
Helium
Lithium
Beryllium

To print both keys and values:

sh
declare -a my_array=( "Hydrogen" "Helium" "Lithium" "Beryllium" )

for i in "${!my_array[@]}"
do
 echo "$i" "${my_array[$i]}"
done

output

0 Hydrogen
1 Helium
2 Lithium
3 Beryllium

You can also use a C-style loop with the array length:

sh
declare -a my_array=( "Hydrogen" "Helium" "Lithium" "Beryllium" )

length=${#my_array[@]}

for (( i=0; i < ${length}; i++ ))
do
 echo $i ${my_array[$i]}
done

output

0 Hydrogen
1 Helium
2 Lithium
3 Beryllium

Add Elements

To add an element at a specific index:

sh
my_array[index]="New Element"

To append one or more elements without specifying an index, use the += operator:

sh
declare -a my_array=( "Hydrogen" "Helium" "Lithium" "Beryllium" )

my_array+=( Cobalt Nickel )

echo "${my_array[@]}"

output

Hydrogen Helium Lithium Beryllium Cobalt Nickel

Slice an Array

To extract a portion of an array, use the following syntax:

sh
${array_name[@]:offset:length}

offset - the starting index
length - the number of elements to return

For example, to get two elements starting at index 1:

sh
declare -a my_array=( "Hydrogen" "Helium" "Lithium" "Beryllium" )

echo "${my_array[@]:1:2}"

output

Helium Lithium

Delete Elements

To remove a single element by index, use unset:

sh
declare -a my_array=( "Hydrogen" "Helium" "Lithium" "Beryllium" )

unset my_array[2]

echo "${my_array[@]}"

output

Hydrogen Helium Beryllium

Note that unset removes the element but does not re-index the array. The index gap remains.

To delete the entire array:

sh
unset my_array

Quick Reference

For a printable quick reference, see the bash cheatsheet .

Task	Syntax
Declare indexed array	`declare -a arr`
Declare associative array	`declare -A arr`
Initialize array	`arr=( a b c )`
Access element	`${arr[index]}`
Access all elements	`"${arr[@]}"`
Access all keys	`"${!arr[@]}"`
Array length	`${#arr[@]}`
Append elements	`arr+=( x y )`
Slice array	`${arr[@]:offset:length}`
Delete element	`unset arr[index]`
Delete entire array	`unset arr`
Last element	`${arr[-1]}`

FAQ

What is the difference between @ and * when accessing all elements?
Both expand to all array elements, but the behavior differs inside double quotes. "${arr[@]}" expands each element as a separate word, which correctly handles elements containing spaces. "${arr[*]}" expands to a single string with elements joined by the first character of IFS (usually a space). Always use @ when iterating.

How do I check if a Bash array is empty?
Check the length: [[ ${#my_array[@]} -eq 0 ]]. In a script:

sh
if [[ ${#my_array[@]} -eq 0 ]]; then
 echo "Array is empty"
fi

How do I check if a value exists in an array?
Loop through the array and compare each element :

sh
for i in "${my_array[@]}"; do
 [[ "$i" == "Helium" ]] && echo "Found" && break
done

Why does unset leave a gap in the array index?
unset arr[2] removes the element at index 2 but does not shift the remaining elements. The index 2 simply becomes unset. To re-index, reassign: arr=( "${arr[@]}" ).

Can Bash arrays hold arrays as elements?
No. Bash does not support nested or multidimensional arrays. To simulate a 2D structure, use naming conventions such as arr_0_0, arr_0_1, or use associative arrays with compound keys like arr[0,1].

Conclusion

Bash arrays store multiple values in a single variable. Use indexed arrays for ordered lists and associative arrays for key-value pairs. The [@] expansion, ${#arr[@]} for length, += for appending, and unset for deletion are the core operations you will use most often.

For more array techniques such as searching, slicing, and reversing, see Bash Array Operations . For more on Bash scripting, see the guides on for loops and if/else statements .

Bash Array Operations: Length, Search, Slice, and Reverse

hello@linuxize.com (Linuxize) — Tue, 09 Jun 2026 10:10:00 +0200

Once you know how to declare a Bash array, the next tasks are usually finding its length, checking whether it contains a value, extracting a slice, or changing the element order. Bash supports all of these operations, but the expansion syntax can be difficult to remember.

This guide covers the indexed-array operations you will use most often in scripts. For array declaration, element access, and associative arrays, start with the Bash arrays guide .

Sample Array

The examples use the following array:

Terminal
fruits=("apple" "banana" "dragon fruit" "date" "elderberry")

Each quoted value is one element, including dragon fruit, and the indices run from 0 through 4.

Get the Array Length

Use ${#name[@]} to get the number of elements:

Terminal
echo "${#fruits[@]}"

output

The result is 5 because the array contains five elements. ${#name[*]} returns the same count, but @ is the safer default for other array operations because it preserves individual elements when quoted.

To get the character length of one element, include its index:

Terminal
echo "${#fruits[1]}"

output

This counts the six characters in banana, not the number of array elements.

Check If an Array Contains a Value

Bash does not have a built-in contains operator. The reliable approach is to loop over the elements and compare each one with the target value:

sh
contains() {
 local target=$1
 shift

 local element
 for element in "$@"; do
 if [[ $element == "$target" ]]; then
 return 0
 fi
 done

 return 1
}

if contains "dragon fruit" "${fruits[@]}"; then
 echo "found"
else
 echo "not found"
fi

output

found

The function returns status 0 when it finds an exact match and status 1 otherwise. Passing "${fruits[@]}" keeps values containing spaces intact.

Avoid joining the array into one string and testing it with a regular expression. That shortcut can report false matches when a search term appears inside another element or when elements contain the chosen separator.

Slice an Array

Array slicing uses the following expansion:

txt
${name[@]:offset:length}

offset selects where the slice starts, and length is the number of elements to return. This example takes three elements starting at index 1:

sh
slice=("${fruits[@]:1:3}")
printf '<%s>\n' "${slice[@]}"

output

<banana>
<dragon fruit>
<date>

Assigning the result to another array preserves the three values as separate elements.

A negative offset counts from the end. Add a space before the negative number so Bash does not parse :- as the default-value operator:

sh
last_two=("${fruits[@]: -2}")
printf '<%s>\n' "${last_two[@]}"

output

<date>
<elderberry>

Omit length to take every remaining element from the offset to the end.

Reverse an Array

Bash does not provide a reverse operator. The following loop reads the array indices from the end and appends each value to a new array:

sh
indices=("${!fruits[@]}")
reversed=()

for ((i=${#indices[@]} - 1; i >= 0; i--)); do
 reversed+=("${fruits[${indices[i]}]}")
done

printf '<%s>\n' "${reversed[@]}"

output

<elderberry>
<date>
<dragon fruit>
<banana>
<apple>

Using the actual index list makes this pattern work with both contiguous arrays and sparse arrays that have gaps between indices.

Tools such as rev and tac solve different problems. rev reverses characters on each input line, while tac reverses line order. Neither one operates directly on Bash array elements.

Iterate Over Values and Indices

When you only need the values, expand the array with "${name[@]}":

sh
for fruit in "${fruits[@]}"; do
 echo "$fruit"
done

Quoting the expansion ensures that dragon fruit remains one loop item.

When you need both the index and value, use ${!name[@]} to expand the index list:

sh
for i in "${!fruits[@]}"; do
 echo "$i: ${fruits[i]}"
done

output

0: apple
1: banana
2: dragon fruit
3: date
4: elderberry

Iterating over indices is useful when you need to update elements in place or preserve gaps in a sparse array.

Append and Prepend Elements

Append one or more elements with the += operator:

Terminal
fruits+=("fig" "grape")

The new values receive the next available indices at the end of the array.

To prepend a value, create a new array expansion with the new element first:

Terminal
fruits=("apricot" "${fruits[@]}")

This assignment rebuilds the array with contiguous indices starting at 0.

You can also assign a value at a specific index:

Terminal
fruits[10]="kiwi"

This creates a sparse array if indices 7 through 9 do not exist.

Remove Array Elements

Use unset with an index to remove one element:

Terminal
unset 'fruits[2]'

Quote the argument so the brackets are not treated as a filename pattern. The remaining elements keep their original indices, which leaves a gap where index 2 was removed.

To rebuild the array with contiguous indices, assign its current values back to it:

Terminal
fruits=("${fruits[@]}")

This preserves the values and renumbers them from 0.

To remove the entire array, pass only its name:

Terminal
unset fruits

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Task	Syntax
Number of elements	`${#arr[@]}`
Length of one element	`${#arr[index]}`
All values	`"${arr[@]}"`
All indices	`"${!arr[@]}"`
Slice	`"${arr[@]:offset:length}"`
Last two elements	`"${arr[@]: -2}"`
Append elements	`arr+=(x y)`
Prepend an element	`arr=(x "${arr[@]}")`
Set a specific index	`arr[index]=value`
Remove one element	`unset 'arr[index]'`
Reindex after removal	`arr=("${arr[@]}")`
Remove the array	`unset arr`

Common Pitfalls

Always use curly braces when accessing an indexed element. $fruits[1] expands $fruits and then prints the literal text [1], while ${fruits[1]} expands the element at index 1.

Inside double quotes, "${fruits[@]}" expands each element as a separate word. "${fruits[*]}" joins all elements into one string using the first character of IFS. Use the @ form for loops, function arguments, copies, and most other array operations.

Do not assume that array indices are contiguous after using unset or assigning a distant index. Iterate over "${!fruits[@]}" when the actual index values matter.

Conclusion

Bash array expansions cover length checks, slices, index iteration, and most everyday updates. Use quoted @ expansions to preserve element boundaries, and iterate over the real index list when an array may contain gaps.

Bash read Command

hello@linuxize.com (Linuxize) — Tue, 29 Dec 2020 19:11:04 +0100

The read built-in command reads a line from standard input (or a file descriptor) and splits it into words, assigning each word to a named variable. It is one of the most frequently used built-ins for writing interactive scripts and processing text input in Bash.

The general syntax of the read built-in takes the following form:

txt
read [options] [name...]

Reading Input into Variables

To see how the command works, open a terminal, type read var1 var2, and press Enter. The command waits for input. Type two words and press Enter again:

Terminal
read var1 var2
Hello, World!

The words are assigned to the variables passed to read as arguments. Use echo or printf to verify:

Terminal
echo $var1
echo $var2

output

Hello,
World!

Instead of typing on the terminal, you can pass input to read using piping, here-string, or heredoc :

Terminal
echo "Hello, World!" | (read var1 var2; echo -e "$var1 \n$var2")

Info

read and echo are enclosed in parentheses and executed in the same subshell.

output

Hello,
World!

Here is an example using a here-string and printf:

Terminal
read -r var1 var2 <<< "Hello, World!"
printf "var1: %s \nvar2: %s\n" "$var1" "$var2"

output

var1: Hello,
var2: World!

If no variable names are provided, the entire line is assigned to the REPLY variable:

Terminal
echo "Hello, world!" | (read; echo "$REPLY")

output

Hello, World!

If the number of variables supplied to read is less than the number of words, the last variable receives all remaining input:

Terminal
echo "Linux is awesome." | (read var1 var2; echo -e "Var1: $var1 \nVar2: $var2")

output

Var1: Linux
Var2: is awesome.

When more variables are provided than words, extra variables are set to empty:

Terminal
echo "Hello, World!" | (read var1 var2 var3; echo -e "Var1: $var1 \nVar2: $var2 \nVar3: $var3")

output

Var1: Hello,
Var2: World!
Var3:

Backslash Escaping and the `-r` Option

By default, read interprets the backslash as an escape character, which can cause unexpected behavior. To disable backslash escaping, invoke the command with the -r option.

The example below shows how read works with and without -r:

Terminal
read <<< "Hello, \tWorld!"
printf %s "$REPLY"

output

Hello, tWorld!

Terminal
read -r <<< "Hello, \tWorld!"
printf %s "$REPLY"

output

Hello, \tWorld!

Always prefer read -r unless you specifically need escape processing.

Changing the Delimiter (IFS)

The default behavior of read is to split the line into words using spaces, tabs, and newlines as delimiters. To use a different character, assign it to the IFS variable (Internal Field Separator):

Terminal
echo "Linux:is:awesome." | (IFS=":" read -r var1 var2 var3; echo -e "$var1 \n$var2 \n$var3")

output

Linux
is
awesome.

When IFS is set to a character other than space or tab, words are separated by exactly one occurrence of that character:

Terminal
echo "Linux::is:awesome." | \
 (IFS=":" read -r var1 var2 var3 var4; echo -e "Var1: $var1 \nVar2: $var2 \nVar3: $var3 \nVar4: $var4")

The line is separated into four words. The second word is empty, representing the segment between the two consecutive : delimiters:

output

Var1: Linux
Var2:
Var3: is
Var4: awesome.

You can specify multiple delimiters by assigning more than one character to IFS with no spaces between them:

Terminal
echo 'Linux_is-awesome.' | (IFS="-_" read -r var1 var2 var3; echo -e "$var1 \n$var2 \n$var3")

output

Linux
is
awesome.

Prompting the User

When writing interactive Bash scripts, use the -p option to display a prompt before reading. The prompt is printed before read executes and does not include a newline:

Terminal
read -r -p "Are you sure? "

Generally, you would use read within a while loop to prompt the user for one of the expected answers.

The following script prompts the user for a system reboot :

sh
while true; do
 read -r -p "Do you wish to reboot the system? (Y/N): " answer
 case $answer in
 [Yy]* ) reboot; break;;
 [Nn]* ) exit;;
 * ) echo "Please answer Y or N.";;
 esac
done

To read sensitive information such as a password, use the -s option to suppress terminal echoing:

sh
read -r -s -p "Enter your password: "

Reading a File Line by Line

One of the most common uses of read is processing a file line by line. The standard pattern is:

Terminal
while IFS= read -r line; do
 echo "$line"
done < filename.txt

IFS= — clears the field separator for this command so that leading and trailing whitespace in each line is preserved.
-r — disables backslash interpretation so that backslashes in the file are read literally.
< filename.txt — redirects the file as standard input to the loop.

To process the output of a command instead of a file, use process substitution:

Terminal
while IFS= read -r line; do
 echo "Found: $line"
done < <(find /var/log -name "*.log")

Warning

Avoid piping directly into a while read loop (command | while read). In Bash, the right side of a pipe runs in a subshell, so any variables set inside the loop will not be available after the loop ends. Use process substitution or input redirection instead.

Assign the Words to an Array

To read words into an array instead of individual variables, use the -a option:

sh
read -r -a MY_ARR <<< "Linux is awesome."

for i in "${MY_ARR[@]}"; do
 echo "$i"
done

output

Linux
is
awesome.

When both an array and a variable name are given, all words are assigned to the array.

Reading a Fixed Number of Characters

The -n option tells read to return after reading exactly N characters instead of waiting for a newline:

Terminal
read -r -n 1 -p "Press any key to continue..."

This is useful for “press any key” prompts and single-character menu selections. The command returns as soon as the character is received without requiring the user to press Enter.

Custom Line Delimiter with `-d`

By default, read stops at a newline. The -d option changes the delimiter to any character:

Terminal
read -r -d ":" var <<< "hello:world"
echo "$var"

output

hello

read consumed input up to and including the first : and assigned the preceding text to var. This is useful for parsing delimited streams or null-terminated input (-d '').

The Timeout Option

The -t option limits how long read waits for input, in seconds. Fractional values are supported (for example, 0.5 for half a second):

sh
read -r -t 10 -p "Enter your nickname (10 seconds timeout): " nickname
if [[ $? -gt 128 ]]; then
 echo "Timeout occurred!"
 nickname="(default)"
else
 echo "Hello, $nickname!"
fi

If a complete line arrives before the timeout, read succeeds. If it times out, it returns an exit status greater than 128 and discards any partial input.

When the timeout is set to 0, read checks whether input is immediately available and returns without waiting.

Quick Reference

Option	Description
`read var`	Read a line into `var`
`read var1 var2`	Split input into multiple variables
`read -r var`	Disable backslash escaping (recommended)
`read -p "prompt" var`	Display a prompt before reading
`read -s var`	Silent mode — do not echo input
`read -t N var`	Timeout after N seconds
`read -n N var`	Read exactly N characters
`read -d ":" var`	Read until delimiter character
`read -a arr`	Read words into an array
`IFS=":" read -r a b`	Split on a custom delimiter
`while IFS= read -r line`	Read a file line by line

For a printable quick reference, see the Bash cheatsheet .

Troubleshooting

Variables are empty after the while read loop
This happens when read runs in a subshell — most commonly when piping into the loop: command | while read. Variables set inside a subshell are not visible in the parent shell. Use process substitution or input redirection instead: while IFS= read -r line; do ...; done < <(command) or done < file.

Leading and trailing whitespace is stripped from input
By default, IFS includes space and tab, so read trims whitespace from the start and end of each word. To preserve whitespace, clear IFS before read: IFS= read -r line.

Backslash characters disappear
Without -r, read processes backslashes as escape characters (\n becomes a newline, \t becomes a tab, etc.). Always use read -r unless you specifically want this behavior.

-t option not working
The timeout option is a Bash-specific feature. If your script runs under sh (e.g., #!/bin/sh), -t may not be available. Use #!/bin/bash in the shebang line.

FAQ

Why is my variable empty after the while read loop?
The right side of a pipe runs in a subshell in Bash. Variables set inside the subshell are lost when it exits. Replace command | while IFS= read -r line with while IFS= read -r line; do ...; done < <(command) to keep variables in the current shell.

What does IFS= (empty assignment) do before read?
Setting IFS to an empty value before read disables field splitting entirely, which means leading and trailing whitespace is preserved and no splitting on spaces or tabs occurs. It is the recommended form when reading file lines: while IFS= read -r line.

Should I always use read -r?
Yes, in almost all cases. Without -r, backslashes in the input are interpreted as escape sequences, which can silently corrupt data. Use read -r by default and omit it only when you explicitly need escape processing.

How do I read input without showing it on the terminal?
Use the -s (silent) flag: read -r -s -p "Password: " pass. The input is captured in $pass without being echoed to the terminal. Remember to print a newline after (echo) since -s suppresses it.

What is the REPLY variable?
When read is called without any variable names, the entire input line is stored in the built-in variable REPLY. It is automatically available without being declared: read -r; echo "$REPLY".

Conclusion

The read command is the primary way to accept input in Bash scripts — whether prompting a user, processing a file line by line, or splitting delimited data. Use read -r by default, clear IFS when whitespace matters, and prefer input redirection over pipes to avoid subshell variable scoping issues.

Bash Heredoc: Complete Guide with Examples

hello@linuxize.com (Linuxize) — Thu, 09 May 2019 20:31:47 +0100

When writing shell scripts, you may need to pass a multiline block of text or code to an interactive command such as tee , cat, or sftp .

In Bash and other shells like Zsh, a Here document (Heredoc) is a type of redirection that allows you to pass multiple lines of input directly to a command.

Heredocs are commonly used for:

Generating configuration files
Passing scripts to remote servers via SSH
Automating interactive commands
Writing readable multi-line strings in shell scripts

Heredoc Syntax

The basic heredoc syntax looks like this:

txt
[COMMAND] <<[-] 'DELIMITER'
 HERE-DOCUMENT
DELIMITER

The first line starts with an optional command followed by the special redirection operator << and the delimiting identifier.
- You can use any string as a delimiting identifier, though EOF or END are the most common.
- If the delimiting identifier is unquoted, the shell will substitute all variables, commands and special characters before passing the here-document lines to the command.
- Appending a minus sign to the redirection operator <<- causes all leading tab characters to be ignored. This allows you to use indentation when writing heredocs in shell scripts.
The here-document block can contain strings, variables, commands and any other type of input.
The last line ends with the delimiting identifier. White space in front of the delimiter is not allowed.

Heredoc is most often used in combination with the cat command .

Variable and Command Expansion

Unquoted Delimiter (Default Behavior)

If the delimiter is not quoted, the shell performs:

Variable expansion ($VAR)
Command substitution ($(command))
Backslash handling for characters such as \, $, and `

sh
cat << EOF
The current working directory is: $PWD
You are logged in as: $(whoami)
EOF

The output shows the expanded variable and command substitution:

output

The current working directory is: /home/linuxize
You are logged in as: linuxize

Quoted Delimiter (Literal Mode)

Quoting the delimiter with single or double quotes disables all shell expansions:

sh
cat << 'EOF'
The current working directory is: $PWD
You are logged in as: $(whoami)
EOF

output

The current working directory is: $PWD
You are logged in as: $(whoami)

When the delimiter is quoted, no parameter expansion or command substitution is performed by the shell.

This is useful for configuration files, scripts, or regex patterns where you want to prevent accidental variable substitution.

Indented Heredocs with `<<-`

When using heredocs inside functions, loops, or conditionals, indentation improves readability. The <<- operator strips leading tab characters (not spaces) from each line of the heredoc, including the closing delimiter.

sh
#!/bin/bash

generate_page() {
 cat <<-EOF
 <html>
 <head>
 <title>$1</title>
 </head>
 <body>
 <h1>$1</h1>
 </body>
 </html>
 EOF
}

generate_page "My Page"

output

<html>
<head>
<title>My Page</title>
</head>
<body>
<h1>My Page</h1>
</body>
</html>

Warning

The <<- operator only strips tabs, not spaces. If your editor converts tabs to spaces, the heredoc will not work as expected.

Redirecting Heredoc Output to a File

Instead of displaying the output on the screen, you can redirect it to a file using the > or >> operators:

sh
cat << EOF > /tmp/myfile.txt
The current working directory is: $PWD
You are logged in as: $(whoami)
EOF

If the file does not exist, it will be created. Using > overwrites the file, while >> appends to it.

You can also use tee to write to a file that requires root permissions:

sh
sudo tee /etc/myconfig.conf << EOF
setting1=value1
setting2=value2
EOF

Piping Heredoc Content

Heredoc input can be piped to other commands for further processing.

In the following example, the sed command replaces all instances of l with e:

sh
cat <<'EOF' | sed 's/l/e/g'
Hello
World
EOF

output

Heeeo
Wored

To write the piped data to a file:

sh
cat <<'EOF' | sed 's/l/e/g' > file.txt
Hello
World
EOF

Using Heredoc with SSH

Heredocs are useful for executing multiple commands on a remote server over SSH .

When using an unquoted delimiter, escape variables that should be evaluated on the remote server:

sh
ssh -T user@host.com << EOF
echo "Local working directory: $PWD"
echo "Remote working directory: \$PWD"
EOF

output

Local working directory: /home/linuxize
Remote working directory: /home/user

The first $PWD is expanded locally before the heredoc is sent, while \$PWD is escaped and evaluated on the remote server.

To prevent all local expansion, quote the delimiter:

sh
ssh -T user@host.com << 'EOF'
echo "Remote working directory: $PWD"
echo "Remote user: $(whoami)"
EOF

Best practices when using heredoc with SSH:

Use quoted delimiters when all commands should run on the remote server
Escape variables (\$VAR) that should be evaluated remotely when using unquoted delimiters
Consider SSH key-based authentication for automation

Herestring

A herestring is a simpler form of heredoc that passes a single line (or a short string) to a command’s standard input. It uses the <<< operator:

sh
command <<< "string"

For example, to pass a string to grep:

sh
grep "linux" <<< "I love linux and bash"

output

I love linux and bash

Herestrings are useful when you need to pass a variable or short string to a command without using echo and a pipe:

sh
# Using herestring
tr '[:lower:]' '[:upper:]' <<< "hello world"

# Equivalent using echo and pipe
echo "hello world" | tr '[:lower:]' '[:upper:]'

Both commands output:

output

HELLO WORLD

Practical Examples

Writing a Configuration File

sh
cat << EOF > /tmp/nginx.conf
server {
 listen 80;
 server_name $DOMAIN;
 root /var/www/$DOMAIN/html;

 location / {
 try_files \$uri \$uri/ =404;
 }
}
EOF

Note that $DOMAIN is expanded locally, while $uri is escaped to be written literally.

Running SQL Queries

sh
mysql -u root -p << EOF
CREATE DATABASE myapp;
USE myapp;
CREATE TABLE users (
 id INT AUTO_INCREMENT PRIMARY KEY,
 name VARCHAR(100),
 email VARCHAR(100)
);
EOF

Generating JSON

sh
cat << EOF > data.json
{
 "name": "$USER",
 "home": "$HOME",
 "shell": "$SHELL"
}
EOF

Common Mistakes

Spaces Before Closing Delimiter

The closing delimiter must be at the beginning of a line with no leading whitespace:

sh
# Wrong - spaces before EOF
cat << EOF
Hello World
 EOF

# Correct
cat << EOF
Hello World
EOF

Using Spaces Instead of Tabs with `<<-`

The <<- operator only strips tabs, not spaces:

sh
# Wrong - using spaces (will not be stripped)
if true; then
 cat <<- EOF
 Hello # indented with spaces
 EOF
fi

# Correct - using tabs
if true; then
 cat <<- EOF
 Hello # indented with tabs
 EOF
fi

Unintended Variable Expansion

Variables in heredocs are expanded by default, which can cause unexpected results:

sh
# This will fail or produce unexpected output
cat << EOF
The price is $5.00
EOF

Fix by escaping the dollar sign or quoting the delimiter:

sh
# Option 1: Escape the dollar sign
cat << EOF
The price is \$5.00
EOF

# Option 2: Quote the delimiter
cat << 'EOF'
The price is $5.00
EOF

Quick Reference

Syntax	Description
`<< EOF`	Heredoc with variable expansion
`<< 'EOF'`	Heredoc without variable expansion (literal)
`<< "EOF"`	Same as quoted single quotes (literal)
`<<- EOF`	Heredoc with leading tabs stripped
`<<< "string"`	Herestring (single line input)

Conclusion

Heredocs are a powerful tool for embedding multi-line input directly in your scripts. Quote the delimiter when you need literal text, leave it unquoted when you need variable expansion, and use <<- with tabs to keep indented scripts readable. To learn how to run your scripts, see how to run a bash script .

Bash: Write to File

hello@linuxize.com (Linuxize) — Mon, 04 Jan 2021 19:01:12 +0100

When you write a Bash script, you often need to capture command output, save logs, or generate small configuration files on the fly. Bash gives you a few ways to do this directly from the shell, without reaching for a separate editor.

This guide explains how to write text to a file in Bash using the redirection operators (> and >>) and the tee command, including how to create new files, append to existing ones, and write to files that require root privileges.

Writing to a File Using Redirection Operators

In Bash, the redirection of output allows you to capture the output from a command and write it to a file.

The general format for redirecting and writing output to a file is as follows:

txt
output > filename
output >> filename

The > redirection operator writes the output to a given file. If the file exists, it is truncated to zero length. Otherwise, the file is created. Be extra careful when using this operator as you may overwrite an important file.
The >> redirection operator appends the output to a given file. The file is created if it does not exist.

You need to have write permissions to the file. Otherwise, you will receive a permission denied error.

Here is a simple example showing how to redirect the output of the echo command to a file:

Terminal
echo "this is a line" > file.txt

To prevent overwriting existing files, enable the “noclobber” option with the set builtin:

Terminal
set -o noclobber
echo "this is a line" > file.txt

output

bash: file.txt: cannot overwrite existing file

The >| operator allows you to override the Bash “noclobber” option:

Terminal
set -o noclobber
echo "this is a line" >| file.txt

The >> operator appends the output to the end of the file, rather than overwriting it:

Terminal
echo "this is a line" >> file.txt

Use the printf command to create more complex output:

Terminal
printf "Hello, I am %s.\n" "$USER" > file.txt

If you want to write multiple lines to a file, use the Here document (Heredoc) redirection.

For example, you can pass the content to the cat command and write it to a file:

Terminal
cat << EOF > file.txt
The current working directory is: $PWD
You are logged in as $(whoami)
EOF

To append the lines, replace > with >> before the file name:

Terminal
cat << EOF >> file.txt
The current working directory is: $PWD
You are logged in as $(whoami)
EOF

You can write the output of any command to a file:

Terminal
date +"Year: %Y, Month: %m, Day: %d" > file.txt

The output of the date command will be written to the file.

Writing to a File Using the tee Command

The tee command reads from the standard input and writes to both standard output and one or more files simultaneously.

Terminal
echo "this is a line" | tee file.txt

The default behavior of tee is to overwrite the specified file, same as the > operator. To append the output to the file, invoke the command with the -a (--append) option:

Terminal
echo "this is a line" | tee -a file.txt

If you do not want tee to write to the standard output, you can redirect it to /dev/null:

Terminal
echo "this is a line" | tee file.txt >/dev/null

To write the text to more than one file, specify the files as arguments to the tee command:

Terminal
echo "this is a line" | tee file_1.txt file_2.txt file_3.txt

Another advantage of the tee command is that you can use it in conjunction with sudo to write to files owned by other users. To write text to a file that you do not have write permissions to, prepend sudo before tee:

Terminal
echo "this is a line" | sudo tee file.txt

The output of echo is piped to tee, which runs with root privileges and writes the text to the file.

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Task	Syntax
Write to file (overwrite)	`command > file.txt`
Append to file	`command >> file.txt`
Prevent overwriting	`set -o noclobber`
Override noclobber	`command >\| file.txt`
Write multiple lines	`cat << EOF > file.txt`
Write with tee	`command \| tee file.txt`
Append with tee	`command \| tee -a file.txt`
Write as root	`command \| sudo tee file.txt`

FAQ

What is the difference between > and >>?
The > operator overwrites the file with the new output. The >> operator appends the output to the end of the existing file without removing its contents.

How do I write to a file without overwriting it?
Use the >> append operator, or enable the noclobber option with set -o noclobber to prevent accidental overwrites when using >.

How do I write to a file that requires root permissions?
Pipe the output to sudo tee: echo "text" | sudo tee /etc/somefile. Using sudo directly with > does not work because the shell handles the redirection before sudo takes effect.

How do I write multiple lines to a file in a script?
Use a heredoc : cat << EOF > file.txt followed by your lines and a closing EOF delimiter.

Conclusion

For more complex output, pair these redirection patterns with printf for formatted strings, or with a heredoc when building multi-line configuration files.

Bash Append to File: >>, tee, and Heredoc Examples

hello@linuxize.com (Linuxize) — Sat, 21 Dec 2019 21:51:12 +0100

In Bash, appending text to a file means adding content to the end of the file without overwriting what is already there. The >> redirection operator is the most direct way to do this, but the tee command and heredoc syntax offer additional flexibility, especially when appending to multiple files or to files that require elevated permissions.

To append to a file, you need write permissions on it. Otherwise, you will receive a Permission denied error.

This guide explains how to append to files in Bash with practical examples for each method.

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Method	Command	Use When
Redirection	`echo "text" >> file.txt`	Appending to a single file
Heredoc	`cat << EOF >> file.txt`	Appending multiple lines
tee	`echo "text" \| tee -a file.txt`	Appending and displaying output
tee + sudo	`echo "text" \| sudo tee -a file.txt`	Appending to a protected file
tee multiple	`echo "text" \| tee -a f1.txt f2.txt`	Appending to multiple files at once
Append a file	`cat source.txt >> target.txt`	Adding one file’s contents to another

Append to a File Using Redirection

Redirection allows you to capture the output from a command and send it to a file. The >> operator appends the output to the end of a file without overwriting existing content.

The two most commonly used commands for printing text to standard output are echo and printf. To append their output to a file, specify the filename after the >> operator:

Terminal
echo "this is a new line" >> file.txt

When used with the -e option, the echo command interprets backslash-escaped characters such as \n for newline:

Terminal
echo -e "this is a new line \nthis is another new line" >> file.txt

To produce more complex or formatted output, use the printf command:

Terminal
printf "Hello, I am %s.\n" "$USER" >> file.txt

You can append the output of any command to a file. Here is an example using the date command:

Terminal
date +"Year: %Y, Month: %m, Day: %d" >> file.txt

To append multiple lines at once, use a Here document (heredoc). It is a type of redirection that passes a block of text as input to a command. The following example passes content to the cat command and appends it to a file:

sh
cat << EOF >> file.txt
The current working directory is: $PWD
You are logged in as: $(whoami)
EOF

When appending to a file using redirection, always use >>. Using the single > operator will overwrite the entire file instead of appending to it.

Append to a File Using tee

The tee command reads from standard input and writes to both standard output and one or more files simultaneously.

By default, tee overwrites the specified file. To append instead, use the -a (--append) option:

Terminal
echo "this is a new line" | tee -a file.txt

If you do not want tee to write to standard output, redirect it to /dev/null:

Terminal
echo "this is a new line" | tee -a file.txt >/dev/null

One advantage of tee over >> is that it works with sudo, allowing you to append to files owned by root or another user. When combined with sudo, tee runs with elevated privileges and can write to protected files:

Terminal
echo "this is a new line" | sudo tee -a file.txt

To append to more than one file at a time, pass multiple filenames as arguments:

Terminal
echo "this is a new line" | tee -a file1.txt file2.txt file3.txt

Append the Contents of One File to Another

A common task is adding the contents of one file to the end of another. Redirect the output of cat with the >> operator:

Terminal
cat source.txt >> target.txt

This reads source.txt and appends every line to target.txt, leaving the original target content in place. To merge several files into one, list them all before the operator:

Terminal
cat file1.txt file2.txt >> combined.txt

cat concatenates the files in the order given and appends the result to combined.txt.

Troubleshooting

File content is overwritten instead of appended
You used > instead of >>. The single > operator truncates the file before writing. Always use >> to preserve existing content.

Permission denied when appending
Your user does not have write permission on the file. Use sudo tee -a instead of >>: echo "text" | sudo tee -a file.txt.

Heredoc content has unexpected indentation
Tabs inside the heredoc body are preserved literally in the output. Use <<-EOF instead of <<EOF to strip leading tabs from each line.

FAQ

What is the difference between > and >>?
> overwrites the file from the beginning, destroying any existing content. >> appends to the end of the file and leaves existing content intact. Always double-check the operator before redirecting to an important file.

How do I append a blank line to a file?
Run echo >> file.txt. Without arguments, echo outputs an empty line, which >> appends to the file.

How do I append to a file inside a Bash script?
Use the same >> operator or tee -a inside the script. All methods in this guide work identically within scripts.

How do I append to a file I do not have permission to write to?
Pipe the output to tee -a with sudo: echo "text" | sudo tee -a /etc/file.conf. This runs tee as root while keeping your own shell session unprivileged.

Conclusion

The >> redirection operator is the simplest way to append text to a file in Bash. Use tee -a when you need to append to multiple files at once or when the target file requires elevated permissions. To send only error messages to a file, see how to redirect stderr .

How to Redirect stderr to stdout in Bash

hello@linuxize.com (Linuxize) — Fri, 05 Jun 2020 20:11:41 +0100

In Bash and other Linux shells, every running program uses three standard I/O streams. Each stream is represented by a numeric file descriptor:

0 - stdin, the standard input stream.
1 - stdout, the standard output stream.
2 - stderr, the standard error stream.

A file descriptor is simply a number that represents an open file. The input stream provides data to the program, usually from keyboard input. The program sends its regular output to stdout and error messages to stderr. By default, both stdout and stderr are displayed on the screen.

When you redirect the output of a command to a file or pipe it to another command, you might notice that error messages still appear on the screen. This is because redirection typically affects only stdout, while stderr continues to go to the terminal.

This guide explains how to redirect stderr to stdout, redirect both streams to a file, and other common redirection patterns in Bash.

Quick Answer

To redirect stderr to the same file as stdout, place 2>&1 after the file redirection:

Terminal
command > file.txt 2>&1

In Bash, you can use the shorter &> form:

Terminal
command &> file.txt

The order matters. command > file.txt 2>&1 sends both streams to file.txt, while command 2>&1 > file.txt sends only stdout to the file and leaves stderr on the terminal.

Redirecting Output to a File

Streams can be redirected using the n> operator, where n is the file descriptor number. When n is omitted, it defaults to 1 (standard output).

The following two commands are equivalent. Both redirect stdout to a file:

Terminal
command > file.txt

Terminal
command 1> file.txt

To redirect standard error (stderr) to a file, use the 2> operator:

Terminal
command 2> error.txt

You can redirect stdout and stderr to two separate files:

Terminal
command 1> output.txt 2> error.txt

Redirecting stderr to stdout

When saving a program’s output to a file, it is common to redirect stderr to stdout so that everything ends up in a single file.

To redirect stderr to stdout, use 2>&1:

Terminal
command > file.txt 2>&1

In this example, > file.txt redirects stdout to file.txt, and 2>&1 redirects stderr to the current location of stdout (which is now file.txt).

Here is a safe example you can run from any directory. The first path should exist, while the second path is intentionally missing:

Terminal
ls /tmp /missing-path > /tmp/redirect-demo.txt 2>&1

Display the file:

Terminal
cat /tmp/redirect-demo.txt

The file contains the normal ls output for /tmp and the error message for /missing-path, because both stdout and stderr were redirected to the same destination.

Bash also provides the &> shorthand, which redirects both stdout and stderr to a file in a single operator:

Terminal
command &> file.txt

Both forms produce the same result. The &> syntax is shorter and preferred in Bash scripts, but 2>&1 is portable across all POSIX shells.

Redirection Order Matters

The order of redirection operators changes the result. In the following example, only stdout is redirected to the file, even though it looks like both streams are captured:

Terminal
command 2>&1 > file.txt

Bash evaluates redirections left to right. 2>&1 first points stderr to wherever stdout is at that moment (the terminal), then > file.txt redirects stdout to the file. stderr keeps its earlier destination, the terminal.

Always place 2>&1 after the file redirection:

Terminal
command > file.txt 2>&1

Appending Instead of Overwriting

The > operator overwrites the target file each time. To append output to an existing file, use >>:

Terminal
command >> file.txt 2>&1

This appends stdout to file.txt and redirects stderr to the same location.

To append both streams using the shorthand syntax, use &>>:

Terminal
command &>> file.txt

Appending is useful for log files where you want to accumulate output across multiple runs.

Piping stderr Through Another Command

By default, the pipe operator (|) only passes stdout to the next command. Any error messages from the first command are printed to the terminal, not sent through the pipe.

For pipeline syntax, exit statuses, and pipefail, see our guide to Linux pipes and the | operator .

To pipe both stdout and stderr, redirect stderr to stdout before the pipe:

Terminal
command 2>&1 | grep "error"

In this example, both regular output and error messages are passed to grep , which filters for lines containing “error”.

Bash also provides the |& shorthand:

Terminal
command |& grep "error"

Both forms are equivalent. Use 2>&1 | for POSIX compatibility or |& for brevity in Bash scripts.

Discarding Output with /dev/null

/dev/null is a special file that discards all data written to it. Redirecting to /dev/null silences output.

To suppress error messages while keeping regular output:

Terminal
command 2> /dev/null

To suppress all output (both stdout and stderr):

Terminal
command &> /dev/null

To keep only error messages and discard regular output:

Terminal
command > /dev/null

This pattern is common in scripts where you only want to check the exit status of a command without displaying its output.

Redirecting stderr and stdout to Different Destinations

In some cases, you may want to save errors to a log file while still displaying regular output on the screen.

To redirect only stderr to a file while stdout prints normally:

Terminal
command 2> error.log

To do the opposite, display errors on the screen while saving regular output to a file:

Terminal
command > output.log

To save both streams to separate files:

Terminal
command > output.log 2> error.log

If you need to both save and display output at the same time, use the tee command:

Terminal
command 2>&1 | tee output.log

This sends the combined output to output.log and also displays it on the terminal.

To save stdout and stderr to separate files while also showing both on the terminal, use process substitution:

Terminal
command > >(tee output.log) 2> >(tee error.log >&2)

Each stream goes through its own tee process. The >&2 inside the second redirect keeps error output flowing back to stderr on the terminal, so warnings stay visible.

Redirecting All Output in a Script with exec

To redirect every command’s output for the rest of a script, use the exec builtin at the top of the file. This avoids repeating >> log 2>&1 after every line:

backup.shsh
#!/bin/bash
exec >> /var/log/backup.log 2>&1

echo "Starting backup..."
rsync -a /data/ /backup/
echo "Done."

After the exec line, every later command’s stdout and stderr go to the log file. This pattern is common in cron jobs and long-running scripts where you want a single combined log without touching each command.

To redirect only stderr for the rest of the script, omit the first redirection:

Terminal
exec 2>> /var/log/backup.err

Quick Reference

Syntax	Description
`command > file`	Redirect `stdout` to a file (overwrite)
`command >> file`	Redirect `stdout` to a file (append)
`command 2> file`	Redirect `stderr` to a file
`command 2>> file`	Append `stderr` to a file
`command > file 2>&1`	Redirect both `stdout` and `stderr` to a file
`command &> file`	Shorthand for redirecting both streams (Bash)
`command &>> file`	Append both streams to a file (Bash)
`command 2>&1 \| cmd`	Pipe both streams to another command
`command \|& cmd`	Shorthand for piping both streams (Bash)
`command 2> /dev/null`	Discard error messages
`command &> /dev/null`	Discard all output
`exec >> file 2>&1`	Redirect all output for the rest of a script

FAQ

What is the difference between > and >>?
The > operator overwrites the target file, while >> appends to it. Use >> when you want to add output to an existing file without erasing its contents.

What does 2>&1 mean?
It redirects file descriptor 2 (stderr) to the same destination as file descriptor 1 (stdout). The & before 1 tells Bash that 1 is a file descriptor, not a filename.

What is /dev/null?
/dev/null is a special device file that discards all data written to it. Redirecting output to /dev/null effectively silences the command.

Is &> the same as 2>&1?
In Bash, command &> file is equivalent to command > file 2>&1. Both redirect stdout and stderr to the same file. However, &> is a Bash extension and is not available in all POSIX shells.

How do I redirect stderr to stdout in a pipe?
Use command 2>&1 | next_command or the Bash shorthand command |& next_command. Both send stderr and stdout through the pipe.

Conclusion

Redirecting stderr and stdout helps you capture logs, filter errors, and keep scripts quiet when needed. Use 2>&1 for portable shell syntax, &> or |& for Bash shorthand, and /dev/null when you intentionally want to discard output.

Linux Pipes Explained: How to Use the | Operator

hello@linuxize.com (Linuxize) — Thu, 11 Jun 2026 09:40:00 +0200

A pipe in Linux is a one-way channel that connects the standard output of one process to the standard input of another. The shell builds the channel for you when you type a | character between two commands. The first command writes; the second command reads. Both run at the same time, and data flows between them through the kernel without ever touching disk.

The pipe is one of the oldest and most useful ideas in Unix. It is what makes a small command such as grep or sort feel like part of a much larger toolbox. Knowing how pipes behave, where they fit in a shell pipeline, and when to reach for related tools such as xargs and process substitution makes shell work more effective.

This guide explains how to build pipelines, handle errors and exit statuses, and use related features such as named pipes and process substitution.

Pipe Syntax

The general syntax for a shell pipeline is:

txt
command1 | command2 [| command3 ...]

Each command passes its standard output to the standard input of the command on its right. A pipeline can contain two commands or a longer chain, and the shell runs all stages concurrently.

How a Pipe Works

A shell pipeline of the form cmd1 | cmd2 follows these steps:

The shell creates an anonymous pipe with the pipe(2) system call. The call returns two file descriptors: one for reading and one for writing.
The shell starts the commands and connects the first command’s standard output (file descriptor 1) to the write end of the pipe.
The second command reads from the pipe through its standard input (file descriptor 0), while the kernel handles the data flow between them.

Linux pipes have a limited in-kernel buffer. The default is commonly 16 memory pages, or 64 KiB on systems with 4 KiB pages, but applications should not rely on a fixed capacity. When the buffer fills, the writer waits until the reader consumes more data.

A First Example

The following pipeline generates three service names and filters them with grep:

Terminal
printf '%s\n' ssh.service NetworkManager cron.service | grep -i network

output

NetworkManager

printf writes one service name per line. The pipe sends those lines to grep, which prints the line containing network. The -i option makes the match case-insensitive.

The same pattern works with any command that writes to standard output and any command that reads from standard input.

Pipes Pass Data, Not Files

A pipe carries a stream of bytes, not a file name or command-line argument. The receiving command reads that stream from standard input.

For example, the following command sends the text /etc/hosts to wc. It does not ask wc to open that file:

Terminal
printf '%s\n' /etc/hosts | wc -l

output

The result is 1 because wc received one line of text. To count lines in the file, pass the path as an argument with wc -l /etc/hosts. Commands such as rm, mv, and stat also expect paths as arguments rather than reading them from standard input.

Combining Pipes with xargs

xargs reads items from standard input and turns them into arguments for another command. This example creates three empty files:

Terminal
printf '%s\0' report-1.txt report-2.txt report-3.txt | xargs -0 touch

The null character separates each name, and xargs -0 converts the three items into arguments for touch. The same null-delimited pattern safely handles spaces and newlines in file names.

Before deleting files found by find, print the matches and inspect them:

Terminal
find . -type f -name '*.log' -mtime +30 -print

When the list is correct, use -print0 with xargs -0. The -r option prevents GNU xargs from running rm when no files match:

Terminal
find . -type f -name '*.log' -mtime +30 -print0 | xargs -0 -r rm --

The -- marker prevents a path beginning with a hyphen from being interpreted as an rm option.

Reading the Exit Status of a Pipeline

Bash returns the exit status of the last command in a pipeline by default. A failure in an earlier stage can therefore go unnoticed:

Terminal
grep something /missing/file 2>/dev/null | wc -l
echo "$?"

output

0
0

grep failed because the file did not exist, but wc -l succeeded, so the pipeline status was 0. Enable pipefail when the script must detect failures in any stage:

Terminal
set -o pipefail
grep something /missing/file 2>/dev/null | wc -l
echo "$?"

output

0
2

With pipefail enabled, the pipeline returns the status of the rightmost command that failed, or 0 if every command succeeded.

To inspect every stage individually, use the PIPESTATUS array:

Terminal
ls /missing 2>/dev/null | grep foo
echo "${PIPESTATUS[@]}"

output

2 1

PIPESTATUS[0] is ls and PIPESTATUS[1] is grep.

Pipes and Standard Error

A pipe only carries standard output (file descriptor 1). Standard error (file descriptor 2) goes straight to the terminal:

Terminal
ls /missing | wc -l

output

ls: cannot access '/missing': No such file or directory
0

The error message bypassed the pipe. To send errors through the same pipe, redirect standard error to standard output with 2>&1 before the pipe:

Terminal
ls /missing 2>&1 | tee log.txt

The tee command writes the redirected error stream to log.txt and displays it in the terminal. Bash also provides |& as shorthand for 2>&1 |:

Terminal
ls /missing |& tee log.txt

For more redirection patterns and details about ordering, see how to redirect stderr to stdout .

Named Pipes (FIFOs)

The | operator creates an anonymous pipe that vanishes when the pipeline ends. A named pipe lives on the filesystem and lets unrelated processes share data. Create one with mkfifo:

Terminal
mkfifo /tmp/linuxize-pipe

In the first terminal, start the reader:

Terminal
cat /tmp/linuxize-pipe

In a second terminal, write to the FIFO:

Terminal
printf '%s\n' "hello" > /tmp/linuxize-pipe

output

hello

The first terminal prints hello. Opening a FIFO normally blocks until the other end connects, so start the reader and writer in separate terminals. Named pipes are useful for communication between scripts and processes that do not share a parent.

Remove the FIFO when finished:

Terminal
rm /tmp/linuxize-pipe

Process Substitution

When a command expects one or more file paths instead of standard input, process substitution can expose command output through a file-like path:

Terminal
diff <(printf '%s\n' alpha beta) <(printf '%s\n' alpha gamma)

diff receives two generated paths as arguments and compares the output from both printf commands. Bash implements those paths with /dev/fd entries or named pipes, depending on the operating system.

The reverse form, >(command), provides a file-like destination. The following pipeline saves a compressed copy while continuing to filter the original stream:

Terminal
some_command | tee >(gzip > out.gz) | grep error

Process substitution is available in Bash, ksh, and zsh, but it is not part of POSIX sh.

Useful Pipe-Based One-Liners

A handful of pipelines come up again and again in shell work:

Terminal
ps -eo pid,comm,%cpu --sort=-%cpu | head -n 6

ps sorts processes by CPU use, and head keeps the header plus the five busiest processes.

Terminal
awk '{print $1}' access.log | sort | uniq -c | sort -nr | head

This pipeline extracts client addresses from a common Nginx or Apache access log, counts duplicates, and prints the most frequent addresses first.

Terminal
du -h --max-depth=1 . 2>/dev/null | sort -h

The output shows disk use for the current directory and its immediate subdirectories, sorted from smallest to largest.

Each pipeline reads as a sentence: do this, then this, then this. The flow matches how the data moves between processes.

Quick Reference

Task	Command
Send output to another command	`command1 \| command2`
Build a multi-stage pipeline	`command1 \| command2 \| command3`
Pipe stdout and stderr in Bash	`command1 \|& command2`
Enable pipeline failure detection	`set -o pipefail`
Read every Bash pipeline status	`printf '%s\n' "${PIPESTATUS[@]}"`
Convert null-delimited input to arguments	`command1 \| xargs -0 command2`
Save and continue a stream	`command1 \| tee file \| command2`
Create a named pipe	`mkfifo /tmp/name`
Compare generated output as files	`diff <(command1) <(command2)`

Troubleshooting

A variable set in a pipeline is empty afterward
In Bash, each command in a multi-command pipeline normally runs in its own subshell. Variables set there do not survive in the parent shell:

Terminal
echo "data" | read x
printf '<%s>\n' "$x"

output

<>

Use a here-string or redirect process substitution into read so it runs in the current shell:

Terminal
read -r x <<< "data"
printf '<%s>\n' "$x"

output

<data>

A command reports a broken pipe
A writer receives SIGPIPE when the reader closes early, which often happens when head has collected enough lines. This can be expected, but do not hide all errors with a broad 2>/dev/null. Check the individual statuses with PIPESTATUS, especially when pipefail is enabled.

The next command ignores piped file names
Tools such as rm, mv, and stat expect paths as arguments. Use xargs -0 with null-delimited input, and preview destructive operations before running them.

Output appears in delayed batches
Some programs use larger output buffers when writing to a pipe instead of a terminal. GNU grep supports --line-buffered, and GNU stdbuf -oL command can request line-buffered output from programs that use standard C streams. These options are not portable to every Unix system or effective with every command.

Conclusion

Linux pipes let you connect focused commands without intermediate files. Use pipefail when every stage must succeed, xargs when a command needs arguments, and process substitution or named pipes when a simple pipeline does not fit the task.

Bash if...else Statement

hello@linuxize.com (Linuxize) — Tue, 28 May 2019 20:31:47 +0100

When writing shell scripts, you will often need to run different commands depending on whether a condition is true or false. Bash provides the if, if...else, and if...elif...else statements to handle exactly that, letting you branch your script logic based on test results, exit codes, or file checks.

This guide walks through each form of the Bash if statement with practical examples.

`if` Statement

Bash if conditionals can have different forms. The most basic if statement takes the following form:

sh
if TEST-COMMAND
then
 STATEMENTS
fi

The if statement starts with the if keyword followed by the conditional expression and the then keyword. The statement ends with the fi keyword.

If the TEST-COMMAND evaluates to True, the STATEMENTS are executed. If the TEST-COMMAND returns False, nothing happens; the STATEMENTS are ignored.

As a general practice, indent your code and separate code blocks with blank lines. Most people use either 4-space or 2-space indentation. Indentations and blank lines make your code more readable and organized.

The following example script checks whether a given number is greater than 10:

sh
#!/bin/bash

echo -n "Enter a number: "
read VAR

if [[ $VAR -gt 10 ]]
then
 echo "The variable is greater than 10."
fi

Save the code in a file and run it from the command line:

Terminal
bash test.sh

The script will prompt you to enter a number. If, for example, you enter 15, the test command will be evaluated as true because 15 is greater than 10, and the echo command inside the then clause will be executed.

output

The variable is greater than 10.

`if...else` Statement

The Bash if...else statement takes the following form:

sh
if TEST-COMMAND
then
 STATEMENTS1
else
 STATEMENTS2
fi

If the TEST-COMMAND evaluates to True, the STATEMENTS1 will be executed. Otherwise, if TEST-COMMAND returns False, the STATEMENTS2 will be executed. You can have only one else clause in the statement.

Adding an else clause to the previous script gives a message for both outcomes:

sh
#!/bin/bash

echo -n "Enter a number: "
read VAR

if [[ $VAR -gt 10 ]]
then
 echo "The variable is greater than 10."
else
 echo "The variable is less than or equal to 10."
fi

If you run the code and enter a number, the script will print a different message based on whether the number is greater or less/equal to 10.

`if...elif...else` Statement

The Bash if...elif...else statement takes the following form:

sh
if TEST-COMMAND1
then
 STATEMENTS1
elif TEST-COMMAND2
then
 STATEMENTS2
else
 STATEMENTS3
fi

If the TEST-COMMAND1 evaluates to True, the STATEMENTS1 will be executed. If the TEST-COMMAND2 evaluates to True, the STATEMENTS2 will be executed. If none of the test commands evaluate to True, the STATEMENTS3 will be executed.

You can have one or more elif clauses in the statement. The else clause is optional.

The conditions are evaluated sequentially. Once a condition returns True, the remaining conditions are not tested, and program control moves to the end of the if statements.

Adding an elif clause handles the equal case as well:

sh
#!/bin/bash

echo -n "Enter a number: "
read VAR

if [[ $VAR -gt 10 ]]
then
 echo "The variable is greater than 10."
elif [[ $VAR -eq 10 ]]
then
 echo "The variable is equal to 10."
else
 echo "The variable is less than 10."
fi

Nested `if` Statements

Bash allows you to nest if statements within if statements.

You can place multiple if statements inside another if statement.

The following script will prompt you to enter three numbers and print the largest number among the three numbers.

sh
#!/bin/bash

echo -n "Enter the first number: "
read VAR1
echo -n "Enter the second number: "
read VAR2
echo -n "Enter the third number: "
read VAR3

if [[ $VAR1 -ge $VAR2 ]]
then
 if [[ $VAR1 -ge $VAR3 ]]
 then
 echo "$VAR1 is the largest number."
 else
 echo "$VAR3 is the largest number."
 fi
else
 if [[ $VAR2 -ge $VAR3 ]]
 then
 echo "$VAR2 is the largest number."
 else
 echo "$VAR3 is the largest number."
 fi
fi

Here is what the output will look like:

output

Enter the first number: 4
Enter the second number: 7
Enter the third number: 2
7 is the largest number.

Info

When matching a single variable against many fixed values, the case statement is often a cleaner alternative.

Multiple Conditions

The logical OR and AND operators allow you to use multiple conditions in the if statements.

Here is another version of the script to print the largest number among the three numbers. In this version, instead of the nested if statements, we are using the logical AND (&&) operator.

sh
#!/bin/bash

echo -n "Enter the first number: "
read VAR1
echo -n "Enter the second number: "
read VAR2
echo -n "Enter the third number: "
read VAR3

if [[ $VAR1 -ge $VAR2 ]] && [[ $VAR1 -ge $VAR3 ]]
then
 echo "$VAR1 is the largest number."
elif [[ $VAR2 -ge $VAR1 ]] && [[ $VAR2 -ge $VAR3 ]]
then
 echo "$VAR2 is the largest number."
else
 echo "$VAR3 is the largest number."
fi

Test Operators

In Bash, the test command takes one of the following syntax forms. For a complete guide on numeric comparisons, see our Bash comparison operators tutorial.

txt
test EXPRESSION
[ EXPRESSION ]
[[ EXPRESSION ]]

To make the script portable, prefer using the old test [ command, which is available on all POSIX shells. The newer version of the test command [[ (double brackets) is supported on most modern systems using Bash, Zsh, and Ksh as default shells.

To negate the test expression, use the logical NOT (!) operator. When comparing strings , always use single or double quotes to avoid word splitting and globbing issues.

Below are some of the most commonly used operators:

-n VAR - True if the length of VAR is greater than zero.
-z VAR - True if the VAR is empty.
STRING1 = STRING2 - True if STRING1 and STRING2 are equal.
STRING1 != STRING2 - True if STRING1 and STRING2 are not equal.
INTEGER1 -eq INTEGER2 - True if INTEGER1 and INTEGER2 are equal.
INTEGER1 -gt INTEGER2 - True if INTEGER1 is greater than INTEGER2.
INTEGER1 -lt INTEGER2 - True if INTEGER1 is less than INTEGER2.
INTEGER1 -ge INTEGER2 - True if INTEGER1 is equal or greater than INTEGER2.
INTEGER1 -le INTEGER2 - True if INTEGER1 is equal or less than INTEGER2.
-h FILE - True if the FILE exists and is a symbolic link.
-r FILE - True if the FILE exists and is readable.
-w FILE - True if the FILE exists and is writable.
-x FILE - True if the FILE exists and is executable.
-d FILE - True if the FILE exists and is a directory.
-e FILE - True if the FILE exists and is a file, regardless of type (node, directory, socket, etc.).
-f FILE - True if the FILE exists and is a regular file (not a directory or device).

Here are a few practical examples using common operators.

Check whether two strings are equal:

sh
#!/bin/bash

read -p "Enter your username: " USER

if [[ "$USER" = "admin" ]]
then
 echo "Welcome, admin."
else
 echo "Access denied."
fi

Check whether a variable is empty:

sh
#!/bin/bash

read -p "Enter a value: " INPUT

if [[ -z "$INPUT" ]]
then
 echo "No value provided."
fi

Check whether a file exists before reading it:

sh
#!/bin/bash

FILE="/etc/hosts"

if [[ -f "$FILE" ]]
then
 echo "$FILE exists."
else
 echo "$FILE not found."
fi

One-Line Syntax

You can write if statements on a single line, which is useful for simple conditions:

sh
if [[ $VAR -gt 10 ]]; then echo "Greater than 10"; fi

With if...else:

sh
if [[ $VAR -gt 10 ]]; then echo "Greater"; else echo "Smaller or equal"; fi

Short-Circuit Evaluation

For simple conditions, you can use the logical AND (&&) and OR (||) operators as a shorthand:

sh
[[ $VAR -gt 10 ]] && echo "Greater than 10"

This is equivalent to:

sh
if [[ $VAR -gt 10 ]]; then
 echo "Greater than 10"
fi

You can also combine both operators for an if...else effect:

sh
[[ $VAR -gt 10 ]] && echo "Greater" || echo "Smaller or equal"

Info

Be careful with && and || combinations. If the command after && fails, the command after || will also execute.

Quick Reference

Syntax	Description
`if [[ condition ]]; then ... fi`	Basic if statement
`if [[ condition ]]; then ... else ... fi`	If with else
`if [[ c1 ]]; then ... elif [[ c2 ]]; then ... else ... fi`	If with elif
`[[ condition ]] && command`	Execute if true
`[[ condition ]] \|\| command`	Execute if false
`[[ c1 ]] && [[ c2 ]]`	AND - both must be true
`[[ c1 ]] \|\| [[ c2 ]]`	OR - one must be true

Conclusion

For a full list of test expressions you can use in your conditions, see our Bash comparison operators guide. If you need to match a single variable against many values, the Bash case statement is worth a look.

Bash case Statement: Match Patterns in Shell Scripts

hello@linuxize.com (Linuxize) — Thu, 28 Feb 2019 20:31:47 +0100

The Bash case statement simplifies complex conditionals when a single value needs to be compared against multiple patterns. It is cleaner and easier to read than a chain of nested if/elif statements, especially when there are more than two or three possible values.

The case statement works similarly to the switch statement in JavaScript or C. The main difference is that Bash case does not fall through to the next clause after a match by default — it stops and exits the statement once the first matching pattern executes.

This guide explains how to write Bash case statements, use glob patterns, handle command-line arguments, and control fall-through behavior.

case Statement Syntax

txt
case EXPRESSION in

 PATTERN_1)
 STATEMENTS
 ;;

 PATTERN_2)
 STATEMENTS
 ;;

 *)
 STATEMENTS
 ;;

esac

The statement opens with the case keyword, followed by the expression to match and the in keyword, and closes with esac.
Each pattern is followed by ) and ends with ;; to terminate the clause.
You can list multiple patterns in one clause by separating them with |.
The wildcard * as the last pattern acts as a default — it matches anything not caught above.
If no pattern matches and there is no default, the case statement exits with status 0.
Otherwise, the exit status is that of the last command executed in the matching clause.

Basic Example

Here is a script that prints the official language of a given country:

languages.shsh
#!/bin/bash

echo -n "Enter the name of a country: "
read COUNTRY

echo -n "The official language of $COUNTRY is "

case $COUNTRY in

 Lithuania)
 echo "Lithuanian"
 ;;

 Romania | Moldova)
 echo "Romanian"
 ;;

 Italy | "San Marino" | Switzerland | "Vatican City")
 echo "Italian"
 ;;

 *)
 echo "unknown"
 ;;
esac

Run the script:

Terminal
bash languages.sh

If you enter “Lithuania”, the first pattern matches and the script prints:

output

Enter the name of a country: Lithuania
The official language of Lithuania is Lithuanian

If you enter a country that does not match any named pattern, the default * clause runs:

output

Enter the name of a country: Argentina
The official language of Argentina is unknown

Multiple Patterns

Use the | operator to match several values in one clause. Here is a script that handles a yes/no prompt:

confirm.shsh
#!/bin/bash

echo -n "Do you want to continue? [y/n]: "
read ANSWER

case $ANSWER in

 y | Y | yes | Yes | YES)
 echo "Continuing..."
 ;;

 n | N | no | No | NO)
 echo "Aborted."
 exit 1
 ;;

 *)
 echo "Invalid input. Please enter y or n."
 exit 1
 ;;
esac

Argument Parsing

One of the most common uses of case in shell scripting is parsing command-line arguments. The following example mimics a basic service control script:

service.shsh
#!/bin/bash

case $1 in

 start)
 echo "Starting the service..."
 ;;

 stop)
 echo "Stopping the service..."
 ;;

 restart)
 echo "Restarting the service..."
 ;;

 status)
 echo "Checking service status..."
 ;;

 *)
 echo "Usage: $0 {start|stop|restart|status}"
 exit 1
 ;;
esac

Call the script with an argument:

Terminal
bash service.sh start

output

Starting the service...

If you pass an unrecognised argument, the default clause prints usage instructions:

output

Usage: ./service.sh {start|stop|restart|status}

For more advanced argument parsing, see the getopts guide.

Glob Pattern Matching

case patterns support the same glob characters available in filename matching:

Pattern	Matches
`*`	Any string, including empty
`?`	Any single character
`[abc]`	Any one character listed in the brackets
`[a-z]`	Any one character in the range

Here is an example that classifies a filename by extension:

classify.shsh
#!/bin/bash

FILE=$1

case $FILE in

 *.sh)
 echo "$FILE is a shell script"
 ;;

 *.py)
 echo "$FILE is a Python script"
 ;;

 *.jpg | *.jpeg | *.png | *.gif)
 echo "$FILE is an image"
 ;;

 *.txt | *.md)
 echo "$FILE is a text file"
 ;;

 *)
 echo "$FILE: unknown file type"
 ;;
esac

Terminal
bash classify.sh report.md

output

report.md is a text file

Case-Insensitive Matching

By default, case pattern matching is case-sensitive. To match patterns regardless of case, enable the nocasematch shell option before the statement:

Terminal
shopt -s nocasematch

case $ANSWER in
 yes) echo "You said yes" ;;
 no) echo "You said no" ;;
esac

shopt -u nocasematch

Disable nocasematch with shopt -u after the block so it does not affect the rest of the script.

Fall-Through Terminators

By default, Bash stops after the first matching clause. Two alternative terminators change this behavior:

;& — execute the next clause’s commands unconditionally, without testing its pattern.
;;& — continue testing the remaining patterns for additional matches.

Here is an example using ;;& to match a value against multiple independent patterns:

flags.shsh
#!/bin/bash

VALUE="admin"

case $VALUE in

 admin)
 echo "Has admin access"
 ;;&

 admin | editor)
 echo "Can edit content"
 ;;&

 admin | editor | viewer)
 echo "Can view content"
 ;;

esac

output

Has admin access
Can edit content
Can view content

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Syntax	Description
`case VAR in`	Open a case statement on `VAR`
`PATTERN)`	Start a clause matching `PATTERN`
`P1 \| P2)`	Match either `P1` or `P2`
`*)`	Default clause — matches everything
`;;`	End clause, stop matching
`;&`	End clause, run next clause unconditionally
`;;&`	End clause, continue testing patterns
`esac`	Close the case statement
`shopt -s nocasematch`	Enable case-insensitive matching

Troubleshooting

Pattern does not match as expected
Remember that case uses glob patterns, not regex. Use *, ?, and bracket ranges ([a-z]) or switch to [[ =~ ]] for regex checks.

Input with spaces does not match
Quote patterns that contain spaces (for example, "San Marino"). Also quote variables in surrounding commands when needed to avoid word splitting.

Case-insensitive match affects other parts of the script
If you enable shopt -s nocasematch, disable it with shopt -u nocasematch after the case block to avoid side effects.

Unexpected fall-through behavior
Use ;; for standard behavior. ;& always runs the next clause, while ;;& retests the remaining patterns, which can trigger multiple clauses.

Script exits with the wrong status
The case statement returns the status of the last command in the executed clause. Set explicit exit codes in error/default branches when writing scripts.

FAQ

When should I use case instead of if/elif?
Use case when you are comparing one variable or expression against three or more fixed values or patterns. For two conditions or complex boolean logic, if/elif is clearer. For interactive menus with numbered choices, consider select .

Can I match numbers with case?
Yes. case matches strings, but numbers written as strings work fine. For arithmetic comparisons (greater than, less than), use an if statement with comparison operators instead.

What happens if no pattern matches and there is no * default?
The case statement exits silently with status 0. No error is produced and no clause runs. Adding a *) default clause is good practice to handle unexpected input explicitly.

Can I use regular expressions in case patterns?
No. case uses glob patterns, not regular expressions. For regex matching, use the [[ =~ ]] operator inside an if statement.

Conclusion

The Bash case statement is a clean and readable way to branch on a single value across multiple patterns. It handles simple string matching, glob patterns, and command-line arguments well. For more on controlling script flow, see the guides on if/elif , for loops , and positional parameters .

Bash Comparison Operators

hello@linuxize.com (Linuxize) — Wed, 14 Jan 2026 10:10:25 +0100

Comparison operators are used to compare values and return true or false. They are essential for writing conditional logic in Bash scripts, especially when working with if, elif, while, and case statements.

This article explains how to compare integers, strings, and patterns in Bash.

Key Points

Bash uses different operators for comparing integers and for comparing strings.
Comparison operators can be used with single brackets [ ] (POSIX test), double brackets [[ ]] (Bash-specific, safer and more powerful), and double parentheses (( )) (arithmetic context).
Bash variables are untyped. They are treated as integer or string depending on the context.
Bash does not support floating-point operations. To compare floating point numbers, use an external tool such as bc or awk .

Comparing Integers

To compare integers, you can use test operators with brackets or arithmetic operators with double parentheses.

Integer Comparison Operators

Operator	Description
`-eq`	Equal to
`-ne`	Not equal to
`-gt`	Greater than
`-ge`	Greater than or equal to
`-lt`	Less than
`-le`	Less than or equal to

Equal To Operator

The -eq operator checks if two integers are equal and returns true if they are:

sh
#!/bin/bash

NUM1=5
NUM2=5

if [ "$NUM1" -eq "$NUM2" ]; then
 echo "Numbers are equal."
else
 echo "Numbers are not equal."
fi

output

Numbers are equal.

Not Equal To Operator

The -ne operator returns true if two integers are not equal:

sh
#!/bin/bash

NUM1=5
NUM2=10

if [ "$NUM1" -ne "$NUM2" ]; then
 echo "Numbers are not equal."
else
 echo "Numbers are equal."
fi

output

Numbers are not equal.

Greater Than Operator

The -gt operator checks if the first integer is greater than the second and returns true if it is:

sh
#!/bin/bash

NUM1=10
NUM2=5

if [ "$NUM1" -gt "$NUM2" ]; then
 echo "$NUM1 is greater than $NUM2."
fi

output

10 is greater than 5.

Greater Than Or Equal Operator

The -ge operator returns true if the first integer is greater than or equal to the second:

sh
#!/bin/bash

NUM1=10
NUM2=10

if [ "$NUM1" -ge "$NUM2" ]; then
 echo "$NUM1 is greater than or equal to $NUM2."
fi

output

10 is greater than or equal to 10.

Less Than Operator

The -lt operator returns true if the first integer is less than the second:

sh
#!/bin/bash

NUM1=5
NUM2=10

if [ "$NUM1" -lt "$NUM2" ]; then
 echo "$NUM1 is less than $NUM2."
fi

output

5 is less than 10.

Less Than Or Equal Operator

The -le operator returns true if the first integer is less than or equal to the second:

sh
#!/bin/bash

NUM1=5
NUM2=5

if [ "$NUM1" -le "$NUM2" ]; then
 echo "$NUM1 is less than or equal to $NUM2."
fi

output

5 is less than or equal to 5.

Using Arithmetic Operators

You can also compare integers using arithmetic operators inside double parentheses (( )):

Operator	Description
`==`	Equal to
`!=`	Not equal to
`>`	Greater than
`>=`	Greater than or equal to
`<`	Less than
`<=`	Less than or equal to

sh
#!/bin/bash

NUM1=10
NUM2=5

if (( NUM1 > NUM2 )); then
 echo "$NUM1 is greater than $NUM2."
fi

output

10 is greater than 5.

Tip

When using (( )), you do not need to add $ before variable names.

Comparing Strings

String comparison operators check whether strings are equal or not equal, or compare them lexicographically (alphabetically).

String Comparison Operators

Operator	Description
`=` or `==`	Equal to
`!=`	Not equal to
`<`	Less than (lexicographically)
`>`	Greater than (lexicographically)
`-z`	String is empty
`-n`	String is not empty
`=~`	Regex match

Check if Two Strings are Equal

Use the = operator with single brackets or == with double brackets (recommended):

sh
#!/bin/bash

VAR1="Linuxize"
VAR2="Linuxize"

if [ "$VAR1" = "$VAR2" ]; then
 echo "Strings are equal."
else
 echo "Strings are not equal."
fi

output

Strings are equal.

Here’s how to use double brackets with user input:

sh
#!/bin/bash

read -p "Enter first string: " VAR1
read -p "Enter second string: " VAR2

if [[ "$VAR1" == "$VAR2" ]]; then
 echo "Strings are equal."
else
 echo "Strings are not equal."
fi

output

Enter first string: Linuxize
Enter second string: Ubuntu
Strings are not equal.

You can also use logical operators:

sh
[[ "string1" == "string2" ]] && echo "Equal" || echo "Not equal"

output

Not equal

Check if a String Contains a Substring

Use the * wildcard to match patterns in strings:

sh
#!/bin/bash

VAR='GNU/Linux is an operating system'
if [[ $VAR == *"Linux"* ]]; then
 echo "It's there."
fi

output

It's there.

You can also use the =~ operator for regular expression matching:

sh
#!/bin/bash

VAR='GNU/Linux is an operating system'
if [[ $VAR =~ .*Linux.* ]]; then
 echo "It's there."
fi

Check if a String is Empty

Use -z to check if a string is empty, and -n to check if it is not empty:

sh
#!/bin/bash

VAR=''
if [[ -z $VAR ]]; then
 echo "String is empty."
fi

output

String is empty.

sh
#!/bin/bash

VAR='Linuxize'
if [[ -n $VAR ]]; then
 echo "String is not empty."
fi

output

String is not empty.

Comparing Strings with the Case Operator

You can also use the case statement to compare strings:

sh
#!/bin/bash

VAR="Arch Linux"

case $VAR in
 "Arch Linux")
 echo "Arch matched"
 ;;
 Fedora | CentOS)
 echo "Red Hat based"
 ;;
esac

output

Arch matched

The case statement is useful when you need to match a variable against several patterns.

Lexicographic Comparison

Lexicographic comparison compares strings alphabetically, character by character:

sh
#!/bin/bash

VAR1="Linuxize"
VAR2="Ubuntu"

if [[ "$VAR1" > "$VAR2" ]]; then
 echo "${VAR1} is lexicographically greater than ${VAR2}."
elif [[ "$VAR1" < "$VAR2" ]]; then
 echo "${VAR2} is lexicographically greater than ${VAR1}."
else
 echo "Strings are equal"
fi

output

Ubuntu is lexicographically greater than Linuxize.

Comparing Floating-Point Numbers

Bash cannot compare floating-point numbers directly, but we can use utilities like bc or awk to make the comparison.

Using `bc`

sh
NUM1=3.14
NUM2=2.71

if (( $(echo "$NUM1 > $NUM2" | bc -l) )); then
 echo "$NUM1 is greater"
fi

Using `awk`

sh
awk 'BEGIN { if (3.14 > 2.71) print "3.14 is greater" }'

Important Notes

Always use double quotes around variable names to avoid word splitting or globbing issues.
Make sure to put a space between the operator and the operands.
Use = with single brackets [ ] and == with double brackets [[ ]].
Inside double brackets, < and > don’t need to be escaped.
Inside single brackets, < and > must be escaped: \< and \>.

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Operator	Context	Description
`-eq`	`[ ]` `[[ ]]`	Integer equal to
`-ne`	`[ ]` `[[ ]]`	Integer not equal to
`-gt`	`[ ]` `[[ ]]`	Integer greater than
`-ge`	`[ ]` `[[ ]]`	Integer greater than or equal to
`-lt`	`[ ]` `[[ ]]`	Integer less than
`-le`	`[ ]` `[[ ]]`	Integer less than or equal to
`==` `!=` `>` `<`	`(( ))`	Arithmetic comparison
`=` or `==`	`[ ]` `[[ ]]`	String equal to
`!=`	`[ ]` `[[ ]]`	String not equal to
`<` `>`	`[[ ]]`	String lexicographic comparison
`-z`	`[ ]` `[[ ]]`	String is empty
`-n`	`[ ]` `[[ ]]`	String is not empty
`=~`	`[[ ]]`	String matches regex

FAQ

What is the difference between [ ] and [[ ]] in Bash?
[ ] is the POSIX test command and works in any POSIX-compatible shell. [[ ]] is a Bash-specific keyword that is safer and more powerful — it supports regex matching with =~, does not require quoting variables to prevent word splitting, and allows < and > without escaping. Prefer [[ ]] in Bash scripts.

Why does -eq not work for strings?
-eq is an arithmetic operator and should be used only with integers. If you use it with non-numeric strings, Bash typically raises an integer-expression error instead of doing a meaningful comparison. Use = or == for string comparison.

Can I compare numbers with == inside single brackets?
No. Inside [ ], == is a string comparison, so [ 10 == 10 ] works but [ 10 == 9+1 ] does not — it compares the literal strings 10 and 9+1. Use -eq for integer comparison in [ ], or use (( 10 == 9+1 )) for arithmetic evaluation.

How do I check if a variable is greater than zero?
Use [[ $VAR -gt 0 ]] or (( VAR > 0 )). Both are equivalent in Bash.

Conclusion

Comparison operators in Bash allow you to compare integers and strings in your scripts. Use -eq, -ne, -gt, -ge, -lt, -le for integer comparison in brackets, or arithmetic operators like > and == inside (( )). For string comparison, prefer [[ ]] with ==, !=, -z, and -n.

How to Compare Strings in Bash

hello@linuxize.com (Linuxize) — Fri, 03 May 2019 23:31:47 +0100

When writing Bash scripts, you will often need to compare two strings to check if they are equal or not. Two strings are equal when they have the same length and contain the same sequence of characters.

This guide explains how to compare strings in Bash using comparison operators, pattern matching, and regular expressions.

Comparison Operators

When comparing strings in Bash, you can use the following operators:

string1 = string2 and string1 == string2 - The equality operator returns true if the operands are equal. Use = with the test ([) command and == with the [[ command.
string1 != string2 - The inequality operator returns true if the operands are not equal.
string1 =~ regex - The regex operator returns true if the left operand matches the extended regular expression on the right.
string1 > string2 - The greater than operator returns true if the left operand is greater than the right in lexicographical (alphabetical) order.
string1 < string2 - The less than operator returns true if the left operand is less than the right in lexicographical order.
-z string - True if the string length is zero.
-n string - True if the string length is non-zero.

A few points to keep in mind when comparing strings:

A blank space must be used between the binary operator and the operands.
Always use double quotes around variable names to avoid word splitting or globbing issues.
Bash does not segregate variables by type. Variables are treated as integer or string depending on the context.

Check if Two Strings are Equal

The most common string comparison checks whether two strings are equal or not.

The following script uses the if statement and the [ test command with the = operator:

sh
#!/bin/bash

VAR1="Linuxize"
VAR2="Linuxize"

if [ "$VAR1" = "$VAR2" ]; then
 echo "Strings are equal."
else
 echo "Strings are not equal."
fi

When the script is executed, it prints the following output:

output

Strings are equal.

Here is another example that takes input from the user and compares the given strings. This example uses the [[ command with the == operator:

sh
#!/bin/bash

read -p "Enter first string: " VAR1
read -p "Enter second string: " VAR2

if [[ "$VAR1" == "$VAR2" ]]; then
 echo "Strings are equal."
else
 echo "Strings are not equal."
fi

Run the script and enter the strings when prompted:

output

Enter first string: Linuxize
Enter second string: Ubuntu
Strings are not equal.

You can also use logical AND (&&) and OR (||) for inline comparisons:

Terminal
[[ "string1" == "string2" ]] && echo "Equal" || echo "Not equal"

output

Not equal

Check if a String Contains a Substring

There are multiple ways to check if a string contains a substring.

One approach is to surround the substring with asterisk symbols (*), which match any sequence of characters:

sh
#!/bin/bash

VAR='GNU/Linux is an operating system'
if [[ $VAR == *"Linux"* ]]; then
 echo "It is there."
fi

The script will echo the following:

output

It is there.

Another option is to use the regex operator =~:

sh
#!/bin/bash

VAR='GNU/Linux is an operating system'
if [[ $VAR =~ .*Linux.* ]]; then
 echo "It is there."
fi

The period followed by an asterisk (.*) matches zero or more occurrences of any character except a newline.

Check if a String is Empty

You will often need to check whether a variable is an empty string or not. You can do this with the -z and -n operators.

The -z operator returns true if the string is empty:

sh
#!/bin/bash

VAR=''
if [[ -z $VAR ]]; then
 echo "String is empty."
fi

output

String is empty.

The -n operator returns true if the string is not empty:

sh
#!/bin/bash

VAR='Linuxize'
if [[ -n $VAR ]]; then
 echo "String is not empty."
fi

output

String is not empty.

Case-Insensitive Comparison

By default, string comparisons in Bash are case-sensitive. There are two ways to perform case-insensitive comparisons.

The first approach uses the ,, parameter expansion to convert both strings to lowercase before comparing:

sh
#!/bin/bash

VAR1="Hello"
VAR2="hello"

if [[ "${VAR1,,}" == "${VAR2,,}" ]]; then
 echo "Strings are equal (case-insensitive)."
fi

output

Strings are equal (case-insensitive).

The second approach uses shopt -s nocasematch, which makes all pattern matching and == comparisons case-insensitive within the current shell:

sh
#!/bin/bash

shopt -s nocasematch

VAR1="Hello"
VAR2="hello"

if [[ "$VAR1" == "$VAR2" ]]; then
 echo "Strings are equal (case-insensitive)."
fi

shopt -u nocasematch

Always restore the default behavior with shopt -u nocasematch after the comparison to avoid affecting the rest of your script.

Pattern Matching

When using the [[ command, the == operator supports glob-style pattern matching on the right side. The pattern is not quoted so that Bash interprets the wildcards.

The following example checks whether a string starts with “Linux”:

sh
#!/bin/bash

VAR="Linuxize"
if [[ "$VAR" == Linux* ]]; then
 echo "Starts with Linux."
fi

output

Starts with Linux.

You can also use ? to match a single character, or [...] to match a character class:

sh
#!/bin/bash

VAR="file1.txt"
if [[ "$VAR" == file[0-9].txt ]]; then
 echo "Matches the pattern."
fi

output

Matches the pattern.

Comparing Strings with the Case Statement

Instead of using test operators, you can use the case statement to compare strings against multiple patterns:

sh
#!/bin/bash

VAR="Arch Linux"

case $VAR in
 "Arch Linux")
 echo "Arch Linux matched."
 ;;
 Fedora | Debian)
 echo "Fedora or Debian matched."
 ;;
 *)
 echo "No match found."
 ;;
esac

output

Arch Linux matched.

The case statement is especially useful when you need to compare a string against more than two or three values.

Lexicographic Comparison

Lexicographic comparison compares two strings alphabetically, character by character from left to right. This is useful when you need to sort or order strings.

The following script compares two strings lexicographically:

sh
#!/bin/bash

VAR1="Linuxize"
VAR2="Ubuntu"

if [[ "$VAR1" > "$VAR2" ]]; then
 echo "${VAR1} is lexicographically greater than ${VAR2}."
elif [[ "$VAR1" < "$VAR2" ]]; then
 echo "${VAR2} is lexicographically greater than ${VAR1}."
else
 echo "Strings are equal."
fi

output

Ubuntu is lexicographically greater than Linuxize.

The > and < operators compare based on the ASCII value of each character. Uppercase letters have lower ASCII values than lowercase letters, so "A" is less than "a".

Quick Reference

Operator	Description
`=`, `==`	Equal (use `=` with `[`, `==` with `[[`)
`!=`	Not equal
`=~`	Regex match
`<`	Less than (lexicographic)
`>`	Greater than (lexicographic)
`-z`	String is empty
`-n`	String is not empty
`pattern`	Substring/glob match (with `[[`)
`${var,,}`	Convert to lowercase
`${var^^}`	Convert to uppercase

FAQ

What is the difference between [ and [[ in Bash?
[ is the POSIX-compatible test command. [[ is a Bash built-in that supports pattern matching, regex, and does not require quoting variables to prevent word splitting. Prefer [[ in Bash scripts.

How do I compare strings case-insensitively?
Either convert both strings to the same case with ${var,,} (lowercase) or ${var^^} (uppercase), or enable shopt -s nocasematch before the comparison.

What is the difference between = and == for string comparison?
Both check for equality. The = operator is POSIX-compliant and works with [ and [[. The == operator works only with [[ and also supports glob patterns on the right side.

How do I check if a variable is set and not empty?
Use [[ -n "$VAR" ]] to check that the string is not empty. To also verify the variable is set, use [[ -v VAR ]] (Bash 4.2+).

What is the difference between string comparison and numeric comparison?
String operators (==, !=, <, >) compare character by character. Numeric operators (-eq, -ne, -lt, -gt) compare integer values. For example, [[ "02" == "2" ]] is false (different strings), but [[ 02 -eq 2 ]] is true (same number).

Conclusion

Comparing strings is one of the most fundamental operations in Bash scripting. Use == and != for equality checks, =~ for regex matching, and -z and -n to test for empty strings. You can also check our guide about string concatenation .

Bash: Check if String Contains Substring

hello@linuxize.com (Linuxize) — Fri, 19 Jul 2019 20:31:47 +0100

Checking whether a string contains a substring is one of the most common operations in Bash scripting.

This guide covers four ways to do it: wildcard matching, the case statement, the regex operator, and grep.

Quick Reference

Method	Example	Portable
Wildcard `[[ ]]`	`[[ "$STR" == "$SUB" ]]`	Bash only
`case` wildcard	`case "$STR" in "$SUB") ...`	Yes (POSIX sh)
Regex `=~`	`[[ "$STR" =~ ."$SUB". ]]`	Bash only
`grep` here-string	`grep -q "$SUB" <<< "$STR"`	Bash only
Does not contain	`[[ "$STR" != "$SUB" ]]`	Bash only
Case-insensitive	`grep -qi "$SUB" <<< "$STR"`	Bash only

Using Wildcards

The simplest approach is to wrap the substring in asterisk wildcards (*) and use [[ ]] with the equality operator. An asterisk matches zero or more characters, so *"$SUB"* matches any string that contains $SUB.

In the following example, the script checks whether STR contains the substring SUB:

sh
#!/bin/bash

STR='GNU/Linux is an operating system'
SUB='Linux'

if [[ "$STR" == *"$SUB"* ]]; then
 echo "It is there."
fi

output

It is there.

This is the most readable and recommended approach for Bash scripts. Note that [[ ]] is Bash-specific and not available in POSIX sh. For more details on Bash test expressions, see Bash comparison operators .

Using the case Statement

The case statement also supports wildcard patterns, making it a clean option for substring checks:

sh
#!/bin/bash

STR='GNU/Linux is an operating system'
SUB='Linux'

case "$STR" in
 *"$SUB"*)
 echo "It is there."
 ;;
esac

output

It is there.

The case approach works in both Bash and POSIX sh, making it more portable than [[ ]].

Using the Regex Operator

The =~ operator inside [[ ]] tests a string against a regular expression. The right-hand side is treated as a regex pattern, and .* matches zero or more of any character:

sh
#!/bin/bash

STR='GNU/Linux is an operating system'
SUB='Linux'

if [[ "$STR" =~ .*"$SUB".* ]]; then
 echo "It is there."
fi

output

It is there.

While this works, it is more complex than the wildcard approach for simple substring checks. Use =~ when you need full regular expression matching; for example, to match a pattern like a date or IP address format.

Using grep

The grep command can search for a substring within a string using a here-string (<<<):

sh
#!/bin/bash

STR='GNU/Linux is an operating system'
SUB='Linux'

if grep -q "$SUB" <<< "$STR"; then
 echo "It is there."
fi

output

It is there.

The -q option suppresses output and returns an exit code of 0 if the pattern is found. This approach runs an external grep process and is usually slower than the pure-Bash methods above. Use it when you need grep features such as case-insensitive search (-i) or fixed-string matching (-F).

FAQ

Which method should I use?
For most Bash scripts, use the wildcard method: [[ "$STR" == *"$SUB"* ]]. It is the most readable and requires no subshell. Use case when you need POSIX portability. Use =~ only when you need regular expression matching.

How do I check if a string does NOT contain a substring?
Flip the operator in the wildcard method: [[ "$STR" != *"$SUB"* ]]. With grep, negate the exit status: if ! grep -q "$SUB" <<< "$STR".

How do I do a case-insensitive substring check?
Use grep -qi "$SUB" <<< "$STR". With [[ ]], convert both strings to lowercase first using parameter expansion: [[ "${STR,,}" == *"${SUB,,}"* ]].

Does the wildcard method work with special characters in the substring?
Yes, as long as $SUB is quoted: *"$SUB"*. Quoting prevents the variable content from being interpreted as a glob pattern.

Are these methods Bash-specific?
The [[ ]] and =~ methods are Bash-specific. The case wildcard method is POSIX-compliant and works in any POSIX shell. grep with <<< requires Bash for the here-string syntax, but grep itself is available on all systems.

Conclusion

The simplest and most readable way to check if a string contains a substring in Bash is wildcard matching inside [[ ]]. For POSIX portability, use the case statement. For regular expression matching, use =~. For pattern-based searches with grep options, use grep -q with a here-string.

For more on working with strings in Bash, see the guides on comparing strings and if/else statements .

How to Check if a File or Directory Exists in Bash

hello@linuxize.com (Linuxize) — Tue, 12 Mar 2019 20:31:47 +0100

When writing shell scripts, you may find yourself in a situation where you need to perform an action based on whether a file exists or not.

In Bash, you can use the test command to check whether a file exists and determine the type of the file.

The test command takes one of the following syntax forms:

txt
test EXPRESSION
[ EXPRESSION ]
[[ EXPRESSION ]]

If you want your script to be portable, prefer the [ form, which is available in POSIX shells. The [[ (double bracket) form is supported by Bash, Zsh, and Ksh, but it is not part of POSIX sh.

Check if File Exists

When checking if a file exists, the most commonly used FILE operators are -e and -f. The first one will check whether a file exists regardless of the type, while the second one will return true only if the FILE is a regular file (not a directory or a device).

To check whether a path exists regardless of its type (file, directory, socket, and so on), use -e:

sh
FILE=/etc/resolv.conf
if [ -e "$FILE" ]; then
 echo "$FILE exists."
fi

The most readable option when checking whether a file exists or not is to use the test command in combination with the if statement . Any of the snippets below will check whether the /etc/resolv.conf file exists:

sh
FILE=/etc/resolv.conf
if test -f "$FILE"; then
 echo "$FILE exists."
fi

sh
FILE=/etc/resolv.conf
if [ -f "$FILE" ]; then
 echo "$FILE exists."
fi

sh
FILE=/etc/resolv.conf
if [[ -f "$FILE" ]]; then
 echo "$FILE exists."
fi

If you want to perform a different action based on whether the file exists or not, use the if/then construct:

sh
FILE=/etc/resolv.conf
if [ -f "$FILE" ]; then
 echo "$FILE exists."
else
 echo "$FILE does not exist."
fi

Info

Always use double quotes to avoid issues when dealing with files containing whitespace in their names.

You can also use the test command without the if statement. The command after the && operator will only be executed if the exit status of the test command is true.

sh
FILE=/etc/resolv.conf
test -f "$FILE" && echo "$FILE exists."

sh
[ -f "$FILE" ] && echo "$FILE exists."

sh
[[ -f "$FILE" ]] && echo "$FILE exists."

If you want to run a series of commands after the && operator, enclose the commands in curly brackets separated by ; or &&:

sh
[ -f "$FILE" ] && { echo "$FILE exists."; cp "$FILE" /tmp/; }

For a quick one-liner that only runs when the file exists, use &&:

sh
[ -f "$FILE" ] && echo "$FILE exists."

If you need one action when the file exists and another when it does not, use an if statement instead:

sh
if [ -f "$FILE" ]; then
 echo "$FILE exists."
else
 echo "$FILE does not exist."
fi

Check if Directory Exists

The flag -d allows you to test whether a file is a directory or not.

For example, to check whether the /etc/docker directory exists, you would use:

sh
FILE=/etc/docker
if [ -d "$FILE" ]; then
 echo "$FILE is a directory."
fi

sh
[ -d "$FILE" ] && echo "$FILE is a directory."

To run different commands depending on whether the directory exists, use an if/else block:

sh
FILE=/etc/docker
if [ -d "$FILE" ]; then
 echo "$FILE is a directory."
else
 echo "$FILE does not exist or is not a directory."
fi

To check whether a directory does not exist, negate the expression with !:

sh
FILE=/etc/docker
if [ ! -d "$FILE" ]; then
 echo "$FILE does not exist."
fi

Check if File Does Not Exist

Like many other languages, the test expression can be negated using the ! (exclamation mark) logical not operator:

sh
FILE=/etc/docker
if [ ! -f "$FILE" ]; then
 echo "$FILE does not exist."
fi

The same check as a one-liner:

sh
[ ! -f "$FILE" ] && echo "$FILE does not exist."

Check if File Is Readable, Writable, or Executable

To test permissions, use -r, -w, and -x:

sh
FILE=/usr/local/bin/script.sh

if [ -r "$FILE" ]; then
 echo "$FILE is readable."
fi

sh
if [ -w "$FILE" ]; then
 echo "$FILE is writable."
fi

sh
if [ -x "$FILE" ]; then
 echo "$FILE is executable."
fi

Check if File Is Not Empty

Use -s to check for a file that exists and has nonzero size:

sh
FILE=/var/log/syslog

if [ -s "$FILE" ]; then
 echo "$FILE is not empty."
fi

Check if a File Is a Symlink

Use -L to check for a symbolic link:

sh
FILE=/etc/localtime

if [ -L "$FILE" ]; then
 echo "$FILE is a symbolic link."
fi

Check if Multiple Files Exist

To test whether multiple files exist, combine separate checks with &&:

sh
if [ -f /etc/resolv.conf ] && [ -f /etc/hosts ]; then
 echo "Both files exist."
fi

sh
if [[ -f /etc/resolv.conf && -f /etc/hosts ]]; then
 echo "Both files exist."
fi

Equivalent variants without using the IF statement:

sh
[ -f /etc/resolv.conf ] && [ -f /etc/hosts ] && echo "Both files exist."

sh
[[ -f /etc/resolv.conf && -f /etc/hosts ]] && echo "Both files exist."

File Test Operators

The test command includes the following FILE operators that allow you to test for particular types of files:

-b FILE - True if the FILE exists and is a special block file.
-c FILE - True if the FILE exists and is a special character file.
-d FILE - True if the FILE exists and is a directory.
-e FILE - True if the FILE exists and is a file, regardless of type (node, directory, socket, etc.).
-f FILE - True if the FILE exists and is a regular file (not a directory or device).
-G FILE - True if the FILE exists and has the same group as the user running the command.
-h FILE - True if the FILE exists and is a symbolic link.
-g FILE - True if the FILE exists and has set-group-id (sgid) flag set.
-k FILE - True if the FILE exists and has a sticky bit flag set.
-L FILE - True if the FILE exists and is a symbolic link.
-O FILE - True if the FILE exists and is owned by the user running the command.
-p FILE - True if the FILE exists and is a pipe.
-r FILE - True if the FILE exists and is readable.
-S FILE - True if the FILE exists and is a socket.
-s FILE - True if the FILE exists and has nonzero size.
-u FILE - True if the FILE exists and set-user-id (suid) flag is set.
-w FILE - True if the FILE exists and is writable.
-x FILE - True if the FILE exists and is executable.

Conclusion

For scripts that run across different shells, the single-bracket [ form is the portable choice. Double brackets [[ add useful extras like pattern matching and regex but work only in Bash, Ksh, and Zsh. For the full operator reference, run man test or help test (for the built-in version) in your terminal.

Bash Range: Sequence Expression Syntax and Examples

hello@linuxize.com (Linuxize) — Sun, 09 Feb 2020 21:13:22 +0100

The Bash sequence expression generates a range of integers or characters by defining a start and end point. It is most commonly used in for loops to iterate over a numeric or alphabetic range without writing out each value manually.

This guide covers the sequence expression syntax, step increments, zero-padding, character ranges, practical loop examples, and how to work with dynamic ranges using variables.

Bash Sequence Expression Syntax

The sequence expression takes the following form:

txt
{START..END[..INCREMENT]}

The expression begins with an opening brace and ends with a closing brace.
START and END can be either positive integers or single characters.
The START and END values are mandatory and separated with two dots .., with no space between them.
The INCREMENT value is optional. If present, it must be separated from the END value with two dots .., with no space between them.
The expression expands to each number or character between START and END, including the provided values.
An incorrectly formed expression is left unchanged.

Integer Ranges

Here is the expression in action — generating a range from 0 to 3:

Terminal
echo {0..3}

output

0 1 2 3

If START is greater than END, the expression creates a decrementing range:

Terminal
echo {3..0}

output

3 2 1 0

Character Ranges

The sequence expression also works with single characters. The following example prints the lowercase alphabet:

Terminal
echo {a..z}

output

a b c d e f g h i j k l m n o p q r s t u v w x y z

When characters are given, the expression expands in lexicographic order. You can also use uppercase letters:

Terminal
echo {A..Z}

Increment and Step

When an INCREMENT is given, it sets the step between each generated value:

Terminal
for i in {0..20..5}
do
 echo "Number: $i"
done

output

Number: 0
Number: 5
Number: 10
Number: 15
Number: 20

You can use a negative increment to step down:

Terminal
for i in {10..0..2}
do
 echo "Number: $i"
done

output

Number: 10
Number: 8
Number: 6
Number: 4
Number: 2
Number: 0

Leading Zeros

When using integers, you can force each number to have the same width by prefixing START or END with a leading zero:

Terminal
for i in {00..5}
do
 echo "Number: $i"
done

output

Number: 00
Number: 01
Number: 02
Number: 03
Number: 04
Number: 05

Prefix and Suffix

The expression can be combined with static text before or after the braces:

Terminal
echo file{01..4}.txt

output

file01.txt file02.txt file03.txt file04.txt

This is useful for generating file names, directory names, or any pattern that includes a numeric suffix.

Using Ranges in for Loops

The sequence expression is most commonly used in for loops. The following example iterates from 1 to 5 and prints each value:

If you are looking for the Bash equivalent of Python’s for i in range(...), brace expansion is the simplest option for fixed ranges.

Terminal
for i in {1..5}
do
 echo "Iteration: $i"
done

output

Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4
Iteration: 5

A common use case is creating a set of numbered directories:

Terminal
for i in {1..5}
do
 mkdir "backup_$i"
done

This creates backup_1 through backup_5 in the current directory.

Variable Ranges with seq

A common point of confusion is that Bash does not expand variables inside brace expressions. If you try to use a variable as START or END, the brace expression is left unexpanded:

Terminal
START=1
END=5
echo {$START..$END}

output

{1..5}

The literal string {1..5} is printed instead of the expanded range. This is a Bash limitation — brace expansion happens before variable substitution.

To use a dynamic range, use the seq command instead:

Terminal
START=1
END=5
for i in $(seq $START $END)
do
 echo "Number: $i"
done

output

Number: 1
Number: 2
Number: 3
Number: 4
Number: 5

seq also accepts a step argument:

Terminal
for i in $(seq 0 2 10)
do
 echo "Number: $i"
done

output

Number: 0
Number: 2
Number: 4
Number: 6
Number: 8
Number: 10

Another option for variable ranges is a C-style for loop, which supports variables directly:

Terminal
START=1
END=5
for ((i=START; i<=END; i++))
do
 echo "Number: $i"
done

Both seq and the C-style loop work reliably with variables. Use whichever reads more clearly for your script.

Practical Examples

Countdown timer

Terminal
for i in {10..1}
do
 echo "$i..."
 sleep 1
done
echo "Done"

Generate test files

Terminal
for i in {1..10}
do
 touch "testfile_${i}.log"
done

Print columns of the alphabet

Terminal
for c in {a..z}
do
 printf "%s " "$c"
done
echo

Create numbered backups

Terminal
for i in {01..07}
do
 cp config.conf "config_backup_${i}.conf"
done

Quick Reference

Expression	Result
`{1..5}`	`1 2 3 4 5`
`{5..1}`	`5 4 3 2 1`
`{0..10..2}`	`0 2 4 6 8 10`
`{01..04}`	`01 02 03 04` (zero-padded)
`{a..e}`	`a b c d e`
`{A..E}`	`A B C D E`
`file{1..3}.txt`	`file1.txt file2.txt file3.txt`
`seq $START $END`	Dynamic integer range using variables
`seq $START $STEP $END`	Dynamic range with step

FAQ

Why does {$START..$END} not work?
Brace expansion in Bash happens before variable substitution, so {$START..$END} is treated as a literal string rather than a range. Use seq $START $END inside a command substitution, or use a C-style for ((i=START; i<=END; i++)) loop instead.

What is the difference between {1..5} and seq 1 5?
{1..5} is a pure Bash brace expansion — fast and with no external command. seq 1 5 is an external command that prints numbers to standard output, one per line. The main practical difference is that brace expansion does not support variables, while seq does.

Can I use the sequence expression with strings longer than one character?
No. The sequence expression only supports single characters or integers. For multi-character strings you need a different approach, such as an array or a loop over a list.

How do I create a reverse or countdown range?
Set START higher than END: {5..1}. With an increment, use {10..0..2} to step down by 2.

Can I use the sequence expression outside of for loops?
Yes. echo {1..5} prints the expanded values space-separated on a single line. You can also use it in command arguments, file globs, or anywhere Bash performs brace expansion — for example mkdir dir{1..5} creates five directories at once.

Conclusion

Use {START..END} for fixed ranges in loops and brace expansions. When you need a dynamic range driven by variables, reach for seq $START $END or a C-style for ((i=START; i<=END; i++)) loop. For more on Bash loops, see the Bash for loop guide .

Bash For Loop: Syntax and Examples

hello@linuxize.com (Linuxize) — Fri, 09 Nov 2018 20:31:47 +0100

Loops are a fundamental concept in programming languages. They allow you to execute a series of commands repeatedly until a specific condition is met.

In scripting languages like Bash, loops are especially useful for automating repetitive tasks, eliminating the need to duplicate code.

There are three basic loop constructs in Bash scripting: for loop, while loop , and until loop .

This guide focuses on the for loop in Bash, including its syntax variations, nesting, flow-control statements like break and continue, and practical examples.

The Standard Bash `for` Loop

The for loop iterates over a list of items and performs the given set of commands.

The basic Bash for loop syntax is:

txt
for item in [LIST]
do
 [COMMANDS]
done

The [LIST] can be a series of strings separated by spaces, a range of numbers, command output, an array, command-line arguments, and so on.

Loop Over Strings

The example below shows a loop that iterates over a list of strings. The loop operates on each item in the list, and the variable element stores the item that the loop is currently processing.

sh
for element in Hydrogen Helium Lithium Beryllium
do
 echo "Element: $element"
done

output

Element: Hydrogen
Element: Helium
Element: Lithium
Element: Beryllium

Loop Over a Range

You can use the sequence expression to specify a range of numbers or characters by defining the start and end point of the range. The sequence expression takes the following form:

txt
{START..END}

Here is an example loop that iterates through all numbers from 0 to 3:

sh
for i in {0..3}
do
 echo "Number: $i"
done

output

Number: 0
Number: 1
Number: 2
Number: 3

Bash also supports specifying an increment when using ranges:

txt
{START..END..INCREMENT}

Here is an example showing how to increment by 5:

sh
for i in {0..20..5}
do
 echo "Number: $i"
done

output

Number: 0
Number: 5
Number: 10
Number: 15
Number: 20

Loop Over Array Elements

You can use the for loop to iterate over the elements of a Bash array .

In the example below, we define an array named BOOKS and iterate over each element of the array.

sh
BOOKS=('In Search of Lost Time' 'Don Quixote' 'Ulysses' 'The Great Gatsby')

for book in "${BOOKS[@]}"; do
 echo "Book: $book"
done

output

Book: In Search of Lost Time
Book: Don Quixote
Book: Ulysses
Book: The Great Gatsby

The C-style `for` Loop

Bash also supports a C-style for loop syntax:

txt
for ((INITIALIZATION; TEST; STEP))
do
 [COMMANDS]
done

The INITIALIZATION part is executed only once when the loop starts. Then, the TEST part is evaluated using comparison operators . If it is false, the loop is terminated. If the TEST is true, commands inside the body of the for loop are executed, and the STEP part is updated.

In the following example, the loop starts by initializing i = 0 and, before each iteration, checks whether i ≤ 10. If true, it prints the current value of i and increments i by 1 (i++). Otherwise, the loop terminates.

sh
for ((i = 0 ; i <= 10 ; i++)); do
 echo "Counter: $i"
done

The loop iterates 11 times and produces the following output:

output

Counter: 0
Counter: 1
Counter: 2
...
Counter: 8
Counter: 9
Counter: 10

Nested Loops

A nested loop is a loop inside another loop. You can nest loops to any depth.

In a nested for loop, the inner loop runs a complete cycle of its iterations for every outer loop iteration.

Here is an example that copies three files one by one to three servers:

sh
for f in file_{1..3}; do
 for j in server_{1..3}; do
 echo "Copying file $f to server $j"
 # command to copy files
 done
done

output

Copying file file_1 to server server_1
Copying file file_1 to server server_2
Copying file file_1 to server server_3
Copying file file_2 to server server_1
Copying file file_2 to server server_2
Copying file file_2 to server server_3
Copying file file_3 to server server_1
Copying file file_3 to server server_2
Copying file file_3 to server server_3

Controlling Loop Flow: `break` and `continue`

The break and continue statements are used to control the execution of a for loop.

`break` – Terminate the Loop

The break statement terminates the current loop and passes control to the statement that follows it. It is generally used to exit the loop when a specific condition is met.

In the following example, the if statement terminates the loop once the current item is equal to Lithium:

sh
for element in Hydrogen Helium Lithium Beryllium; do
 if [[ "$element" == 'Lithium' ]]; then
 break
 fi
 echo "Element: $element"
done

echo 'All Done!'

output

Element: Hydrogen
Element: Helium
All Done!

`continue` – Skip to the Next Iteration

The continue statement exits the current iteration and passes control to the next one.

In the following example, when the current item equals 2, the continue statement skips the echo and moves to the next iteration:

sh
for i in {1..5}; do
 if [[ "$i" == '2' ]]; then
 continue
 fi
 echo "Number: $i"
done

output

Number: 1
Number: 3
Number: 4
Number: 5

Real-World Examples

Rename Files with Spaces in the Name

The following example renames all files in the current directory that contain a space, replacing spaces with underscores:

sh
for file in *\ *; do
 mv "$file" "${file// /_}"
done

*\ * matches all filenames that contain a space.
${file// /_} uses shell parameter expansion to replace every space with an underscore.

Change File Extension

The following example renames all files ending in .jpeg in the current directory, replacing the extension with .jpg:

sh
for file in *.jpeg; do
 mv -- "$file" "${file%.jpeg}.jpg"
done

*.jpeg matches all .jpeg files in the current directory.
${file%.jpeg} strips the .jpeg suffix using shell parameter expansion, and .jpg is appended to form the new name.
The -- flag prevents mv from misinterpreting filenames that start with a dash as options.

Restart Multiple Docker Containers

Here is an example that restarts a list of containers after deploying new code:

sh
for container in web db cache redis; do
 docker restart "$container" && echo "Restarted $container"
done

Containers are passed to the loop as a list of strings.

Troubleshooting

Loop splits a filename or string with spaces into multiple items Without quotes, Bash performs word splitting on spaces. Always quote variables and array expansions: use "${ARRAY[@]}" instead of ${ARRAY[@]}, and "$file" instead of $file.

Glob pattern in the list expands unexpectedly When a glob pattern like *.jpeg matches no files, Bash passes the literal string *.jpeg to the loop variable. Add shopt -s nullglob before the loop to make unmatched globs expand to nothing instead.

C-style loop does not behave like expected with [[ ]] The C-style loop uses arithmetic evaluation — comparisons inside (( )) use <, >, and == directly. Do not mix [[ ]] test syntax inside the loop initializer or condition.

Range with a variable does not expand Brace expansion happens before variable substitution, so {1..$N} does not work. Use a C-style loop or seq instead: for i in $(seq 1 "$N"); do.

Quick Reference

Syntax	Description
`for item in a b c; do ... done`	Loop over a list of strings
`for i in {1..10}; do ... done`	Loop over a numeric range
`for i in {0..20..5}; do ... done`	Loop over a range with increment
`for item in "${ARRAY[@]}"; do ... done`	Loop over array elements
`for ((i=0; i<10; i++)); do ... done`	C-style loop
`break`	Exit the loop immediately
`continue`	Skip to the next iteration

FAQ

What is the difference between the standard for loop and the C-style for loop? The standard for loop iterates over a list of items (strings, array elements, a range). The C-style for loop uses arithmetic initialization, condition, and step expressions — it is better suited for counter-based iteration where you control the start, end, and step explicitly.

How do I loop over lines in a file? Use a while loop with read instead: while IFS= read -r line; do echo "$line"; done < file.txt. A for loop is not suited for line-by-line file reading because it splits on whitespace, not newlines.

Can I use break or continue in nested loops? Yes. By default, break and continue affect only the innermost loop. To exit an outer loop from an inner one, use a numeric argument: break 2 exits two levels of nesting.

How do I loop over command-line arguments? Use for arg in "$@"; do to iterate over all positional parameters passed to the script.

Conclusion

The Bash for loop iterates over a list of items or runs for a defined number of iterations using C-style syntax. Combined with break, continue, nesting, and parameter expansion, it enables elegant solutions to many automation tasks.

To learn all the ways to run your scripts, see How to Run a Bash Script .

If you have any questions, feel free to leave a comment below.

Bash while Loop: Syntax and Examples

hello@linuxize.com (Linuxize) — Sun, 25 Nov 2018 21:33:44 +0100

Loops are one of the fundamental concepts of programming languages. Loops are handy when you want to run a series of commands a number of times until a particular condition is met. Before diving in, make sure you are familiar with the basic Linux commands .

In scripting languages such as Bash, loops are useful for automating repetitive tasks. There are three basic loop constructs in Bash scripting, for loop , while loop, and until loop .

This tutorial covers the basics of while loops in Bash. We will also show you how to use the break and continue statements to alter the flow of a loop.

while Loop Syntax

The while loop is used to perform a given set of commands an unknown number of times as long as the given condition evaluates to true.

The Bash while loop takes the following form:

txt
while [CONDITION]
do
 [COMMANDS]
done

The while statement starts with the while keyword, followed by the conditional expression.

The condition is evaluated before executing the commands. If the condition evaluates to true, commands are executed. Otherwise, if the condition evaluates to false, the loop is terminated, and the program control is passed to the command that follows.

In the example below, on each iteration, the current value of the variable i is printed and incremented by one. The condition uses the -le comparison operator to check if i is less than or equal to 2.

sh
i=0

while [ $i -le 2 ]
do
 echo Number: $i
 ((i++))
done

The loop iterates as long as i is less than or equal to two. It will produce the following output:

output

Number: 0
Number: 1
Number: 2

Infinite while Loop

An infinite loop is a loop that repeats indefinitely and never terminates. If the condition always evaluates to true, you get an infinite loop.

In the following example, we are using the built-in command : to create an infinite loop. : always returns true. You can also use the true built-in or any other statement that always returns true.

sh
while :
do
 echo "Press <CTRL+C> to exit."
 sleep 1
done

The while loop above will run indefinitely. You can terminate the loop by pressing CTRL+C.

Here is a single-line equivalent:

sh
while :; do echo 'Press <CTRL+C> to exit.'; sleep 1; done

Other Condition Forms

The examples so far use [ ] (single-bracket test). Bash also accepts [[ ]] for richer string comparisons and (( )) for arithmetic evaluation.

Use (( )) when the condition is purely numeric. Variables inside (( )) do not need $, and the syntax is closer to other programming languages:

sh
i=0
while (( i < 3 ))
do
 echo "Number: $i"
 ((i++))
done

Use [[ ]] when the condition involves string patterns or && / || operators:

sh
while read -r line && [[ "$line" != "END" ]]
do
 echo "$line"
done

Read a File Line By Line

One of the most common usages of the while loop is to read a file, data stream, or variable line by line.

Here is an example that reads the /etc/passwd file line by line and prints each line:

sh
file=/etc/passwd

while read -r line; do
 echo "$line"
done < "$file"

Instead of controlling the while loop with a condition, we are using input redirection (< "$file") to pass a file to the read command, which controls the loop. The while loop will run until the last line is read.

When reading file line by line, always use read with the -r option to prevent backslash from acting as an escape character.

By default, the read command trims the leading/trailing whitespace characters (spaces and tabs). Use the IFS= option before read to prevent this behavior:

sh
file=/etc/passwd

while IFS= read -r line; do
 echo "$line"
done < "$file"

Pipes and the Subshell Trap

When you pipe data into a while loop, the loop runs in a subshell, so any variable changes inside the loop are lost once the loop exits:

sh
count=0
seq 1 5 | while read -r n; do
 ((count++))
done
echo "$count"

output

To keep the variable in the current shell, use input redirection or process substitution instead:

sh
count=0
while read -r n; do
 ((count++))
done < <(seq 1 5)
echo "$count"

output

break and continue Statements

The break and continue statements can be used to control the while loop execution.

break Statement

The break statement terminates the current loop and passes program control to the command that follows the terminated loop. It is usually used to terminate the loop when a certain condition is met.

In the following example, the execution of the loop will be interrupted once the current iterated item is equal to 2.

sh
i=0

while [ $i -lt 5 ]
do
 echo "Number: $i"
 ((i++))
 if [[ "$i" == '2' ]]; then
 break
 fi
done

echo 'All Done!'

output

Number: 0
Number: 1
All Done!

continue Statement

The continue statement exits the current iteration of a loop and passes program control to the next iteration of the loop.

In the following example, once the current iterated item is equal to 2 the continue statement will cause execution to return to the beginning of the loop and to continue with the next iteration.

sh
i=0

while [ $i -lt 5 ]
do
 ((i++))
 if [[ "$i" == '2' ]]; then
 continue
 fi
 echo "Number: $i"
done

echo 'All Done!'

output

Number: 1
Number: 3
Number: 4
Number: 5
All Done!

Quick Reference

For a printable quick reference, see the bash cheatsheet .

Pattern	Example
Basic while loop	`while [ $i -le 10 ]; do ...; done`
Arithmetic condition	`while (( i < 10 )); do ...; done`
Infinite loop	`while :; do ...; done`
Read file line by line	`while read -r line; do ...; done < file`
Preserve whitespace	`while IFS= read -r line; do ...; done < file`
Break on condition	`if [[ ... ]]; then break; fi`
Skip iteration	`if [[ ... ]]; then continue; fi`

Troubleshooting

Loop never terminates
Make sure the variable in the condition is updated inside the loop body and that the condition will eventually become false.

integer expression expected error
This usually means a numeric variable is empty or contains non-numeric text. Initialize counters before use, for example i=0.

Whitespace is lost when reading lines
Use IFS= read -r line and print with echo "$line" to preserve leading spaces and backslashes.

FAQ

What is the difference between while and until?
A while loop runs as long as the condition is true. An until loop runs as long as the condition is false; it is the logical opposite of while.

How do I exit an infinite while loop?
From the terminal, press CTRL+C to interrupt the loop. Inside the script, use a break statement inside an if block to exit when a condition is met.

Can I use while to loop a specific number of times?
Yes. Initialize a counter variable and increment it each iteration using ((i++)). Use a condition like [ $i -le 10 ] to control how many times the loop runs. See the increment and decrement guide for counter examples.

Why does my while loop not terminate?
The condition always evaluates to true. Check that the variable being tested is actually changing inside the loop body, and that the condition will eventually become false.

Can I nest while loops?
Yes. You can place a while loop inside another while loop. Use separate counter variables for each loop to avoid conflicts.

Conclusion

The while loop repeatedly executes a given set of commands as long as a condition is true. To learn more about running your scripts, see our guide on how to run a Bash script .

Bash until Loop

hello@linuxize.com (Linuxize) — Sat, 02 Mar 2019 21:33:44 +0100

The until loop in Bash executes a set of commands repeatedly as long as a given condition evaluates to false. Once the condition becomes true, the loop stops.

In Bash scripting, there are three basic loop constructs: the for loop , the while loop , and the until loop. The until loop is the inverse of while — it runs while the condition is false rather than true.

This guide explains the syntax of the until loop and demonstrates its use with practical examples.

Syntax

The Bash until loop takes the following form:

sh
until [CONDITION]
do
 [COMMANDS]
done

The condition is evaluated before each iteration. If it evaluates to false (non-zero exit status), the commands inside the loop body run. If it evaluates to true (zero exit status), the loop terminates and control passes to the next command after done.

Basic Example

In the following example, the loop prints the current value of counter and increments the variable by one on each iteration. The condition uses the -gt comparison operator to check if counter is greater than 5:

sh
#!/bin/bash

counter=0

until [ $counter -gt 5 ]
do
 echo Counter: $counter
 ((counter++))
done

The loop runs as long as counter is not greater than 5. Once counter reaches 6, the condition [ 6 -gt 5 ] evaluates to true and the loop stops. The output is:

output

Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5

Use the break and continue statements to control the loop execution.

Practical Examples

Waiting for a Git Host

The following script retries git pull until it succeeds. This is useful when a git host has downtime and you do not want to keep typing the command manually:

sh
#!/bin/bash

until git pull &> /dev/null
do
 echo "Waiting for the git host ..."
 sleep 1
done

echo -e "\nThe git repository is pulled."

The sleep command pauses for one second between attempts. Once the repository is pulled successfully, the script prints a confirmation message:

output

Waiting for the git host ...
Waiting for the git host ...
Waiting for the git host ...
The git repository is pulled.

Waiting for a Service to Start

This script waits until a service is listening on a specific port before continuing:

sh
#!/bin/bash

echo "Waiting for port 3306 to become available..."

until nc -z localhost 3306 2>/dev/null
do
 sleep 1
done

echo "MySQL is ready."

Retry with Maximum Attempts

To avoid an infinite loop, you can add a retry counter that exits after a set number of attempts:

sh
#!/bin/bash

max_retries=10
attempt=0

until curl -s http://localhost:8080/health > /dev/null
do
 ((attempt++))
 if [ $attempt -ge $max_retries ]; then
 echo "Service did not start after $max_retries attempts."
 exit 1
 fi
 echo "Attempt $attempt of $max_retries..."
 sleep 2
done

echo "Service is up."

Countdown Timer

A simple countdown using until:

sh
#!/bin/bash

seconds=10

until [ $seconds -eq 0 ]
do
 echo "$seconds..."
 ((seconds--))
 sleep 1
done

echo "Done!"

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Pattern	Description
`until [ condition ]; do ... done`	Loop while condition is false
`until command; do ... done`	Loop until command succeeds (exit 0)
`until false; do ... done`	Infinite loop (use `break` to exit)
`break`	Exit the loop immediately
`continue`	Skip to the next iteration
`until [[ $var =~ regex ]]`	Loop until a regex matches

FAQ

What is the difference between while and until? The while loop runs as long as the condition is true. The until loop runs as long as the condition is false. They are logical inverses of each other: until [ condition ] is equivalent to while [ ! condition ].

Can I use until with command exit status instead of a test condition? Yes. The until loop checks the exit status of whatever follows until. Any command that returns a non-zero exit status (failure) keeps the loop running. When the command returns zero (success), the loop stops.

How do I create an infinite until loop? Use until false; do ... done. The false command always returns a non-zero exit status, so the condition never becomes true. Use break inside the loop to exit when needed.

How do I avoid an infinite loop when waiting for something? Add a retry counter that increments on each iteration and use break or exit when the maximum number of attempts is reached. See the Retry with Maximum Attempts example above.

Conclusion

The until loop repeats commands as long as a condition is false, making it ideal for waiting on external events like service availability or network connectivity. For the inverse behavior, use the while loop .

Bash break and continue Statements

hello@linuxize.com (Linuxize) — Tue, 28 Jan 2020 20:33:44 +0100

When a Bash loop runs over a list of files, exit codes, or counter values, you will sometimes want to leave the loop early or skip a single bad entry without aborting the rest of the work. Bash provides two built-in statements for exactly that: break to leave the enclosing loop, and continue to jump straight to the next iteration.

This guide explains how both statements behave inside for, while, until , and select loops, including how the optional numeric argument lets you target an outer loop in nested constructs.

Bash break Statement

The break statement terminates the current loop and passes program control to the command that follows the terminated loop. It works inside any of the loop forms Bash supports: for, while, until, and select.

The syntax of the break statement takes the following form:

txt
break [n]

[n] is an optional argument and must be greater than or equal to 1. When [n] is provided, the nth enclosing loop is exited. break 1 is equivalent to break.

Breaking a While Loop

In the script below, the execution of the while loop will be interrupted once the counter reaches 2:

sh
i=0

while [[ $i -lt 5 ]]
do
 echo "Number: $i"
 ((i++))
 if [[ $i -eq 2 ]]; then
 break
 fi
done

echo 'All Done!'

output

Number: 0
Number: 1
All Done!

Breaking Nested Loops

When used inside nested for loops , break without an argument terminates the innermost enclosing loop. The outer loops are not terminated:

sh
for i in {1..3}; do
 for j in {1..3}; do
 if [[ $j -eq 2 ]]; then
 break
 fi
 echo "j: $j"
 done
 echo "i: $i"
done

echo 'All Done!'

output

j: 1
i: 1
j: 1
i: 2
j: 1
i: 3
All Done!

If you want to exit from the outer loop, use break 2. The argument 2 tells break to terminate the second enclosing loop:

sh
for i in {1..3}; do
 for j in {1..3}; do
 if [[ $j -eq 2 ]]; then
 break 2
 fi
 echo "j: $j"
 done
 echo "i: $i"
done

echo 'All Done!'

output

j: 1
All Done!

Bash continue Statement

The continue statement skips the remaining commands inside the body of the enclosing loop for the current iteration and passes program control to the next iteration of the loop.

The syntax of the continue statement is as follows:

txt
continue [n]

The [n] argument is optional and can be greater than or equal to 1. When [n] is given, the nth enclosing loop is resumed. continue 1 is equivalent to continue.

Skipping an Iteration in a While Loop

In the example below, once the current iterated item equals 2, the continue statement will cause execution to return to the beginning of the loop and continue with the next iteration:

sh
i=0

while [[ $i -lt 5 ]]; do
 ((i++))
 if [[ $i -eq 2 ]]; then
 continue
 fi
 echo "Number: $i"
done

echo 'All Done!'

output

Number: 1
Number: 3
Number: 4
Number: 5
All Done!

Skipping an Iteration in a For Loop

The same pattern works inside a for loop . The script below iterates over a fixed list of names and skips the entry bob:

sh
for user in alice bob carol dave; do
 if [[ "$user" == "bob" ]]; then
 continue
 fi
 echo "Greeting: $user"
done

output

Greeting: alice
Greeting: carol
Greeting: dave

When continue runs, Bash drops the rest of the loop body for that iteration and moves on to the next item in the list. The loop is not aborted, so dave is still processed at the end.

Continuing in Nested Loops

In nested loops, you can use continue 2 to skip the rest of the current iteration of the outer loop:

sh
for i in {1..3}; do
 for j in {1..3}; do
 if [[ $j -eq 2 ]]; then
 continue 2
 fi
 echo "i: $i, j: $j"
 done
done

output

i: 1, j: 1
i: 2, j: 1
i: 3, j: 1

Filtering Iterations with continue

The following script prints numbers from 1 through 50 that are divisible by 9. If a number is not divisible by 9, the continue statement skips the echo command and passes control to the next iteration of the loop:

sh
for i in {1..50}; do
 if [[ $(( $i % 9 )) -ne 0 ]]; then
 continue
 fi
 echo "Divisible by 9: $i"
done

output

Divisible by 9: 9
Divisible by 9: 18
Divisible by 9: 27
Divisible by 9: 36
Divisible by 9: 45

Practical Example

A common real-world use case is processing files in a directory and skipping certain entries. The following script processes all .log files in a directory but skips empty files:

sh
for file in /var/log/*.log; do
 if [[ ! -s "$file" ]]; then
 continue
 fi
 echo "Processing: $file ($(wc -l < "$file") lines)"
done

You can combine break and continue in the same loop. For example, to search for a specific string in files and stop after the first match:

sh
for file in /etc/*.conf; do
 if [[ ! -r "$file" ]]; then
 continue
 fi
 if grep -q "MaxSessions" "$file"; then
 echo "Found in: $file"
 break
 fi
done

Troubleshooting

break or continue outside a loop
You used break or continue outside of a loop, often by accident inside a function that no longer wraps a loop. Bash prints an error saying the statement is only meaningful in a for, while, or until loop. The script keeps running, but the statement does nothing. Move the call back inside a loop, or replace it with return if you only want to leave a function.

break inside a pipeline does not exit the outer script
A construct like cat file.txt | while read line; do ...; break; done runs the while loop in a subshell because of the pipe. The break exits that subshell, not the script that started the pipeline. Read from the file directly with redirection, for example while read line; do ...; break; done < file.txt. If the input comes from another command, use process substitution instead of a pipe.

break 0 or a negative argument
The optional numeric argument to break and continue must be greater than or equal to 1. A value of 0 or a negative number is rejected with an error and the loop is not affected. Pass 1 to target the innermost loop or 2 for the next enclosing loop.

Quick Reference

Statement	Effect
`break`	Exit the innermost loop
`break n`	Exit the nth enclosing loop
`continue`	Skip to the next iteration of the innermost loop
`continue n`	Skip to the next iteration of the nth enclosing loop

FAQ

Can I use break and continue outside a loop?
No. Using break or continue outside a loop will produce an error saying the statement is only meaningful in a for, while, or until loop. The script will continue running, but the statement has no effect.

What is the difference between break and exit?
break exits only the current loop and continues executing the rest of the script. exit terminates the entire script immediately.

Do break and continue work in select loops?
Yes. Both statements work in select loops the same way they work in for, while, and until loops.

Can I use break and continue in the same loop?
Yes. You can use both statements in the same loop. For example, continue to skip certain iterations and break to exit when a condition is met.

Conclusion

break and continue are the two statements that let you steer Bash loops without restructuring them, and the optional numeric argument is what makes them work cleanly inside nested loops. For a deeper look at the loop forms themselves, see the guides on Bash for loops and Bash while loops .

Bash Select (Make Menus)

hello@linuxize.com (Linuxize) — Wed, 29 Jan 2020 21:11:32 +0100

The select construct in Bash allows you to generate interactive menus in shell scripts. It displays a numbered list of items and prompts the user to make a selection.

In this guide, we will cover the syntax of the select construct and show you how to use it with practical examples.

Syntax

The select construct has almost the same syntax as the for loop:

txt
select ITEM in [LIST]
do
 [COMMANDS]
done

The [LIST] can be a series of strings separated by spaces, a range of numbers, output of a command, an array, and so on.

When the select construct is invoked, each item from the list is printed to standard error, preceded with a number.

If the user enters a number that corresponds to one of the displayed items, then the value of [ITEM] is set to that item. The selected number is stored in the variable REPLY. If the user input is empty, the prompt and the menu list are displayed again.

The select loop will continue to run and prompt for user input until the break command is executed.

The PS3 Prompt

A custom prompt for the select construct can be set using the PS3 environment variable . If PS3 is not set, the default prompt is #? .

Examples

The following examples show how select is commonly used in bash scripts.

This script displays a list of characters and prints the selection:

sh
#!/bin/bash

PS3="Enter a number: "

select character in Sheldon Leonard Penny Howard Raj
do
 echo "Selected character: $character"
 echo "Selected number: $REPLY"
done

The script displays a menu with an accompanying number and the PS3 prompt. When the user enters a number, the script prints the selected character and number:

output

1) Sheldon
2) Leonard
3) Penny
4) Howard
5) Raj
Enter a number: 3
Selected character: Penny
Selected number: 3
Enter a number:

Using Select with Case

Usually, select is used in combination with case or if statements to act on the user’s choice.

The following script is a simple calculator that prompts the user for input and performs basic arithmetic operations:

sh
#!/bin/bash

PS3="Select the operation: "

select opt in add subtract multiply divide quit; do

 case $opt in
 add)
 read -p "Enter the first number: " n1
 read -p "Enter the second number: " n2
 echo "$n1 + $n2 = $(($n1+$n2))"
 ;;
 subtract)
 read -p "Enter the first number: " n1
 read -p "Enter the second number: " n2
 echo "$n1 - $n2 = $(($n1-$n2))"
 ;;
 multiply)
 read -p "Enter the first number: " n1
 read -p "Enter the second number: " n2
 echo "$n1 * $n2 = $(($n1*$n2))"
 ;;
 divide)
 read -p "Enter the first number: " n1
 read -p "Enter the second number: " n2
 echo "$n1 / $n2 = $(($n1/$n2))"
 ;;
 quit)
 break
 ;;
 *)
 echo "Invalid option $REPLY"
 ;;
 esac
done

When the script is executed, it displays the menu and the PS3 prompt. The user selects an operation and enters two numbers. Depending on the input, the script prints the result. The loop continues until the user selects quit:

output

1) add
2) subtract
3) multiply
4) divide
5) quit
Select the operation: 1
Enter the first number: 4
Enter the second number: 5
4 + 5 = 9
Select the operation: 9
Invalid option 9
Select the operation: 5

One drawback of this script is that it works only with integers. Here is an improved version that uses bc to support floating-point numbers. The repetitive code is grouped inside a function :

sh
#!/bin/bash

calculate () {
 read -p "Enter the first number: " n1
 read -p "Enter the second number: " n2
 echo "$n1 $1 $n2 = " $(bc -l <<< "$n1$1$n2")
}

PS3="Select the operation: "

select opt in add subtract multiply divide quit; do

 case $opt in
 add)
 calculate "+";;
 subtract)
 calculate "-";;
 multiply)
 calculate "*";;
 divide)
 calculate "/";;
 quit)
 break;;
 *)
 echo "Invalid option $REPLY";;
 esac
done

output

1) add
2) subtract
3) multiply
4) divide
5) quit
Select the operation: 4
Enter the first number: 8
Enter the second number: 9
8 / 9 = .88888888888888888888
Select the operation: 5

Using Select with an Array

You can pass an array as the list of items to select:

sh
#!/bin/bash

options=("Start" "Stop" "Restart" "Status" "Quit")

PS3="Select an action: "

select opt in "${options[@]}"; do
 case $opt in
 Start|Stop|Restart)
 echo "Performing: $opt"
 ;;
 Status)
 echo "Service is running"
 ;;
 Quit)
 echo "Exiting."
 break
 ;;
 *)
 echo "Invalid option $REPLY"
 ;;
 esac
done

Selecting Files from a Directory

The select construct can be combined with command output to create a file picker. The following script lists all .sh files in the current directory and lets the user choose one to execute:

sh
#!/bin/bash

PS3="Select a script to run: "

select file in *.sh; do
 if [[ -n "$file" ]]; then
 echo "Running $file..."
 bash "$file"
 break
 else
 echo "Invalid selection"
 fi
done

If the directory contains backup.sh, deploy.sh, and test.sh, the output looks like:

output

1) backup.sh
2) deploy.sh
3) test.sh
Select a script to run: 2
Running deploy.sh...

Confirmation Prompt

A simple yes/no confirmation menu:

sh
#!/bin/bash

PS3="Are you sure? "

select answer in Yes No; do
 case $answer in
 Yes)
 echo "Confirmed."
 break
 ;;
 No)
 echo "Cancelled."
 break
 ;;
 *)
 echo "Please select 1 or 2."
 ;;
 esac
done

Quick Reference

Element	Description
`select VAR in LIST`	Create a menu from LIST
`$REPLY`	Holds the number the user entered
`$VAR`	Holds the selected item text
`PS3`	Custom prompt (default: `#?` )
`break`	Exit the select loop
`*) ...`	Handle invalid selections in `case`

FAQ

How do I change the select prompt?
Set the PS3 variable before the select construct. For example, PS3="Choose an option: ". If PS3 is not set, the default prompt #? is used.

How do I exit a select loop?
Use the break command. Without it, the select loop runs indefinitely and keeps prompting the user for input.

What happens when the user enters an invalid number?
The ITEM variable is set to an empty string. Use the *) pattern in a case statement to handle invalid selections.

Can I use select with command output?
Yes. For example, select file in $(ls *.txt) creates a menu from all .txt files. However, it is better to use a glob pattern like select file in *.txt to correctly handle filenames with spaces.

What is the difference between $REPLY and the select variable?
$REPLY contains the raw number the user typed. The select variable (e.g., $opt) contains the corresponding text from the list. If the user enters an invalid number, the select variable is empty but $REPLY still holds the entered value.

Conclusion

The select construct allows you to generate interactive menus in shell scripts. It is commonly used with case statements to perform different actions based on the user’s selection.

If you have any questions, feel free to leave a comment below.

Bash Functions

hello@linuxize.com (Linuxize) — Mon, 14 Jan 2019 20:31:47 +0100

A Bash function is a reusable block of commands that can be called multiple times within a script. Functions help you make your Bash scripts more readable, easier to maintain, and less repetitive.

While Bash functions are more limited than those in other programming languages, they are still very powerful for shell scripting.

In this guide, we will cover the basics of Bash functions and show you how to use them in your shell scripts. If you are new to Bash, consider reviewing the basic Linux commands first.

Defining Bash Functions

There are two different ways to define a function in Bash.

Preferred Syntax (Most Common) The first format starts with the function name, followed by parentheses. This is the preferred and most-used syntax.
sh
```
function_name () {
 commands
}
```
Single line version:
sh
```
function_name () { commands; }
```
Using the function Keyword The second format starts with the reserved word function, followed by the function name.
sh
```
function function_name {
 commands
}
```
Single line version:
sh
```
function function_name { commands; }
```

Important points to note:

The commands inside the curly braces ({}) make up the function body.
The opening and closing braces must be separated from the body by spaces or newlines.
A function runs only when explicitly called by name.
The function must be defined before it is called.
When using single-line “compacted” functions, a semicolon ; is required after the last command.
Use descriptive function names whenever possible.

Tip

Stick to the first syntax (function_name () {}) for better portability and readability.

Example: Hello World Function

To understand this better, take a look at the following example:

~/hello_world.shsh
#!/bin/bash

hello_world () {
 echo 'Hello, World.'
}

hello_world

Here is what each line does:

In line 3, we are defining the function by giving it a name. The curly brace { marks the start of the function’s body.
Line 4 is the function body. The function body can contain multiple commands, statements, and variable declarations.
Line 5, the closing curly bracket }, defines the end of the hello_world function.
In line 7, we are executing the function. You can execute the function as many times as you need.

Running the script prints:

output

Hello, World.

Variable Scope in Bash Functions

Knowing how variable scope works helps you write scripts that are safe and predictable.

Global Variables

Global variables are variables that can be accessed and modified anywhere in the script, including inside functions.
By default, all variables are defined as global, even if declared inside the function.

Local Variables

Local variables are declared with the local keyword.
Local variables can be declared only inside the function and can be used only inside that function.
You can have local variables with the same name in different functions.
Local variables override global variables with the same name within the function.

Tip

Always use local variables inside functions unless you explicitly need global access.

Example: Variable Scope

To better illustrate how variable scope works in Bash, consider the following example:

~/variables_scope.shsh
#!/bin/bash

var1='A'
var2='B'

my_function () {
 local var1='C'
 var2='D'
 echo "Inside function: var1: $var1, var2: $var2"
}

echo "Before executing function: var1: $var1, var2: $var2"

my_function

echo "After executing function: var1: $var1, var2: $var2"

The script starts by defining two global variables var1 and var2. Then there is a function that sets a local variable var1 and modifies the global variable var2.

If you run the script, you should see the following output:

output

Before executing function: var1: A, var2: B
Inside function: var1: C, var2: D
After executing function: var1: A, var2: D

From the output above, we can conclude that:

When a local variable is defined within a function with the same name as an existing global variable, the local variable takes precedence.
Global variables can be changed from within the function.

Return Values in Bash Functions

Unlike functions in “real” programming languages, Bash functions do not return values when called.

When a Bash function completes, its return value is the status of the last statement executed in the function:

0 for success.
Any non-zero value in the (1 - 255) range for failure.

The return status can be specified using the return keyword, and it is assigned to the variable $?. The return statement terminates the function. You can think of it as the function’s exit status .

~/return_values.shsh
#!/bin/bash

my_function () {
 echo "some result"
 return 55
}

my_function
echo $?

output

some result
55

Returning Data from a Bash Function

Since Bash cannot return arbitrary values directly, we need to use other methods. There are two common workarounds.

Using a Global Variable:

The simplest option is to assign the result of the function to a global variable:
~/return_values.shsh
```
#!/bin/bash

my_function () {
 func_result="some result"
}

my_function
echo $func_result
```
output
```
some result
```
Using Standard Output (Recommended)

Another option is to send the value to stdout using echo or printf . This approach is cleaner and avoids unnecessary global variables:
~/return_values.shsh
```
#!/bin/bash

my_function () {
 local func_result="some result"
 echo "$func_result"
}

func_result="$(my_function)"
echo $func_result
```
output
```
some result
```
Instead of simply executing the function, which prints the message to stdout, we assign the function’s output to the func_result variable using the $() command substitution. The variable can later be used as needed.

Passing Arguments to Functions

Arguments are passed to a function by placing them after the function name, separated by a space. It is a good practice to double-quote the arguments to avoid the misparsing of an argument with spaces in it.

sh
function_name arg1 arg2 arg3

Special Variables

Positional parameters $1, $2, $3 … $n, correspond to the position of the parameter after the function’s name.
The $0 variable holds the name of the script. To get the current function’s name from inside the function, use ${FUNCNAME[0]}.
The $# variable holds the number of positional parameters/arguments passed to the function.
The $* and $@ variables hold all positional parameters/arguments passed to the function.
- When double-quoted, "$*" expands to a single string separated by space (the first character of IFS) - "$1 $2 $n".
- When double-quoted, "$@" expands to separate strings - "$1" "$2" "$n".
- When not double-quoted, $* and $@ are the same.

Here is an example:

~/passing_arguments.shsh
#!/bin/bash

greeting () {
 echo "Hello $1"
}

greeting "Zoe"

output

Hello Zoe

Bash Function Best Practices

Choose function names that clearly describe what the function does.
Declare variables as local inside functions to avoid unexpected behavior.
Return the data via standard output rather than relying on global variables.
Be sure to quote variables, such as “$var”.
Write functions that are short and handle only one specific task.
Put your function definitions at the top of your scripts.
Turn on strict mode with set -euo pipefail when writing scripts for production.
Add comments to explain any complex logic inside your functions.

Conclusion

A Bash function is a block of reusable code designed to perform a particular operation. Once defined, the function can be called multiple times within a script.

Functions are especially useful for repeating tasks, simplifying complex scripts, and creating readable and modular code.

You can also read about how to use a Bash function to create a memorable shortcut command (alias) for a longer command. For more details on executing scripts, see our guide on how to run a bash script .

Bash source Command: Load Scripts and Variables

hello@linuxize.com (Linuxize) — Mon, 17 Jun 2019 20:31:47 +0100

The most common reason to use source is reloading your shell configuration without opening a new terminal: after editing ~/.bashrc, run source ~/.bashrc and the changes take effect immediately in your current session.

source reads and executes a file in the current shell environment. Any variables and functions it defines remain available after it exits. This is what sets it apart from running a script with bash script.sh, which uses a subshell and discards everything on exit.

Syntax

The syntax for the source command is:

txt
source FILENAME [ARGUMENTS]
. FILENAME [ARGUMENTS]

source and . (a period) are the same command. The dot form is POSIX-compliant and works in any POSIX shell.
If FILENAME does not contain a slash, the command searches for the file in the directories listed in the $PATH environment variable . If the file is not found in $PATH, it looks in the current directory.
If ARGUMENTS are provided, they become the positional parameters of the sourced file.
The exit code is the status of the last command executed in the sourced file. If Bash cannot read the file, source returns a failure status.

source vs. Running a Script Directly

The key difference between source script.sh and bash script.sh is which shell environment the commands run in:

bash script.sh: spawns a new subshell, runs the script there, and discards all variables and functions when the subshell exits. The parent shell is unchanged.
source script.sh: runs the script in the current shell. Any variables, functions, or environment changes defined in the script remain available after it finishes.

This distinction is the core reason source exists. If you want a script to set variables that your current session can use, you must source it.

Reload Shell Configuration

The most common use of source is reloading the shell configuration file after making changes, without needing to open a new terminal:

Terminal
source ~/.bashrc

After editing ~/.bashrc to add aliases , functions, or environment variables, run the command above to apply the changes immediately. Without source, you would need to log out and log back in.

For login shells, reload the profile instead:

Terminal
source ~/.bash_profile

See .bashrc vs .bash_profile for an explanation of when each file is used.

Sourcing Functions

If multiple scripts use the same functions , extract them into a shared file and source it where needed. This avoids duplicating code across scripts.

In the following example, we create a file that contains a function to check whether the script is running as root:

functions.shsh
check_root () {
 if [[ $EUID -ne 0 ]]; then
 echo "This script must be run as root"
 exit 1
 fi
}

In each script that requires root, source the file and call the function:

sh
#!/usr/bin/env bash

source functions.sh
check_root

echo "I am root"

If the script runs as a non-root user, it prints the message and exits. The advantage of this approach is that your scripts stay smaller and more readable, the shared function file is maintained in one place, and any update to it is automatically picked up by all scripts that source it.

Read Variables from a File

source can also read variables from a configuration file. The variables must use Bash assignment syntax: VARIABLE=VALUE.

Create a configuration file:

config.shsh
VAR1="foo"
VAR2="bar"

In your script, source the file to load the variables:

sh
#!/usr/bin/env bash

source config.sh

echo "VAR1 is $VAR1"
echo "VAR2 is $VAR2"

Running the script produces:

output

VAR1 is foo
VAR2 is bar

This pattern is useful for keeping configuration separate from logic, making scripts easier to maintain and reuse across different environments.

Quick Reference

Task	Command
Source a file	`source filename.sh`
Source using dot shorthand	`. filename.sh`
Reload `.bashrc`	`source ~/.bashrc`
Reload `.bash_profile`	`source ~/.bash_profile`
Source with arguments	`source filename.sh arg1 arg2`

Troubleshooting

source: filename: not found
Use an explicit path such as source ./filename.sh and confirm the file exists with ls -l.

Variables are not loaded after sourcing
Check the sourced file for valid Bash assignments (VAR=value with no spaces around =) and syntax errors.

Script exits right after source file.sh
The sourced file may contain exit, which terminates the current shell or script. Use return in sourced helper files. Also remember that sourced files run in the current shell, so they inherit options such as set -euo pipefail. See Bash strict mode for more on that behavior.

FAQ

What is the difference between source and . (dot)?
They are identical. . is the POSIX standard form and works in any POSIX-compliant shell. source is a Bash built-in that does the same thing. Use . in scripts intended to run in /bin/sh, and source in Bash-specific scripts for readability.

Why do I need source to reload .bashrc?
Because running bash ~/.bashrc would execute it in a subshell. Any variables or aliases defined in it would be discarded when that subshell exits. Using source ~/.bashrc runs it in your current session, so the changes take effect immediately.

Can I pass arguments to a sourced file?
Yes. Any arguments after the filename become positional parameters ($1, $2, etc.) inside the sourced file: source script.sh arg1 arg2.

What happens if the file does not exist?
source returns exit code 1 and prints an error. In a script, you can handle this with: source file.sh || echo "file not found".

What is the difference between source and import in other languages?
source is similar in concept; it loads and executes another file. The key difference is that source is not a module system; it simply runs the file inline in the current shell, with no namespacing or isolation.

Conclusion

The source command runs a file in the current shell environment, making its variables and functions available to the calling session or script. Use it to reload shell configuration files, share functions across scripts, and load variables from configuration files.

Bash Exit Command and Exit Codes

hello@linuxize.com (Linuxize) — Mon, 08 Jun 2020 20:31:34 +0100

Often when writing Bash scripts, you will need to terminate the script when a certain condition is met or take action based on the exit code of a command.

This article covers the Bash exit built-in command and the exit statuses of executed commands.

Exit Status

Each shell command returns an exit code when it terminates, whether successfully or not.

By convention, an exit code of zero indicates the command completed successfully, and a non-zero value means an error was encountered.

The special variable $? holds the exit status of the last executed command:

Terminal
date &> /dev/null
echo $?

The date command completed successfully, so the exit code is zero:

output

If you try to run ls on a nonexistent directory, the exit code will be non-zero:

Terminal
ls /nonexistent_dir &> /dev/null
echo $?

output

Each command’s man page documents its possible exit codes and what they mean.

When executing a multi-command pipeline, the exit status of the pipeline is that of the last command:

Terminal
sudo tcpdump -n -l | tee file.out
echo $?

This example uses sudo because tcpdump often requires elevated privileges, and it keeps running until you stop it (for example, with Ctrl+C).

In the example above, echo $? prints the exit code of the tee command. To capture the exit code of every command in a pipeline, use the $PIPESTATUS array:

Terminal
sudo tcpdump -n -l | tee file.out
echo "${PIPESTATUS[0]}" # exit code of tcpdump
echo "${PIPESTATUS[1]}" # exit code of tee

Bash `exit` Command

The exit command exits the shell with a given status:

txt
exit N

If N is not given, the exit status is that of the last executed command.

When used in shell scripts, the value supplied to exit is returned to the shell as the exit code.

Exit Code Conventions

While any value from 0 to 255 is valid, the following codes have well-established meanings:

Code	Meaning
`0`	Success
`1`	General error
`2`	Misuse of a shell built-in (wrong arguments, etc.)
`126`	Command found but not executable (permission issue)
`127`	Command not found
`128`	Invalid argument passed to `exit`
`128+N`	Script terminated by signal N (e.g., `130` = Ctrl+C, `137` = SIGKILL)

Using meaningful exit codes in your scripts makes it easier for callers — other scripts, CI pipelines, or monitoring tools — to handle failures correctly.

Using Exit Codes in Scripts

Exit status can be used in conditional commands such as if . In the following example, grep exits with zero (true in shell scripting) if the string is found:

sh
if grep -q "search-string" filename; then
 echo "String found."
else
 echo "String not found."
fi

When running commands separated by && (AND) or || (OR), the exit status determines whether the next command runs. The mkdir command below runs only if cd succeeds:

Terminal
cd /opt/code && mkdir project

With ||, the second command runs only if the first fails:

Terminal
cd /opt/code || echo "Directory not found"

If a script ends with exit without a parameter, the script exit code is that of the last command executed:

~/script.shsh
#!/bin/bash

echo "doing stuff..."

exit

Using exit alone is equivalent to exit $? or simply omitting the exit.

Here is an example showing how to terminate the script if invoked by a non-root user:

~/check-root.shsh
#!/bin/bash

if [[ $EUID -ne 0 ]]; then
 echo "Only user root can run this script."
 exit 1
fi

echo "doing stuff..."

exit 0

If you run the script as root, the exit code will be zero. Otherwise, the script exits with status 1.

Automatic Exit on Error

By default, Bash continues executing a script even when a command fails. To make the script exit immediately on any non-zero exit code, add set -e at the top:

~/script.shsh
#!/bin/bash
set -e

cp config.txt /etc/myapp/
echo "Config copied successfully."

If cp fails, the script stops immediately without running the echo line.

set -e has exceptions in conditionals, command lists, and subshell contexts, so test your script paths carefully rather than relying on it as the only error-handling strategy.

To also catch failures inside pipelines, combine set -e with set -o pipefail:

~/script.shsh
#!/bin/bash
set -e
set -o pipefail

grep "ERROR" app.log | sort | uniq -c

Without pipefail, a failure in grep would be masked by the exit codes of sort and uniq. With pipefail, the pipeline fails if any command in it fails.

For a full walkthrough of set -e, set -u, set -o pipefail, and IFS, see Bash strict mode .

`exit` vs `return` in Functions

Inside a Bash function , exit terminates the entire script, not just the function. To exit only the function and return control to the caller, use return:

sh
check_file () {
 if [[ ! -f "$1" ]]; then
 echo "File not found: $1"
 return 1
 fi
 echo "File exists: $1"
 return 0
}

check_file "/etc/hosts"
echo "Exit code: $?"

return without an argument returns the exit code of the last command in the function. Using exit inside a function is valid when you intentionally want to stop the entire script on a condition.

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Command / Variable	Description
`exit N`	Exit shell or script with status N
`exit`	Exit with status of last command
`$?`	Exit status of the last command
`${PIPESTATUS[@]}`	Exit codes of all commands in last pipeline
`set -e`	Exit script immediately on any error
`set -o pipefail`	Propagate pipeline failures to `$?`
`return N`	Exit a function with status N

Troubleshooting

$? always shows 0 even after a failing command You are likely reading $? after an intermediate command such as echo or a variable assignment, which reset it. Capture $? immediately after the command you want to check: cmd; status=$?.

Pipeline exit code does not reflect the failing command By default, $? captures only the last command in a pipeline. Use set -o pipefail so that the pipeline returns the exit code of the first failing command. Alternatively, inspect individual codes with ${PIPESTATUS[@]}.

Script continues running after a command fails Bash does not stop on errors by default. Add set -e at the top of the script to make it exit immediately when any command returns a non-zero exit code.

FAQ

What does exit code 127 mean? Exit code 127 means the command was not found. This usually indicates a typo in the command name, a missing PATH entry, or a program that is not installed.

What is the difference between exit and return in a function? exit terminates the entire script regardless of where it is called. return exits only the current function and returns control to the caller. Use return inside functions and exit at the script level.

How do I exit a script automatically when any command fails? Add set -e at the top of your script. For pipelines, also add set -o pipefail to catch failures in intermediate pipeline commands.

Can I pass any number to exit? Valid exit codes are integers from 0 to 255. Values above 255 wrap around (256 becomes 0). Non-integer values produce an error. Stick to 0 for success and small positive integers for specific error conditions.

How do I check the exit code of a command without using $?? You can test the exit code directly in an if statement: if command; then ... fi. The if statement evaluates the command’s exit code — zero means the then branch runs, non-zero runs the else branch.

Conclusion

Every command in Bash returns an exit code. Use $? to check it, exit N to set it explicitly, and set -e to make your scripts fail fast on errors. Inside functions, use return instead of exit to avoid terminating the entire script unintentionally.

If you have any questions, feel free to leave a comment below.

Bash wait Command

hello@linuxize.com (Linuxize) — Tue, 26 Jan 2021 18:11:04 +0100

The wait command waits for one or more background jobs to complete and returns the exit status of the waited-for command. Since it affects the current shell execution environment, wait is implemented as a built-in command in most shells.

In this guide, we will show you how to use the Bash wait command with practical examples.

Syntax

The general syntax of the wait built-in takes the following form:

Terminal
wait [options] ID...

ID is the process or job ID. If no ID is specified, the command waits until all child background jobs are completed.

The wait command returns the exit status of the last command waited for.

For example, to wait for a background process with PID 7654, you would use:

Terminal
wait 7654

When multiple processes are given, the command waits for all processes to complete.

Waiting by Job Specification

Jobs can be specified using the job specification (“jobspec”), which is a way to refer to the processes that make up a job. A jobspec starts with a percentage symbol followed by the job number (%n).

Run a command in the background :

Terminal
rsync -a /home /tmp/home &

The job number (shown in brackets) and process ID will be displayed on your terminal:

output

[2] 54377

You can list active jobs and their IDs with:

Terminal
jobs -l

To wait for the job, run the wait command followed by the job specification:

Terminal
wait %2

Options

The wait command accepts the following options:

Wait for the First Job (`-n`)

When invoked with the -n option, the command waits only for a single job from the given PIDs or jobspecs to complete and returns its exit status. If no arguments are provided, wait -n waits for any background job to complete:

Terminal
wait -n 45432 54346 76573

Get the Completed Job ID (`-p`)

By default, wait -n does not show the PID of the job that completed first. Use the -p option to assign it to a variable:

Terminal
wait -p job_id -n 45432 54346 76573

You can then use the captured PID:

Terminal
wait -p job_id -n 45432 54346 76573
echo "First finished PID: $job_id"

Info

The -p option was introduced in Bash 5.1. If you use an older Bash version, you will get an “invalid option” error.

Wait for Actual Termination (`-f`)

The -f option tells wait to wait for each PID or jobspec to actually terminate before returning its exit code, rather than returning when the job status changes (e.g., when stopped with kill -STOP). This option is only valid when job control is enabled, which is the default for interactive shells.

Examples

The following examples demonstrate common uses of the wait command in Bash scripts.

Waiting for a Single Background Process

wait is typically used in shell scripts that spawn child processes that execute in parallel.

To illustrate how the command works, create the following script:

sh
#!/bin/bash
sleep 30 &
process_id=$!
echo "PID: $process_id"
wait $process_id
echo "Exit status: $?"

Here is what each line does:

The sleep command runs in the background to emulate a time-consuming process.
$! is an internal Bash variable that stores the PID of the last job run in the background. We store it in the process_id variable.
The PID is passed to the wait command, which waits until the sleep command completes.
$? holds the exit status of the last command executed.

If you run the script, it will print something like this:

output

PID: 36353
Exit status: 0

Waiting for the First Job to Complete

Here is an example using the -n option:

sh
#!/bin/bash
sleep 3 &
sleep 30 &
sleep 5 &
wait -n
echo "First job completed."
wait
echo "All jobs completed."

When the script is executed, it spawns 3 background processes. wait -n waits until the first job is completed and the echo statement is printed. wait without arguments waits for all remaining background jobs to complete.

output

First job completed.
All jobs completed.

Understanding the `-f` Option

This example shows the difference between wait and wait -f. Open the terminal and run:

Terminal
sleep 3600 &

output

[1] 46671

Wait for the process using the PID from the output above:

Terminal
wait 46671

Open another terminal and stop the process with the kill command:

Terminal
kill -STOP 46671

Once the process status changes, the wait command will complete and return the process exit code.

Now repeat the same steps, but this time use wait -f:

Terminal
sleep 3600 &

Use the PID from the output:

Terminal
wait -f 46671

Stop the process from the other terminal:

Terminal
kill -STOP 46671

This time the wait command will not complete. It will continue running until the sleep process actually terminates.

Parallel Execution with Error Handling

A common use case for wait is running multiple tasks in parallel and checking whether any of them failed:

sh
#!/bin/bash
task1() { echo "Running task 1"; sleep 2; }
task2() { echo "Running task 2"; sleep 3; }
task3() { echo "Running task 3"; sleep 1; return 1; }

task1 &
task2 &
task3 &

failed=0
for pid in $(jobs -p); do
 wait "$pid" || ((failed++))
done

if ((failed > 0)); then
 echo "$failed task(s) failed."
 exit 1
fi

echo "All tasks completed successfully."

This script runs three tasks in parallel, waits for each one individually, and counts how many failed.

Quick Reference

Task	Command
Wait for all background jobs	`wait`
Wait for a specific PID	`wait 12345`
Wait for a job by jobspec	`wait %1`
Wait for the first job to finish	`wait -n`
Get the PID of the completed job	`wait -p var -n`
Wait for actual termination	`wait -f 12345`
Get PID of last background job	`echo $!`

FAQ

What is the difference between wait and wait -n?
wait without arguments waits for all background jobs to complete. wait -n waits for only the first job to finish and returns its exit status.

What does $! do in Bash?
$! is a special Bash variable that holds the process ID (PID) of the last command run in the background.

Can I use wait with commands run in a subshell?
No. wait can only wait for child processes of the current shell. Processes started in a subshell or a different shell session cannot be waited on.

What happens if the PID does not exist?
If the specified PID is not a child of the current shell, wait returns exit status 127.

Conclusion

The wait command waits for background jobs to complete and returns their exit status. It is essential for writing Bash scripts that run tasks in parallel and need to handle their results.

If you have any questions, feel free to leave a comment below.

sleep Command in Linux: Pause a Bash Script

hello@linuxize.com (Linuxize) — Mon, 13 May 2019 21:51:47 +0100

The sleep command in bash pauses the execution of a script for a specified amount of time. It is one of the most common commands used in shell scripting, especially when you want to retry a failed operation, rate-limit a series of requests, or add a small delay inside a loop.

In this guide, we will show you how to use the sleep command with practical examples, including how to sleep for fractional seconds, how to combine multiple time units, and how to run sleep in the background.

Syntax

The syntax for the sleep command is as follows:

txt
sleep NUMBER[SUFFIX]...

The NUMBER may be a positive integer or a floating-point number.

The SUFFIX may be one of the following:

s - seconds (default)
m - minutes
h - hours
d - days

When no suffix is specified, it defaults to seconds.

When two or more arguments are given, the total amount of time is equivalent to the sum of their values.

Sleep Command Examples

Here are a few simple examples demonstrating how to use the sleep command:

Sleep for Seconds

Terminal
sleep 5

Sleep for Fractional Seconds

Terminal
sleep 0.5

Sleep for Multiple Durations

You can combine multiple values. The following pauses for 2 minutes and 30 seconds:

Terminal
sleep 2m 30s

Sleep Indefinitely

To pause a process indefinitely until it is manually interrupted, use infinity:

Terminal
sleep infinity

This is commonly used in Docker containers and systemd services to keep a process running without consuming CPU.

Script Examples

The following examples show how sleep is commonly used in bash scripts.

Timing a Delay

This script prints the time before and after a 5-second delay:

sh
#!/bin/bash

# start time
date +"%H:%M:%S"

# sleep for 5 seconds
sleep 5

# end time
date +"%H:%M:%S"

When you run the script, it will print the current time in HH:MM:SS format. Then the sleep command pauses the script for 5 seconds. Once the specified time period elapses, the last line prints the current time.

output

13:34:40
13:34:45

The output shows a 5-second gap between the first and second timestamps, which confirms that sleep 5 paused the script before the final date command ran.

Waiting for a Host to Come Online

The following script checks whether a host is online every 5 seconds and notifies you when it becomes reachable:

sh
#!/bin/bash

while :
do
 if ping -c 1 192.168.1.10 &> /dev/null
 then
 echo "Host is online"
 break
 fi
 sleep 5
done

How the script works:

The while loop runs indefinitely using : as the condition.
The ping command sends a single packet to the target host.
If the host is reachable, the script prints “Host is online” and exits the loop with break.
If the host is not reachable, sleep 5 pauses the script for 5 seconds before retrying.

Retry with Exponential Backoff

When retrying a failed operation, it is good practice to increase the delay between attempts. This avoids overwhelming the target service:

sh
#!/bin/bash

max_retries=5
delay=1

for ((i = 1; i <= max_retries; i++)); do
 if curl -s --fail https://example.com > /dev/null; then
 echo "Request succeeded on attempt $i"
 exit 0
 fi

 echo "Attempt $i failed. Retrying in ${delay}s..."
 sleep "$delay"
 delay=$((delay * 2))
done

echo "All $max_retries attempts failed."
exit 1

The delay starts at 1 second and doubles after each failure: 1s, 2s, 4s, 8s, 16s.

Countdown Timer

A simple countdown timer that prints the remaining seconds:

sh
#!/bin/bash

seconds=${1:-10}

for ((i = seconds; i > 0; i--)); do
 printf "\rTime remaining: %d seconds " "$i"
 sleep 1
done

printf "\rTime's up! \n"

Run the script with an optional number of seconds:

Terminal
bash countdown.sh 30

Running Sleep in the Background

You can run sleep in the background to create non-blocking delays:

Terminal
sleep 10 &
echo "Sleep is running in the background with PID $!"

The & operator sends the process to the background. The special variable $! holds the PID of the last background process.

To wait for a background sleep to finish, use the wait command :

Terminal
sleep 10 &
pid=$!
echo "Doing other work..."
wait "$pid"
echo "Sleep finished"

Pause Until a Keypress

In some scripts, you may want to pause until the user presses a key instead of waiting for a fixed amount of time. The sleep command cannot do this on its own, but you can combine it with the read command :

sh
#!/bin/bash

read -n 1 -s -r -p "Press any key to continue..."
echo

The -n 1 option tells read to accept a single character, -s hides the keypress from the terminal, and -r prevents backslash interpretation. This is a common way to make a script wait for confirmation before continuing.

Interrupting Sleep

To interrupt a running sleep command, press Ctrl+C. This sends a SIGINT signal that terminates the process.

To terminate a background sleep process, use kill:

Terminal
sleep 300 &
kill $!

Quick Reference

Task	Command
Sleep for 5 seconds	`sleep 5`
Sleep for 0.5 seconds	`sleep 0.5`
Sleep for 2 minutes	`sleep 2m`
Sleep for 1 hour 30 minutes	`sleep 1h 30m`
Sleep indefinitely	`sleep infinity`
Sleep in background	`sleep 10 &`
Interrupt sleep	`Ctrl+C` or `kill PID`

FAQ

Is sleep a bash builtin?
No. The sleep command is provided by the GNU coreutils package and lives at /usr/bin/sleep. Because it is an external program rather than a shell builtin, the GNU version supports features like fractional seconds and the infinity argument that are not part of the POSIX specification.

Can sleep accept decimal values?
Yes. The GNU version of sleep used on Linux supports floating-point numbers. For example, sleep 0.5 pauses for half a second. The POSIX specification only requires integer support, so this will not work on every Unix system.

How do I wait for user input with a timeout?
Use read -t SECONDS instead of sleep. For example, read -t 5 -p "Enter your name: " name waits up to 5 seconds for input and continues automatically if the user does not type anything in time.

What is sleep infinity used for?
sleep infinity pauses a process indefinitely without consuming CPU. It is commonly used in Docker containers to keep the container running, or in scripts that need to wait for a signal.

Does sleep use CPU while waiting?
No. The sleep command suspends the process and does not consume CPU cycles during the wait period.

Can I combine multiple time values?
Yes. sleep 1h 30m 10s sleeps for 1 hour, 30 minutes, and 10 seconds. The values are added together.

How do I cancel a sleep in a script?
Press Ctrl+C to send SIGINT to the foreground process. For background sleep processes, use kill PID where PID is the process ID returned by $!.

Conclusion

The sleep command pauses the execution of the next command for a given amount of time. It is commonly used in shell scripts for retrying operations, rate limiting, and scheduling delays.

For longer scripts, keep delays explicit and pair them with clear output so you can tell whether the script is waiting, retrying, or finished.

How to Read a File Line By Line in Bash

hello@linuxize.com (Linuxize) — Thu, 16 May 2019 20:31:47 +0100

When writing Bash scripts, you will sometimes find yourself in situations where you need to read a file line by line. For example, you may have a text file containing data that should be processed by the script.

In this tutorial, we will discuss how to read a file line by line in Bash.

Info

If you are looking for the read command’s -p prompt option or other read flags, see the Bash read Command guide.

Quick Reference

Method	When to use
`while IFS= read -r line; do ... done < file`	Standard file reading — preserves all whitespace
`while IFS=, read -r f1 f2; do ... done < file`	Split each line on a delimiter
`while IFS= read -r line; do ... done < <(cmd)`	Read from command output, variables stay in scope
`while IFS= read -r -u9 line; do ... done 9< file`	Loop body also reads from stdin

Reading a File Line By Line Syntax

The standard syntax for reading a file line by line is:

txt
while IFS= read -r line; do
 printf '%s\n' "$line"
done < input_file

Or the equivalent single-line version:

txt
while IFS= read -r line; do printf '%s\n' "$line"; done < input_file

How it works:

input_file is redirected into the while loop as standard input.
The read command reads one line at a time and assigns it to the line variable.
IFS= clears the Internal Field Separator so that leading and trailing whitespace in each line is preserved. Without it, read strips spaces and tabs from both ends of the line.
-r disables backslash interpretation so that backslashes in the file are treated as literal characters. Without it, read may silently alter data containing backslash sequences.
printf is used instead of echo to avoid unexpected behavior when a line starts with a value like -e that echo might interpret as an option.
Once all lines are processed, the while loop terminates.

Reading a File Line By Line Examples

Let us take a look at the following example. Suppose we have a file named distros.txt containing a list of Linux distributions and their package managers, separated by a comma:

distros.txtini
Ubuntu,apt
Debian,apt
AlmaLinux,dnf
Arch Linux,pacman
Fedora,dnf

To read the file line by line and print each line:

sh
while IFS= read -r line; do
 printf '%s\n' "$line"
done < distros.txt

The code reads the file line by line, assigns each line to a variable, and prints it. The output is the same as running cat distros.txt.

To print only the distributions that use apt, use an if statement to check if the line contains the substring apt:

sh
while IFS= read -r line; do
 if [[ "$line" == *"apt"* ]]; then
 printf '%s\n' "$line"
 fi
done < distros.txt

output

Ubuntu,apt
Debian,apt

Splitting Lines into Fields

You can pass more than one variable to read to split each line into fields based on IFS. The first field goes into the first variable, the second into the second, and so on. If there are more fields than variables, the leftover fields are all assigned to the last variable.

The following example sets IFS to a comma and splits each line into distro and pm:

sh
while IFS=, read -r distro pm; do
 printf '%s is the package manager for %s\n' "$pm" "$distro"
done < distros.txt

output

apt is the package manager for Ubuntu
apt is the package manager for Debian
dnf is the package manager for AlmaLinux
pacman is the package manager for Arch Linux
dnf is the package manager for Fedora

Alternative File Reading Methods

Using Process Substitution

Process substitution lets you use the output of a command as the input file. This is the recommended way to read from a command rather than a static file, because it keeps the loop in the current shell — unlike piping, which runs the loop body in a subshell and causes variables to be lost after the loop ends:

sh
while IFS= read -r line; do
 printf '%s\n' "$line"
done < <(grep "apt" distros.txt)

The < <(command) syntax redirects the command output as standard input to the loop without creating a subshell for the loop body.

Using a Here String

A here string passes a string directly as standard input. Using $(cat input_file) inside a here string preserves newlines:

sh
while IFS= read -r line; do
 printf '%s\n' "$line"
done <<< "$(cat input_file)"

Note that command substitution strips trailing newlines from the output, so the last line may behave differently from input redirection.

Using a File Descriptor

You can open the file on a specific file descriptor and pass it to read with the -u option:

sh
while IFS= read -r -u9 line; do
 printf '%s\n' "$line"
done 9< input_file

Use a file descriptor number between 4 and 9 to avoid conflicts with shell internal file descriptors. This approach is useful when the loop body also reads from standard input (for example, prompting the user).

Troubleshooting

Variables set inside the loop are empty after the loop ends
This happens when read runs in a pipe subshell. Replace command | while IFS= read -r line with while IFS= read -r line; do ...; done < <(command). Process substitution keeps the loop in the current shell so variables are accessible after the loop.

Leading or trailing whitespace is being stripped
The IFS= assignment before read is missing or incorrect. Make sure you write IFS= read -r line (with no characters between = and read), not IFS=" " read or just read -r line.

The last line of the file is not processed
If the file does not end with a newline, read returns a non-zero exit code on the final line and the loop exits before processing it. To handle this, add || [[ -n "$line" ]] to the while condition: while IFS= read -r line || [[ -n "$line" ]]; do.

The loop produces garbled output on binary files
The while read pattern is designed for text files. Binary files contain null bytes and non-printable characters that read cannot handle reliably. Use dedicated tools for binary data.

FAQ

Why must I write IFS= with nothing after the equals sign?
IFS= sets the Internal Field Separator to an empty string for the duration of the read command. This disables word splitting, which means read does not trim leading or trailing spaces or tabs from the line. If you omit it, whitespace at the start and end of each line is silently removed.

Why should I always use read -r?
Without -r, read interprets backslashes as escape characters — for example, \n becomes a newline and \\ becomes a single backslash. This can silently corrupt data. Use -r by default and only omit it when you explicitly need escape processing.

Why is my variable empty after the while loop?
Piping into while read runs the loop in a subshell. Variables set inside a subshell are not visible in the parent shell. Use done < file or done < <(command) (process substitution) to keep the loop in the current shell.

What is the difference between done < file and cat file | while read?
Both read the same data, but done < file keeps the loop body in the current shell so variables persist after the loop. cat file | while read runs the loop in a subshell due to the pipe, and any variables set inside the loop are lost when it exits.

I am looking for the read -p prompt option — is it covered here?
The -p flag and other interactive read options are covered in the Bash read Command guide, which includes prompting the user, silent input, timeouts, and arrays.

Conclusion

The while IFS= read -r line; do ... done < file pattern is the reliable, portable way to read a file line by line in Bash. Use IFS= to preserve whitespace, -r to prevent backslash interpretation, and process substitution instead of pipes when you need variables to remain in scope after the loop. For details on the read built-in and its options, see the Bash read Command guide.

How to Create Bash Aliases

hello@linuxize.com (Linuxize) — Thu, 20 Dec 2018 21:33:44 +0100

If you often find yourself typing long commands or searching your shell history for something you ran before, bash aliases can save you a great deal of time. Bash aliases let you define short, memorable shortcut commands that expand to longer ones.

For example, you could set the alias tgz as a shortcut for the tar -xzvf command .

This article explains how to create bash aliases so you can be more productive on the command line.

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Command	Description
`alias name="command"`	Define a temporary alias
`alias`	List all active aliases
`unalias name`	Remove a specific alias
`unalias -a`	Remove all aliases in the current session
`source ~/.bashrc`	Reload `.bashrc` in the current session
`type name`	Check whether a name is an alias or a command

Creating Bash Aliases

Creating aliases in bash is straightforward. The syntax is as follows:

txt
alias alias_name="command_to_run"

An alias declaration starts with the alias keyword followed by the alias name, an equal sign, and the command to run when you type the alias. The command must be enclosed in quotes with no spaces around the equal sign. Each alias must be declared on a new line.

The ls command is one of the most used commands on the Linux command line. We often use it with the -la flag to list all files and directories, including hidden ones, in long format.

To create a simple alias named ll as a shortcut for the ls -la command , open a terminal and type:

Terminal
alias ll="ls -la"

Now if you type ll, you will get the same output as ls -la.

The ll alias is available only for the current shell session. If you exit or open a new terminal, the alias will not be available.

Making Aliases Persistent

To make an alias persistent across sessions, declare it in ~/.bashrc . If you use a login shell, make sure ~/.bash_profile sources ~/.bashrc so the alias is available there too.

Before creating an alias, check whether the name conflicts with an existing command:

Terminal
type ll

If type reports that ll is already a command or alias, choose a different name.

Open ~/.bashrc in your text editor :

Terminal
nano ~/.bashrc

Add your aliases. It is good practice to add a comment above each alias for future reference:

~/.bashrcsh
# Aliases
# alias alias_name="command_to_run"

# Long format list
alias ll="ls -la"

# Print my public IP
alias myip='curl https://ipinfo.io/ip'

Save and close the file, then reload it in the current session with source :

Terminal
source ~/.bashrc

Tip

To keep your .bashrc modular, store aliases in a separate ~/.bash_aliases file. Ubuntu and Debian include this file by default and source it automatically from ~/.bashrc.

Removing Aliases

To remove an alias from the current session, use unalias:

Terminal
unalias ll

To remove all active aliases at once:

Terminal
unalias -a

To permanently remove an alias, delete or comment out its line in ~/.bashrc, then run source ~/.bashrc.

Creating Bash Aliases with Arguments (Bash Functions)

Bash aliases cannot define or rearrange positional arguments. Extra words typed after an alias are appended to the expanded command, but when you need a shortcut that handles input with $1, $2, or custom logic, use a bash function instead.

Functions can be declared in two formats:

txt
function_name () {
 [commands]
}

txt
function function_name {
 [commands]
}

To pass arguments to a bash function, place them after the function name separated by spaces. Inside the function, $1 refers to the first argument, $2 to the second, and so on. $0 refers to the shell or script name, while ${FUNCNAME[0]} gives you the current function name.

Here is a function that creates a directory and immediately navigates into it:

~/.bashrcsh
mkcd ()
{
 mkdir -p -- "$1" && cd -P -- "$1"
}

Add the function to your ~/.bashrc and run source ~/.bashrc to load it. Now instead of running mkdir followed by cd, you can type:

Terminal
mkcd new_directory

The -- and && in the function serve specific purposes:

-- - signals the end of options, preventing a directory name starting with - from being interpreted as a flag
&& - ensures the cd command runs only if mkdir succeeds

Quick Tips

To temporarily bypass an alias and run the original command, prefix it with a backslash:

Terminal
\ls

To see the definition of an existing alias:

Terminal
type ll

Troubleshooting

Alias is not available after adding it to .bashrc
You need to reload the file after editing it. Run source ~/.bashrc in the current terminal. New sessions will pick up the alias automatically.

You are using Zsh, not Bash
If your shell is Zsh, add aliases to ~/.zshrc instead of ~/.bashrc, then run source ~/.zshrc or open a new terminal session.

Alias does not work inside a shell script
Bash does not expand aliases in non-interactive scripts by default. Use a shell function instead, or add shopt -s expand_aliases at the top of the script before the alias declaration.

Alias name shadows a system command
If an alias shares a name with an existing command, the alias takes precedence. Run type name before defining an alias to check for conflicts. To bypass an alias temporarily, use \name.

FAQ

How do I list all currently defined aliases?
Run alias without any arguments. It prints all active aliases in the current session in alias name='command' format.

How do I remove an alias?
Use unalias alias_name to remove a single alias from the current session. To make the removal permanent, delete the corresponding line from ~/.bashrc and run source ~/.bashrc.

Why do aliases not work in shell scripts?
Aliases are only expanded in interactive shells. In scripts, use shell functions instead. If you must use aliases in a script, add shopt -s expand_aliases before defining them.

How do I temporarily run the original command when an alias is defined?
Prefix the command with a backslash: \ls. This bypasses the alias and runs the original binary directly.

Can I use single quotes and double quotes interchangeably in an alias?
Both work, but they behave differently with variable expansion. Double quotes expand variables when the alias is defined; single quotes expand them when the alias is run. For most aliases, single quotes are safer.

Conclusion

Bash aliases are a simple way to shorten repetitive commands and make the command line faster to work with. Store your aliases in ~/.bashrc or ~/.bash_aliases and reload the file with source ~/.bashrc after each change.

Bash Strict Mode: set -euo pipefail Explained

hello@linuxize.com (Linuxize) — Mon, 20 Apr 2026 16:20:00 +0200

By default, a Bash script will keep running after a command fails, treat unset variables as empty strings, and hide errors inside pipelines. That is convenient for one-off commands in an interactive shell, but inside a script it is a recipe for silent corruption: a failed backup step that still reports success, an unset path that expands to rm -rf /, a curl | sh pipeline that swallows a 500 error.

Bash strict mode is a short set of flags you put at the top of a script to make the shell fail loudly instead. This guide explains each flag in set -euo pipefail, shows what it changes with real examples, and covers the cases where you need to turn it off. For a closer look at the set builtin and each option on its own, see our bash set command guide.

The Strict Mode Line

You will see this line at the top of many modern shell scripts:

script.shsh
#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

Each flag addresses a different class of silent failure:

set -e exits immediately when a command returns a non-zero status.
set -u treats references to unset variables as an error.
set -o pipefail makes a pipeline fail if any command in it fails, not just the last.
IFS=$'\n\t' narrows word splitting so unquoted expansions do not split on spaces.

You can enable the options separately, but in practice they are almost always used together.

set -e: Exit on Error

Without set -e, a failing command in a script does not stop execution. The script happily continues to the next line:

no-strict.shsh
#!/usr/bin/env bash
cp /does/not/exist /tmp/dest
echo "Backup complete"

Running it prints both the error and the success message:

Terminal
./no-strict.sh

output

cp: cannot stat '/does/not/exist': No such file or directory
Backup complete

The script exits with status 0, so any caller thinks the backup worked. Adding set -e changes the behavior:

strict.shsh
#!/usr/bin/env bash
set -e
cp /does/not/exist /tmp/dest
echo "Backup complete"

Terminal
./strict.sh
echo $?

output

cp: cannot stat '/does/not/exist': No such file or directory
1

The script stops at the failing cp, never prints “Backup complete”, and exits with a non-zero status. Anyone scheduling this through cron or a CI pipeline now gets a real failure signal.

Opting Out for a Single Command

Sometimes you expect a command to fail and want to handle the result yourself. Append || true to tell set -e to ignore the exit status of that one command:

sh
grep "pattern" config.txt || true

You can also use if or &&, which set -e treats as deliberate checks:

sh
if ! grep -q "pattern" config.txt; then
 echo "pattern missing"
fi

This is the canonical way to check for something without exiting the script when it is not there.

set -u: Fail on Unset Variables

A classic shell footgun is a typo in a variable name. Without strict mode, Bash silently expands the misspelled variable to an empty string:

unset.shsh
#!/usr/bin/env bash
TARGET_DIR="/var/backups"
rm -rf "$TARGE_DIR/old"

The script deletes /old because $TARGE_DIR is empty. With set -u, the same script exits before the rm runs:

unset-strict.shsh
#!/usr/bin/env bash
set -u
TARGET_DIR="/var/backups"
rm -rf "$TARGE_DIR/old"

output

./unset-strict.sh: line 4: TARGE_DIR: unbound variable

Handling Optional Variables

Environment variables that may or may not be set need a default to play nicely with set -u. The ${VAR:-default} syntax provides one without touching the original:

sh
PORT="${PORT:-8080}"
echo "Listening on $PORT"

If $PORT is unset or empty, the script uses 8080. If it is set, the original value is kept.

set -o pipefail: Catch Failures Inside Pipelines

By default, the exit status of a pipeline is the exit status of the last command. Everything to the left can fail silently:

sh
curl https://bad.example.com/data | tee data.txt

If curl fails with a 404, the pipeline still exits 0 because tee wrote its (empty) input successfully. With set -o pipefail, the pipeline adopts the first non-zero exit status from any command in it:

pipefail.shsh
#!/usr/bin/env bash
set -o pipefail
curl https://bad.example.com/data | tee data.txt
echo "Exit: $?"

output

curl: (6) Could not resolve host: bad.example.com
Exit: 6

This is the one flag that fixes the most “my script said it succeeded but clearly did not” bugs, and it is the one most often forgotten when people add just set -e.

IFS: Safer Word Splitting

The Internal Field Separator (IFS) controls how Bash splits unquoted expansions into words. The default is space, tab, and newline, which means a filename with a space in it gets split into two arguments:

sh
files="one two.txt three.txt"
for f in $files; do
 echo "$f"
done

output

one
two.txt
three.txt

Setting IFS=$'\n\t' removes the space from the separator list. You still get clean splitting on newlines (useful for reading find or ls output) and on tabs (useful for TSV data), but spaces inside values are preserved.

Even with a narrower IFS, always quote your expansions ("$var", "${array[@]}"). IFS tightening is a safety net, not a replacement for quoting.

When Strict Mode Gets in the Way

Strict mode is opinionated, and a few situations push back. The most common one is reading a file line by line with a while loop and a counter:

sh
count=0
while read -r line; do
 count=$((count + 1))
done < input.txt

That works fine, but if you increment with ((count++)) inside set -e, the script exits on the first iteration because ((count++)) returns the pre-increment value (0), which Bash treats as a failure. Use count=$((count + 1)) or ((count++)) || true to stay compatible.

Another common case is probing for a command:

sh
if ! command -v jq >/dev/null; then
 echo "jq is not installed"
 exit 1
fi

Using command -v inside an if is safe even under set -e, because set -e does not trigger on commands in conditional contexts.

If you need to temporarily disable a flag for a specific block, turn it off and back on:

sh
set +e
some_flaky_command
result=$?
set -e

This is cleaner than sprinkling || true everywhere when you have a block of commands that need softer error handling.

A Minimal Strict Script Template

Use this as a starting point for new scripts:

template.shsh
#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

# Script body goes here.

It is four lines, and it catches the majority of silent failures that cause shell scripts to misbehave in production.

Quick Reference

Flag	What it does
`set -e`	Exit when any command returns a non-zero status
`set -u`	Treat unset variables as an error
`set -o pipefail`	A pipeline fails if any command in it fails
`IFS=$'\n\t'`	Word-split only on newline and tab, not on spaces
`set +e` / `set +u`	Turn the matching flag back off for a block
`command \|\| true`	Ignore the exit status of a single command
`${VAR:-default}`	Provide a default for optional variables

Troubleshooting

Script exits silently with no error message
A command is failing under set -e without printing anything. Run the script with bash -x script.sh to trace execution and see which line aborts.

unbound variable on a variable that sometimes is set
Replace the reference with ${VAR:-} to provide an empty default, or ${VAR:-fallback} to provide a meaningful one.

Pipeline fails on a command that is supposed to stop early
Commands like head can cause the producer to receive SIGPIPE, which pipefail treats as a failure. Either redesign the pipeline or wrap the producer in || true when the early exit is expected.

Strict mode breaks a sourced script
The set flags apply to the current shell. If you source a script that expects the old behavior, either fix the sourced script or wrap the source call between set +e and set -e.

FAQ

Should every Bash script use strict mode?
For scripts that run unattended (cron jobs, CI steps, deployment scripts), yes. For short interactive helpers, the flags are still useful, but the cost of a missed edge case is lower.

Does strict mode work in sh or dash?
set -e and set -u are POSIX, so they work in any compliant shell. set -o pipefail is a Bash extension that also works in Zsh and Ksh, but not in pure POSIX sh or dash.

Is set -e really that unreliable?
set -e has well-known edge cases, especially around functions and subshells. It is not a replacement for explicit error handling in critical paths, but combined with pipefail and -u it catches far more bugs than it causes.

How do I pass set -euo pipefail to a one-liner?
Use bash -euo pipefail -c 'your command' when invoking Bash from another program such as ssh or a Makefile.

Conclusion

set -euo pipefail and a tighter IFS catch many of the silent failures that make shell scripts hard to trust. Pair strict mode with clear error handling using Bash functions and a proper shebang line when you want scripts to fail early and predictably.

history Command in Linux: View and Manage Bash History

hello@linuxize.com (Linuxize) — Sun, 27 Oct 2019 20:21:42 +0100

If you spend a lot of time on the command line, viewing the history of the commands you have previously run can make your day-to-day work easier and improve your productivity.

In this article, we will cover the history command, which allows you to view a list of previously executed commands, search through the list, and manipulate the history file.

Using the history Command

history is a shell builtin, and its behavior may slightly differ from shell to shell. We will cover the Bash builtin version of history. If you use Zsh, the concepts are similar but the history file defaults to ~/.zsh_history and some options differ.

In its simplest form, when invoked without any option or argument, the history command displays the whole history list with line numbers.

Terminal
history

output

...
467 git push
468 tail -f var/logs/error
469 nano +22,5 functions.sh
470 source project-env/bin/activate
471 history

Typically, history displays many lines of output that do not fit on the screen. To view the output one page at a time, pipe it to a pager program like more or less :

Terminal
history | less

To display the last n lines, pass the number as an argument to the command. For example, to view only the last five lines from the history list you would type:

Terminal
history 5

Use the Up and Down arrow keys to navigate through previously executed commands. When the command you are looking for appears, press Enter to execute it.

History Expansions

Bash provides several expansion shortcuts to re-run commands from the history list.

Typing !n executes the nth command from the history list, and !-n the command n lines back. In the following example we are executing the command on line 467:

Terminal
!467

!-1 is the same as !! and executes the last command from the history list, !-2 the second to last, and so on.

Type !! to execute the previous command:

Terminal
!!

This is especially useful when you forget to prepend a command with sudo , and instead of re-typing the command you can type:

Terminal
sudo !!

The !word expansion executes the most recent command starting with word:

Terminal
!git

Argument Expansions

You can also reuse arguments from the previous command:

Expansion	Description
`!$`	Last argument of the previous command
`!^`	First argument of the previous command
`!*`	All arguments of the previous command

For example, if you just ran ls -la /etc/nginx, you can quickly open the same path with:

Terminal
cd !$

Quick Substitution

^word1^word2^ allows you to re-run the last command replacing “word1” with “word2”. If you accidentally typed sduo command instead of sudo command, you can fix it with:

Terminal
^sduo^sudo^

Searching the History

Use the grep command to filter the output. For example, to view all commands including “nano” you would run:

Terminal
history | grep nano

output

302 sudo nano /etc/resolv.conf
356 nano setup.py
413 sudo nano /etc/hosts
469 nano +22,5 functions.sh

Now, if you want to re-run the nano setup.py command simply type:

Terminal
!356

Another way to search through the command history is by pressing Ctrl+R. The prompt will change to the following, and you can start typing to search for a previously executed command:

sh
(reverse-i-search)`':

The shell will display a matching line. To move to the next match, press Ctrl+R again.

Check the Bash manual for more information about History Expansion , modifiers, and designators.

Editing History with fc

The fc builtin lets you open a previous command in your default text editor ($EDITOR), edit it, and execute the modified version when you save and close the file:

Terminal
fc

This opens the last command. To edit a specific command by number:

Terminal
fc 467

To list recent commands without editing, use fc -l:

Terminal
fc -l -10

Saving the History List

By default, when starting a new session, Bash reads the history list from the ~/.bash_history file. The list of commands executed in the current session is kept in memory and saved to the file when the session is closed.

If you opened several shell sessions, only the history of the session that is closed last is saved.

The -a option allows you to append the current session history list to the ~/.bash_history file:

Terminal
history -a

The -w option writes the complete history list to the history file.

Terminal
history -w

Clearing History

The history command allows you to clear the complete history list or remove certain parts.

To clear the history list, use the -c option:

Terminal
history -c

To delete a specific line or lines between a starting and ending position from the history list, use the -d option.

For example, to remove the lines between 365 and 375 (including those lines), you would type:

Terminal
history -d 365-375

The range form of -d requires Bash 5.0 or later. On older versions, you can only delete one line at a time.

If you provide only one number to the -d option, the command removes the given line.

When a negative integer is used, the lines are counted back from the end of the history list.

The commands above clear the history list, which is kept in memory, but do not remove entries from the ~/.bash_history file on disk. To clear the file, you need to write the history list to the file:

Terminal
history -c
history -w

Modifying History Behavior

The behavior of the Bash history can be defined using several different environment variables . When modifying the history behavior, set the variables in ~/.bashrc or any other configuration file which is loaded when the user logs in.

By default Bash keeps 500 lines in the command history list, though many distributions override this to 1000 or more. The HISTSIZE variable controls how many commands are kept in memory during a session. To set it to 10000 add the following line to your ~/.bashrc file:

sh
HISTSIZE=10000

The HISTFILESIZE variable controls the maximum number of lines stored in the history file on disk. When a session ends, Bash truncates the file to this many lines. To keep the same number as HISTSIZE:

sh
HISTFILESIZE=10000

If HISTFILESIZE is unset, the history file is never truncated.

The HISTFILE variable defines the path to the history file. By default it is set to ~/.bash_history:

sh
HISTFILE=~/.bash_history

The HISTCONTROL variable accepts a colon-separated list of values that define how the commands are saved in the history list:

ignorespace - commands that start with space are not saved in the history list.
ignoredups - duplicate commands are not saved.
ignoreboth - is a shorthand, including both ignorespace and ignoredups.
erasedups - removes all previous occurrences of the command from the list before saving it.

sh
HISTCONTROL=ignoreboth

The HISTIGNORE variable is a colon-separated list of patterns used to decide which commands should be excluded from the history. For example, to ignore ls, cd, and history commands:

sh
HISTIGNORE="ls:cd:history"

When the HISTTIMEFORMAT variable is set, Bash prepends a timestamp of execution for the command on each line.

For example, if you set:

sh
HISTTIMEFORMAT="%F %T: "

The history will be displayed in the following format:

output

413 2019-10-27 21:13:07: sudo nano /etc/hosts

By default, when multiple terminals are open, each session maintains its own history in memory. Only the last session to close writes to the history file, overwriting what other sessions saved.

To share history across all open terminals, enable the histappend shell option and configure your prompt to save and reload history:

sh
shopt -s histappend
PROMPT_COMMAND="history -a; history -c; history -r; $PROMPT_COMMAND"

history -a appends new commands to the history file.
history -c clears the in-memory history list.
history -r re-reads the history file into memory.

Add these lines to your ~/.bashrc to make them permanent.

Security Considerations

Command history can store sensitive data like passwords, tokens, or private URLs. Avoid pasting secrets into the shell, and consider:

Setting HISTCONTROL=ignoreboth to skip duplicates and commands starting with a space.
Using HISTIGNORE to exclude common sensitive patterns.
Removing sensitive entries immediately with history -d 365 followed by history -w.

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Task	Command
Show full history	`history`
Show last 10 commands	`history 10`
Run command by number	`!467`
Run previous command	`!!`
Run previous command with sudo	`sudo !!`
Last argument of previous command	`!$`
All arguments of previous command	`!*`
Search history	`history \| grep keyword`
Reverse search	`Ctrl+R`
Edit and re-run last command	`fc`
Append session to file	`history -a`
Clear history	`history -c`
Delete a specific entry	`history -d 365`

FAQ

How do I prevent a command from being saved to history?
Start the command with a space (e.g., secret-command). This works when HISTCONTROL includes ignorespace or ignoreboth.

Where is the history file stored?
By default it is stored in ~/.bash_history. You can change this with the HISTFILE environment variable.

What is the difference between HISTSIZE and HISTFILESIZE?
HISTSIZE controls how many commands are kept in memory during a session. HISTFILESIZE controls how many lines are stored in the history file on disk.

How do I share history across multiple terminal sessions?
Enable shopt -s histappend and set PROMPT_COMMAND to save and reload the history file on each prompt. See the “Sharing History Across Terminal Sessions” section above.

How do I remove a specific command from history?
Use history -d 365 to delete a single entry, then history -w to persist the change to disk.

Conclusion

The history command displays a list of previously executed commands and provides shortcuts to re-run them quickly. Combined with environment variables like HISTSIZE, HISTFILESIZE, HISTCONTROL, and HISTIGNORE, you can customize history behavior to fit your workflow.

How to Pass Arguments to a Bash Script

hello@linuxize.com (Linuxize) — Sat, 30 May 2026 15:40:00 +0200

Arguments let a Bash script behave differently each time you run it. Instead of hard-coding a file path, username, environment name, or port number inside the script, you pass those values on the command line and read them from inside the script.

This guide explains how to pass arguments to Bash scripts, read positional parameters such as $1 and $2, work with all arguments through "$@", set defaults, validate required input, and parse named flags with getopts.

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Syntax	Description
`bash script.sh arg1 arg2`	Run a script with two arguments
`$0`	Script name or path
`$1`, `$2`	First and second positional arguments
`${10}`	Tenth positional argument
`$#`	Number of arguments passed
`"$@"`	All arguments as separate quoted words
`"${1:-default}"`	Use a default value when the first argument is missing
`shift`	Remove the first positional argument and move the rest down
`getopts`	Parse short named options such as `-p 3000 -v`

Positional Parameters

When you run a script, Bash assigns each argument to a numbered variable:

~/greet.shsh
#!/usr/bin/env bash

printf 'Hello, %s!\n' "$1"
printf 'Argument count: %s\n' "$#"

Run the script with one argument:

Terminal
bash greet.sh World

output

Hello, World!
Argument count: 1

The special variables are:

Variable	Value
`$0`	The script name or path
`$1`, `$2`, …	First, second, … argument
`${10}`, `${11}`, …	Tenth argument and beyond
`$#`	Number of arguments passed
`$@`	All arguments as separate words
`$*`	All arguments as a single string

For more detail about each special parameter, see the Bash positional parameters guide.

Access All Arguments

Use $@ to iterate over every argument regardless of how many were passed:

~/list-args.shsh
#!/usr/bin/env bash

for arg in "$@"; do
 printf 'Argument: %s\n' "$arg"
done

Terminal
bash list-args.sh alpha beta "hello world"

output

Argument: alpha
Argument: beta
Argument: hello world

Always quote "$@" so arguments with spaces stay as single values. Unquoted $@ allows word splitting, which turns "hello world" into two separate words.

Set Default Values

When an argument is optional, assign a default with ${N:-default}:

~/deploy.shsh
#!/usr/bin/env bash

ENV=${1:-production}
BRANCH=${2:-main}

printf 'Deploying %s to %s\n' "$BRANCH" "$ENV"

If the caller passes no arguments, ENV becomes production and BRANCH becomes main. If they pass one argument, ENV uses that value and BRANCH falls back to main.

Validate Required Arguments

Exit early with a usage message when a required argument is missing:

~/backup.shsh
#!/usr/bin/env bash

if [ $# -lt 2 ]; then
 echo "Usage: $0 SOURCE DESTINATION" >&2
 exit 1
fi

SOURCE=$1
DEST=$2

printf 'Ready to back up %s to %s\n' "$SOURCE" "$DEST"

$# -lt 2 checks whether fewer than two arguments were provided. The error message goes to stderr with >&2, and the script exits with code 1 to signal failure. After validation succeeds, you can safely use $SOURCE and $DEST in the real backup command, such as rsync.

Shift Through Arguments

shift removes the first argument and renumbers the rest. It is useful when a script accepts a variable number of items to process:

~/process.shsh
#!/usr/bin/env bash

printf 'Script: %s\n' "$0"

while [ $# -gt 0 ]; do
 printf 'Processing: %s\n' "$1"
 shift
done

Each shift call moves $2 into $1, $3 into $2, and so on, and decrements $# by one. The loop continues until no arguments remain.

Named Flags with getopts

For scripts with optional flags, getopts parses named options in the style of standard Unix commands:

~/server.shsh
#!/usr/bin/env bash

PORT=8080
VERBOSE=0

usage() {
 echo "Usage: $0 [-p PORT] [-v]" >&2
}

while getopts ":p:v" opt; do
 case $opt in
 p) PORT=$OPTARG ;;
 v) VERBOSE=1 ;;
 \?) usage; exit 1 ;;
 :) usage; exit 1 ;;
 esac
done

shift $((OPTIND - 1))

printf 'Starting server on port %s (verbose: %s)\n' "$PORT" "$VERBOSE"

The option string ":p:v" means -p takes a value, -v is a flag with no value, and the leading colon lets the script handle errors itself. $OPTARG holds the value for options that require one. shift $((OPTIND - 1)) removes all parsed flags so $1, $2, and the rest refer to any remaining positional arguments after the flags.

Run it:

Terminal
bash server.sh -p 3000 -v

output

Starting server on port 3000 (verbose: 1)

For a deeper look at option strings, OPTARG, OPTIND, and error handling, read the Bash getopts guide.

Conclusion

Bash positional parameters handle the straightforward case of ordered arguments, while getopts adds named flag support for more complex scripts. Start with positional parameters, validate the count early, set defaults for optional arguments, and use getopts when your script grows a meaningful set of options. For more on script execution and permissions, see the guide on running Bash scripts .

How to Parse Command-Line Options in Bash with getopts

hello@linuxize.com (Linuxize) — Wed, 11 Feb 2026 10:00:00 +0100

The getopts command is a Bash built-in that provides a clean, structured way to parse command-line options in your scripts. Instead of manually looping through arguments with case and shift, getopts handles option parsing, argument extraction, and error reporting for you.

This guide explains how to use getopts to process options and arguments in Bash scripts. If you are new to command-line arguments, start with our guide on positional parameters .

Syntax

The basic syntax for getopts is:

sh
while getopts "optstring" VARNAME; do
 case $VARNAME in
 # handle each option
 esac
done

optstring — A string that defines which options the script accepts
VARNAME — A variable that holds the current option letter on each iteration

Each time the while loop runs, getopts processes the next option from the command line and stores the option letter in VARNAME. The loop ends when there are no more options to process.

Here is a simple example:

~/flags.shsh
#!/bin/bash

while getopts "vh" opt; do
 case $opt in
 v) echo "Verbose mode enabled" ;;
 h) echo "Usage: $0 [-v] [-h]"; exit 0 ;;
 esac
done

Run the script:

Terminal
./flags.sh -v
./flags.sh -h
./flags.sh -vh

output

Verbose mode enabled
Usage: ./flags.sh [-v] [-h]
Verbose mode enabled
Usage: ./flags.sh [-v] [-h]

Notice that -vh works the same as -v -h. The getopts command automatically handles combined short options.

The Option String

The option string tells getopts which option letters are valid and which ones require an argument. There are three patterns:

f — A simple flag (no argument). Used for boolean switches like -v for verbose.
f: — An option that requires an argument. The colon after the letter means the user must provide a value, such as -f filename.
: (leading colon) — Enables silent error mode. When placed at the very beginning of the option string, getopts suppresses its default error messages so you can handle errors yourself.

For example, the option string ":vf:o:" means:

: — Silent error mode
v — A simple flag (-v)
f: — An option requiring an argument (-f filename)
o: — An option requiring an argument (-o output)

OPTARG and OPTIND

When working with getopts, two special variables track the parsing state:

OPTARG

The OPTARG variable holds the argument value for options that require one. When you define an option with a trailing colon (e.g., f:), the value the user passes after -f is stored in OPTARG:

~/optarg_example.shsh
#!/bin/bash

while getopts "f:o:" opt; do
 case $opt in
 f) echo "Input file: $OPTARG" ;;
 o) echo "Output file: $OPTARG" ;;
 esac
done

Terminal
./optarg_example.sh -f data.csv -o results.txt

output

Input file: data.csv
Output file: results.txt

OPTIND

The OPTIND variable holds the index of the next argument to be processed. It starts at 1 and increments as getopts processes each option. After the while loop finishes, OPTIND points to the first non-option argument.

Use shift $((OPTIND - 1)) after the loop to remove all processed options, leaving only the remaining positional arguments in $@:

~/optind_example.shsh
#!/bin/bash

while getopts "v" opt; do
 case $opt in
 v) echo "Verbose mode enabled" ;;
 esac
done

shift $((OPTIND - 1))

echo "Remaining arguments: $@"

Terminal
./optind_example.sh -v file1.txt file2.txt

output

Verbose mode enabled
Remaining arguments: file1.txt file2.txt

The shift $((OPTIND - 1)) line is a common pattern. Without it, the processed options would still be part of the positional parameters, making it difficult to access the non-option arguments.

Error Handling

The getopts command has two error handling modes: verbose (default) and silent.

Verbose Mode (Default)

In verbose mode, getopts prints its own error messages when it encounters an invalid option or a missing argument:

~/verbose_errors.shsh
#!/bin/bash

while getopts "f:" opt; do
 case $opt in
 f) echo "File: $OPTARG" ;;
 esac
done

Terminal
./verbose_errors.sh -x
./verbose_errors.sh -f

output

./verbose_errors.sh: illegal option -- x
./verbose_errors.sh: option requires an argument -- f

In this mode, getopts sets opt to ? for both invalid options and missing arguments.

Silent Mode

Silent mode is enabled by adding a colon at the beginning of the option string. In this mode, getopts suppresses its default error messages and gives you more control:

For an invalid option, opt is set to ? and OPTARG contains the invalid option character.
For a missing argument, opt is set to : and OPTARG contains the option that was missing its argument.

~/silent_errors.shsh
#!/bin/bash

while getopts ":f:vh" opt; do
 case $opt in
 f) echo "File: $OPTARG" ;;
 v) echo "Verbose mode" ;;
 h) echo "Usage: $0 [-v] [-f file] [-h]"; exit 0 ;;
 \?) echo "Error: Invalid option -$OPTARG" >&2; exit 1 ;;
 :) echo "Error: Option -$OPTARG requires an argument" >&2; exit 1 ;;
 esac
done

Terminal
./silent_errors.sh -x
./silent_errors.sh -f

output

Error: Invalid option -x
Error: Option -f requires an argument

Silent mode is the recommended approach for production scripts because it allows you to write custom error messages that are more helpful to the user.

Practical Examples

Example 1: Script with Flags and Arguments

This script demonstrates a common pattern — a usage function , boolean flags, options with arguments, and input validation:

~/process.shsh
#!/bin/bash

usage() {
 echo "Usage: $0 [-v] [-o output] [-n count] file..."
 echo ""
 echo "Options:"
 echo " -v Enable verbose output"
 echo " -o output Write results to output file"
 echo " -n count Number of lines to process"
 echo " -h Show this help message"
 exit 1
}

VERBOSE=false
OUTPUT=""
COUNT=0

while getopts ":vo:n:h" opt; do
 case $opt in
 v) VERBOSE=true ;;
 o) OUTPUT="$OPTARG" ;;
 n) COUNT="$OPTARG" ;;
 h) usage ;;
 \?) echo "Error: Invalid option -$OPTARG" >&2; usage ;;
 :) echo "Error: Option -$OPTARG requires an argument" >&2; usage ;;
 esac
done

shift $((OPTIND - 1))

if [ $# -eq 0 ]; then
 echo "Error: No input files specified" >&2
 usage
fi

if [ "$VERBOSE" = true ]; then
 echo "Verbose: ON"
 echo "Output: ${OUTPUT:-stdout}"
 echo "Count: ${COUNT:-all}"
 echo "Files: $@"
 echo ""
fi

for file in "$@"; do
 if [ ! -f "$file" ]; then
 echo "Warning: '$file' not found, skipping" >&2
 continue
 fi

 if [ -n "$OUTPUT" ]; then
 if [ "$COUNT" -gt 0 ] 2>/dev/null; then
 head -n "$COUNT" "$file" >> "$OUTPUT"
 else
 cat "$file" >> "$OUTPUT"
 fi
 else
 if [ "$COUNT" -gt 0 ] 2>/dev/null; then
 head -n "$COUNT" "$file"
 else
 cat "$file"
 fi
 fi
done

Terminal
echo -e "line 1\nline 2\nline 3\nline 4\nline 5" > testfile.txt
./process.sh -v -n 3 testfile.txt

output

Verbose: ON
Output: stdout
Count: 3
Files: testfile.txt
line 1
line 2
line 3

The script parses the options first, then uses shift to access the remaining file arguments.

Example 2: Configuration Wrapper

This example shows a script that wraps another command, passing different configurations based on the options provided:

~/deploy.shsh
#!/bin/bash

ENV="staging"
DRY_RUN=false
TAG="latest"

while getopts ":e:t:dh" opt; do
 case $opt in
 e) ENV="$OPTARG" ;;
 t) TAG="$OPTARG" ;;
 d) DRY_RUN=true ;;
 h)
 echo "Usage: $0 [-e environment] [-t tag] [-d] service"
 echo ""
 echo " -e env Target environment (default: staging)"
 echo " -t tag Image tag (default: latest)"
 echo " -d Dry run mode"
 exit 0
 ;;
 \?) echo "Error: Invalid option -$OPTARG" >&2; exit 1 ;;
 :) echo "Error: Option -$OPTARG requires an argument" >&2; exit 1 ;;
 esac
done

shift $((OPTIND - 1))

SERVICE="${1:?Error: Service name required}"

echo "Deploying '$SERVICE' to $ENV with tag '$TAG'"

if [ "$DRY_RUN" = true ]; then
 echo "[DRY RUN] Would execute: docker pull myregistry/$SERVICE:$TAG"
 echo "[DRY RUN] Would execute: kubectl set image deployment/$SERVICE $SERVICE=myregistry/$SERVICE:$TAG -n $ENV"
else
 echo "Pulling image and updating deployment..."
fi

Terminal
./deploy.sh -e production -t v2.1.0 -d webapp

output

Deploying 'webapp' to production with tag 'v2.1.0'
[DRY RUN] Would execute: docker pull myregistry/webapp:v2.1.0
[DRY RUN] Would execute: kubectl set image deployment/webapp webapp=myregistry/webapp:v2.1.0 -n production

getopts vs getopt

The getopts built-in is often confused with the external getopt command. Here are the key differences:

Feature	`getopts` (built-in)	`getopt` (external)
Type	Bash/POSIX built-in	External program (`/usr/bin/getopt`)
Long options	Not supported	Supported (`--verbose`)
Portability	Works on all POSIX shells	Varies by OS (GNU vs BSD)
Whitespace handling	Handles correctly	GNU version handles correctly
Error handling	Built-in verbose/silent modes	Manual
Speed	Faster (no subprocess)	Slower (spawns a process)

Use getopts when you only need short options and want maximum portability. Use getopt (GNU version) when you need long options like --verbose or --output.

Troubleshooting

Options are not being parsed
Make sure your options come before any non-option arguments. The getopts command stops parsing when it encounters the first non-option argument. For example, ./script.sh file.txt -v will not parse -v because file.txt comes first.

OPTIND is not resetting between function calls
If you use getopts inside a function and call that function multiple times, you need to reset OPTIND to 1 before each call. Otherwise, getopts will start from where it left off.

Missing argument not detected
If an option requires an argument but getopts does not report an error, check that you included a colon after the option letter in the option string. For example, use "f:" instead of "f" if -f needs an argument.

Unexpected ? in the variable
In verbose mode (no leading colon), getopts sets the variable to ? for both invalid options and missing arguments. Switch to silent mode (leading colon) to distinguish between the two cases and write custom error messages.

Quick Reference

Element	Description
`getopts "opts" var`	Parse options defined in `opts`, store current letter in `var`
`f` in option string	Simple flag, no argument
`f:` in option string	Option that requires an argument
`:` (leading)	Enable silent error mode
`$OPTARG`	Holds the argument for the current option
`$OPTIND`	Index of the next argument to process
`shift $((OPTIND - 1))`	Remove parsed options, keep remaining arguments
`\?` in case	Handles invalid options
`:` in case	Handles missing arguments (silent mode only)

FAQ

Does getopts support long options like –verbose?
No. The getopts built-in only supports single-character options (e.g., -v). For long options, use the external getopt command (GNU version) or parse them manually with a case statement and shift.

Can I combine options like -vf file?
Yes. The getopts command automatically handles combined options. When it encounters -vf file, it processes -v first, then -f with file as its argument.

What happens if I forget shift $((OPTIND - 1))?
The processed options will remain in the positional parameters. Any code that accesses $1, $2, or $@ after the getopts loop will still see the option flags instead of just the remaining arguments.

Is getopts POSIX compliant?
Yes. The getopts command is defined by the POSIX standard and works in all POSIX-compliant shells, including bash, dash, ksh, and zsh. This makes it more portable than the external getopt command.

How do I make an option’s argument optional?
The getopts built-in does not support optional arguments for options. An option either always requires an argument (using :) or never takes one. If you need optional arguments, handle the logic manually after parsing.

Conclusion

The getopts built-in provides a reliable way to parse command-line options in Bash scripts. It handles option string definitions, argument extraction, combined flags, and error reporting with minimal code.

If you have any questions, feel free to leave a comment below.

Bash Best Practices: Writing Safer, Cleaner Scripts

hello@linuxize.com (Linuxize) — Wed, 13 May 2026 10:00:00 +0200

Bash scripts tend to start small and grow over time. A helper you wrote in five minutes to copy a few files can end up running in a cron job, a deployment pipeline, or a server startup script. When that happens, small oversights such as an unquoted variable or an ignored error become real outages.

This guide covers practical Bash best practices that keep scripts predictable, safe to re-run, and easy for other people to read.

Start With a Clear Shebang

Every Bash script should begin with a proper shebang line. The portable choice for Bash is:

~/script.shsh
#!/usr/bin/env bash

Using /usr/bin/env bash lets the script find Bash through the PATH, which matters on systems where Bash is installed outside /bin, such as macOS with Homebrew. If you rely on features that exist only in Bash, do not use #!/bin/sh. On many distributions /bin/sh points to dash or another minimal shell, and arrays, [[ ]], and local will not behave the same way.

Enable Strict Mode

By default, Bash ignores many errors. A command can fail, a variable can be unset, and the script will keep running as if nothing happened. Enabling strict mode at the top of the script changes that behavior.

~/script.shsh
#!/usr/bin/env bash
set -euo pipefail

Here is what each flag does:

-e - Exit immediately if any command returns a non-zero status.
-u - Treat unset variables as an error and exit.
-o pipefail - Make a pipeline fail if any command in it fails, not only the last one.

A common extra is IFS=$'\n\t', which prevents word splitting on spaces and avoids surprises when iterating over filenames that contain spaces.

~/script.shsh
#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

Strict mode is not magic. It will not catch logic errors, and in some scripts you will need to opt out locally with || true for commands that are allowed to fail. The point is to flip the default from “keep going on errors” to “stop on errors”, which is almost always the safer choice. For a closer look at each option on its own, see our bash set command guide.

Always Quote Your Variables

Unquoted variables in Bash are expanded and then word-split. If a variable contains spaces, wildcards, or is empty, the result may be very different from what you expect.

Terminal
file="My Report.txt"
printf '<%s>\n' $file

Because $file is not quoted, Bash passes two arguments to printf: My and Report.txt. Quoting fixes it and keeps the filename as one value:

Terminal
printf '<%s>\n' "$file"

The same rule applies inside tests, loops, and command substitutions. When in doubt, quote. The only common case where you intentionally leave a variable unquoted is when you want word splitting, which should be rare and deliberate.

Prefer [[ ]] Over [ ]

Bash supports two test constructs: the older [ ] (a synonym for the test command) and the newer [[ ]] keyword. For Bash scripts, prefer [[ ]]:

sh
if [[ -f "$config" && "$env" == "production" ]]; then
 echo "Loading production config"
fi

[[ ]] handles empty variables safely even without quotes, supports pattern matching with == and regex with =~, and allows logical operators such as && and || inside the test. Only fall back to [ ] when writing a portable POSIX script that must run under sh or dash.

Use Functions for Repeated Logic

Once a script has more than a couple of steps, group related commands into functions. Functions make scripts easier to read, test, and refactor.

~/backup.shsh
log() {
 printf '[%s] %s\n' "$(date +'%F %T')" "$*"
}

backup_dir() {
 local src="$1"
 local dst="$2"

 log "Backing up $src to $dst"
 rsync -a "$src/" "$dst/"
}

backup_dir "/var/www" "/backup/www"

Declare variables inside functions with local so they do not leak into the rest of the script. Pass input as positional parameters, and return output via echo or printf rather than global variables when possible.

See Bash functions for more details on arguments, return values, and scoping.

Handle Errors Explicitly

Strict mode stops the script on errors, but it does not tell the user what went wrong. Adding a trap on ERR gives you a single place to log failures.

~/script.shsh
#!/usr/bin/env bash
set -Eeuo pipefail

on_error() {
 local exit_code=$?
 local line=$1
 echo "Error on line $line (exit code $exit_code)" >&2
 exit "$exit_code"
}

trap 'on_error $LINENO' ERR

The -E option makes the ERR trap inherit into functions and subshells. Without it, a failure inside a helper function may exit the script without running your error handler.

For cleanup tasks such as removing temporary files, use trap on EXIT:

~/script.shsh
tmp_dir=$(mktemp -d)
trap 'rm -rf "$tmp_dir"' EXIT

The EXIT trap runs whether the script exits normally, hits an error under set -e, or is interrupted with Ctrl+C. It is the safest way to guarantee cleanup.

Validate Input Early

Scripts that take arguments should fail fast when those arguments are missing or invalid. Check them before doing any work:

~/deploy.shsh
if [[ $# -lt 2 ]]; then
 echo "Usage: $0 <environment> <version>" >&2
 exit 1
fi

env="$1"
version="$2"

case "$env" in
 staging|production) ;;
 *)
 echo "Unknown environment: $env" >&2
 exit 1
 ;;
esac

For scripts with several flags, use getopts instead of parsing $@ manually. It handles short options, arguments, and error reporting in a consistent way.

Avoid Parsing the Output of ls

A common beginner mistake is looping over ls output:

sh
for f in $(ls /var/log); do
 echo "$f"
done

This breaks on filenames with spaces, newlines, or special characters. Use a glob or find instead:

sh
for f in /var/log/*; do
 echo "$f"
done

For recursive traversal, use find with -print0 and xargs -0, or a while read loop with IFS= and -d '' to handle unusual filenames correctly.

Keep Scripts Idempotent When Possible

A script you can safely re-run is much easier to work with than one that breaks on the second attempt. Aim for idempotent behavior: check before creating directories, use mkdir -p instead of mkdir, use ln -sf instead of ln -s, and guard commands with if blocks when they would otherwise fail on re-run.

Terminal
mkdir -p /opt/app/config

The same pattern applies to package installation, user creation, and configuration edits. Tools like Ansible enforce idempotency by design; in Bash, you have to add those checks yourself.

Use Shellcheck

Shellcheck is a static analyzer for shell scripts. It catches unquoted variables, unsafe for loops, and many other common mistakes before you hit them in production.

Install it from your package manager:

Terminal
sudo apt install shellcheck

Then run it against your script:

Terminal
shellcheck script.sh

Fix the warnings it raises, or document with an inline comment why a specific check is being ignored. Making shellcheck part of your editor or pre-commit hook removes an entire class of Bash bugs.

Prefer Readable Over Clever

Bash is full of shortcuts and obscure expansions. They can make scripts shorter, but they also make them harder to read six months later. Choose the clearer form, even when it is a few characters longer.

sh
if [[ -z "$name" ]]; then
 name="anonymous"
fi

is almost always easier to maintain than the golfed equivalent:

Terminal
: "${name:=anonymous}"

Aim for scripts that a teammate can read once and understand, not ones that require a reference manual.

Quick Reference

For a printable quick reference, see the Bash cheatsheet .

Before committing a Bash script, confirm the following:

#!/usr/bin/env bash shebang is present.
set -euo pipefail is enabled.
All variable expansions are quoted.
Tests use [[ ]] instead of [ ].
Functions replace long repeated blocks, with local variables.
trap handles errors and cleanup.
Input is validated before work begins.
No parsing of ls output.
shellcheck reports no warnings, or they are explicitly ignored.

FAQ

Is set -e enough on its own?
No. set -e stops on many errors, but it misses failures in pipelines and ignores unset variables. Combine it with -u and -o pipefail to cover those cases.

Does strict mode break existing scripts?
It often surfaces bugs that were already there, such as unset variables and ignored errors. The fix is to quote variables, use default values like ${VAR:-}, and handle expected failures with || true.

Should I write scripts in Bash or switch to Python?
Bash is a good fit for short glue scripts that mostly call other commands. Once a script grows past a few hundred lines, has complex data structures, or needs proper error handling and testing, Python or another language is usually a better choice.

Where can I learn more safe scripting patterns?
Keep the Shellcheck wiki open while you write, and read through the official Bash manual section on shell builtins. Both cover the reasoning behind each rule, not only the rule itself.

Conclusion

Strict mode, quoting, and a few well-placed traps cover most of the risk in Bash scripting. Make these practices your defaults, run shellcheck on every change, and your scripts will behave the same way on your laptop, in CI, and on a production server.

Bash Scripting Fundamentals on Linuxize

Shebang Explained: #! in Bash and Shell Scripts

What Is a Shebang? #

Shebang Syntax #

Common Shebang Lines #

Bash Shebang: /bin/bash vs /usr/bin/env bash #

Passing Options to the Interpreter #

#!/bin/sh vs #!/bin/bash #

Example Script #

Overriding the Shebang #

Troubleshooting #

Quick Reference #

FAQ #

Conclusion #

How to Run a Bash Script in Linux

Quick Reference #

Making a Script Executable #

Running a Script with the Bash Interpreter #

Sourcing a Script (Run in the Current Shell) #

Running Scripts in the Background #

Running Scripts with Debug Mode #

Running Scripts from Anywhere #

Using /usr/bin/env in the Shebang #

Troubleshooting #

Security Considerations #

Conclusion #

Bash Comments: Single-Line, Multiline, and Best Practices

Why Comments Matter #

How Bash Handles Comments #

Single-Line Comments #

Multiline and Block Comments in Bash #

Multiple Single-Line Comments (Recommended) #

HereDoc Block Comment #

Best Practices #

Quick Reference #

FAQ #

Conclusion #

.bashrc vs .bash_profile: What is the Difference?

Interactive vs Non-Interactive Shells #

Login vs Non-Login Shells #

Startup File Loading Order #

Difference Between .bashrc and .bash_profile #

Where to Put What #

.profile vs .bash_profile #

macOS Note #

Quick Reference #

Troubleshooting #

FAQ #

Conclusion #

Bash Positional Arguments: How to Use $1, $2, $@, and shift

What Are Bash Positional Arguments? #

Accessing Positional Parameters #

Basic Parameters ($1, $2, $3, …) #

Parameters Beyond $9 #

Special Parameter Variables #

The Script Name ($0) #

Counting Arguments ($#) #

All Arguments ($@ and $*) #

The shift Command #

Shifting Multiple Positions #

Processing All Arguments with shift #

Practical Examples #

Example 1: File Backup Script #

Example 2: Simple Calculator #

Example 3: Processing Command-Line Options #

Positional Parameters in Functions #

Default Values for Parameters #

Conclusion #

echo Command in Linux: Print Text and Variables

Syntax #

Display a String #

Display Strings with Quotes #

Use Escape Characters #

Suppress the Trailing Newline #

Display Variables #

Display Command Output #

Use Pattern Matching #

Redirect Output to a File #

Write to Standard Error #

Display Colored Output #

What Is a Shebang?

Shebang Syntax

Common Shebang Lines

Bash Shebang: /bin/bash vs /usr/bin/env bash

Passing Options to the Interpreter

#!/bin/sh vs #!/bin/bash

Example Script

Overriding the Shebang

Troubleshooting

Quick Reference

FAQ

Conclusion

Quick Reference

Making a Script Executable

Running a Script with the Bash Interpreter

Sourcing a Script (Run in the Current Shell)

Running Scripts in the Background

Running Scripts with Debug Mode

Running Scripts from Anywhere

Using /usr/bin/env in the Shebang

Troubleshooting

Security Considerations

Conclusion

Why Comments Matter

How Bash Handles Comments

Single-Line Comments

Multiline and Block Comments in Bash

Multiple Single-Line Comments (Recommended)

HereDoc Block Comment

Best Practices

Quick Reference

FAQ

Conclusion

Interactive vs Non-Interactive Shells

Login vs Non-Login Shells

Startup File Loading Order

Difference Between .bashrc and .bash_profile

Where to Put What

.profile vs .bash_profile

macOS Note

Quick Reference

Troubleshooting

FAQ

Conclusion

What Are Bash Positional Arguments?

Accessing Positional Parameters

Basic Parameters ($1, $2, $3, …)

Parameters Beyond $9

Special Parameter Variables

The Script Name ($0)

Counting Arguments ($#)

All Arguments ($@ and $*)

The `shift` Command

Shifting Multiple Positions

Processing All Arguments with shift

Practical Examples

Example 1: File Backup Script

Example 2: Simple Calculator

Example 3: Processing Command-Line Options

Positional Parameters in Functions

Default Values for Parameters

Conclusion

Syntax

Display a String

Display Strings with Quotes

Use Escape Characters

Suppress the Trailing Newline

Display Variables

Display Command Output

Use Pattern Matching

Redirect Output to a File

Write to Standard Error

Display Colored Output

Quick Reference

FAQ

Conclusion

The `printf` Command

Backslash Escapes

Conversion Specifiers

Type conversion specifier