Zsh 5.9

Perhaps it's niche, but there's a single feature that makes me use zsh over bash: EXTENDED_GLOB, used together with * filename expansion.

    ls **/*.d

gives me all files, recursively, that end in .d. That's available in bash too if you `shopt -s starglob`.

But it also gives all directories, so if I do eg

    grep pattern **/*.d

then I get lots of error messages about trying to grep on directories (if I happen to have directories ending in .d). With zsh, I can do

    grep pattern **/*.d(.)

and it will restrict to just files. I use this pretty often, and it saves me from many `find | xargs` commands. I pretty much only use `find` when there are too many matches for a single command.

My muscle memory types

    fgrep -l SOMESTRING **/*(.)

multiple times per day. That'll list out all files containing the literal SOMESTRING anywhere in or below my current directory. I'm sure I could be using one of the fancy grep replacements, and I have in the past, but this works Good Enough and only requires zsh to be installed, so it's what I have held onto.

I switched to ZSH and was quite happy with it, now using FISH - mainly because of it's excellent auto-completion that displays as you type. Otherwise both ZSH and FISH are good options IMHO.

Although for typical "shell-scripting" I still use BASH for the most-part where scripting languages like Python aren't as suitable, so my scripts can be used on other peoples systems.

Tab completion alone is a good reason to switch. bash completes only filenames most of the time even with a bunch of third party completion scripts. Meanwhile, zsh provides smarter completion as part of its default installation, which you can enable with this 3 line configuration:

    autoload -Uz compinit; compinit
    setopt menu_complete
    zstyle ':completion:*' menu select

I switched from Bash to ZSH with the caveat that I use prezto and powerlevel10k (included with prezto) and I will never go back.

I had to turn off some of the Zsh-specific brackets and quoting features to make it more bash-like because of the tools I use which make it kinda wonky to use with Zsh but otherwise it’s been absolutely fantastic. Remoting into our systems that only have bash feels absolutely prehistoric.

https://github.com/sorin-ionescu/prezto

> It is worth, as a long time Bash user, to change to ZSH?

It doesn't make a lot of a difference. For me the major selling point of zsh is that it has two forms of process subsitution: regular <(...) as in bash, based on sockets, and =(...), which creates temporary files. This allows you to do some neat things that are not possible or comfortable in bash.

If you like vim mode, the zle vim mode is more complete than readline's, it can handle test objects for example. That's a small thing but that's nice. Prompt config is also quicker/easier to remember. Small things do add up.

bash is great for scripting and zsh can be made great for interactivity. I use zsh with prezto and history-substring on and auto-suggestions on, it's great.

Probably not. I think they both have comparable features, and by default are pretty bare bones without a lot of extensions and configuration. If you do want to try something new I would suggest fish shell. It is like a fully tricked out bash or zsh, but out of box. It is also very fast, because those tricks are built directly into the shell. I used to use zsh and after adding all the bells and whistles it got very slow.

I recommend Fish. Very nice shell.

https://fishshell.com/

Parameter expansions don't need to be defensively quoted. That's what got me to switch.

Sure. Some of its features are pretty handy and it is basically fully bash compatible. You don't really loose anything.

I have been using bash for decades, not only on Linux, but also on other UNIX-derived operating systems.

Less than a year ago, I have tried zsh, without a definite intention to switch to it, but eventually I ended always using zsh for interactive use, while continuing to use bash for scripts.

I have benchmarked some scripts with both zsh and bash, but I have not seen any significant difference in speed.

While there are a few scripting features originally introduced by zsh (most of the brace expansion variants), bash has also incorporated them many years ago. Besides those, both bash and zsh implement the ksh93 features, so there is little reason to prefer one or the other. Therefore I have stuck to bash for scripts.

It is hard to say exactly why now I prefer zsh for interactive use, because there is no killer feature, but mostly various small details.

For some reason, zsh seems more responsive, when interactive. I rely a lot on autocompletion and the default autocompletion rules in zsh are more powerful and also the zsh autocompletion seems faster.

While in most cases I prefer the way zsh handles autocompletion, there are times when zsh annoys me by trying to be too smart, e.g. it will never autocomplete "mkdir" with the name of an existing file. I need that frequently, when I want to create a subdirectory in which to move a bunch of related files, with very long names that I do not want to type, but I want to edit slightly to make a name for the new subdirectory, so I have to use a workaround like autocompleting a "ls", then editing it into a "mkdir", while that was not needed in bash.

In zsh I use a much more complex shell prompt that I had used in bash, which displays a lot of useful information in a format that avoids confusion with the command lines or with the text output of the executed commands.

After switching to it in zsh, I have discovered that such a complex shell prompt is also possible in bash. Nevertheless, after using it in bash I have discovered some bash bugs. The too complex shell prompt confused bash and the text cursor became desynchronized with the correct position in certain contexts, so I had to revert in bash to a simple shell prompt.

I think that you should give zsh a try for interactive use. After using it for some days you will see if you prefer it to bash or not.

Now I prefer the interactive zsh, but there are no large differences, bash and zsh are similar and mostly equivalent, because whenever one was improved somehow, the other also copied that feature soon.

I had completely forgotten, but when I have tried for the first time to use zsh as a bash user, I have spent some ten minutes of great confusion, until discovering that I have to add to my ".zshrc" the lines:

bindkey '^[[H' beginning-of-line

bindkey '^[[F' end-of-line

bindkey '^[[3~' delete-char-or-list

in order to have the line editing keys with which I was accustomed.

Have you seen https://ohmyz.sh/ ? It’s indispensable, can’t imagine zsh without it now…

I really like right prompt. My config is:

    PS1="%# "
    RPS1="%40<...<%~"

This way I have current directory information without eating precious space.

Other than that, I don't really use much zsh-specific functionality.

the fact that you can tab/navigate through autocomplete instead of having it fill up your screen every time you move

Look into https://ohmyz.sh/ or https://github.com/zdharma-continuum/zinit (or any other plugin managers) and some nice plugins.

Tab completion and zmv are neat, nothing new to learn, no complicated configs.

Some of my favourite features which are built in to the shell, not part of third-party plugin systems, include:

The "command1 =(command2)" syntax, which runs "command2", pipes its output to a new temporary file, runs "command1" with that file's name as an argument, and then removes the temporary file, all in one operation. It's like "<(command2)", which is in Bash and Zsh, but allows "command1" to perform a seek on the file because it's not a pipe.

Redirections like ">file" where there's no command implicitly use cat, so ">file" just pipes STDIN to the file. Same for "<file", which pipes file to STDOUT.

"command &>/dev/null" is shorthand for "command >/dev/null 1>&2".

Floating-point arithmetic built-in (Bash has integer arithmetic only), including C math functions like sin, log, floor.

Implicit insertion of "tee" where you obviously want it; for example, "command >file1 >file2" is the same as "command | tee file1 > file2"

You don't need to quote variable expansions like $1 (except arrays). You still have to do so for command expansions $(command

More expressive pattern syntax, including backreferences, approximate matching (using Damerau-Levenshtein distance), and flags/qualifiers to limit searching to specific kinds of file. E.g. "ls *(-@)" lists all broken symbolic links.

The string =foo is expanded to the path to the "foo" command in $PATH, which allows you to do, for example, "vim =myscript" without needing to remember where "myscript" is exactly.

Lots of parameter expansion flags for various string operators (search/replace, sorting, case translation, splitting and joining, ...).

POSIX extended regex and optional PCRE support for pattern matching.

zle, which does a similar job to readline in bash, but with an enormous number of useful features built-in.

Generalised tilde expansion: ~ is the current user's $HOME, but ~john is the user john's home directory. You can make up your own using "hash -d foo=/path/too/foo"; now "~foo" refers to "/path/to/foo".

Dynamic version of the above: ~[string] uses the function zsh_directory_name to expand "string" into any path; see the manual "zshexpn(1) § Filename Generation § Dynamic named directories".

Easily create more explicit pipes using file descriptors:

    # open
    exec {fd}>file

    command1 >&$fd
    command2 >&$fd
    #...

    # close
    exec {fd}>&-

Additional concise and useful syntax for loops, function definitions, etc.:

    while (( x < 5 )) { echo $x; let x++ }  # more obvious than "
    repeat 5 echo hi  # does what it says on the tin
    myfunc() echo hi  # declares a function
    for ((x = 0; x++; x < 5)) { echo $i }  # C-style for-loop

The equivalent of "try-finally" in some programming languages:

    {
        # do some stuff which might error
    } always {
        # do some important cleanup
    }

This construct also enables special support for another feature: actual exceptions with throw/catch.

Very flexible prompt expansion: conditionals using %(condition.true.false). Optionally, command expansion "$()" can be enabled in prompts.

All kinds of extra optional modules which can be loaded using "zmodload", for manipulating xattrs, POSIX Capabilities, TCP sockets, an FTP client!?; also, built-in plugin functions which can be loaded with "autoload": a full calendar application, an interactive calculator, colours, regex replace, tetris!

> Zsh was once accused of not being as complete as Emacs, because it lacked a Tetris game. This function was written to refute this vicious slander.

    autoload -U tetriscurses
    tetriscurses

Ability to set the value of argv[0] received by a command, rather than just the name it was invoked by, e.g. "ARGV0=ls busybox"

Options to emulate the behaviour of other shells: pure POSIX sh, ksh, etc.?

Sorry, that was perhaps a bit more than "some of my favourites". It really does have a lot of stuff.

It used to be that I’d end up on older systems with only cshell as the default. So immediately would install bash for what I had expected to be default behavior by that point.

zsh never clicked for me though, until I used oh-my-zsh, which allows for sharing custom extensions from folks. And it’s great, and superior to bash.

I used to not care, but these little improvements are worth it.

If you prefer an POSIX compliance for your interactive shell then I would completely agree with you: it probably doesn't matter which shell you are using. If you don't care about POSIX compliance then there are several options that offer better productivity out-of-the-box (fish and oil are probably the most mature right now).

Do you spend most of your days reading from a shell/entering commands in a shell? That might make it more/less likely to care about the tooling you use. I spend a lot of time editing code, so naturally I care about what editor I use. Same with the shell.

I sometimes feel like zsh is one of those things along with tiling WMs that people spend so much time dinking around with the configuration of that any gain in productivity is negated

Nope, there's plenty of you. As long as the shell is sufficiently compatible (which often entails being 'bash-compatible'...) and it has the rudimentary CLI features of command history and repetition I don't care either. I just use whatever is the largest common denominator - currently bash - in the knowledge that any scripts I produce are likely to work elsewhere. If it really needs to work everywhere I limit myself to POSIX shell but otherwise I use the handy bits of bash without remorse. If most of the world moves to zsh or Oil shell or Fish then so will I.

Quite the contrary. I haven't seen a single HN thread on zsh that's not full of comments questioning its reason for existence.

Depends what you need I guess. It’s great to tab complete files on a remote host whenn rsyncing to your own machine. Saves a ton of time over the years. Can you live without? Yeah sure but… why? It’s free.

Isn’t it the default shell on macos?