Why does Zsh complain of the variable assignment as “command not found”

macosmacos-bigsurshellzsh

When I try to write a Zsh script on macOS Big Sur, Version 11.5.1, I noticed that it keeps failing to recognize my variables as variables.

Instead, Zsh treats them as UNIX-like commands.

Screenshot of the problem on the Terminal Application – variable assignment problem for Zsh shell scripts

In the screenshot linked above, I did the following on the Terminal application.

Showed the contents of the simple Zsh shell script.
Used the "ls -l" UNIX-like command to indicate its file permissions, and show that it is an executable Zsh shell script.
Executed the Zsh shell script, which shows that the Zsh script interpreter complains of how my variable name is a "command not found".

The source code for my Zsh shell script is provided as follows:

#!/bin/zsh

unix_cmd = "ls -al"

Can you please kindly let me know what am I missing, and what did I do wrong?

I just want to assign values to variables in my Zsh shell scripts.

Thank you so much, and have a great day! Ciao!

Best Answer

The syntax to assign a value to a variable is foo=bar, not foo = bar. Whitespaces matter. The latter syntax is a command foo with arguments = and bar.

Few examples of how = is interpreted:

code	meaning
`foo=bar`	proper assignment; now the value of `foo` is `bar`
`foo = bar`	command `foo` with arguments `=` and `bar`
`foo =bar`	command `foo` with one argument `=bar`
`foo= bar`	command `bar` with `foo` in its environment; the value of `foo` is empty
`foo=1 bar`	command `bar` with `foo` in its environment; the value of `foo` is `1`
`foo='1 bar'`	proper assignment; now the value of `foo` is `1 bar`
`foo=' bar'`	proper assignment; now the value of `foo` is `bar` (note the leading space)
`foo=\ bar`	proper assignment; now the value of `foo` is `bar` (note the leading space)
`foo-x=bar`	command `foo-x=bar` (because `foo-x` is not a valid name for a shell variable)

This is not specific to Zsh. The POSIX shell (sh) and POSIX-compliant shells behave this way. Zsh (while not being POSIX-compliant in general) also follows.

Related Solutions

How to ‘source’ a shell script using bash from zsh

You could put your compilation commandline in a bash script, which sources the compilation scripts bevor executing the compilation command.

Something like

    #!/bin/bash
    . /path/to/environmentscript
    . /path/to/morefunctionsscript

    compile_command

Then instead of invoking compile_command by hand, you just invoke your new bash script.

Writing shell scripts that will run on any shell (using multiple shebang lines?)

Which shell executes scripts when there's no shebang line (#!/path/to/shell) at the beginning? I assume /bin/sh but I can't confirm.

The kernel refuses to execute such scripts and returns ENOEXEC, so the exact behavior depends on the program you run such a script from.

bash 4.2.39 – uses itself
busybox-ash 1.20.2 – uses itself
dash 0.5.7 – runs /bin/sh
fish 1.23.1 – complains about ENOEXEC, then blames the wrong file
AT&T ksh 93u+2012.08.01 – uses itself
mksh R40f – runs /bin/sh
pdksh 5.2.14 – runs /bin/sh
sh-heirloom 050706 – uses itself
tcsh 6.18.01 – runs /bin/sh
zsh 5.0.0 – runs /bin/sh
cmd.exe 5.1.2600 – looks at you funny.

In glibc, functions execv() or execve() just return ENOEXEC. But execvp() hides this error code and automatically invokes /bin/sh. (This is documented in exec(3p).)

What is considered "best practices" in terms of writing shell scripts that will run on any platform? (ok, this is sort of open-ended)

Either stick to sh and only POSIX-defined features, or just go full bash (which is widely available) and mention it in your requirements if distributing it.

(Now that I think of it, Perl – or perhaps Python – would be even more portable, not to mention having a better syntax.)

Always add the shebang line. If using bash or zsh, use #!/usr/bin/env bash instead of hardcoding the shell's path. (However, the POSIX shell is guaranteed to be at /bin/sh, so skip env in that case.)

(Unfortunately, even /bin/sh is not always the same. The GNU autoconf program has to deal with many different quirks.)

Is it possible to write a script that tries to use zsh and falls back to bash if zsh is not available? I've tried putting two shebang lines, like below, but it just errors with bad interpreter: /bin/zsh: no such file or directory out if I try it on a machine without zsh.

There can only be one shebang line; everything after the newline character isn't even read by the kernel, and treated as a comment by shells.

It's possible to write a script that runs as #!/bin/sh, checks which shell is available, and runs exec zsh "$0" "$@" or exec bash "$0" "$@" depending on the result. However, the syntax used by bash and zsh is so different in various places that I would not recommend doing this for your own sanity.

Best Answer

Related Solutions

How to ‘source’ a shell script using bash from zsh

Writing shell scripts that will run on any shell (using multiple shebang lines?)

Related Question