Looping, Splitting, and Globbing in Zsh and Bash

1. Overview

Most Linux distributions have accustomed us to Bash as the interactive login shell and shell language. However, this is not the only choice for us. We have the Z shell Zsh, KornShell ksh, or the Berkeley UNIX C shell tcsh at our disposal as well.

In this tutorial, we’ll compare the loop statement of the Bash and Zsh shells, with additional emphasis on string splitting and globbing.

2. Installing Zsh

If our distribution doesn’t come with the Zsh shell, we need to install it. On Ubuntu, let’s use apt:

$ sudo apt install zsh

Afterward, we should create an empty configuration file .zshrc in our home folder:

$ touch .zshrc

Of course, we can fill it with our preferred settings later on. Finally, let’s open the Zsh shell by issuing in the terminal:

$ zsh

Throughout this tutorial, we’ll indicate the Zsh command line snippets with the % prompt, while Bash’s ones with $.

To run the script with Zsh, we should change the script’s usual Bash shebang #!/bin/bash to:

#!/bin/zsh

For clarity, the Zsh script will bear the zsh extension, while we leave the bash ones without an extension.

3. Loop Syntax

Let’s recall the basic syntax of the for loop, which is common for both Zsh and Bash:

for <variable> in <list_of_items>; do <command_1>; ... ; <command n>; done

Then let’s run a simple example:

$ for x in foo bar foobar; do echo $x; done
foo
bar
foobar

Note that we separated the elements in this explicitly defined list with a space. In the case when we want to use items with spaces inside, we should enclose them in single quotes:

$ for x in 'item 1' 'item 2' 'item 3'; do echo $x; done
item 1
item 2
item 3

4. Zsh Loop Alternatives

The Zsh shell offers a different syntax for the loop:

% for x (foo bar foobar); do echo $x; done                  
foo
bar
foobar

So, we dropped the in keyword and put the items list into parenthesis.

Another interesting Zsh feature is looping with multiple indices. Let’s assume that we want to print data concerning popular DNS providers with the multi_index.zsh script:

#!/bin/zsh

printf "%-12s %-12s %-12s\n" "Provider" "Primary DNS" "Secondary DNS"
for provider primary secondary (Google 8.8.8.8 8.8.4.4 'Control D' 76.76.2.0 76.76.10.0 Quad9 9.9.9.9 149.112.112.112)
do
    printf "%-12s %-12s %-12s\n" "$provider" "$primary" "$secondary"
done

The result pretty well explains this syntax:

% ./multi_index.zsh
Provider     Primary DNS  Secondary DNS
Google       8.8.8.8      8.8.4.4   
Control D    76.76.2.0    76.76.10.0  
Quad9        9.9.9.9      149.112.112.112

5. Arrays

In both Bash and Zsh, we can define arrays using parenthesis. So, let’s create a four-element array containing letters letters=(a b c d). Now, let’s print all elements in Zsh with the array.zsh script:

#!/bin/zsh

letters=(a b c d)

for x in $letters
do
    echo $x
done

Equally, we can skip in and surround the reference to d with parenthesis:

#!/bin/zsh

letters=(a b c d)

for x ($letters)
do
    echo $x
done

The Bash syntax is a bit more complex:

#!/bin/bash

letters=(a b c d)

for x in "${letters[@]}"
do
    echo $x
done

Note that Zsh recognizes the last form too.

6. Splitting and Globbing

Although string splitting and globbing are features in their own right, we often use their result to feed the loop.

6.1. String Splitting

The splitting occurs in every place where multiple items are expected, as in the loop item list. As a result, a string is divided into words. Usually, the delimiter is a whitespace character as space, tab, or newline. We can change it by setting the IFS (Internal Field Separator) variable.

Let’s run an example script string_split in Bash:

#!/bin/bash

text="a b c d"

for x in $text
do
    echo $x
done

As we loop over words that result from splitting the text variable, we’ll obtain the following:

$ ./string_split
a
b
c
d

But when we run this script with Zsh (by changing the shebang from #!/bin/bash to #!/bin/zsh), the result is different:

% ./string_split
a b c d

Unlike Bash, Zsh doesn’t split strings by default. Therefore, we need to set the shell option shwordsplit first. Let’s check the string_split.zsh script::

#!/bin/zsh

text="a b c d"

setopt shwordsplit

for x in $text
do
    echo $x
done

unsetopt shwordsplit # unset when unnecessary

Finally, we’ll get the desired result:

% ./string_split.zsh
a
b
c
d

6.2. Globbing

The glob term refers to recognizing text as a pattern followed by expanding matching filenames. Let’s take a look at perhaps the most common example:

$ for file in *; do echo $file; done

The star symbol is expanded to a list filled with the names of all files in the current directory. We can run this example in both Bash and Zsh with the same result. However, things get complicated when we get down to variable substitution. Let’s use a variable named pattern with string  * as a value and check Bash:

$ pattern=*; for file in $pattern; do echo $file; done
array1.zsh
array.zsh
glob.zsh
string_split
string_split.zsh

So, we’ve got the same result as in the bare star symbol case. Now let’s give Zsh the whirl:

% pattern=*; for file in $pattern; do echo $file; done
*

By default, the variable value is printed literally, without any expansion. Similar to string splitting, we can change this behavior by setting an appropriate option, globsubst in this case:

#!/bin/zsh

pattern=*

setopt globsubst

for x in $pattern
do
    echo $x
done

unsetopt globsubst # unset when unnecsssary

6.3. More on Zsh Splitting and Globbing

As we’ve observed, Bash performs string splitting and filename expansion by default. In Zsh, we can enable both features using shell options. However, we have more straightforward possibilities with special syntax.

So, with $=variable, we can perform word splitting:

% letters="a b c d"; for letter ($=letters); do echo $letter; done
a
b
c
d

With $~variable, we ask for globbing:

% pattern=*; for file ($~pattern); do echo $file; done
array1.zsh
array.zsh
glob.zsh
string_split
string_split.zsh

Finally, we can use $~=variable to perform both. Here is a rather silly example, which lists the content of the current directory twice:

% pattern="* *"; for file ($=~pattern); do echo $file; done
array1.zsh
array.zsh
glob.zsh
string_split
string_split.zsh
array1.zsh
array.zsh
glob.zsh
string_split
string_split.zsh

7. Conclusion

In this article, we looked at looping, string splitting, and globbing in the Bash and Zsh shells. First, we studied the for loop syntax and highlighted the Zsh specifics. Then, we moved to string splitting and globbing, using both these features to fuel loops.

We highlighted that, unlike Bash, Zsh didn’t perform splitting and globbing operations by default. Finally, we learned the related, specific forms of Zsh variable reference operator $.