zsh-lovers - Bulutta Çevrimiçi

Program:

ADI

zsh-severler - Z kabuğu için ipuçları, püf noktaları ve örnekler

SİNOPSİS

Sadece oku. ;-)

GENEL BAKIŞ

Ne zaman zsh kılavuzuna baksak, neden hiçbir örnek olmadığını ya da sadece bunların olmadığını merak ediyoruz.
(kabuk) hayattaki şeyler. Zsh birçok özellik içeriyor, ancak bazı özelliklerin yer aldığı bir kılavuz sayfası yoktu.
örnekler (gibi procmailex(5)). Bu kılavuz sayfasını bu yüzden yazdık.

Hilelerin ve oneliner'ın çoğu zsh-users, zsh-workers, google posta listelerinden geliyor.
haber gruplarından ve kendimizden. Bölüme bakın   Ayrıntılar için.

Not: Bu kılavuz sayfası (zsh-severler(1)) değil Z kabuğunun resmi bir parçası! Bu sadece bir adalet
eğlence için - manpage ;) Yorumlar, hata raporları ve geri bildirimler için şu adrese hızlıca göz atın:
Bölüm BÖCEK.

SHELL-Scripting

Bu bölümde sıklıkla ihtiyaç duyulan kabuk komut dosyaları için bazı örnekler verilmektedir. dikkat et
kullanılmamalıdır, aksi takdirde çoğu örnek çalışmaz. Kabuk komut dosyalarındaki ayrıştırma seçenekleri. Örnek
Adam Chodorowski tarafından ZWS'den alınmıştır (http://www.chodorowski.com/projects/zws/):

ayrıştırma_options()
{
o_port=(-p 9999)
o_root=(-r WWW)
o_log=(-d ZWS.log)

zparseopts -K -- p:=o_port r:=o_root l:=o_log h=o_help
eğer [[ $? != 0 || "$o_help" != "" ]]; Daha sonra
echo Kullanımı: $(basename "$0") "[-p PORT] [-r DİZİN]"
çıkış 1
fi

bağlantı noktası=$o_port[2]
kök=$o_root[2]
log=$o_log[2]

if [[ $root[1] != '/' ]]; sonra root = "$PWD/$root"; fi
}
# şimdi fonksiyonu kullanın:
ayrıştırma_seçenekleri $*

ÖRNEKLER

Mevcut alt bölümler şunlardır: Takma adlar, Sürecin Tamamlanması, Sıralanmamış/Çeşitli örnekler, (Yinelemeli)
Küre - Örnekler, Düzenleyiciler kullanım, Yönlendirme-Örnekler, ZMV-Örnekler ve
Modül Örnekleri.

takma adlar
Sonek takma adları zsh'de 4.2.0 sürümünden beri desteklenmektedir. Bazı örnekler:

takma ad -s tex=vim
takma ad -s html=w3m
takma ad -s org=w3m

Şimdi girdikten sonra dönüş tuşuna basıyorum foobar.tex vim'i foobar.tex ile başlatır. Birini aramak
html dosyası w3m tarayıcısını çalıştırır. www.zsh.org ve enter tuşuna basmak w3m'yi argümanla başlatır
www.zsh.org. Genel takma adlar komut satırının herhangi bir yerinde kullanılabilir. Örnek:

$ takma ad -g C='| wc -l'
$ grep takma adı ~/.zsh/* c
443

Az ya da çok yararlı bazı genel takma adlar (sizin için yararlı olup olmadıklarını seçin)
kendi):

takma ad -g ...='../ ..'
takma ad -g ....='../../..'
takma ad -g .....='../../../..'
takma ad -g CA="2>&1 | kedi -A"
takma ad -g C='| wc -l'
takma ad -g D="GÖSTER=:0.0"
takma ad -g DN=/dev/null
alias -g ED=dışa aktar EKRAN=:0.0"
takma ad -g EG='|& egrep'
takma ad -g EH='|& kafa'
takma ad -g EL='|& daha az'
takma ad -g ELS='|& daha az -S'
takma ad -g ETL='|& kuyruk -20'
takma ad -g ET='|& kuyruk'
takma ad -g F=' | fmt-'
takma ad -g G='| egrep'
takma ad -g H='| KAFA'
takma ad -g HL='|& kafa -20'
takma ad -g Sk = "*~(*.bz2|*.gz|*.tgz|*.zip|*.z)"
takma ad -g LL="2>&1 | daha az"
takma ad -g L = "| daha az"
takma ad -g LS='| daha az -S'
takma ad -g MM='| en'
takma ad -g M='| Daha'
takma ad -g NE="2> /dev/null"
takma ad -g NS='| sıralama -n'
takma ad -g NUL=> /dev/null 2>&1"
takma ad -g BORU='|'
takma ad -g R=' > /c/aaa/tee.txt '
takma ad -g RNS='| sıralama -nr'
takma ad -g S='| düzenlemek'
takma ad -g TL='| kuyruk -20'
takma ad -g T='| kuyruk'
takma ad -g ABD='| sırala -u'
takma ad -g VM=/var/log/mesajlar
takma ad -g X0G='| xargs -0 egrep'
takma ad -g X0='| xargs -0'
takma ad -g XG='| xargs egrep'
takma ad -g X='| xargs'

BİTİŞ
Ayrıca bkz. man 1 zshcompctl zshcompsys zshcompwid. zshcompctl, zsh'nin eski tarzıdır
programlanabilir tamamlama, zshcompsys yeni tamamlama sistemidir, zshcompwid ise zsh'dir
tamamlama widget'ları.

_apt ve _dpkg gibi bazı işlevler çok yavaştır. Proxy yapmak için bir önbellek kullanabilirsiniz
sonuçların listesi (mevcut debian paketlerinin listesi gibi) Önbellek kullanın:

zstyle ':tamamlama:*' kullanım önbelleği açık
zstyle ':tamamlama:*' önbellek yolu ~/.zsh/cache

CVS dosyalarının/dizinlerinin tamamlanmasını önleyin:

zstyle ':tamamlama:*:(all-|)files' görmezden gelinen kalıplar '(|*/)CVS'
zstyle ':tamamlama:*:cd:*' görmezden gelinen kalıplar '(*/)#CVS'

Tamamlamaları yanlış yazdığınızda bulanık eşleştirme:

zstyle ':tamamlama:*' tamamlayıcı _tamamlandı _eşleşme _yaklaşık
zstyle ':tamamlama:*:eşleşme:*' yalnızca orijinal
zstyle ':tamamlama:*:aproximate:*' maksimum hatalar 1 sayısal

Ve _aproximate tarafından izin verilen hata sayısının uzunlukla birlikte artmasını istiyorsanız
şu ana kadar yazdıklarınızdan:

zstyle -e ':tamamlama:*:yaklaşık:*' \
max-errors 'yanıt=($((($#PREFIX+$#SUFFIX)/3))sayısal)'

Sahip olmadığınız komutların tamamlama işlevlerini göz ardı edin:

zstyle ':tamamlama:*:işlevler' görmezden gelinen kalıplar '_*'

Aşağıdaki gibi yardımcı işlevlerle:

xdvi() { komut xdvi ${*:-*.dvi(om[1])} }

çoğu durumda tamamlama zorunluluğundan kurtulabilirsiniz, ancak bunu yaparsanız,
hemen menü seçimine geçin ve kelimelerin zamana göre sıralanmasını sağlayın:

zstyle ':tamamlama:*:*:xdvi:*' menüsü evet seç
zstyle ':tamamlama:*:*:xdvi:*' dosya sıralama süresi

İşlem kimliklerini menü seçimiyle tamamlama:

zstyle ':tamamlama:*:*:kill:*' menü evet seç
zstyle ':tamamlama:*:kill:*' kuvvet listesi her zaman

Eğer argüman olarak bir dizini kullanırsanız, bu sondaki eğik çizgiyi kaldıracaktır (yararlı)
ln'de)

zstyle ':tamamlama:*' doğruya doğru sıkma çizgisi

cd hiçbir zaman ana dizini seçmez (örneğin: cd ../ ):

zstyle ':tamamlama:*:cd:*' görmezden-ebeveynler ebeveyn pwd

İçin başka bir yöntem hızlı değişiklik dizinleri. Bunu ekle ~ / .zshrc, ardından girin
“cd ..../dir”

rasyonelleştirme-nokta() {
if [[ $LBUFFER = *.. ]]; Daha sonra
LBUFFER+=/ ..
başka
LBUFFER+=.
fi
}
zle -N rasyonelleştirme noktası
bağlama anahtarı rasyonelleştirme noktası

SIRALANMAMIŞ/ÇEŞİTLİ örnekler
İpucu: Geçerli glob Niteleyicilerinin bir listesini şu adreste bulabilirsiniz: zshexpn(1). Bkz. “man 1 zshexpn |
ayrıntılar için less -p” Niteleyicileri.

# Dosyanın *herhangi bir yerinde* bir desenle *eşleşmeyen* tüm dosyaların adlarını alın
# dosya (ve GNUish olduğu için ``-L'' olmadan)
$ print -rl -- *(.^e{'grep -q desen $REPLY'})
# veya
$ : *(.e{'grep -q desen $REPLY || print -r -- $REPLY'})

# rastgele numaralar
$ echo $[${RANDOM}%1000] # 0-999 arasında rastgele
$ echo $[${RANDOM}%11+10] # 10-20 arasında rastgele
$ echo ${(l:3::0:)${RANDOM}} # N basamak uzunluğunda (3 basamak)

# bir kelimeyi ters çevir
$ echo "${(j::)${(@Oa)${(s::):-merhaba}}}"

# En yeni dizini göster
$ ls -ld *(/om[1])

# rastgele dizi öğesi
$ DOSYALAR=( .../dosyalar/* )
$ feh $FILES[$RANDOM%$#FILES+1]

# cat bu dizindeki tüm dosyaların ilk satırı
$ dosya için (*(ND-.)) IFS= okuma -re < $dosya

# parametrenin sayısal olup olmadığını test edin
$ if [[ $1 == <-> ]] ; Daha sonra
yankı sayısal
başka
sayısal olmayan yankı
fi

# .o dosyası bulunmayan tüm .c dosyalarını bana göster.
$ print *.c(e_'[[ ! -e $REPLY:ro ]]'_)

# Tüm dosyalar /oldu/ root'a ait olmayanlar
$ ls -ld /oldu/*(^u:kök)

# Sahibinin okuma ve yürütme izinlerine sahip olduğu tüm dosyalar
$ echo *(f:u+rx :)

# Aynı, ancak diğerlerinin de yürütme izinleri yok
$ echo *(f:u+rx,öküz :)

# ayraç genişletme - örnek
$X=(ABC)
$ Y=(+ -)
$ print -r -- $^X.$^Y

A.+ A.- B.+ B.- C.+ C.-
# 'fgractg*.log' dizesini içeren en yeni dosyayı getir
# dosya adı ve içinde 'ORA-' dizesini içeriyor
$ dosya=(fgractg*.log(Nm0om[1]))
$ (($#dosya)) && grep -l ORA- $dosya
# Zsh olmadan
$ files=$( find . -name . -o -prune -name 'fgractg*>log' -mtime 0 -print )
> if [ -n "$dosyalar" ]; Daha sonra
> IFS='
> '
> -f'yi ayarla
> dosya=$(ls -td $dosyalar | kafa -1)
> grep -l ORA- "$dosya"
> fi

# görevin tamamı bitene kadar belirtilen sayıda alt işlemi çalışır durumda tut
$ zsh -c 'uyku 1 & uyku 3 & uyku 2& yazdır -rl -- $işmetinleri'

# Bir dizindeki sıfır uzunluktaki ve .bak dosyalarını kaldırın
$ rm -i *(.L0) *.bak(.)

# uzantısı olmayan dosyaları yazdır
$ printf '%s\n' ^?*.*
$ printf '%s\n' ^?*.[^.]*(D)
$ ls -d -- ^?*.*(D)

# Belirli bir dize içermeyen dosyaları bulma
$ yazdır -rl dosyası* | comm -2 -3 - <(grep -l dize dosyası*)'
$ for f (dosya*(N)) grep -q string $f || yazdır -r $f'

# Bir seçeneğin ayarlanıp ayarlanmadığını gösterin/kontrol edin. Her ikisi de $options ile çalışır
# $yerleşiklerle
$ echo $seçenekler[doğru]
kapalı
$ $seçenekler[zle]
on

# Yığındaki dizin sayısını sayın
$ print $((${${(z)${(f)"$(dirs -v)"}[-1]}[1]} + 1)) # veya
$ dizin -v | awk '{n=$1}END{n+1'i yazdır}'

# Dosya adında nokta bulunmayan tüm dosyaları eşleştirme
$ ls *~*.*(.)

# Yalnızca ``ifconfig aygıtının' ip adresini göster
# ifconfig net-tools'tan (Linux)
$ yazdır ${${$(LC_ALL=C / sbin / ifconfig eth0)[7]}:gs/addr://}
# ifconfig 4.2BSD'den {Free,Net,Open}BSD
$ yazdır ${$(/ sbin / ifconfig tun0)[6]}

# Birkaç C sınıfının veya tüm ana bilgisayarların tüm IP adreslerine ping atın
# içine / Etc / hosts
{1..254}'te i için $; ping -c 1 192.168.13.$i yapın; Tamamlandı
or
$ben=1
$ while ( [[ $I -le 255 ]] ) ; ping yap -1 2 150.150.150.$I; izin ver ben++; Tamamlandı
or
$ i için $(sed 's/#.*//' > / Etc / hosts | awk '{$2 yazdır}')
: yapmak
: echo "$i deneniyor..."
: ping -c 1 $i;
: echo '============================='
: Tamamlandı

# başlangıçta mevcut tüm modülleri yükle
$ dizgi -U m
$m=()
md için $ ($module_path) m=($m $md/**/*(*e:'REPLY=${REPLY#$md/}'::r))
$ zmodload -i $m

# Bir dizindeki tüm dosyaları, adları rakam alacak şekilde yeniden adlandırın
# varsayılan sıralama düzenindeki önek.
$i=1; *'daki j için; do mv $j $i.$j; ((i++)); Tamamlandı
$i=1; * cinsinden f için; do mv $f $(echo $i | \
awk '{ printf("%03d", $0)}').$f; ((i++)); Tamamlandı
$ tamsayı i=0; * cinsinden f için; do mv $f $[i+=1].$f; Tamamlandı

# Geçerli içindeki hedef olmayan tüm sembolik bağlantıları bulun (ve yazdırın)
#dirtree.
$ $ dosya **/*(D@) | fgrep kırık
$ i için **/*(D@); [[ -f $i || -d $i ]] || yankı $i
$ echo **/*(@-^./=%p)
$ yazdır -l **/*(-@)

# `fignore'da listelenen uzantılara sahip olmayan tüm düz dosyaları listele
$ ls **/*~*(${~${(j/|/)fignore}})(.)
# yukarıya bakın, ancak şimdi yürütülebilir dosyaları atlayın
$ ls **/*~*(${~${(j/|/)fignore}})(.^*)

# Uzantısı olmayan dosyaları yazdırın (*setopt extendglob* gerektirir)
# ve *setopt dotglob*)
$ printf '%s\n' ^?*.*

# Dosyaları ada göre sıralanmış olarak ters sırada listeleyin
$ print -rl -- *(Açık)
or
$ print -rl -- *(^açık)

# ``ps axe ile eşanlamlıdır | awk '{$1 yazdır}'''
$ yazdır -l /proc/*/cwd(:h:t:s/self//)

# Bir işlemin PID'sini alın (``ps'', ``sed'', ``pgrep'' olmadan, ..
# (Linux altında)
$ pid2 () {
> yerel ben
> benim için /proc/<->/stat
> yap
> [[ "$(< $i)" = *\((${(j:|:)~@})\)* ]] && echo $i:h:t
> bitti
> }

# 'n' 'o' 'p' 'q' 'r' 's' 't' 'u' 'v' 'w' 'x' 'y' içindeki X için; Yapmak ...
$ for (( i = 36#n; i <= 36#y; i++ )); Yapmak
> ${$(([##36]i))):l} yazdır
> bitti
# veya ``dc'' ile birlikte
$ print {$(((##n))..$((##y))}P\ 10P | doğru akım
# veya ``eval'' ile
$ eval print '${$(([##36]'{$((36#n)))..$((36#y))}')):l}'

# foreach kabuğun bir satırında
$ f için (*) yazdır -r -- $f

# bir dizini veriler/dosyalar olmadan yinelemeli olarak kopyalama
$ dizin=(**/*(/))
$ cd -- $hedef_kök
$ mkdir -p -- $dir
# veya zsh olmadan
$ bul. -type d -exec env d = "$hedef_kök" \
sh -c ' exec mkdir -p -- "$d/$1"' '{}' '{}' \;

# Eğer `foo=23'' ise, başında '10' olacak şekilde 0 haneli olarak yazdırın.
$foo=23
$ yazdır ${(r:10::0:)foo}

# ana dizinlerindeki tüm dosyaların adını bulun
# dosya adlarında 20'den fazla karakter
yazdır -rl $HOME/${(l:20::?:)~:-}*

# Dizileri kaydet
$ print -r -- ${(qq)m} > $nameoffile # kaydet
$ eval "m=($(cat -- $nameoffile)" # veya kullanın
$ m=("${(@Q)${(z)"$(cat -- $nameoffile)"}}") # geri yüklemek için

# ağaçtaki bir dosyadan daha genç olan tüm dosyalara "ls -l" değeri alın
# belirtilen yaş (örn. "ls -l" ağaçtaki tüm dosyalar
# son 2 gün içinde değiştirildi)
$ ls -tld **/*(m-2)
# Bu size 1 dosyalı perl satırı listesi verecektir (la ls -R değil).
# "ls -R" tarzı bir çıktıya sahip olmanın kolay bir yolunu düşünün.
# yalnızca 2 günden daha eski dosyalar.
$ for d (. ./**/*(/)) {
> yazdır -r -- $'\n'${d}:
> cd $d && {
> l=(*(Nm-2))
> (($#l)) && ls -ltd -- $l
> cd ~-
> }
> }
# Ayrıca mtime'ları olsa bile dizinlerin dahil edilmesini istiyorsanız
# 2 günden daha eski:
$ for d (. ./**/*(/)) {
> yazdır -r -- $'\n'${d}:
> cd $d && {
> l=(*(N/,m-2))
> (($#l)) && ls -ltd -- $l
> cd ~-
> }
> }
# Ve eğer sadece mtime < 2 gün olan dizinlerin listelenmesini istiyorsanız:
$ for d (. ./**/*(N/m-2)) {
> yazdır -r -- $'\n'${d}:
> cd $d && {
> l=(*(Nm-2))
> (($#l)) && ls -ltd -- $l
> cd ~-
> }
> }

# 42'yi yazdır ``-''
$ yankı ${(l:42::-:)}
# veya ``$COLUMS'' kullanın
$ echo ${(l:$COLUMNS::-:)}
# ve şimdi renklerle (otomatik yükleme renkleri gerektirir;renkler)
$ echo "$bg[kırmızı]$fg[siyah]${(l:42::-:)}"

# STDOUT'u da yönlendirmeden STDERR'yi xless gibi bir komuta yönlendirin.
$foo 2>>(x'siz)
# ancak bu, komutu eşzamansız olarak yürütür. Bunu eşzamanlı olarak yapmak için:
$ { { foo 1>&3 } 2>&1 | x'siz } 3>&1

# Tüm MP3 dosyalarını, boşluk.mp3'lü addan Spaces.mp3'lü Ad'a yeniden adlandırın
*.mp3'te i için $; Yapmak
> mv $i ${${(C)i}:s/Mp3/mp3/}
> bitti

# Yalnızca rakam içeren ve .xml ile biten dosya adlarını eşleştirin (gerekli
# *setopt kshglob*)
$ ls -l [0-9]##.xml
$ ls -l <0->.xml

# Tüm "txt olmayan" dosyaları kaldırın
$ rm ./^*.txt

# 200 dosyayı bir dizinden diğerine taşıyın
$ mv -- *([1,200]) /başka/Dir

# Görüntüleri dönüştürün (foo.gif => foo.png):
**/*.gif'te i için $; $i $i:r.png dönüştür

# bir mp3 dosyası koleksiyonunu wave veya cdr'ye dönüştürün,
# örneğin dosya.wav -> dosya.mp3)
$ for i (./*.mp3){mpg321 --w - $i > ${i:r}.wav}

# LaTeX2HTML ile oluşturulan Dosyaları indirin (örneğin ZSH Kılavuzu):
f için $ http://zsh.sunsite.dk/Guide/zshguide{,{01..08}}.html; Yapmak
> vaşak -kaynak $f >${f:t}
> bitti

# Dizin1 ve dizin2'deki satır sayısı 10'dan büyük olan tüm dosyaları taşıyın
# başka bir dizin "/more10" diyor
$ mv dir[12]/**/*.cr(-.e{'((`wc -l < ​​$REPLY` > 10))'}) /more10

# dpkg ile yüklediği her dosyanın ana listesini oluşturun
$ fark <(bul / | sırala) <(kedi /var/lib/dpkg/bilgi/*.liste | düzenlemek)

# Şu kahrolası Kaçış Dizilerini değiştir:
$ renkleri otomatik yükle; renkler
$ print "$bg[cyan]$fg[blue]Sen bir aptalsın" >> /dev/pts/3

# Bir karakterin ASCII değerini al
$karakter=N ; yazdır $((#char))

# Dosya adı "Erweiterung"
# Not: (N), bu özel durum için nullglob seçeneğinin kullanılacağını söylüyor
# küresel desen.
$ i için *.o(N); Yapmak
> rm $i
> bitti

# Dosyaları yeniden adlandırın; yani FOO'dan foo'ya ve bar'dan BAR'a
$ i için *(.); mv $i ${i:l} # 'FOO'dan 'foo'ya
$ i için *(.); mv $i ${i:u} # `bar'dan `BAR'a

# $PATH içindeki tüm suid dosyalarını göster
$ ls -latg ${(s.:.)YOL} | grep '^...s'
# veya daha karmaşık ;)
$ print -l ${^yol}/*(Ns,S)
# veya yalnızca kullanıcı tarafından belirlenen desene sahip yürütülebilir dosyaları göster
$ print -l ${^yol}/*vim*(*N)

# belirli bir dize içerdiğinde gzip dosyaları
$ gzip ${(ps:\0:)"$(grep -lZ foobar ./*.txt(.))"}

# Stdin'den okuyan ve ilkini stdout'a yazdıran küçük bir tek satırlık
# benzersiz satır yani daha önce yazdırılan satırları yazdırmaz
# (bu, benzersiz komuta benzer, ancak benzersiz yalnızca
# bitişik satırlar).
$ IFS=$'\n\n'; print -rl -- ${(Oau)${(Oa)$(cat dosyası;echo .)[1,-2]}}

# PATH'deki tüm yürütülebilir dosyaları listeler
$ print -l ${^yol}/*(-*N)

# SCCS alt dizinleri hariç tüm alt dizinlerdeki tüm .c dosyaları eşleştirilsin mi?
$ ls **/*.c~(*/)#SCCS/*

# Tüm `BENİOKU' dosyalarını listele - büyük/küçük harfe duyarlı olmayan, maks. bir yazım hatası
$ ls **/*(#ia2)benioku

# değişkenler için büyük/küçük harfe duyarsız kontrol
$ if [[ $OSTYPE == (#i)LINUX*(#I) ]]; Daha sonra
> echo "Gemide penguen."
> başka
> echo "Linux değil."
> fi

(Yinelemeli) Küre - Örnekler
Geçerli glob Niteleyicilerinin bir listesini şu adreste bulabilirsiniz: zshexpn(1). Not: **/ eşdeğerdir
(*/)#! Örneğin:

$ yazdır (*/)#zsh_us.ps
zsh-4.2.3/Doc/zsh_us.ps
$ yazdır **/zsh_us.ps
zsh-4.2.3/Doc/zsh_us.ps

# Tüm Alt Dizinlerde `BENİOKU'yu arayın
$ ls -l **/BENİOKU

# hem "index.php" hem de "index.html"yi içeren dizinleri bulun veya
# genel, "index.*" ile eşleşen birden fazla dosya içeren dizinler
$ ls **/*(D/e:'[[ -e $REPLY/index.php && -e $REPLY/index.html ]]':)
# veya
$ ls **/*(D/e:'l=($REPLY/index.*(N)); (( $#l >= 2 ))':)

# Taban adı yerine dizin adını aramak için komut bul
$ yazdır -rl /**/*~^*/yol(|/*)
# veya - Zsh olmadan
$ bul / | grep -e /yol/ -e '/yol$'

# En büyük on C normal dosyasını tutan dizinlerin yolunu yazdır
# geçerli dizinde ve alt dizinlerde.
$ print -rl -- **/*.c(D.OL[1,10]:h) | sıralama -u

# Boyutu == 0 olan dosyaları bulun ve bir e-posta gönderin
$ dosyalar=(**/*(ND.L0m+0m-2))
> (( $#dosyalar > 0 )) && yazdır -rl -- $dosyalar | \
mailx -s "boş dosyalar" [e-posta korumalı]

# özyinelemeli chmod
$ chmod 700 **/(.) # Yalnızca dosyalar
$ chmod 700 **/(/) # Yalnızca dizinler

# o dizindeki tüm dosyaları 2 sütun halinde yazdır
$ print -rC2 -- ${1:[...]}/*(D:t)
# ^- sayı ob sütunları
# veya - özel karakterler konusunda endişeleniyorsanız - kullanın
$ liste=(${1:[...]}/*(ND:t))
$ (($#list)) && yazdır -rC2 -- ${(V)list}

# Tüm dosyaları ara /ev/*/*-mail/ ``chmod -s'' bayrağı ayarıyla
# (özyinelemeli, nokta dosyaları dahil) setgid/setuid bayrağını kaldırın ve yazdırın
# bir mesaj
$ chmod -s /ev/*/*-posta(DN'ler, S) /ev/*/*-posta/**/*(DN'ler,S))
# veya küçük bir komut dosyasıyla
$ dosya için (/ev/*/*-posta(DN'ler, S) /ev/*/*-posta/**/*(DN'ler,S)) {
> yazdır -r -- $dosya
> chmod -s $dosya && print -r sabit $dosya
> }
# veya ``zargs'' kullanın (zargs'ın otomatik yüklenmesini gerektirir) arg listesini de engelleyin
# uzun hata
$ zargs /ev/*/*-posta(DN'ler, S) /ev/*/*-mail/**/*(DN'ler,S)) -- chmod -s

# Dosyaları `foo23'ten başlayarak yukarıya doğru listeleyin (foo23, foo24, foo25, ..)
$ ls -l foo<23->

# 4 Haziran'dan itibaren tarih dizeleriyle başlayan tüm dosyaları alın
# 9 Haziran 2004
$ ls -l 200406{04..10}*(N)
# veya 200406XX biçimindeyseler (``setopt Extended_glob'' gerektirir)
$ ls -l 200306<4-10>.*

# dosya adlarındaki boşlukları kaldırın
$ a için ./**/*\ *(Dod); yap mv $a ${a:h}/${a:t:gs/ /_}; Tamamlandı

# Yalnızca *.c ve *.h - Dosyalarının tümünü göster
$ ls -l *.(c|h)

# Yalnızca tüm *.c - dosyalarını göster ve `foo.c'yi yok say
$ ls *.c~foo.c

# verileri *gerçekten* ikili formatta göster
$ zsh -ec 'while {} {printf %.8x $n;tekrar 8 \
> {read -ku0 a printf \ %.8d $(([##2]#a))};print;((n+=8))}' < ikili

# Yalnızca herkes tarafından okunabilen dosyaları göster
$ ls -l *(R)

# Geçerli dizindeki liste dosyaları, sahibi tarafından yazılamaz
$ print -l ~/*(ND.^w)

# verilen parametreden daha eski olan dosyaları bul ve sil
# (saniye/dakika/saat)
# /Diz içindeki 3 saatten eski tüm normal dosyaları siler
$ rm -f /Yön/**/*(.mh+3)
# /Dir içindeki 3 dakikadan eski tüm sembolik bağlantıları siler
$ rm -f /Yön/**/*(@mm+3)
# /Dir içindeki 30 saniyeden eski tüm dizin olmayanları siler
$ rm -f /Yön/**/*(ms+30^/)
# bir saatten eski tüm klasörleri, alt klasörleri ve dosyaları siler
$ rm ./**/*(.Dmh+1,.DL0)
# 6 saatten eski tüm dosyaları siler
$ rm -f **/*(mh+6)
# daha yeni olan on tanesi dışındaki tüm dosyaları kaldırır (son 10 tanesi dışındaki tüm dosyaları sil)
Bir dizindeki # dosya)
$ rm ./*(Om[1,-11])
Not: Eğer bir arg listesi çok uzunsa yerleşik rm'yi kullanırsınız. İçin
örnek:
$ zmodload zsh/dosyalar ; rm -f **/*(mh+6)
veya zargs işlevini kullanın:
$ zargs otomatik yükleme; zargs **/*(mh+6) -- rm -f

# Z-Shell Kullanım Kılavuzu /5.9: Dosya Adı Oluşturma ve Desen
# Eşleştirme, tüm alt dizinlerdeki tüm dosyaları bulur, yinelemeli olarak arama yapar,
# belirli bir ada sahip, büyük/küçük harfe duyarlı olmayan, en az 50 KB büyüklüğünde,
# bir haftadan eski değil ve root kullanıcıya ait ve izin veriliyor
# ismin yazılışında tek bir hataya. Aslında gerekli
# ifade şuna benzer:
$ ls **/(#ia1)isim(LK+50mw-1u0)

# UID'yi 102'den 666'ya değiştirin
$ chown 666 **/*(u102)

# Son 10 saatten beri güncellenmeyen tüm dosyaları listeleyin
$ print -rl -- *(DM+10^/)

# dizindeki yalnızca en eski dosyayı sil
$ rm ./*dosyaadı*(Om[1])

# `ls -l'den çıktıyı dosya boyutuna göre sıralayın
$ ls -fld *(OL)

# bir dizindeki en son dosyayı bul
$ setopt noktaglob; dizini yazdır/**/*(om[1])

# Yalnızca "grup" veya "tüm dünyada yazılabilir" olmayan boş dosyaları göster
$ ls *(L0f.go-w.)

# Dizinlerdeki ve alt dizinlerdeki en yeni on dosyayı bulun ve listeleyin.
# (özyinelemeli)
$ print -rl -- **/*(Dom[1,10])

# "ls" komutuyla yalnızca 5 satır yazdırın (``ls -laS | head -n 5'' gibi).
$ ls -fl *(DOL[1,5])

# En son değiştirilen 5-10 dosyayı görüntüleyin.
$ print -rl -- /yol/giden/dir/**/*(D.om[5,10])

# Geçerli bir sahibi olmayan tüm dosyaları bulun.
$ chmod someuser /**/*(D^u:${(j.:u:.)${(f)"$(/ Etc / passwd)"}%%:*} :)

# Bir ağaçtaki tüm boş dizinleri bulun.
$ f için ***/*(/l2); do foo=($f/*(N)); [[ -z $foo ]] && print $f; Tamamlandı
# Not:Zsh 4.2.1'den beri glob niteleyicisi F boş olmayan bir dizini belirtir.
# Bu nedenle *(F) girişleri olan tüm alt dizinleri belirtir, *(/^F) tümü anlamına gelir
# girişi olmayan alt dizinler.
$ ls -ld *(/^F)

# Daha sonra boş dizinleri kaldırın.
$ rmdir ./**/*(/od) 2> /dev/null

# Yalnızca grup `kullanıcılarına' ait olan dosyaları göster.
$ ls -l *(G[kullanıcılar])

Düzenleyiciler kullanım
Değiştiriciler, parametre tarafından döndürülen sonuçları değiştirmenize olanak tanıyan güçlü bir mekanizmadır.
dosya adı ve geçmiş genişletme. Görmek zshexpn(1) ayrıntılar için.

# NOT: Zsh 4.3.4 gerekli!
$ otomatik yükleme -U yaş
# dosya bugün değiştirildi
$ print *(e:bugünün yaşı şimdi :)
Saat 5:XNUMX'den bu yana # dosya değiştirildi
$ print *(e-yaş 17:00 şimdi-)
# ...dün saat 5'ten beri
$ print *(e-yaş dün,17:00 şimdi-)
# ...geçen Noel'den bugünden önce
$ yazdır *(e-yaş 2006/12/25 bugün-)
# ... Dünden önceki
$ baskı *(e-yaş 1970/01/01 dün-)
# bu tarihlerin başlangıcı arasında değiştirilen tüm dosyalar
$ yazdır *(e:yaş 2006/10/04 2006/10/09 :)
# o tarihte değiştirilen tüm dosyalar
$ yazdır *(e:yaş 2006/10/04 :)
# Tedarik süreleri.
$ print *(e-age 2006/10/04:10:15 2006/10/04:10:45-)

# Başlığı bırakarak sondaki yol adı bileşenini kaldırın. Bu şöyle çalışır
# `dizin adı'.
$ yankı =ls(:h)
/çöp Kutusu

# Kuyruğu bırakarak tüm önde gelen yol adı bileşenlerini kaldırın. Bu çalışıyor
# `taban adı' gibi.
$ yankı =ls(:t)
ls

# Her dosyadan son eki kaldırın (bu örnekte *.sh)
$f:e $f dosya uzantısıdır
:h --> head (dizin adı)
:t --> kuyruk (taban adı)
:r --> dinlenme (uzantı kaldırıldı)
$ f (*.sh) mv için $f $f:r

# Kök adını bırakarak `.xxx' biçimindeki dosya adı uzantısını kaldırın.
$ echo $PWD
/usr/src/linux
$ echo $PWD:t
linux

# Uzantı dışında tümünü kaldırın.
$foo=23.42
$ yankı $foo
23.42
$ echo $foo:e
42

# Yeni komutu yazdırın ancak uygulamayın. Yalnızca geçmişle çalışır
# genleşme.
$ yankı =ls(:h)
/çöp Kutusu
$ !yankı:p
$ yankı =ls(:h)

# Daha fazla değişiklik yapmaktan kaçınarak, değiştirilen kelimeleri alıntılayın.
$ bar = "23'42"
$ yankı $çubuk
23'42
$ echo $çubuk:q
23 \ '42

# Kelimeleri tamamı küçük harfe dönüştürün.
$ bar=FOOBAR
$ yankı $çubuk
FOOBAR
$ yankı $çubuk:l
filanca

# Kelimelerin tamamını büyük harfe dönüştürün.
$ bar=foobar
$ yankı $çubuk
filanca
$ echo $çubuk:u
FOOBAR

# bir kelimenin 1. karakterini büyük harfe çevir
$ foo="bir iki üç dört"
$ print -r -- "${(C)foo}"
Bir iki üç dört

Yönlendirme-Örnekler
Yerimizi zshmisc(1) daha fazla bilgi için (veya daha az ${^fpath}/zmv(N))

# Tüm *.sh dosyalarının sonuna `çıkış 1'i ekleyin
$ echo "çıkış 1" >> *.sh

# foobar.tar.gz'ye dosya ekleme
$ eval set =(gunzip < foobar.tar.gz) '
tar rf $1 ek.txt &&gzip < $1 > foobar.tar.gz'

# Çıktıyı bir dosyaya yönlendir VE ekranda görüntüle
$ foobar >&1 > dosya1 > dosya2 > ..

# tek çıkışı birden fazla girişe yönlendir
$ zcat foobar.Z >> (gzip -9 > dosya1.gz) \
>> (bzip2 -9 > dosya1.bz2) \
>> (acb --en iyi > dosya1.acb)

# Ekle / etc / services 'foo' ve 'bar' dosyasının sonunda
$ kedi / etc / services >> foo >> bar

# Boru STDERR
$ echo Bir hata >&2 2>&1 | sed -e 's/A/I/'

# bir işlemin standart çıktısını birden fazla işlemin standart girişine gönder
# boru hattında
$ setopt çoklu
$ süreç1 > >(işlem1) > >(işlem2)

# bir değişkeni başlatmak ve aynı anda terminal çıktısını tutmak
$ setopt çoklu
$ { a=$(komut >&1 >& 3 3 > &- 2>&1);} 3>&1

# stderr'i iki kez yönlendir
$ setopt çoklular; program 2> dosya2 > dosya1 2>&1

# Stdout ve stderr'yi bir günlük dosyasına kopyalamak
$ exec 3>&1 > günlük dosyası 2>&2 2>&1 >&3 3>&-

# stderr'i (yalnızca) bir dosyaya ve orig'e yönlendirin. :
$ komut 2>&2 2>stderr
# stderr ve stdout'u ayrı dosyalara ve her ikisini de orig'e yönlendirin. stdout:
$ komut 2>&1 1>&1 2>stderr 1>stdout
# stderr ve stdout'u ayrı dosyalara, stdout'u ise orig'e yönlendirin. stdout
# VE stderr'den orig'e. :
$ komut 2>&2 1>&1 2>stderr 1>stdout

# STDERR ile daha eğlenceli ;)
$ ./my-script.sh 2> >(grep -v moron >error.log)|process-output >output.log
$ echo "Bu STDOUT" >>(sed 's/stdout/başka bir örnek/' > foobar)

ZMV-Örnekler (gerekmek özdevinimli_yükle zmv)
Not: -n yürütmenin olmadığı anlamına gelir (sadece ne olacağını yazdırın). Şu tarihte:

# Fat32 dosya sistemindeki yasa dışı karakterleri kaldırın. Yasa dışı karakterler
# / : ; * ? " < > |
# NOT: ``-Q'' ve (D) gizli dosyaları içerecektir.
$ istenmeyen='[:;*?\"<>|]'
$ zmv -Q "(**/)(*$~istenmeyen*)(D)" '$1${2//$~istenmeyen/}'

# Dosya adının bir kısmını değiştirme (yani "dosya-cehennem.adı" -> "dosya-heaven.adı")
$ zmv '(*)cehennem(*)' '${1}cennet${2}'
# veya
$ zmv '*' '$f:s/cehennem/cennet/'

# dosya adlarındaki yuvarlak parantezi kaldır
# yani foo-(bar).avi -> foo-bar.avi
$ zmv '*' '${f//[()]/}'

# seri olarak tüm dosyalar (foo.foo > 1.foo, fnord.foo > 2.foo, ..)
$ otomatik yükleme zmv
$ l *
1.c asd.foo bla.foo fnord.foo foo.fnord foo.foo
$ c=1 zmv '*.foo' '$((c++))).foo'
$ l *
1.c 1.foo 2.foo 3.foo 4.foo foo.fnord

# Noktaları değiştirerek "file.with.many.dots.txt" dosyasını yeniden adlandırın (sonuncusu hariç)
# bir!) bir boşlukla
$ {1..20}-file.with.many.dots.txt'ye dokunun
$ zmv '(*.*)(.*)' '${1//./ }$2'

# Dosya adının ilk 4 karakterini kaldırın
$ zmv -n '*' '$f[5,-1]' # NOT: "5" yazım hatası DEĞİLDİR!

# Geçerli Dizin altındaki tüm dosyaların adlarını küçük harflerle yeniden adlandırın, ancak
# dirnames olduğu gibi.
$ zmv -Qv '(**/)(*)(.D)' '$1${(L)2}'

# "4" olan 1. karakterin tamamını "2" ile değiştirin vb.
$ otomatik yükleme -U zmv
$ zmv '(???)1(???[1-4].txt)' '${1}2${2}'

# Bir dizenin ilk 15 karakterini kaldır
$ 111111111111111{az}'a dokunun
$ otomatik yükleme zmv
$ zmv '*' '$f[16,-1]'

# Dosya adlarındaki boşlukları (istediğiniz sayıda) tek çizgiyle değiştirin
$ otomatik yükleme zmv
$ zmv -n '(**/)(* *)' '$1${2//( #-## #| ##)/-}'
# veya - Bash ile
$ bul. -derinlik -isim '* *' -exec bash -c '
> shopt -s extglob
> dosya=$1
> dir=${dosya%/*}
> name=${file##*/}
> yeniisim=${isim//*([ -]) *([ -])/-}
> mv -i -- "$dosya" "$Diz/$yeniad"' {} {} \;

# Dosya adlarını temizleyin ve özel karakterleri kaldırın
$ otomatik yükleme zmv
$ zmv -n '(**/)(*)' '$1${2//[^A-Za-z0-9._]/_}'

# Bir dizindeki bir grup python betiğine *.py ekleyin (bazıları
*.py dosyasına # ekleyin ve hepsine uygun bir uzantı verin
$ otomatik yükleme zmv
$ zmv -n '(**/)(con*)(#qe,file $REPLY | grep "python betiği",)' '$1$2.py'

# tüm uzantılar küçük harf (ör. *.JPG) dahil. alt klasörler
$ otomatik yükleme zmv
$ zmv '(**/)(*).(#i)jpg' '$1$2.jpg'
# Veya - Zsh olmadan
$ find Dizin -name '*.[jJ][pP][gG]' -print | f okurken
> yap
> case $f in
> *.jpg) ;
> *) mv "$f" "${f%.*}.jpg"loading="tembel" ;
> esac
> bitti

# dosya uzantısından baştaki sıfırları kaldırın
$ otomatik yükleme zmv
$ l
dosyaadı.001 dosyaadı.003 dosyaadı.005 dosyaadı.007 dosyaadı.009
dosyaadı.002 dosyaadı.004 dosyaadı.006 dosyaadı.008 dosyaadı.010
$ zmv '(dosyaadı.)0##(?*)' '$1$2'
$ l
dosyaadı.1 dosyaadı.10 dosyaadı.2 dosyaadı.3 dosyaadı.4 dosyaadı.5 ..

# dosyaları yeniden numaralandır.
$ otomatik yükleme zmv
$ l *
foo_10.jpg foo_2.jpg foo_3.jpg foo_4.jpg foo_5.jpg foo_6.jpg ..
$ zmv -fQ 'foo_(<0->).jpg(.nOn)' 'foo_$(($1 + 1)).jpg'
$ l *
foo_10.jpg foo_11.jpg foo_3.jpg foo_4.jpg foo_5.jpg ...

# dosya adının başına sıfır ekleme (1.jpg -> 001.jpg, ..
$ otomatik yükleme zmv
$ zmv '(<1->).jpg' '${(l:3::0:)1}.jpg'

# Yukarıya bakın, ancak artık yalnızca dosya adı >= 30 karakter olan dosyalar
$ otomatik yükleme zmv
$ c=1 zmv "${(l:30-4::?:)}*.foo" '$((c++))foo'

# Dosya adlarındaki boşlukları alt çizgiyle değiştirin
$ otomatik yükleme zmv
$ zmv '* *' '$f:gs/ /_'

# Son eki *.sh'den *.pl'ye değiştirin
$ otomatik yükleme zmv
$ zmv -W '*.sh' '*.pl'

# ${HOME} içindeki tüm dosyalara "".txt" uzantısı ekleyin
# ``-.'' yalnızca normal dosyaları veya sembolik bağlantıları normal dosyalara yeniden adlandırmak içindir,
# ``D'' aynı zamanda gizli dosyaları da yeniden adlandırmaktır (nokta dosyaları)
$ otomatik yükleme zmv
$ zmv -Q '/ev/**/*(D-.)' '$f.txt'
# Veya yalnızca uzantısı olmayan dosyaları yeniden adlandırmak için:
$ zmv -Q '/ev/**/^?*.*(D-.)' '$f.txt'

# Dosya adlarını karakterlerle yinelemeli olarak değiştirilsin mi? [ ] / = + < >; : " , - *
$ otomatik yükleme zmv
$ chars='[][?=+<>;",*-]'
$ zmv '(**/)(*)' '$1${2//$~karakter/%}'

# Dosya adlarından tek alıntının kaldırılması (yinelemeli olarak)
$ otomatik yükleme zmv
$ zmv -Q "(**/)(*'*)(D)" "\$1\${2//'/}"

# Yeni bir dosya geldiğinde (file.txt adında), tüm dosyaları yeniden adlandırın.
# get (örneğin, dosya119.txt, dosya120.txt olur, dosya118.txt olur)
# dosya119.txt ve benzeri dosya.txt'nin dosya1.txt olmasıyla biter
$ otomatik yükleme zmv
$ zmv -fQ 'dosya([0-9]##).txt(Açık)' 'dosya$(($1 + 1)).txt'

# tüm dosyalar/dizinler küçük/büyük harf
$ otomatik yükleme zmv
$ zmv '(*)' '${(L)1}' # küçük harf
$ zmv '(*)' '${(U)1}' # büyük harf

# *.c son ekini tüm C Dosyalarından kaldırın
$ otomatik yükleme zmv
$zmv '(*).c' '$1'

# Tüm *.mp3 dosyalarının yalnızca ilk harfi büyük harf
$ otomatik yükleme zmv
$ zmv '([az])(*).mp3' '${(C)1}$2.mp3'

# `README' hedefini her `Makefile' ile aynı dizine kopyalayın
$ otomatik yükleme zmv
$ zmv -C '(**/)Makefile' '${1}BENİOKU'

# Dosya adlarından tek alıntının kaldırılması (yinelemeli olarak)
$ otomatik yükleme zmv
$ zmv -Q "(**/)(*'*)(D)" "\$1\${2//'/}"

# pic1.jpg, pic2.jpg, ..'yi pic0001.jpg, pic0002.jpg, .. olarak yeniden adlandırın
$ otomatik yükleme zmv
$ zmv 'resim(*).jpg' 'resim${(l:4::0:)1}.jpg'
$ zmv '(**/)pic(*).jpg' '$1/pic${(l:4::0:)2}.jpg' # yinelemeli olarak

Modül Örnekleri
Lütfen oku zshmodülleri(1) ilk!

zsh/pcre (gerekmek zmod yükü zsh/pcre)
# Belirli bir döneme ait dosyaları kopyalayın (dosya adlarında belirtilen tarih)
$ zmodload zsh/pcre
$ ls -d -- *(e:'[[ $REPLY -pcre-match pcre-regexp ]]':)
# veya
$ m() { [[ $1 -pcre-eşleşme pcre-regexp ]] }
$ ls -d -- *(+m)

zsh/klon (gerekmek zmod yükü zsh/klon)
# Geçerli kabuğun çatallı bir örneğini oluşturur ($! sıfıra ayarlıdır) ve
# /dev/tty8'de ``komutu' yürütün (bu örnek için).
$ zmodload zsh/klon
$ clone /dev/tty8 && (($! == 0)) && exec komutu

zsh/tarih saat (gerekmek zmod yükü zsh/tarihsaat)
$ zmodload zsh/tarihsaat
$ alias datereplacement='strftime "%Y-%m-%d" $EPOCHSECONDS'
$ ihracat DATE=`tarih değiştirme`
$ echo $TARİH

# dosya adından tarihi çıkar
$ $ zmodload zsh/tarihsaat
$ setopt genişletilmişglob
$ touch aaa_bbb_20041212_c.dat eee_fff_20051019_g.dat
$ strftime -s desen \
'???_???_<0-%Y%m%d>_?.dat' $((EPOCHSECONDS - 365 * 24 * 60 * 60 / 2))
$ yazdır -rl -- $~desen
aaa_bbb_20041212_c.dat
$ yazdır -rl -- $desen
???_???_<0-20050815>_?.dat

# Arama dosyalarının boyutu == 0, tarih içeren dosya adına göre belirlenecek
# dosyanın "son değiştirilme" tarihi yerine
$ zmodload -i zsh/tarihsaat
$ strftime -s dosya "abc_de_%m%d%Y.dat" $((EPOCHSECONDS - 24 * 60 * 60 ))
$ dosyalar=(**/$dosya(N.L0))
$ (( $#dosyalar > 0 )) && yazdır -rl -- $dosyalar | \
mailx -s "boş dosyalar" [e-posta korumalı]

zsh/stat (gerekmek zmod yükü zsh/stat)
# sembolik bir bağlantının belirli bir dosyaya bağlanıp bağlanmadığını test edin
$ zmodload -i zsh/stat
$! stat -LH s foo.ln || [[ $s[bağlantı] != "foo.exe" ]] || ln -sf foo.exe foo.ln

# dosya tarihlerini karşılaştırma
$ zmodload zsh/stat
$ dosya1=foo
$ dosya2=çubuk
$ dokunmatik çubuk ve uyku 5 ve dokunmatik foo
$ echo $dosya1 is $(($(stat +mtime $dosya2) - \
$(stat +mtime $file1))) $file2'den saniye daha eski.
bar foo'dan 5 saniye daha eskidir

# başka bir dosyadan daha küçük bir diskteki dosyaları listeler
$ zmodload zsh/stat
$ stat -A max +size başka bir dosya
$ yazdır -rl ./**/*(DL-$max)

# Bir diskteki en büyük 100 dosyayı listeleyin
$ zmodload zsh/stat
$ ls -fld ./**/*(d`stat +device .`OL[1,100])

# Yalnızca kullanıcı adını ve dosya adlarını (gibi) alın
# ls -l * | awk '{$3 yazdır" " $8}')
$ zmodload zsh/stat
Dosya için $; Yapmak
> stat -sA kullanıcı +uid -- "$file" &&
> print -r -- "$kullanıcı" "$dosya"
> bitti

# dosyanın gerçek baytları ile ayrılmış dosya baytları arasındaki farkı bulun
$ zmodload zsh/stat
$ print $(($(stat +block -- dosya) * 512 - $(stat +size -- dosya)))

# En büyük dosyayı bul
# ``D'' : nokta dosyalarını dahil etmek için (d küçük harf aygıt içindir)
# ``O'' : ters sıralı (o ters olmayan sıra için küçük harf)
# ``L'' : dosya uzunluğuna göre (l bağlantı sayısı içindir)
# ``[1]'': yalnızca ilkini döndür
$ zmodload zsh/stat
$ istatistik +boyut ./*(DOL[1])

# bayt cinsinden dosya boyutu
$ zmodload zsh/stat
$ istatistik -L +boyut ~ / .zshrc
4707

# Son on gün içinde erişilmeyen bir dizindeki dosyaları silin
# ve dosyaların sahibine dosyalar hakkında bilgi veren BİR posta gönderin
#silme.
$ zmodload zsh/stat zsh/dosyalar
$ typeset -A f; f=()
$ rm -f /yol/**/*(.a+10e{'stat -sA u +uidr $REPLY; f[$u]="$f[$u]$REPLY"'})
$ kullanıcı için (${(k)f}) {print -rn $f[$user]|mailx -s "..." $user}

# Ağaçtaki bir dosyadan daha genç olan tüm dosyalara "ls -l" alın
# belirtilen yaş
$ zmodload zsh/stat
$ d (. ./**/*(N/m-2)) için
> yazdır -r -- $'\n'$d: && cd $d && {
> f için (*(Nm-2om))
> stat -F '%b %d %H:%M' -LsAs -- $f &&
> yazdır -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]}
> cd ~-
> }

# dosya oluşturma tarihini al
$ zmodload zsh/stat
$ stat -F '%d %m %Y' +mtime ~ / .zshrc
+30 06 2004
$ stat -F '%D' +mtime ~ / .zshrc
06/30/04

zsh/dosyalar (gerekmek zmod yükü zsh/dosyalar)
# belirli bir dizeyi içeren dosyalar için bir dizinde arama yapın ve bunları kopyalayın
# dosya başka bir dizine.
$ zmodload zsh/dosyalar
$ IFS=$'\0'
$ cp $(grep -lZr foobar .) diğerdizin

zsh/harita dosyası (gerekmek zmod yükü zsh/harita dosyası)
# iki kalıp için grepping
$ zmodload zsh/harita dosyası
$ model1 = "foo"
$ model2 = "bar foo"
$ print -l ./**/*(DN.e{'z=$mapfile[$REPLY] && [[ $z = *$pattern1* && \
$z = *$desen2* ]]'})
# veya zsh/pcre ile kombinasyon halinde bir çözüm
$ zmodload -i zsh/harita dosyası zsh/pcre
$ model1 = "foo"
$ model2 = "bar foo"
$ pcre_compile "(?s)(?=.*?$pattern1).*?$pattern2"
$ pcre_study
$ print -l ./**/*(DN.e{'pcre_match $mapfile[$REPLY]'})

# ``daha az'ın eşdeğeri / Etc / passwd | grep -v kök''
$ zmodload zsh/harita dosyası
$ IFS=$'\n\n'
$ print -rl -- ${${=haritadosyası[/ Etc / passwd]}:#*kök*}
# veya - büyük/küçük harfe duyarlı olmayanlar için
$ setopt genişletilmişglob
$ print -rl -- ${${=haritadosyası[/ Etc / passwd]}:#*(#i)kök*}

# Eğer bir XML dosyası `` gibi şeyler içeriyorsa '' ve '' '', sayı
# bu boş etiketler ('/>' ile bitenler) yani aynı şekilde karşılaşılırsa
# sipariş, önceki etiketler `` olur 1 '' Ve
# `` 2 ''
$ zmodload zsh/harita dosyası
$ adet=0
$ apfile[data.xml.new]=${(S)mapfile[data.xml]//\
> (#im) *<\/TAGA>/ $((++cnt))<\/TAGA>}

# Maildir/new kullanıcılarında ``filename='gone.src'' içeren tüm dosyalar kaldırılıyor
$ zmodload zsh/{dosyalar,haritadosyası}
$ rm -f /u1/??/*/Maildir/new/100*(.e{'[[ $mapfile[$REPLY] == \
*dosyaadı=\"gitti.scr\"* ]]'})

# Bir postscript dosyasından Başlığı çıkartın ve bu değeri
# dosya adının sonu
$ otomatik yükleme -U zmv
$ zmodload zsh/harita dosyası
$ zmv '(*).ps' '$1-${${${mapfile[$f]##*%%Title: }%% *}//[^a-zA-Z0-9_]/}. not'

zsh/matematik işlevi (gerekmek zmod yükü zsh/matematik işlevi)
$ zmodload zsh/mathfunc
$ echo $(( sin(1/4.0)**2 + cos(1/4.0)**2 - 1 ))
-1.1102230246251565-16
$ echo $(( pi = 4.0 * atan(1.0) ))
3.1415926535897931
$ echo $(( f = sin(0.3) ))
0.29552020666133955
$ yazdır $((1e12 * rand48()))
847909677310.23413
$ print $(( rand48(seed) ))
0.01043488334700271

zsh/termcap (gerekmek zmod yükü zsh/termcap)
$ zmodload -ab zsh/termcap echotc
$ YEŞİL=`echotc AF 2`
$ SARI=`echotc AF 3`
$ KIRMIZI=`echotc AF 1`
$ PARLAKKIRMIZI=`echotc md ; yankı AF 1`
$ yazdır -l ${GREEN}yeşil ${YELLOW}sarı ${RED}kırmızı ${BRIGHTRED}parlakkırmızı

zsh/zpty (gerekmek zmod yükü zsh/zpty)
$ zmodload zsh/zpty
$ zpty PW şifresi $1
$ zpty PW şifresi $1
# ``-r'': komut adının çıktısını okuyun.
# ``z'' : Parametre
$ zpty -r PW z '*şifre:'
# verilen dizeleri giriş olarak komut adına gönder
$ zpty -w PW $2
$ zpty -r PW z '*şifre:'
$ zpty -w PW $2
# -d seçeneği olan ikinci form komutları silmek için kullanılır
# daha önce adlarının bir listesini sağlayarak başlamıştı. İsim yoksa
# verilirse tüm komutlar silinir. Bir komutun silinmesi HUP'a neden olur
# İlgili işleme gönderilecek sinyal.
$ zpty -d PW

zsh/net/soket (gerekmek zmod yükü zsh/net/soket)
# ``-l'': dosya adını dinleyen bir soket aç
# ``-d'': argümanı hedef dosya tanımlayıcısı olarak alınacak
# bağlantı
# ``3'' : dosya tanımlayıcı. ``Z-Shell Kullanım Kılavuzu''na bakın
# (3.7.2: Dosya tanımlayıcıları)
$ zmodload zsh/net/soket
$ zsocket -l -d 3
# ``-a'': sokete gelen bağlantıyı kabul et
$ zsocket -a -d 4 3
$ zsocket -a -d 5 3 # bağlantıyı kabul et
$ echo foobar >&4
$ echo barfoo >&5
$ 4>&- 5>&- 3>&

zsh/zftp (gerekmek zmod yükü zsh/zftp)
$ otomatik yükleme -U zfinit
$zfinit
$ zfparams www.example.geçersiz kullanıcı kimliğim şifrem
$zfopen
$ zfcd ipuçları
$ zfls -l zshtips.html
$ zfput zshtips.html
$ zfls -l zshtips.html

# Hata kontrolüyle FTP kullanarak dosyaları otomatik olarak aktarın
$ otomatik yükleme -U zfinit ; zfinit
$ zftp open host.name.geçersiz kullanıcı şifresi || çıkış
$ zftp get /uzak/dosya > /yerel/dosya; r=$?
$ zftp kapat && çık r

# anında sıkıştırma ve ftp
$ otomatik yükleme -U zfinit ; zfinit
$ zftp open host.name.geçersiz kullanıcı şifresi
$ zftp $dosyasını al | bzip2 > ${dosya}.bz2
$ zftp kapat

# ``get'' yinelemesi
$ otomatik yükleme -U zfinit ; zfinit
$ zfanon cr.yp.to
$ zfcd daemontools
$ 'zfls' dosyası için; Yapmak
> zfget $dosyası
$ bitti
$zfclose

# $HOME/foobar (özyinelemeli) içindeki şundan daha yeni olan tüm normal dosyaları yükleyin:
# ftp.foobar.invalid/path/to/upload'a iki saat
$ otomatik yükleme -U zfinit ; zfinit
$ zfopen ftp.foobar.invalid/path/to/upload
$ cd $HOME/foobar
$ zfput -r **/*(.mh-2)
$zfclose

# ftp'deki uzun dosya listesi
$ otomatik yükleme -U zfinit ; zfinit
$ zfopen bazı ana makineler
$ zfcd /bazı/uzaktan/Yön
$ cd /bazı/yerel/Diz
# List.txt uzak ana bilgisayarda bulunuyorsa, olarak değiştirin
# zfget ${(f)"$(zftp get /path/to/remote/list.txt)"}
$ zfget ${(f)"$(cat list.txt)"}
$zfclose

zsh/zseçimi (gerekmek zmod yükü zsh/zselect)
# Şuna benzer
,----
| $ sg=$(stty -g)
| $ stty -icanon dk 0 kez 50
| $ oku evethayır
| $ stty "$sg"
| $ durumu "$evethayır" in
| > evet) komut1;;
| > *) komut2;;
| > esac
`----
$ zmodload zsh/zselect
$ if zselect -t 500 -r 0 && oku evethayır && [ yes = "$evethayır" ]; Daha sonra
> komut1
> başka
> komut1
> fi

SEÇENEKLER

Navigasyon seçenekleri
auto_cd (komut olarak girerek bir dizine geçiş yapılmasına izin verin). auto_pushd
(dirsleri otomatik olarak push/pop listesine ekleyin) pushd_ignore_dups (ve kopyalamayın)
onları).

Çeşitli
hayır_hup (ZSH'den çıkarken arka plan işlerine HUP sinyali göndermeyin). print_exit_value (göstermek
bir komut sıfırdan farklı bir çıkış koduyla geri döndüğünde çıkış kodunu içeren bir mesaj)

Tarihçe seçenekleri
hist_verify (geçmiş genişletmeden sonra kullanıcının komut satırını düzenlemesine izin verin (örneğin !ls)
hemen çalıştırmak yerine) Tüm oturumlar için aynı geçmiş dosyasını kullanın: seçmek
PAYLAŞIM_TARİHİ

Gizlilik / Güvenlik
no_clobber (veya -C'yi ayarlayın; önleyin > verilen dosyanın kesilmesinden yeniden yönlendirme
zaten var)

Yazım düzeltme
doğru (komutların yazımını otomatik olarak düzeltin). doğru_hepsi (otomatik olarak
komut satırındaki her kelimenin yazımını düzeltin) dvorak (dvorak düzeni)

SIRALANMAMIŞ/ÇEŞİTLİ

Posta yolu: basit çoklu posta yolu:

mailpath=($HOME/Mail/mbox'?mbox'ta yeni posta'
$HOME/Mail/tux.u-strasbg'?smokindeki yeni posta'
$HOME/Mail/lilo'?lilo'da yeni posta'
$HOME/Mail/ldap-fr'?ldap-fr'deki yeni posta')

Posta yolu: dinamik posta yolu:

dizgi -bir posta yolu
ben için ~/Posta/Listeler/*(.); Yapmak
mailpath[$#mailpath+1]="${i}?${i:t} içinde yeni postanız var."
yapılmış

Özel komutlarda gezinmekten kaçının:

com için diğer ad ifadesinde mattrib mcopy mdir mdel'i bulun;
takma ad $com = "noglob $com"

Bashprompt'unuzu zsh'ye geçirmek için zsh'de bulunan bash2zshprompt betiğini kullanın.
altında kaynak dağıtımı Çeşitli.

(t)csh'den zsh'ye geçiş için csh takma adlarını dönüştüren c2z aracını kullanın ve
ortam ve kabuk değişkenlerini zsh'ye aktarın. Bunu csh çalıştırarak ve csh raporuna sahip olarak yapar.
takma adlar ve değişkenler hakkında. Betik daha sonra bunları zsh başlangıç ​​dosyalarına dönüştürür. Biraz var
Bu betiğin üst kısmında belgelenen sorunlar ve kullanım bilgileri.

Burada bir öğenin başlığını ve sabit durumunu ayarlamaya yönelik işlevler yer almaktadır. XTermi veya GNU Ekran için zsh ve
istem görüntülendiğinde sırasıyla geçerli dizine ve komut adına
ve bir komut yürütüldüğünde sırasıyla komut satırının geri kalanı:

işlev başlığı {
if [[ $TERM == "ekran" ]]; Daha sonra
# GNU Ekranı için bu ikisini kullanın:
yazdır -nR $' 33k'$1$' 33'\
yazdır -nR $' 33]0;'$2$''
elif [[ $TERM == "xterm" || $TERM == "rxvt" ]]; Daha sonra
# XTerms için bunun yerine bunu kullanın:
yazdır -nR $' 33]0;'$*$''
fi
}
function precmd { title zsh "$PWD" }
işlev preexec {
-L zsh'yi taklit et
yerel -a cmd; cmd=(${(z)1})
title $cmd[1]:t "$cmd[2,-1]"
}

Aşağıdaki satırı dosyanıza koyun ~/.screenrc bu süslü zor durumu görmek için:

başlık her zaman "%3n %t%? (%u)%?%?: %h%?"

Atanan özel değişkenler:

$LINENO $RANDOM $SECONDS $COLUMNS $HISTCHARS $UID
$EUID $GID $EGID $USERNAME $fignore $mailpath $cdpath

 

Birincil site

http://www.zsh.org/

Proje sayfası

http://sourceforge.net/projects/zsh/

sunsite.dk'deki Z kabuk sayfası

http://zsh.sunsite.dk/

Bash'ten Z Shell'e: Komut Satırını Fethetmek - kitap

http://www.bash2zsh.com/

"Zsh - die magische Shell" (Zsh hakkında Almanca kitap), Sven Guckes ve Julius Plenz tarafından

http://zshbuch.org/

Posta listesi arşivi

http://www.zsh.org/mla/

ZSH-SSS

http://zsh.dotsrc.org/FAQ/

Kullanici rehberi

http://zsh.sunsite.dk/Guide/

ZSH-Wiki

http://zshwiki.org/home/

BYU'dan kısa bir tanıtım

http://docs.cs.byu.edu/linux/advanced/zsh.html

Fare Desteği ;)

http://stchaz.free.fr/mouse.zsh

Perdeler yukarı: Z kabuğunu tanıtıyoruz

http://www-128.ibm.com/developerworks/linux/library/l-z.html?dwzone=linux

ZSH-Liebhaberseite (almanca)

http://michael-prokop.at/computer/tools_zsh_liebhaber.html

ZSH-Seite von Michael Prokop (almanca)

http://michael-prokop.at/computer/tools_zsh.html

ZSH Hızlı giriş

http://aperiodic.net/phil/prompt/

Adam'ın ZSH sayfası

http://www.adamspiers.org/computing/zsh/

Zzappers ZSH'nin En İyi İpuçları

http://www.rayninfo.co.uk/tips/zshtips.html

Zsh Web Sayfası, Christian Schneider

http://www.strcat.de/zsh/

zsh-aşıklar web sayfası

http://grml.org/zsh/

IRC kanalı

#zsh at irc.freenode.org

Z kabuğu referans kartı (zsh-lovers debian paketine dahildir)

http://www.bash2zsh.com/zsh_refcard/refcard.pdf

YAZARLAR

Bu kılavuz sayfası Christian Michael Prokop tarafından yazılmıştır. sokak kedisi Schneider ve Matthias
Kopfermann. Ancak zsh-geek'lerden, örneğin zsh-posta listelerinden birçok fikir alınmıştır.
(zsh kullanıcıları ve zsh çalışanları), google, haber grupları ve zsh-Wiki. Havalılığınız için teşekkürler ve
inanılmaz ipuçları. Sizden çok şey öğrendik!

Alfabetik sırayla:

Andrew 'zefram' Ana - http://www.fysh.org/~zefram/
Barton E. Schaefer - http://www.well.com/user/barts/
Matthias Kopfermann- http://www.infodrom.north.de/~matthi/
Oliver Kiddle- http://people.freenet.de/opk/
Paul Falstad- http://www.falstad.com/
Peter Stephenson- http://homepage.ntlworld.com/p.w.stephenson/
Richard Coleman
Stephane Chazelas- http://stephane.chazelas.free.fr/
Sven Guckes- http://www.guckes.net/
Sven Wischnowsky- http://w9y.de/zsh/zshrc

Onworks.net hizmetlerini kullanarak zsh-lovers'ı çevrimiçi kullanın