Zsh vs. Bash Scripting. What’s the Difference?

When it comes to shell scripting on Unix-like operating systems, two shells dominate: Bash (Bourne Again Shell) and Zsh (Z Shell). If you are a programmer or a system administrator, the choice between these two significantly impacts your efficiency and productivity.

Understanding the differences and similarities between these two shells will help you optimize your command-line workflow. Knowing about the nuances of each shell will help you make informed decisions.

Bash is popular on both Linux and macOS systems. It’s a powerful tool that you can use to interact with the operating system and run commands. You can also use Bash for shell scripting, which automates tasks by writing scripts containing more than one command.

Zsh (Z shell) is an extended version of Bash that has many more features. It is the default shell on macOS. It is also becoming increasingly popular on Linux systems.

If you are using a Linux system and would like to switch to Zsh, start by using your package manager to install it. For example, on Debian or Ubuntu, use the following command:

sudo apt install zsh

After installing it on your system, switch to it by running the following command:

chsh -s $(which zsh)

If you are using macOS, Zsh is already installed. To switch to it run the following command:

chsh -s /bin/zsh

To switch back to Bash, replace Zsh with Bash in the above commands.

To check which shell you are using, run the following command:

echo $SHELL

This will help you confirm you are using the shell you intended to.

There are several differences between Zsh and Bash. Considering these differences will help you decide which shell best suits you.

Zsh offers an easier way for customizing your prompts using %-based escape sequences. This allows for dynamic prompts with color and information. To customize your shell prompt, define the PS1 (Primary Prompt).

PS1="%F{green}%n@%m %F{blue}%~ %f$ "

The above custom prompt displays the username, hostname, and current directory in different colors:

There are many other ways to customize the Zsh prompt, letting you set an admin indicator, include the date and time, and save the new prompt.

Bash uses a slightly different approach when it comes to prompt customization. It uses escape codes to specify color and formatting changes in the prompt. To achieve the same customization as Zsh above, you can use the following custom prompt.

PS1="\[\033[32m\]\u@\h \[\033[34m\]\w \[\033[0m\]\$ "

Using \[\033[0m\] is crucial as it ensures that the color changes don't affect text that follows the prompt.

Zsh natively supports associative arrays. These arrays provide a convenient way to associate data which makes it easy to organize and retrieve information. Use declare -A command to explicitly declare an associative array:

# Declare an associative array in Zsh
declare -A my_assoc_array

You can then assign values to the associative array:

my_assoc_array=(key1 value1 key2 value2) 

And, finally, access the values using their keys:

echo $my_assoc_array[key1] # Outputs: value1

Bash has included native support for associative arrays since version 4.0. You declare and assign values the same way as you would in Zsh. But when it comes to accessing array values, you need to wrap the key inside curly brackets:

echo "${my_assoc_array[key1]}" 

The main difference is that Zsh's support for associative arrays is more feature-rich and advanced than Bash. Zsh allows associative arrays to have keys of various data types, not just strings. Bash only supports string keys.

In earlier versions of Bash, you need to figure out a way to workarounds or have external tools to use associative arrays.

Extended globbing patterns provide a powerful and flexible way to select and manipulate files and directories based on various criteria. They’re useful when you’re working with complex file structures or when you need precise control over file selections.

In a Zsh script, you can enable these patterns using the setopt command. For example, to match all .txt files in the current directory:

setopt extended_glob
txt_files=(*.txt)

To match all files except those with .log extension:

setopt extended_glob
non_log_files=^(*.log)

In Bash, you need to enable them using the shopt command with the extglob option. For example, to match all .txt files in the current directory:

shopt -s extglob
txt_files=(*.txt)

To match all files except those with .log extension:

shopt -s extglob
non_log_files=!(*.log)

The main difference between Zsh and Bash when it comes to globbing patterns is the command used to enable them. However, notice that some operators are different between the two shells.

Zsh supports the indirect expansion of parameters. This allows you to expand the value of a variable whose name is stored in another variable. To achieve this, you need to prefix the variable name with an exclamation point !.

name="foo"
result="${!name}"
echo "$result"

Bash on the other hand does not allow for indirect expansion natively. The workaround for this is using the eval built-in command or the ${!var} syntax for indirect variable references.

name="world"
var="name"
echo ${!var} # This will output: world

While there are differences between Bash and Zsh, they also share some similarities.

Bash and Zsh share a similar command line syntax. This is great because it means most commands and scripts you write will work in either shell, without modification. Zsh is built on top of Bash, so it includes all the same basic commands and features.

There are, however, very minor differences in syntax which you’ll need to identify and adjust.

Command substitution is the process of embedding the output of one command into another. It is consistent between both shells.

result=$(ls) 

In both Bash and Zsh, you can use the $(command) syntax to substitute the output of a command into a variable. This allows for easy portability of scripts between the two shells.

Both Bash and Zsh use -x flag for script debugging. When you run a script with this flag, it displays each command before it runs. This helps you identify issues in your scripts.

# Debugging a script in both Bash and Zsh
#!/bin/bash -x

echo "Debugging Bash script"

In this Bash script, the -x flag enables debugging. You can use a similar approach in Zsh; just replace bash with zsh.

Knowing how to automate tasks using shell scripts is of great importance. You can automate repetitive tasks and save lots of time.

You can also use these scripts to manage user accounts, monitor system resources, back up data, and perform routine maintenance. When carefully written, they can also reduce the potential for human error.