# ZSH Cheat Sheet ## Conditionals ```zsh if [[ -z "$string" ]]; then echo "String is empty" elif [[ -n "$string" ]]; then echo "String is not empty" fi ``` ### String conditions ┌────────────────────────┬──────────────────┐ │ `[[ -z STRING ]]` │ Empty string │ ├────────────────────────┼──────────────────┤ │ `[[ -n STRING ]]` │ Not empty string │ ├────────────────────────┼──────────────────┤ │ `[[ STRING == STRING ]]` │ Equal │ ├────────────────────────┼──────────────────┤ │ `[[ STRING != STRING ]]` │ Not Equal │ ├────────────────────────┼──────────────────┤ │ `[[ STRING =~ STRING ]]` │ Regex │ └────────────────────────┴──────────────────┘ ### Number conditions ┌────────────────────────┬───────────────────────┐ │ `[[ NUM1 -eq NUM2 ]]` │ Equal │ ├────────────────────────┼───────────────────────┤ │ `[[ NUM1 -ne NUM2 ]]` │ Not Equal │ ├────────────────────────┼───────────────────────┤ │ `[[ NUM1 -lt NUM2 ]]` │ Less than │ ├────────────────────────┼───────────────────────┤ │ `[[ NUM1 -le NUM2 ]]` │ Less than or equal │ ├────────────────────────┼───────────────────────┤ │ `[[ NUM1 -gt NUM2 ]]` │ Greater than │ ├────────────────────────┼───────────────────────┤ │ `[[ NUM1 -ge NUM2 ]]` │ Greater than or equal │ ├────────────────────────┼───────────────────────┤ │ `(( NUM < NUM ))` │ Numeric conditions │ └────────────────────────┴───────────────────────┘ ### File conditions ┌───────────────────────┬─────────────────────────┐ │ `[[ -e FILE ]]` │ Exists │ ├───────────────────────┼─────────────────────────┤ │ `[[ -r FILE ]]` │ Readable │ ├───────────────────────┼─────────────────────────┤ │ `[[ -h FILE ]]` │ Symlink │ ├───────────────────────┼─────────────────────────┤ │ `[[ -d FILE ]]` │ Directory │ ├───────────────────────┼─────────────────────────┤ │ `[[ -w FILE ]]` │ Writable │ ├───────────────────────┼─────────────────────────┤ │ `[[ -s FILE ]]` │ Size is > 0 bytes │ ├───────────────────────┼─────────────────────────┤ │ `[[ -f FILE ]]` │ File │ ├───────────────────────┼─────────────────────────┤ │ `[[ -x FILE ]]` │ Executable │ ├───────────────────────┼─────────────────────────┤ │ `[[ FILE1 -nt FILE2 ]]` │ 1 is more recent than 2 │ ├───────────────────────┼─────────────────────────┤ │ `[[ FILE1 -ot FILE2 ]]` │ 2 is more recent than 1 │ ├───────────────────────┼─────────────────────────┤ │ `[[ FILE1 -ef FILE2 ]]` │ Same files │ └───────────────────────┴─────────────────────────┘ ### Other conditions ┌────────────────────┬────────────────────┐ │ `[[ -o noclobber ]]` │ Option enabled │ ├────────────────────┼────────────────────┤ │ `[[ ! EXPR ]]` │ Not │ ├────────────────────┼────────────────────┤ │ `[[ X && Y ]]` │ And │ ├────────────────────┼────────────────────┤ │ `[[ X || Y ]]` │ Or │ └────────────────────┴────────────────────┘ ## Parameter manipulation ┌─────────────────────────────────┬────────────────────────────────────────────────────────────────┐ │ `${foo}` │ Variable │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${foo/from/to}` │ Replace first match │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${foo/#from/to}`/`${foo/%from/to}` │ Replace first match anchored to start (default) or end │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${foo//from/to}` │ Replace all │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${foo[start,length]}` │ Slice from `start` to `length` (`length` can be negative) │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${foo%suffix}`/`${foo%%suffix}` │ Remove `suffix` (ungreedy/greedy) │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${foo#prefix}`/`${foo##prefix}` │ Remove `prefix` (ungreedy/greedy) │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${#foo}` │ Length of `foo` │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${(L)foo}` │ Lowercase all letters │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${(U)foo}` │ Uppercase all letters │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${(q)foo}` │ Quote safely │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${(qq)foo}` │ Quote more explicitely │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${(s.del.)foo}` │ Split on `del` │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${(j.del.)foo}` │ Join with `del` │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${file:h}` │ Directory of `file` │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${file:t}` │ Filename of `file` │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${file:e}` │ Extension of `file` │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${file:r}` │ Root of `file` (without extension) │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${file:a}` │ Absolute path of `file` │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${file:A}` │ Absolute path of `file` (resolves symlinks) │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${foo:-val}` │ Use `val` if `foo` is unset or null │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${foo:=val}` │ Set `foo` to `val` if unset or null │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${foo:+val}` │ Use `val` if `foo` **is** set and not null │ ├─────────────────────────────────┼────────────────────────────────────────────────────────────────┤ │ `${foo:?message}` │ Print `message` and exit if `foo` is unset or null │ └─────────────────────────────────┴────────────────────────────────────────────────────────────────┘ > Omitting the `:` for default values will only check if the variable is set, not if it is null. ### Examples ```zsh name="John" echo "${name}" echo "${name/J/j}" #=> "john" (substitution) echo "${name[0,2]}" #=> "Jo" (slicing) echo "${food:-Cake}" #=> $food or "Cake" length=2 echo "${name[1,length]}" #=> "Jo" (slicing with variable) str="/path/to/foo.cpp" echo "${str%.cpp}" # /path/to/foo echo "${str%.cpp}.o" # /path/to/foo.o echo "${str%/*}" # /path/to echo "${str##*.}" # cpp (extension) echo "${str##*/}" # foo.cpp (basepath) echo "${str#*o}" # o/foo.cpp (first occurrence of 'o') echo "${str##*o}" # oo.cpp (last occurrence of 'o') echo "${str#*/}" # path/to/foo.cpp echo "${str##*/}" # foo.cpp echo "${str/foo/bar}" # /path/to/bar.cpp str="HELLO WORLD!" echo "${(L)str}" #=> "hello world!" (all lowercase) str="hello world!" echo "${(U)str}" #=> "HELLO WORLD!" (all uppercase) ``` ## Globs ┌───────────────┬───────────────────────┐ │ `ls **/*.js` │ Recursive expansion │ ├───────────────┼───────────────────────┤ │ `ls *(.)` │ Plain files │ ├───────────────┼───────────────────────┤ │ `ls *(/)` │ Directories │ ├───────────────┼───────────────────────┤ │ `ls *(@)` │ Symlinks │ ├───────────────┼───────────────────────┤ │ `ls *(*)` │ Executables │ ├───────────────┼───────────────────────┤ │ `ls *(L+1M)` │ Files larger than 1MB │ ├───────────────┼───────────────────────┤ │ `ls *(om[1,5])` │ 5 newest files │ ├───────────────┼───────────────────────┤ │ `ls *(.)~*.bak` │ Files except *.bak │ └───────────────┴───────────────────────┘ ## Comments ```zsh # This is a comment : ' This is a multi-line comment workaround ' ``` ## Loops ### Basic for loop ```zsh for i in /etc/rc.*; do echo "$i" done ``` ### C-style for loop ```zsh for (( i = 0; i < 10; i++ )); do echo "$i" done ``` ### Ranges ```zsh for i in {1..10}; do echo "$i" done # With step size for i in {1..10..2}; do echo "$i" done ``` ### Reading lines ```zsh while IFS= read -r line; do print -r -- "$line" done < file.txt ``` ### Infinite loop ```zsh while true; do echo "Press [CTRL+C] to stop.." sleep 1 done ``` ## History ┌───────────────┬────────────────────────────────────────────────────────────────┐ │ `!!` │ Expand latest command in history │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!$` │ Expand last parameter of latest command │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!*` │ Expand all parameters of latest command │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!-n` │ Expand nth latest command in history │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!n` │ Expand nth command in history │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!string` │ Expand latest command starting with string │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!!:s/from/to` │ Replace first occurrence of "from" with "to" in latest command │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!!:gs/from/to` │ Replace all occurrences of "from" with "to" in latest command │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!!:p` │ Print latest command without executing it │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!$:t` │ Expand basename of last parameter of latest command │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!$:h` │ Expand directory of last parameter of latest command │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!!:n` │ Expand only nth parameter of latest command │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!^` │ Expand first parameter of latest command │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!$` │ Expand last parameter of latest command │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!!:n-m` │ Expand parameters from nth to mth of latest command │ ├───────────────┼────────────────────────────────────────────────────────────────┤ │ `!!:n-$` │ Expand parameters from nth to last of latest command │ └───────────────┴────────────────────────────────────────────────────────────────┘ ## Redirection ┌────────────────────────┬─────────────────────────────────┐ │ `SCRIPT > FILE` │ stdout to FILE │ ├────────────────────────┼─────────────────────────────────┤ │ `SCRIPT >> FILE` │ Append stdout to FILE │ ├────────────────────────┼─────────────────────────────────┤ │ `SCRIPT 2> FILE` │ stderr to FILE │ ├────────────────────────┼─────────────────────────────────┤ │ `SCRIPT 2>&1` │ stderr to stdout │ ├────────────────────────┼─────────────────────────────────┤ │ `SCRIPT &> FILE` │ stderr and stdout to FILE │ ├────────────────────────┼─────────────────────────────────┤ │ `SCRIPT 2> /dev/null` │ stderr to /dev/null │ ├────────────────────────┼─────────────────────────────────┤ │ `SCRIPT > FILE 2>&1` │ stdout and stderr to FILE │ ├────────────────────────┼─────────────────────────────────┤ │ `SCRIPT &> /dev/null` │ stdout and stderr to /dev/null │ ├────────────────────────┼─────────────────────────────────┤ │ `echo "$0: warning" >&2` │ Print to stderr │ ├────────────────────────┼─────────────────────────────────┤ │ `SCRIPT < FILE` │ stdin from FILE │ └────────────────────────┴─────────────────────────────────┘ ## Switch statement ```zsh case "$1" in start | up) vagrant up ;; *) echo "Usage: $0 {start|stop|ssh}" ;; esac ``` ### Options switch statement ```zsh while [[ "$1" =~ ^- && ! "$1" == "--" ]]; do case $1 in -V | --version ) echo "$version" exit ;; -s | --string ) shift; string=$1 ;; -f | --flag ) flag=1 ;; esac; shift; done if [[ "$1" == '--' ]]; then shift; fi ``` ## Functions ```zsh my_function() { echo "Hello, World!" } ``` ### Arguments ┌────┬───────────────────────────────────┐ │ `$#` │ Number of arguments │ ├────┼───────────────────────────────────┤ │ `$*` │ All arguments │ ├────┼───────────────────────────────────┤ │ `$@` │ All arguments as separate strings │ ├────┼───────────────────────────────────┤ │ `$1` │ First argument │ ├────┼───────────────────────────────────┤ │ `$_` │ Last argument │ └────┴───────────────────────────────────┘ ## Arrays ```zsh # Create an array in one line Fruits=('Apple' 'Banana' 'Orange') # Or assign each value Fruits[1]="Apple" Fruits[2]="Banana" Fruits[3]="Orange" # Associative array typeset -A sounds sounds[dog]="bark" sounds[cow]="moo" sounds[bird]="tweet" sounds[wolf]="howl" ``` ### Array element expansion ┌──────────────────────────────────────┬────────────────────────────────────┐ │ `${array[key]}` │ Element at `key` │ ├──────────────────────────────────────┼────────────────────────────────────┤ │ `${array[-1]}` │ Last element (not for associative) │ ├──────────────────────────────────────┼────────────────────────────────────┤ │ `${array[@]}` │ All elements │ ├──────────────────────────────────────┼────────────────────────────────────┤ │ `${#array}` │ Number of elements │ ├──────────────────────────────────────┼────────────────────────────────────┤ │ `${#array[key]}` │ String length of element at `key` │ ├──────────────────────────────────────┼────────────────────────────────────┤ │ `${array:n:length}`/`${array[n,length]}` │ `length` eements from position `n` │ ├──────────────────────────────────────┼────────────────────────────────────┤ │ `${(k)array}` │ Keys of all elements │ └──────────────────────────────────────┴────────────────────────────────────┘ ### Operations ```zsh Fruits=("${Fruits[@]}" "Watermelon") # Push Fruits+=('Watermelon') # Also Push Fruits=( "${Fruits[@]/Ap*/}" ) # Remove by regex match unset Fruits[3] # Remove one item Fruits=("${Fruits[@]}") # Duplicate Fruits=("${Fruits[@]}" "${Veggies[@]}") # Concatenate words=($(< datafile)) # From file (split by IFS) ``` ### Looping ```zsh for i in "${Fruits[@]}"; do echo "$i" done for val in "${(v)sounds}"; do echo "$val" done for key in "${(k)sounds}"; do echo "$key" done ``` ## Misc ### Directory of script ```zsh DIR="$( cd "$( dirname "${ZSH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" ``` ### Special variables ┌──────────────────┬───────────────────────────────────────────────┐ │ `$?` │ Exit status of last task │ ├──────────────────┼───────────────────────────────────────────────┤ │ `$!` │ PID of last background task │ ├──────────────────┼───────────────────────────────────────────────┤ │ `$$` │ PID of shell │ ├──────────────────┼───────────────────────────────────────────────┤ │ `$#` │ Number of arguments passed to script │ ├──────────────────┼───────────────────────────────────────────────┤ │ `$0` │ Filename of the shell script │ ├──────────────────┼───────────────────────────────────────────────┤ │ `$_` │ Last arugment of altest command │ ├──────────────────┼───────────────────────────────────────────────┤ │ `$argv` │ Array of all arguments passed to script │ ├──────────────────┼───────────────────────────────────────────────┤ │ `$ARGC` │ Number of arguments passed to script │ ├──────────────────┼───────────────────────────────────────────────┤ │ `${pipestatus[n]}` │ Return value of piped commands (array) │ ├──────────────────┼───────────────────────────────────────────────┤ │ `$RANDOM` │ Random number between 0 and 32767 │ ├──────────────────┼───────────────────────────────────────────────┤ │ `$SECONDS` │ Number of seconds since the shell was started │ ├──────────────────┼───────────────────────────────────────────────┤ │ `$PWD` │ Current working directory │ ├──────────────────┼───────────────────────────────────────────────┤ │ `$OLDPWD` │ Previous working directory │ └──────────────────┴───────────────────────────────────────────────┘