File indexing completed on 2024-05-12 04:02:11

 # basic types:
 echo 'single quoted string'
 echo "double quoted string"
 echo $'string with esc\apes\x0din it'
 echo $"string meant to be translated"
 
 
 # comments:
 # this is a comment
 #this too
 echo this is#nt a comment
 dcop kate EditInterface#1 #this is
 grep -e "^default/linux/amd64/" |\ #this is not a comment but #this is
 mkdir this\ isnt\ #a\ comment
 mkdir this\ isnt\\\;#a\ comment
 mkdir this\\ #is a comment
 
 # brace expansion
 mv my_file.{JPG,jpg}
 echo f.{01..100..3} f.{#..Z} f.{\{..\}} f.{$i..$j..$p}
 echo f.{01..100} f.{a..Z} f.{'a'..$Z}
 # no brace expansion
 echo f.{..100} f.{a..Z..}
 
 
 # special characters are escaped:
 echo \(output\) \&\| \> \< \" \' \*
 
 
 # variable substitution:
 echo $filename.ext
 echo $filename_ext
 echo ${filename}_ext
 echo text${array[$subscript]}.text
 echo text${array["string"]}.text
 echo short are $_, $$, $?, ${@}, etc.
 echo ${variable/a/d}
 echo ${1:-default}
 echo ${10} $10a
 echo $! $=!
 
 
 # expression subst:
 echo $(( cd << ed + 1 ))
 
 
 # command subst:
 echo $(ls -l)
 echo `cat myfile`
 
 
 # file subst:
 echo $(<$filename)
 echo $(</path/to/myfile)
 
 # process subst:
 sort <(show_labels) | sed 's/a/bg' > my_file.txt 2>&1
 
 
 # All substitutions also work in strings:
 echo "subst ${in}side string"  'not $inside this ofcourse'
 echo "The result is $(( $a + $b )). Thanks!"
 echo "Your homedir contains `ls $HOME |wc -l` files."
 
 
 # Escapes in strings:
 p="String \` with \$ escapes \" ";
 
 
 # keywords are black, builtins dark purple and common commands lighter purple
 set
 exit
 login
 
 
 # Other colorings:
 error() {
         cat /usr/bin/lesspipe.sh
         runscript >& redir.bak
         exec 3>&4
 }
 
 
 # do - done make code blocks
 while [ $p -lt $q ]
 do
         chown 0644 $file.$p
 done
 
 
 # braces as well
 run_prog | sort -u |
 {
         echo Header
         while read a b d
         do
                 echo $a/$b/$c
         done
         echo Footer
 }
 
 
 # Any constructions can be nested:
 echo "A long string with $(
         if [ $count -gt 100 ] ; then
                 echo "much"
         else
                 echo "not much"
         fi ) substitutions." ;
 
 
 # Even the case construct is correctly folded:
 test -f blaat &&
 (       do_something
         case $p in
                 *bak)
                         do_bak $p
                         ;;
                 *)
                         dont_bak $p
                         ;;
         esac
 ) # despite the extra parentheses in the case construction.
 
 
 # more control flow
 while :;
   break
   continue
   return
 done
 
 
 # variable assignments:
 DIR=/dev
 p=`ls`
 LC_ALL="nl" dcop 'kate*'
 _VAR=val
 ARR=(this is an array)
 ARR2=([this]=too [and]="this too")
 usage="$0 -- version $VERSION
 Multiple lines of output
 can be possible."
 ANSWER=yes      # here 'yes' isn't highlighed as command
 
 
 # Some commands expect variable names, these are colored correctly:
 export PATH=/my/bin:$PATH BLAAT
 export A B D
 local p=3  x  y='\'
 read x y z <<< $hallo
 unset B
 declare -a VAR1 VAR2 && exit
 declare less a && b
 declare a=(1 2)
 getopts :h:l::d arg
 read #comment
 let a=4+4 3+a b=c+3 d+3 d*4 # * is a glob
 
 # options are recoqnized:
 zip -f=file.zip
 ./configure  --destdir=/usr
 make  destdir=/usr/
 
 
 # [[ and [ correctly need spaces to be regarded as structure,
 # otherwise they are patterns (currently treated as normal text)
 if [ "$p" == "" ] ; then
         ls /usr/bin/[a-z]*
 elif [[ $p == 0 ]] ; then
         ls /usr/share/$p
 fi
 
 # Fixed:
 ls a[ab]*               # dont try to interprete as assignment with subscript (fixed)
 a[ab]
 a[ab]=sa
 
 
 # Here documents are difficult to catch:
 cat > myfile << __EOF__
 You're right, this is definitely no bash code
 But ls more $parameters should be expanded.
 __EOF__
 
 
 # quoted:
 cat << "EOF" | egrep "this" >&4   # the rest of the line is still considered bash source
 You're right, this is definitely no bash code
 But ls more $parameters should be expanded. :->
 EOF
 
 cat <<bla || exit
 bla bla
 bla
 
 
 # indented:
 if true
 then
         cat <<- EOF
                 Indented text with a $dollar or \$two
         EOF
 elif [ -d $file ]; then
         cat <<- "EOF"
                 Indented text without a $dollar
         EOF
 fi
 
 if ! { cmd1 && cmd2 ; }; then echo ok ; fi
 if ! {cmd1 && cmd2}; then echo ok ; fi
 if ! cmd1 arg; then echo ok ; fi
 
 case 1 in
 2) echo xxx;
 ;;
 ?) foo || yyy ; foo abc || echo abc ;;
 1) echo yyy;
 esac
 
 ls #should be outside of case 1 folding block
 
 for i in `ls tests/auto/output/*.html`; do
     refFile=`echo $i | sed -e s,build,src, | sed -e s,output,reference, | sed -e s,.html,.ref.html,`
     cp -v $i $refFile
 done
 
 ## >Settings >Configure Kate >Fonts & Colors >Highlitghing Text Styles >Scripts/Bash >Option >Change colors to some distinct color
 ## 1- In following line the -ucode should not be colored as option
 
 pacman -Syu --needed intel-ucode grub
 pacman -syu --needed intel-ucode grub
 
 [[ $line_name =~ \{([0-9]{1,})\}\{([0-9]{1,})\}(.*) ]]
 [[ $name =~ (.*)_(S[0-9]{2})(E[0-9]{2,3}[a-z]{0,1})_(.*) ]]
 rm /data/{hello1,hello2}/input/{bye1,$bye2}/si{a,${b},c{k,p{e,a}}}/*.non
 rm /data/{aa,{e,i}t{b,c} # Not closed
 rm /data/{aa,{e,i}t{b,c}}
 rm /data/{aa,{i}}
 rm /data{aa{bb{cc{dd}}}}
 rm /data{aaa`aaa}aa`aaa}a
 
 # TODO `
 
 # commands
 abc
 cp
 :
 .
 :#nokeyword
 path/cmd
 ec\
 ho
 2
 'a'c
 $ab
 ${ab}c
 \ a
 !a
 'a'[
 \ [
 !a[
 a{}d
 a{bc}d
 a{b,c}d
 a'b'c
 a$bc
 a${bc}d
 a\ b
 a!b
 
 # commands + params
 shortopt -ol -f/fd/fd -hfd/fds - -ol'a'b -f'a'/fd/fd -h'a'fd/fds
 longopt --long-a --long-b=value --file=* --file=file* --file=dir/file
 longopt --long-a'a'b --long'a'-b=value --fi'a'le=*
 noopt 3 3d -f -- -f --xx dir/file
 opt param#nocomment ab'a'cd ~a .a #comments
 path path/file dir/ / // 3/f a@/ 'a'/b d/'a'b a\ d/f f/f\
 ile
 path ~ ~/ ~a/ . .. ./a ../a
 path /path/* /path/f* /path/f@ /path/f@(|) {a/b} a{b}/c a/b{c} a/{b} a/{b}c
 glob ? * ?f *f f* f? **/ ~/* ~* /path/f* 'a'* 'a'f/?
 # ksh pattern is in conflict with extended pattern
 extglob @ @(*) @(f*|f??(f)) f!(+(?(@(*(f)f)f)f)f)f @'a'@(|) a@(?)
 echo *.*~(lex|parse).[ch](^D^l1)
 echo /tmp/foo*(u0^@:t) *(W,X) *(%W)
 subs f! f!! f!s 'a'!s \( $v {a,b} {a} {a}/d {a\,} {a,} {a,\},b} ds/{a,b}sa/s
 
 ls !?main
 ls $(echo NF)(:a)
 ls ${(s.:.)PATH} | grep '^...s'
 ls (#i)*.pmm
 ls (#ia1)README
 ls (*/)#bar
 ls (../)#junk2/down.txt(:a)
 ls (^(backup*|cache*|list*|tmp)/)##*(.)
 ls (_|)fred.php
 ls (dev*|fred*|joe*)/index*
 ls (x*~x[3-5])
 ls (xx|yy)
 ls *(*@)
 ls *(+nt)
 ls *(.)^php~*.c~*.txt
 ls *(.L-20)
 ls *(.L0)
 ls *(.Om[1,5])
 ls *(.^m0)
 ls *(.e#age 2017-10-01:00:00:00 2017-10-08:23:59:59#) /tmp
 ls *(.e-age 2018/09/01 2018/01/01-)
 ls *(.f644)
 ls *(.g:root:)
 ls *(.m-1)
 ls *(.mM+6)
 ls *(.mh+3)
 ls *(.mh-3)
 ls *(.mh3)
 ls *(.mw+2)
 ls *(.om[0,5]e-age 2017/09/01 2017/10/01-)
 ls *(.om[2,$]) old/
 ls *(.rwg:nobody:u:root:)
 ls *(.u:apache:)
 ls *(/)
 ls *(/^F)
 ls *(L0f.go-w.)
 ls *(Lk+100)
 ls *(Lm+2)
 ls *(R)
 ls *([1,10])
 ls *(^/,f44?,f.gu+w.,oL+rand,oe:"$cmd -x":P:echo::h)
 ls *(m4)
 ls *(mh0)
 ls *(mw3)
 ls *(${globqualifiers}N)
 ls *(\^'/')
 ls **.php
 ls **/*(#ia2)readme
 ls **/*(-@)
 ls **/*(.)
 ls **/*(.:g-w:)
 ls **/*(.Lm+10)
 ls **/*(D/e:'[[ -e $REPLY/index.php && -e $REPLY/index.html ]]':)
 ls **/*(u0WLk+10m0)
 ls **/*.(js|php|css)~(djr|libs|dompdf)/*~*/junk/*
 ls **/*.(js|php|css)~(libs|locallibs|test|dompdf)/*
 ls **/*.(php|inc)
 ls **/*.(php|inc)~(libs|locallibs)/*(.OL[1,5])
 ls **/*.txt(D.om[1,5])
 ls **/*~*(${~${(j/|/)fignore}})(.^*)
 ls **/*~*vssver.scc(.om[1,20])
 ls **/*~pdf/*(.m0om[1,10])
 ls **/^(vssver.scc|*.ini)(.om[1,20])
 ls **/^vssver.scc(.om[1,20])
 ls **/index.php~dev*(/*)##
 ls **/main.{php,js,css}
 ls *.(jpg|gif|png)(.)
 ls *.*(e-age 2018/06/01 now-)
 ls *.*(mM4)
 ls *.*~(lex|parse).[ch](^D^l1)
 ls *.*~[a-m]*(u:nobody:g:apache:.xX)
 ls *.c(#q:s/#%(#b)s(*).c/'S${match[1]}.C'/)
 ls *.c(:r)
 ls *.c~lex.c
 ls *.h~(fred|foo).h
 ls *.{aux,dvi,log,toc}
 ls *.{jpg,gif}(.N)
 ls *[^2].php~*template*
 ls *y(2|).cfm
 ls *y2#.cfm
 ls *~*.*(.)
 ls ./*(Om[1,-11])
 ls ./**/*(/od) 2> /dev/null
 ls ./**/*.(php|inc|js)
 ls ./**/*.{inc,php}
 ls ./*.back(#qN)
 ls ./{html,live}/**/*.(php|inc|js)~(**/wiki|**/dompdf)/*
 ls /path/**/*(.a+10e{'stat -sA u +uidr $REPLY; f[$u]="$f[$u]$REPLY"'})
 ls <-> <-6> <4-> <4-5> 0<-> {1..5} {2,3} {00..03} (4|5) [3-4]  [3-47-8] 0? ?2 *2
 ls =some_file
 ls DATA_[0-9](#c,4).csv
 ls DATA_[0-9](#c3).csv
 ls DATA_[0-9](#c4,).csv
 ls DATA_[0-9](#c4,7).csv
 ls PHP*/**/*.php
 ls [01]<->201[45]/Daily\ report*.csv(e#age 2014/10/22 now#)
 ls ^*.(css|php)(.)
 ls ^?*.*
 ls ^?*.*(D)
 ls ^?*.[^.]*(D)
 ls a(#c3).txt
 ls file<20->
 ls foot(fall)#.pl
 ls fred<76-88>.pl
 ls fred<76->.pl
 ls fred^erick*
 ls fred{09..13}.pl
 ls fred{joe,sid}.pl
 ls x*~(x3|x5)
 ls x*~^x[3,5]
 ls x*~x[3,5]
 ls x^[3,5]
 ls y2#.cfm y{2,}.cfm y(2|).cfm {y2,y}.cfm (y|y2).cfm y*.cfm
 ls {^dev*,}/index.php(.N)
 ls {_,}fred.php
 ls {p..q}<5->{1..4}.(#I)php(.N)
 ls ~1/*(.om[1])
 ls **/*.php~*junk*/*  #find all calls to mail, ignoring junk directories
 ls **/(*.cfm~(ctpigeonbot|env).cfm)
 ls **/*.{js,php,css}~(libs|temp|tmp|test)/*
 ls */*.php~libs/*~temp/*~test/*
 ls **/(*.cfm~(ctpigeonbot|env).cfm)~*((#s)|/)junk*/*(.)
 ls **/*.(js|php|css)~(libs|temp|test)/*
 ls **/*.(js|php|css)~libs/*~temp/*~test/*
 ls report/**/*.{inc,php}  # searching for a php variable
 ls *.log(Ne-age 2006/10/04:10:15 2006/10/04:12:45-)
 ls $(echo /c/aax/*(.om[1]))(+cyg) &
 ls *~vssver.scc(.om[1])
 ls /c/aax/*(.om[1]+cyg)
 ls ${(ps:\0:)"$(grep -lZ foobar ./*.txt(.))"}
 ls [[[[]]x*
 
 2 - f -f
 !a -f
 'a' -f
 $a -f
 ! cmd
 
 # coproc command (#460301)
 coproc ls thisfiledoesntexist 2>&1
 coproc { ls thisfiledoesntexist; read; } 2>&1
 
 # redirections (prefix)
 <<<s cat
 <<<'s' cat
 <<<'s's cat
 <<<s's's cat
 <<<s${s}s cat
 <<< s${s}s cat
 >&2 cat
 <f cat
 2>3 cat
 2>&3 cat
 2>& 3 cat
 2>f cat
 &>f cat
 2>>(xless) cat
 2<<(xless) cat
 2>>(xless)cat
 2<<(xless)cat
 
 # redirections
 cat f>2
 cat d/f>2
 cat d/f >2
 cat d/f >& 2
 cat >2 d/f
 cat > 2
 cat <(echo) <(echo a) <(echo a/f) <(echo ) <(echo a ) <(echo a/f )
 cat 2>>(xless)
 cat 2<<(xless)
 cat 2>&1 &>f &>>f 2<&1- 2<>f 2<<heredoc
 bla bla
 heredoc
 <<-'h' cat
 bla
 h
 <<"'" cat
 bla
 '
 cat <<heredoc
 bla bla
 heredoc
 cat <<heredoc -a
 bla bla
 heredoc
 r=$(xxx $@ 2>&1)
 
 # branches
 cat a|cat
 cat a&cat
 cat a||cat
 cat a&&cat
 cat a;cat
 cat a | cat
 cat a & cat
 cat a || cat
 cat a && cat
 cat a ; cat
 cat a'a';cat
 
 # substitutions
 echo '' 'a' '\' "" "a" "\\" "$a" "a""a"'a''a' a'b'c a"b"c a$'\n'c
 echo a!bc a{a}b a{b,c}d a{b,{d,e}}d a\ b
 echo a$bc a$b/c a${b}c a$((b-3))c a$(b)c a$(a b c)c
 echo ${a[*]} ${a[@]} ${a[${b}]} ${a:-x$z} ${a/g} ${a//f/f} ${a//f*/f*}
 echo ${!} ${!a} ${#a[1]} ${a:1:$b} $((++i,i--))
 echo ${a:^v} ${=a:/#%a#?*/bla} ${x#??(#i)} ${das:-{}<a.zsh}
 echo ${(f)"$(<$1)"} ${${(Az)l}[$2]} ${(f)"$(eval ${(q)@[2,$]})"}
 echo ${(@)foo} ${(@)foo[1,2]} ${${(A)name}[1]} ${(AA)=name=...} ${(Q)${(z)foo}}
 echo ${(ps.$sep.)val} ${(ps.${sep}.)val} ${(s.$sep.)val} ${(s.)(.)val}
 echo ${(pr:2+3::_::$d:)var} ${(r:2+3::_::$d:)var}
 echo ${${:-=cat}:h}
 $foo:h34:a:gs/dfs/fds/:s/fds/d'd'f xyz $foo: $foo:O $foo:A
 3=$foo:QQQ xyz $a[3,$]:h3:t1:e
 echo ${${~foo}//\*/*.c}
 echo !$ !!:$ !* !!:* !-2:2 !:-3 !:2* !:2- !:2-3 !^ !:1 !!:1
 echo "$bg[blue]$fg[yellow]highlight a message"
 echo "$bg[red]$fg[black]${(l:42::-:)}"
 echo "${${(@)foo[2,4]}[2]}"
 echo "${(j::)${(@Oa)${(s::):-hello}}}"
 echo "${(j::)${(@Oa)${(s::):-hello}}}"
 echo "<a href='$url'>$anchortext</a>"
 echo $(( sin(1/4.0)**2 + cos(1/4.0)**2 - 1 ))
 echo $a[${RANDOM}%1000] $a[${RANDOM}%11+10]
 echo $convtable[158]
 echo ${array[0]: -7 : +  22  }  ${array[1]: num  }
 echo ${parameter##word} ${parameter%%word}
 echo $f ' # $fred'
 echo $f:e $f:h $f:h:h $f:r $f:t $f:t:r $file:r
 echo ${(C)foo:gs/-/ /:r} ${(M)0%%<->} ${(j/x/s/x/)foo} ${(l:$COLUMNS::-:)}
 echo ${(l:3::0:)${RANDOM}} ${(s/x/)foo%%1*} ${0##*[!0-9]}
 echo ${a:2:2} ${a:2} ${a[1,3]} ${d/#?/} ${d/%?/} ${d[1,-2]} ${d[2,$]}
 echo ${d[2,-1]} ${file##*/} ${file%.*} ${texfilepath%/*.*} *(f:u+rx,o-x:)
 echo *(f:u+rx:) **/*(@-^./=%p) **/*(@-^./=%p) convert_csv.php(:a)
 cd $(locate -l1 -r "/zoo.txt$")(:h) # cd to directory of first occurence of a file zoo.txt
 cd ${$(!!)[3]:h}  # cd to 3rd in list
 cd ${$(locate zoo.txt)[1]:h}
 cd ${drive}/inetpub/wwwdev/www.some.co.uk/
 cd **/*.php(.om[1]:h) # cd to directory of newest php file
 cd -
 cd /tmp/test/;touch {1..5} {6,7,8,12} {00..03}
 cd ~www/admin
 chmod g+w **/*
 chmod someuser /**/*(D^u:${(j.:u:.)${(f)"$(</etc/passwd)"}%%:*}:)
 cp *.mp3(mh-4) /tmp # copy files less than 4 hours old
 cp -a file1 file   # -a transfer  permissions etc of file1 to file2preserve
 file **/*(D@) | fgrep broken
 file **/*(D@) | fgrep broken
 file=${1/#\//C:\/} # substitute / with c:/ Beginning of string
 file=${1/%\//C:\/} # substitute / with c:/ End of string
 file=${1/\//C:\/} # substitute / with c:/ ANYWHERE in string
 filelst+=($x)
 filelst[$(($#filelst+1))]=$x
 files=(${(f)"$(egrepcmd1l)"} )
 files=(${(f)"$(ls *$**)"}(.N)) # ")`
 files=(**/*(ND.L0m+0m-2))
 mkdir $f:h;touch $f
 mv Licence\ to\ Print\ Money.pdf !#^:gs/\\ //
 path=(${path:#$path_to_remove})
 path=(${path:|excl})
 pattern=${(b)str}
 pattern=${(q)str}
 print "$aa[one\"two\"three\"quotes]"
 print "$bg[cyan]$fg[blue]Welcome to man zsh-lovers" >> $TTY
 print $(( [#8] x = 32, y = 32 ))
 print $((${${(z)${(f)"$(dirs -v)"}[-1]}[1]} + 1)) # or
 print $(history -n -1|sed 's/.* //')
 print $aa[(e)*]
 print $ass_array[one]
 print $x $y
 print ${#path[1]}       # length of first element in path array
 print ${#path}          # length of "path" array
 print ${$( date )[2,4]} # Print words two to four of output of ’date’:
 print ${$(/sbin/ifconfig tun0)[6]}
 print ${${$( LC_ALL=C /sbin/ifconfig lo )[6]}#addr:}
 print ${${$(LC_ALL=C /sbin/ifconfig eth0)[7]}:gs/addr://}
 print ${${(Cs:-:):-fred-goat-dog.jpg}%.*}
 print ${${(z)$(history -n -1)}[-1]}
 print ${${(z)history[$((HISTCMD-1))]}[-1]}
 print ${(L)s// /-}.jpg
 print ${(L)s:gs/ /-/}.jpg
 print ${(S)foo//${~sub}/$rep}
 print ${(k)ass_array} # prints keys
 print ${(v)ass_array} # prints values
 print ${JUNK/%./_}                 # substitute last . for a _
 print ${JUNK/.(#e)/_}              # substitute last . for a _
 print ${arr//(#m)[aeiou]/${(U)MATCH}}
 print ${array:t}
 print ${foo%%$'\n'}                # strip out a trailing carriage return
 print ${foo//$'\n'}                # strip out any carriage returns (some systems use \r)
 print ${foo//${~sub}/$rep}
 print ${foo: 1 + 2}
 print ${foo:$(( 1 + 2))}
 print ${foo:$(echo 1 + 2)}
 print ${foo:3}
 print ${param:&}   (last substitute)
 print ${somevar//[^[:alnum:]]/_}   # replace all non-alphanumerics with _ the // indicates global substitution
 print ${string[(r)d?,(r)h?]}
 print '\e[1;34m fred'
 print (*/)#zsh_us.ps
 print *(e:age 2006/10/04 2006/10/09:)
 print **/*(/^F) | xargs -n1 -t rmdir #delete empty directories
 print *.c(e_'[[ ! -e $REPLY:r.o ]]'_)
 print -C 1 $X           # print each array element on it's own line
 print -l "${(s.:.)line}"
 print -l $MATCH X $match
 print -l $accum
 print -l *(n:t)      # order by name strip directory
 print -l **/*(-@)
 print -l **/*(On:t)  # recursive reverse order by name, strip directory
 print -r -- $^X.$^Y
 print -r -- ${(qq)m} > $nameoffile      # save it
 print -rC1 /tmp/foo*(u0^@:t)
 print -rC1 b*.pro(#q:s/pro/shmo/)(#q.:s/builtin/shmiltin/)
 print -rC2 -- ${1:[...]}/*(D:t)
 print -rl $HOME/${(l:20::?:)~:-}*
 print -rl -- ${${=mapfile[/etc/passwd]}:#*(#i)root*}
 print -rl /**/*~^*/path(|/*)
 print {$((##n))..$((##y))}P\ 10P | dc
 print root@192.168.168.157:${PWD/test/live}v
 
 
 # conditions
 [ a ]
 [ -f f'f'f ]
 [ -f f]'f'f] ]
 [ -t 13 ]
 [ -t 13] ]
 [ -t 13] ]
 [ -v abc ]
 [ -z abc ]
 [ abc -ef abc ]
 [ abc -ef abc ]
 [ abc-ef -ef abc-ef ]
 [ abc == abc ]
 [ abc < abc ]
 [ abc -eq abc ]
 [[ abc -eq abc ]]
 [ 1+2 -eq 1+2 ]
 [[ 1+2 -eq 1+2 ]]
 [ a = b c ]
 [ -z 1 -a 1 -eq 1 ]
 [ 2 -eq 1 -o 1 -eq 1 ]
 ( [ a = b ] )
 ([ a = b ])
 [[ a = b c ]]
 [[ x =~ a(b c|$)' '{1,}[a[.digit.]] ]]
 [[ x =~ [ ] ]]
 [[ x =~ ([ ]) ]]
 [[ x =~ [ ]]
 [[ x =~ ([) ]]
 [[ (a =~ a) ]]
 [[ (a =~
 a) ]]
 [[ a =~ a || a -eq 2 ]]
 [[ (a =~ a) || a -eq 2 ]]
 [[ a<b ]]
 [[ a <b ]]
 [[ a< b ]]
 [[ a < b ]]
 [[(! -d .)]]
 [[ ! -d . ]]
 [[ !(-d .) ]]
 [[ -f a || -f b ]]
 [[ -f a||-f b ]]
 [[ ! (a -eq b) ]]
 [ -d `echo .`] ]
 [[ -d `echo .`]] ]]
 [[ a != b && ${a}a = b${b} ]]
 [[
   1 -eq 2
 ]]
 [[
   1
   -eq
   2
 ]]
 [[ -""(#i)* == $x ]]
 [[ ]]
 [[ -f ]]
 [[ -f <0-99> ]]
 [[ $1 == <-> ]]
 [[ ?*<0-99> = <0-99> ]]
 [[ -f = ?*<0-99> ]]
 [[ a/sa[s = dsad?*<0-9>dsa$ds ]]
 [[ a/sa[s = dsad?*<0-9>ds/a$ds ]]
 [[ a =~ <1-2>a<->a<-2>a<2->a([!d]a?s[x[:alnum:]]|d?)p ]]
 [[ -n file*(#qN) ]]
 [[ ( -f foo || -f bar ) && $report = y* ]] && print File exists.
 [[ $str = ${~pattern} ]]
 [[ $str = ${~pattern} ]]
 [[ "?" = ${(~j.|.)array} ]]
 ( [[ a = b ]] )
 ([[ a = b ]])
 
 [[ #comm1
  #comm2
  ! #comm3
  p[1] #comm4
  == #comm5
  p[2] #comm6
  #comm7
  #comm8
 ]]
 
 [[ #comm1
  #comm2
  -f #comme3
  #comm4
  p[2] #comm5
  #comm6
  #comm7
 ]]
 
 [ a -eq 2 ] || [ a -eq 2] ] && [[ a -eq 2 ]] || [[ a != b ]];
 [ a -eq 2 ]||[ a -eq 2] ]&&[[ a -eq 2 ]]||[[ a != b ]];
 
 ((3+1+a+$c*(x) & 0x4342_2fd+03-08_5/23#D9a@_^8))
 ((1.3/(2-(a-4))))
 
 # they are not arithmetic evaluations...
 ((cmd && cmd) || cmd)
 $((cmd && cmd) || cmd)
 ((cmd &&
 cmd) || cmd)
 $((cmd &&
 cmd) || cmd)
 
 print $(( [#_] sqrt(1e7) 0__39 1423e23 .2443 43.34 34.43e4 .d))
 
 { echo
     echo
 }
 { echo ; }
 { echo }
 {echo}
 {ls f} always {ls}
 {echo {a}}
 }echo
 echo {a} {a/b} a{b}/c a/b{c} a/{b} a/{b}c d/{{a}}
 echo {a{a{a}}}
 echo {a{a{a}a}a}a
 echo {a
 echo a}
 echo{a}
 echo{a{a{a}}}
 echo{a{a{a}a}a}a
 echo{a
 echo}
 
 { {echo a} }
 { {echo a}a} }
 { { echo a } }
 { { echo a}a } }
 
 { {echo a/b} }
 { {echo a/b}a} }
 { { echo a/b } }
 { { echo a/b}a } }
 
 { {echo >a/b} }
 { {echo >a/b}a} }
 { { echo >a/b } }
 { { echo >a/b}a } }
 
 {ab}c}
 {a,b}c}
 {ab}[}
 {a,b}[}
 
 cat >f{oo,ar}
 
 (echo ; echo)
 (echo
     echo)
 (echo a)
 test a -eq b
 
 # functions
 a() { echo x; }
 a  () { echo x; }
 function f { echo x; }
 kde.org() { echo x; }
 --func() { echo x; }
 noglob function f { echo x; }
 
 # variables
 a=(a b c)
 a='a'
 a+=b
 a[1]='a'
 a[$i]='x'
 a[$((
     2+4
 ))]='x'
 a=([a]=2 `echo` -s > 'ds')
 a=(#comment
 value#nocomment #comment)
 )
 a=a cat
 a=`ls` cat
 a[2+3][d]=5
 
 # control structure
 for name in a b c {d,e} ; do echo ; done
 for name; do echo ; done
 for name do echo ; done
 for ((i=0;i<5;++i)) ; do echo $i ; done
 for ((i=1;$#A[i];i++)) echo $A[$i]
 for c ({1..50}) {php ./test.php; sleep 5;}
 for count in {1..10}; do echo $count ; done
 for f (*(.)) mv $f fixed_$f
 for f (**/x) cp newx $f
 for f (*.txt) { echo $f }
 for f in **/x; do;cp newx $f; done
 for f in */include/dbcommon.php; do;cp dbcommon.php $f; done
 for file (*(ND-.)) IFS= read -re < $file
 for i (./*.mp3){mpg321 --w - $i > ${i:r}.wav}
 for i in *(.); mv $i ${i:u} # `bar to `BAR
 for i in **/*(D@); [[ -f $i || -d $i ]] || echo $i
 for i in **/*.gif; convert $i $i:r.jpg
 for i in {3,4}; sed s/flag=2/flag=$i/ fred.txt > fred$i.txt
 for ip ({217..219} 225) {echo -n $ip ;ping -n 1 11.2.2.$ip| grep Received}
 for user (${(k)f}) {print -rn $f[$user]|mailx -s "..." $user}
 for x ( 1 2 {7..4} a b c {p..n} *.php) {echo $x}
 select name in a ; do echo ; done
 select name; do echo ; done
 if : ; then echo ; elif [[ : ]] ; then echo ; else echo ; fi
 if [ $# -gt 0 ];then string=$*;else;string=$(getclip);fi
 if [ $# -gt 0 ];then string=$*;else;string=$(getclip);fi # get parameter OR paste buffer
 if [[ (($x -lt 8) && ($y -ge 32)) || (($z -gt 32) && ($w -eq 16)) ]] ; then print "complex combinations"; fi
 if builtin cd $1 &> /dev/null ; then echo ; fi
 if grep -iq 'matching' *.php ;then echo "Found" ;else echo "Not Found"; fim=("${(@Q)${(z)"$(cat -- $nameoffile)"}}") fi
 while : || : ; do echo ; done
 while (true){echo -n .;sleep 1}
 while (true){echo .;sleep 1}
 while true ;do date; sleep 5; done # forever
 while true; do echo "infinite loop"; sleep 5; done
 until : ; : ; do echo ; done
 case a in a) esac
 case a in a) echo ; esac
 case pwd in (patt1) echo ; echo ;; (patt*) echo ;& patt?|patt) echo ;|
 patt) echo ;; esac
 repeat 1+2+`echo 1`+23 do echo pl; done
 repeat 3 time sleep 3   # single command
 repeat 5 ;do date; sleep 5; done # multi
 foreach x y z ( a `a b`; c ) echo ;end
 for x y ( a b bc d ds ) echo $x $y
 for x y in a b c ; echo $x $y
 for x y ; echo $x $y
 case w { a) echo ;& (b?) echo }
 case a in
 #a) echo ;;
 a#) echo ;;
 esac
 
 for name in a
  b c ;
 do
 echo
 done
 
 case a in
   a\( | b*c? ) echo
   (b$c) # no pattern
   ;;
   (b$c) ;;
   # no pattern
   (b$c)
 esac
 
 case "$1" in
  "a") run_a|&a;;
  "b") run_b;;
  "c") run_c;;
  *) echo "Plase choose between 'a', 'b' or 'c'" && exit 1;;
 esac
 
 case $ans in
  1|a) sdba $key;;
  2|f) sdbf $key;;
  3|i) sdbi $key;;
  *) echo "wrong answer $ans\n" ;;
 esac
 
 case "$ans" in
  2|${prog}9) cd "$(cat /c/aam/${prog}9)" ;;
  **) echo "wrong number $ans\n" ;;
 esac
 
 select f in $(ls **/*.tex |egrep -i "${param}[^/]*.tex")
 do
  if [[ "$REPLY" = q ]]
  then
     break
  elif [[ -n "$f" ]]; then
     gvim $f
  fi
 done
 
 for d (. ./**/*(N/m-2)) {
   print -r -- $'\n'${d}:
   cd $d && {
      l=(*(Nm-2))
      (($#l)) && ls -ltd -- $l
      cd ~-
   }
 }
 
 for f in http://zsh.sunsite.dk/Guide/zshguide{,{01..08}}.html; do
     lynx -source $f >${f:t}
 done
 
 for f in ./**/*(-@); do
     stat +link -A l $f
     (cd $f:h & [[ -e $l.gz ]]) & ln -sf $l.gz $f
 done
 
 for ((i=1; i <= $#fpath; ++i)); do
     dir=$fpath[i]
     zwc=${dir:t}.zwc
     if [[ $dir == (.|..) || $dir == (.|..)/* ]]; then
         continue
     fi
     files=($dir/*(N-.))
     if [[ -w $dir:h && -n $files ]]; then
         files=(${${(M)files%/*/*}#/})
         if ( cd $dir:h &&
             zrecompile -p -U -z $zwc $files ); then
         fpath[i]=$fpath[i].zwc
         fi
     fi
 done
 
 if ztcp pwspc 2811; then
     tcpfd=$REPLY
     handler() {
         zle -I
         local line
         if ! read -r line <&$1; then
             # select marks this fd if we reach EOF,
             # so handle this specially.
             print "[Read on fd $1 failed, removing.]" >&2
             zle -F $1
             return 1
         fi
         print -r - $line
     }
     zle -F $tcpfd handler
 fi
 
 while [[ $? -eq 0 ]] do
     b=($=ZPCRE_OP)
     accum+=$MATCH
     pcre_match -b -n $b[2] -- $string
 done
 
 # bug #380229
 ${str:$((${#a[1]}+1))}
 
 # from http://zshwiki.org/home/examples/hardstatus
 function title {
   if [[ $TERM == "screen" ]]; then
     # Use these two for GNU Screen:
     print -nR $'\033k'$1$'\033'\\
 
     print -nR $'\033]0;'$2$'\a'
   elif [[ $TERM == "xterm" || $TERM == "rxvt" ]]; then
     # Use this one instead for XTerms:
     print -nR $'\033]0;'$*$'\a'
   fi
 }
 
 function precmd {
   title zsh "$PWD"
 }
 
 function preexec {
   emulate -L zsh
   local -a cmd; cmd=(${(z)1})
   title $cmd[1]:t "$cmd[2,-1]"
 }
 
 function ddump(){diff -w ~dump/"$1" "$1"}   # diff local file with new one in dump
 function g{0..9} { gmark $0 $* }          # declaring multiple functions
 function hello_function { echo "hello world" ; zle .accept-line}
 function scd(){setopt nonomatch;e=/dev/null;cd $1(/) &> $e||cd $1*(/) &> $e||cd *$1(/) &> $e||cd *${1}*(/) &> $e||echo sorry}
 function vx{0..9} {gvim.exe c:/aax/${0/#v/} &}
 function {xyt,xyy} { if [ "$0" = "xyy" ]; then echo run xyy code; else  echo run xyt code; fi ; echo run common code } #
 
 # creating a family of functions
 # generate hrefs from url
 function href{,s}
 {
     # href creates an HTML hyperlink from a URL
     # hrefs creates an HTML hyperlink from a URL with modified anchor text
     PROGNAME=`basename $0`
     url=`cat /dev/clipboard`
     if [ "$PROGNAME" = "href" ] ; then
         href="<a href='$url'>$url"
     elif [ "$PROGNAME" = "hrefs" ] ; then
         anchortext=${${(C)url//[_-]/ }:t}
         href="<a href='$url'>$anchortext"
     fi
     echo -n $col
     echo $href > /dev/clipboard | more
 }
 
 # create vim scratch files va,vb to vz
 function vx{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q,r,s,t,u,v,w,x,y,z}
 {
     scratchfile=${0/#v/}
     gvim.exe c:/aax/$scratchfile &
 }
 
 VDF(){cd *(/om[1]);F=$(echo *(.om[1]));vi $F}
 cyg(){reply=("$(cygpath -m $REPLY)")}
 f  (){for i; do echo $i;done}
 fg_light_red=$'%{\e[1;31m%}'
 fn() { setopt localtraps; trap '' INT; sleep 3; }
 nt() { [[ $REPLY -nt $NTREF ]] }
 preexec(){ echo using $@[1]}
 take(){[ $# -eq 1 ]  && mkdir "$1" && cd "$1"} # create a directory and move to it in one go
 
 caption always "%3n %t%? (%u)%?%?: %h%?"
 
 preexec() {
   emulate -L zsh
   local -a cmd; cmd=(${(z)1})             # Re-parse the command line
 
   # Construct a command that will output the desired job number.
   case $cmd[1] in
       fg)
         if (( $#cmd == 1 )); then
           # No arguments, must find the current job
           cmd=(builtin jobs -l %+)
         else
           # Replace the command name, ignore extra args.
           cmd=(builtin jobs -l ${(Q)cmd[2]})
         fi;;
        %*) cmd=(builtin jobs -l ${(Q)cmd[1]});; # Same as "else" above
        exec) shift cmd;& # If the command is 'exec', drop that, because
           # we'd rather just see the command that is being
           # exec'd. Note the ;& to fall through.
        *)  title $cmd[1]:t "$cmd[2,-1]"    # Not resuming a job,
           return;;                        # so we're all done
       esac
 
   local -A jt; jt=(${(kv)jobtexts})       # Copy jobtexts for subshell
 
   # Run the command, read its output, and look up the jobtext.
   # Could parse $rest here, but $jobtexts (via $jt) is easier.
   $cmd >>(read num rest
           cmd=(${(z)${(e):-\$jt$num}})
           title $cmd[1]:t "$cmd[2,-1]") 2>/dev/null
 }
 
 function precmd() {
   title zsh "$IDENTITY:$(print -P %~)"
 }
 
 "%{^[]0;screen ^En (^Et) ^G%}"
 
 print -nRP $'\033k%(!.#\[.)'$1$'%'$\(\(20\-${#1}\)\)$'< ..<'${${2:+${${${@[${#${@}}]##/*/}/#/ }:-}}//\"/}$'%(!.\].)\033'\\
 
 c() { echo -E "$(<$1)" }
 col() { for l in ${(f)"$(<$1)"} ; echo ${${(Az)l}[$2]} }
 colx() { for l in ${(f)"$(eval ${(q)@[2,$]})"} ; echo ${${(Az)l}[$1]} }
 
 [[ -r /etc/ssh/ssh_known_hosts ]] && _global_ssh_hosts=(${${${${(f)"$(</etc/ssh/ssh_known_hosts)"}:#[\|]*}%%\ *}%%,*}) || _global_ssh_hosts=()
 _ssh_hosts=(${${${${(f)"$(<$HOME/.ssh/known_hosts)"}:#[\|]*}%%\ *}%%,*}) || _ssh_hosts=()
 _ssh_config=($(cat ~/.ssh/config | sed -ne 's/Host[=\t ]//p')) || _ssh_config=()
 : ${(A)_etc_hosts:=${(s: :)${(ps:\t:)${${(f)~~"$(</etc/hosts)"}%%\#*}##[:blank:]#[^[:blank:]]#}}} || _etc_hosts=()
 
 prefix='(I:'$@[$(($i+1))]':)'$prefix || prefix='${('$tmp'I:'$@[$(($i+1))]':'${prefix[$(($#tmp+4)),-1]}
 prefix='${'${j:+($j)}$prefix; suffix+=':#'${@[$(($i+1))]//(#m)[\/\'\"]/\\$MATCH}'}'
 cmd+='<'${(q)@[$(($i+1))]}';'
 C=${OPTARG//(#m)[[\/\'\"\\]/\\$MATCH}
 $=p $e'"$(<'${(j:<:)${(q)@}}')"'$m
 
 zshaddhistory() {
     print -sr -- ${1%%$'\n'}
     fc -p .zsh_local_history
 }
 
 TRAPINT() {
     print "Caught SIGINT, aborting."
     return $(( 128 + $1 ))
 }
 
 zsh_directory_name() {
     emulate -L zsh
     setopt extendedglob
     local -a match mbegin mend
     if [[ $1 = d ]]; then
         # turn the directory into a name
         if [[ $2 = (#b)(/home/pws/perforce/)([^/]##)* ]]; then
             typeset -ga reply
             reply=(p:$match[2] $(( ${#match[1]} + ${#match[2]} )) )
         else
             return 1
         fi
     elif [[ $1 = n ]]; then
         # turn the name into a directory
         [[ $2 != (#b)p:(?*) ]] && return 1
         typeset -ga reply
         reply=(/home/pws/perforce/$match[1])
     elif [[ $1 = c ]]; then
         # complete names
         local expl
         local -a dirs
         dirs=(/home/pws/perforce/*(/:t))
         dirs=(p:${^dirs})
         _wanted dynamic-dirs expl 'dynamic directory' compadd -S\] -a dirs
         return
     else
         return 1
     fi
     return 0
 }
 
 () {
     print File $1:
     cat $1
 } =(print This be the verse)
 
 if [[ $foo = (a|an)_(#b)(*) ]]; then
     print ${foo[$mbegin[1],$mend[1]]}
 fi
 
 zshaddhistory() {
     emulate -L zsh
     ## uncomment if HISTORY_IGNORE
     ## should use EXTENDED_GLOB syntax
     # setopt extendedglob
     [[ $1 != ${~HISTORY_IGNORE} ]]
 }
 
 pick-recent-dirs-file() {
     if [[ $PWD = ~/text/writing(|/*) ]]; then
         reply=(~/.chpwd-recent-dirs-writing)
     else
         reply=(+)
     fi
 }
 
 run-help-ssh() {
     emulate -LR zsh
     local -a args
     # Delete the "-l username" option
     zparseopts -D -E -a args l:
     # Delete other options, leaving: host command
     args=(${@:#-*})
     if [[ ${#args} -lt 2 ]]; then
         man ssh
     else
         run-help $args[2]
     fi
 }
 
 local -A zdn_top=(
     g   ~/git
     ga  ~/alternate/git
     gs  /scratch/$USER/git/:second2
     :default: /:second1
 )
 
 (( $#files > 0 )) && print -rl -- $files | \
     mailx -s "empty files" foo [at] bar.tdl
 
 print -r -- $s[3] ${(l:4:)s[4]} ${(l:8:)s[5]} \
     ${(l:8:)s[6]} ${(l:8:)s[8]} $s[10] $f ${s[14]:+-> $s[14]}
 
 paste <(cut -f1 file1) <(cut -f3 file2) |
     tee >(process1) >(process2) >/dev/null
 
 ls \
 > x*
 
 sed '
  s/mvoe/move/g
  s/thier/their/g' myfile
 
 
 trap '
     # code
     ' NAL
 
 !! # previous command
 !!:0 !^ !:2 !$ !#$ !#:2 !#1 !#0
 !!:gs/fred/joe/       # edit previous command replace all fred by joe
 !!:gs/fred/joe/       # edit previous command replace all fred by joe
 !!:s/fred/joe/        # Note : sadly no regexp available with :s///
 !!:s/fred/joe/        # edit previous command replace first fred by joe
 !$ (last argument of previous command)
 !$:h (last argument, strip one level)
 !$:h:h (last argument, strip two levels)
 !-2 # command before last
 !1 # oldest command in your history
 !42                   # Re-execute history command 42
 !42:p
 !?echo
 !?saket?:s/somefile1/somefile2/
 
 (($#l)) && ls -ltd -- $l
 ((val2 = val1 * 2))
 (mycmd =(myoutput)) &!
 : *(.e{'grep -q pattern $REPLY || print -r -- $REPLY'})
 : > /apache/access.log  # truncate a log file
 < readme.txt
 A=(1 2 5 6 7 9) # pre-populate an array
 C:\cygwin\bin\mintty.exe -i /Cygwin-Terminal.ico /bin/zsh --login
 C=3 && F=$(print *(.om[1,$C])) && for f ($(print $F)){php -l $f} && scp -rp $(print $F) user@192.168.1.1:$PWD
 EDITOR='/bin/vim'
 FILE=$(echo *(.om[1])) && ls -l $FILE && ssh 192.168.1.1 -l root "zsh -c 'ls -l $PWD/$FILE'"
 FILES=( .../files/* )
 IFS=$'\n\n'; print -rl -- ${(Oau)${(Oa)$(cat file;echo .)[1,-2]}}
 IPREFIX=${PREFIX%%\=*}=
 PREFIX=${PREFIX#*=}
 PROMPT3="Choose File : "
 PROMPT="%{$bg[cyan]%}%% "
 PS3="$fg_light_red Select file : "
 REPORTTIME=10 # Automatically /Report CPU usage for commands running longer than 10 seconds
 RPROMPT="[%t]" (display the time)
 X=(x1 x2)
 Y=(+ -)
 [[ "$(< $i)" = *\((${(j:|:)~@})\)* ]] && echo $i:h:t
 [[ $OSTYPE == (#i)LINUX*(#I) ]];
 [[ 'cell=456' =~ '(cell)=(\d+)' ]] && echo $match[1,2] $MATCH
 [[ -e $L/config.php ]] && cp -p -update $T/config.php $L
 [[ -n ${key[Left]} ]] && bindkey "${key[Left]}" backward-char
 [[ 1 = 0 ]] && echo eq || echo neq
 [[ alphabetical -regex-match ^a([^a]+)a([^a]+)a ]] &&
 ^chim^&-&ney-&-&-cheree # reuse LHS
 ^fred^joe             # edit previous command replace fred by joe
 ^php^cfm          # modify previous command (good for correcting spellos)
 ^str1^str2^:G         # replace as many as possible
 ^str1^str2^:u:p       # replace str1 by str2 change case and just display
 a=(**/*(.D));echo $#a  # count files in a (huge) hierarchy
 a=(1 2 3 4); b=(a b); print ${a:^b}
 a=(a b); b=(1 2); print -l "${a:^b}"; print -l "${${a:^b}}"
 a=12345
 aa[(e)*]=star
 accum=()
 alias '..'='cd ..'
 alias -g ...='../..'
 alias -g NF='*(.om[1])' # newest file
 alias gcd="cd $MCD"  # double quote stops once only evaluation
 alias mcd="MCD=$(pwd)"  # double quote stops once only evaluation
 anchortext=${${(C)url//[_-]/ }:t}  # titlecase
 arr=(veldt jynx grimps waqf zho buck)
 array=(~/.zshenv ~/.zshrc ~/.zlogout)
 autoload edit-command-line
 autoload -Uz up-line-or-beginning-search
 autoload colors ; colors
 bindkey "^N" most-recent-file
 bindkey -s "^[OS" "\^d\^c\n"
 bindkey -s "^[[18~" "ls -l\n"
 c=(*.c) o=(*.o(N)) eval 'ls ${${c:#(${~${(j:|:)${o:r}}}).c}:?done}'
 cd !$:h
 cd !?ls
 diff <(find / | sort) <(cat /var/lib/dpkg/info/*.list | sort)
 dpath=${upath/#\/c\//c:/}          # convert /c/path/ to c:\path\
 drive=$([[ "$LOGNAME" != davidr ]] && echo '/o' || echo '/c') # trad way
 drive=${${${LOGNAME:#davidr}:+/o}:-/c}                        # zsh way
 egrep -i "^ *mail\(" **/*.php
 eval "$1=$PWD"
 eval "m=($(cat -- $nameoffile)"
 feh $FILES[$RANDOM%$#FILES+1]
 foo="twinkle twinkle little star" sub="t*e" rep="spy"
 foo=$'bar\n\nbaz\n'
 foo=fred-goat-dog.jpg
 fred=$((6**2 + 6))      # can do maths
 (( $# == 0 ));
 [ "$p1" = "end" ] || [ "$p1" = "-e" ]
 [ $# -gt 0 ]  # parameter cnt > 0 (arguments)
 [ $cnt -eq 1 ]
 [[ "$1" == [0-9] ]]  # if $1 is a digit
 [[ "$p2" == *[a-zA-Z][a-zA-Z][a-zA-Z]* ]]  # contains at least 3 letters
 [[ "$pwd" == *$site2* ]]
 [[ "$url" = www* ]] # begins with www
 [[ -e /c/aam/z$1 ]]  # file exists
 p1 p2 p3
 pcre_compile -m "\d{5}"
 pcre_match -b -- $string
 perl -ne 's/(<\/\w+>)/$1\n/g; print' < NF > $(print NF).txt
 ps -p $$ | grep $$ | awk '{print $NF}'
 r oldstr=newstr
 r\m $(locate nohup.out)
 read -r line <&$fd; print -r - $line
 read ans ; # read in a parameter
 setopt EXTENDED_GLOB   # lots of clever stuff requires this
 source ${ZDOTDIR:-$HOME}/.zkbd/$TERM-$VENDOR-$OSTYPE
 ssh -t root@192.18.001.001 'sh -c "cd /tmp && exec zsh -l"'
 ssh 192.168.1.218 -l root "zsh -c 'for i (/usr/*(/)) {ls \$i }'"
 sshpass -p myppassword scp -rp * user@18.128.158.158:${PWD/staging/release}
 str=aa,bb,cc;print ${(j:,:)${(qq)${(s:,:)str}}} # quotify a string
 tel blenkinsop | grep -o "[[:alnum:][:graph:]]*@[[:alnum:][:graph:]]*" # filter just an email address from a text stream (not zsh)
 touch {t,p}{01..99}.{php,html,c}  # generate 600 test files
 touch {y,y2}.cfm
 trap - INT
 typeset "aa[one\"two\"three\"quotes]"=QQQ
 typeset -A aa
 typeset -A ass_array; ass_array=(one 1 two 2 three 3 four 4)
 typeset -A convtable
 typeset -i 16 y
 unsetopt XTRACE VERBOSE
 unsetopt localtraps
 upath=${wpath//\\/\/}              # convert backslashes to forward slashes (Dos to Unix
 url='www.some.com/some_strIng-HERe'
 val=a:b:c
 var=133;if [[ "$var" = <-> ]] ; then echo "$var is numeric" ;fi
 var=ddddd; [[ "$var" =~ ^d+$ ]] && echo matched || echo did not match
 var=dddee; regexp="^e+$"; [[ "$var" =~ $regexp ]] && echo $regexp matched $var || echo $regexp did not match $var
 vared -p "choose 1-3 : " -c ans
 vared PATH
 whence -vsa ${(k)commands[(I)zsh*]}  # search for zsh*
 widget
 wpath=${wpath//\//\\\\}            # substitute Unix / with dos \ slashes
 x=$?
 zmodload -F zsh/stat b:zstat
 zsh -lxic : 2> >(grep "> alias 'web'")
 { paste <(cut -f1 file1) <(cut -f3 file2) } > >(process)