The note Get index of a value in an array (0 if not found) is incorrect; ${VARNAME[(ie)value]} does not return 0 if the item is not found. It instead returns one more than the length of the array.

The note Get index of a value in an array (0 if not found) is incorrect; ${VARNAME[(ie)value]} does not return 0 if the item is not found. It instead returns one more than the length of the array.

Indeed, it's with (Ie) that the index is 0. I fixed that in the document, thanks :) !

bar | wc -l zsh-ism: (breaks tree-sitter bash syntax highlighting)

foo="${#${(@f)$(bar)}[@]}"

My google-fu is weak on something here. I'd like to find the docs where there's a list of all these zsh parameter flags?

For example:

(f)

(f) splits input on newline to populate an array (ignores blank lines)

an_array=("${(f)$(command)}")

(F)

(F) Join the contents of an array using newlines.

array(one two three four)

echo ${(F)array}

=>
one
two
three
four

(@)

Get all the contents of and array or associative array.

I think this does more but I'm not sure...

array=(1 2 3 4 5 6)

echo ${(@)array}

=> 1 2 3 4 5 6

It can be used with (f) to keep blank lines from being skipped.

an_array=("${(@f)$(command)}")

(k) and (v)

Accessing associative arrays (k) keys, or (v) values.

aso=(key value another\ key another\ value another\ day dollars)

echo ${(k)aso}

(q)

Quote all the heck all the way out of input:

filename="/Volumes/My Drive/Something With [stuff!] that needs escaping (ie. quoting).txt"
echo ${(q)filename}

=> /Volumes/My\ Drive/Something\ With\ \[stuff!\]\ that\ needs\ escaping\ \(ie.\ quoting\).txt

(qq)

Skip the escaping and use single quotes instead...

filename="/Volumes/My Drive/Something With [stuff!] that needs escaping (ie. quoting).txt"
echo ${(qq)filename}

=> '/Volumes/My Drive/Something With [stuff!] that needs escaping (ie. quoting).txt'

(qqq)

Escape/quote chars that would be special in a regualar double quoted string...

myvar='This is ${not_to_be_expanded}...'
echo ${(qqq)myvar}

=> "This is \${not_to_be_expanded}..."

(Q)

Unquote input:

filename=/Volumes/My\ Drive/Something\ With\ \[stuff!\]\ that\ needs\ escaping\ \(ie.\ quoting\).txt
echo ${(Q)filename}

=> "/Volumes/My Drive/Something With [stuff!] that needs escaping (ie. quoting).txt"

(r) and (R)

Array search (r) from the start, or (R) end.

array=(this is a test of \(r\))

echo ${array[(r)t*]}
=> this

echo ${array[(R)t*]}
=> test

(i) and (I)

Array search for index (i) from the start, or (I) end.

array=(this is a test of \(i\))

echo ${array[(i)t*]}
=> 1

echo ${array[(I)t*]}
=> 2

(c) & (w)

Should count the chars or words in an array. (Although this did not work for me...)

Are there more...?!?

Yes, so many, and so few examples!

There is such a list at: https://zsh.sourceforge.io/Guide/zshguide05.html

It's just very long (about 50 pages when printed) and not intuitive at all.

Ah, so (c) and (w) need to be in the form (c)#name / (w)#name.

@ClementNerma - that's the deal, many flags and whatnot but no examples. At least this Gist provides a place to throw more examples.

@ClementNerma https://zsh.sourceforge.io/Guide/zshguide05.html - To be fair, I've seen worse than this.

(u) (plus (M)

(u)nique elements which (M)atch "findme"

myarr=("${(M@)${(uf)$(< myfile)}:#*findme*}")

I suppose it's also worth adding a general note...

Rule 1. Never write a big complex script in any shell, you will regret not using a real programming language sooner or later.

thanks for your comments @jasonm23, btw regarding quoting, there's also (qqqq) which: quotes result with $'...'

  $ filename="/Volumes/My Drive/Something With [stuff\!] that needs escaping (ie. quoting).txt"
  $ echo ${(q)filename}
    echo ${(qq)filename}
    echo ${(qqq)filename}
    echo ${(qqqq)filename}
    echo ${(Q)filename}
  /Volumes/My\ Drive/Something\ With\ \[stuff\!\]\ that\ needs\ escaping\ \(ie.\ quoting\).txt
  '/Volumes/My Drive/Something With [stuff!] that needs escaping (ie. quoting).txt'
  "/Volumes/My Drive/Something With [stuff\!] that needs escaping (ie. quoting).txt"
  $'/Volumes/My Drive/Something With [stuff\!] that needs escaping (ie. quoting).txt'
  /Volumes/My Drive/Something With [stuff!] that needs escaping (ie. quoting).txt

here's the really cool cheatsheets I got that from:

• https://www.bash2zsh.com/zsh_refcard/refcard.pdf
  
• https://zsh.sourceforge.io/Refcard/

  • ps for this one, i had to download the postscript file, then run psnup -1 -Pa4 -pletter < refcard.ps > refcard-letter.ps, then manually rotate each page

and some more resources:

• https://www.bash2zsh.com/
• Book: https://link.springer.com/book/9781590593769

Nice cheatsheet.

TIL I don't know about $'...'

I guess I do now... https://unix.stackexchange.com/a/607085/1335

Can anyone say what the difference is between:

${var%match*} and ${var%%match*}

I've only used ${var%match*} and they seem to be identical.

Huh, I'm surprised the expansion modifiers aren't covered above, or in @akharrou 's otherwise rather snazzy cheatsheet find. Maybe they get overlooked because they're documented in the History Expansion section of zshexpn(1), but there is a note that (most) also work for filename generation and parameter expansion.

The one I use all the time is :r, to remove the last suffix from a filename. (${var:r} is basically a handy shorthand for ${var%.*}.) Great for writing loops to convert files between formats:

for img in $some_list_of_bmp_trash; do
    convert $img ${img:r}.png
done

But there's plenty more, like:

I'd like to find the docs where there's a list of all these zsh parameter flags?

@jasonm23 the official reference is here: https://zsh.sourceforge.io/Doc/Release/Expansion.html

I actually got my explanation of ${var:hN} wrong, above. The same way ${var:tN} walks back from the filename part of the path, the :hN form walks down from the start of the path. So it's nothing like dirname at all.

var="a/path/of/any/depth/to/a/file"; echo "${var:h3}" => a/path/of

Thank u, really need this!

I have found the (R) and (I) useful for slicing associative arrays. This technique is gleaned from a variety of sources that I have to recover. However, I have yet to see any docs present the features quite as follows.

typeset -A aa=( [left]=right [up]=down [forward]=background [green]=brown )

# List matching values from hash
print ${aa[(R)back*|*own]}
# background down brown

# List keys for matching values from hash
print ${(k)aa[(R)back*|*own]}
# forward up green

# Return key-values from matching keys and assign to new hash sub
typeset -A sub=(${(kv)aa[(R)back*|*own]})
printf "%10s => %s\n" ${(kv)sub}

#    forward => background
#        up => down
#     green => brown

# Print key-values for matching keys in hash
print ${(kv)aa[(I)up|left]}

In trying to find my original inspiration for this technique, I do see a nod in the Zsh Native Scripting Handbook. I believe this illustration is more demonstrative of the capabilities. When I find my original inspiration I will update my comment with a reference.

I have found that it is possible to put a parameter/variable for the width in the format modifier flag (l::), which makes dynamic width formatting possible, but I cannot find a similar capability for the inner or outer padding characters. Any suggestions?

var='Hello, World!'
print ${(l:$(( $(tput cols)/2 )):)var}
#                                     Hello, World!

I have found that it is possible to put a parameter/variable for the width in the format modifier flag (l::), which makes dynamic width formatting possible, but I cannot find a similar capability for the inner or outer padding characters. Any suggestions?

@wdeshazer here are the docs:

• l:expr::string1::string2: Pad the resulting words on the left. Each word will be truncated if required and placed in a field expr characters wide. The arguments :string1: and :string2: are optional; neither, the first, or both may be given. See the docs for their usage details.
• r:expr::string1::string2: As l, but pad words on the right and insert string2 immediately to the right of the string to be padded. Left and right padding may be used together. In this case the strategy is to apply left padding to the first half width of each of the resulting words, and right padding to the second half. If the string to be padded has odd width the extra padding is applied on the left.

I have found the (R) and (I) useful for slicing associative arrays. This technique is gleaned from a variety of sources that I have to recover.

... and relevant docs for r/R and i/I: Zsh Manual Section 15.2.3 Array Parameters - Subscript Flags

The official zsh documentation is not too bad in my experience. Sometimes I find it to be a little scattered (within its own manual and user guide), or not detailed enough on some particular matters, but overall it covers a lot. I set up a quick search in my browser to easily filter through their docs with a search engine (i.e. site:zsh.sourceforge.io).

Also available in your terminal, of course (man pages)! They are spread out by concept area. A subset of them returned by man -k zsh:

zsh          Zsh overview (this section)
zshroadmap   Informal introduction to the manual
zshmisc      Anything not fitting into the other sections
zshexpn      Zsh command and parameter expansion
zshparam     Zsh parameters
zshoptions   Zsh options
zshbuiltins  Zsh built-in functions
zshzle       Zsh command line editing
zshcompwid   Zsh completion widgets
zshcompsys   Zsh completion system
zshcompctl   Zsh completion control
zshmodules   Zsh loadable modules
zshtcpsys    Zsh built-in TCP functions
zshzftpsys   Zsh built-in FTP client
zshcontrib   Additional zsh functions and utilities
zshall       Meta-man page containing all of the above

I've often found myself opening up zshall in a pager and then searching for the term of interest, otherwise I'd not know how to find it across the different sections they have.

Another good one is zsh-lovers, community maintained. You'll have to install that one on your own. I think I installed it via homebrew a while back.

@andelink, the man references are great (and I use them extensively), but my question is about dynamic specification of the values. I would love to do:

# Note this does not work for anyone who might get confused
print ${(l:$w::$char1::$char2:)param} [edited per @ferdnyc]

but only the width can be specified dynamically. Using your extraction from the docs, Only the width allows for an "expression" and the other two must be "strings". Those strings can't be passed as a parameter? The answer is no and I think your doc reference supports that, but then what is the recommended zsh alternative for dynamic formatting. (Use perl? 💀)

@wdeshazer You left out some :s, but you can do this:

eval "print \${(l:$w::$char1::$char2:)param}"