Dies ist der Befehl von zsh-lovers, der beim kostenlosen Hosting-Anbieter OnWorks mit einer unserer zahlreichen kostenlosen Online-Workstations wie Ubuntu Online, Fedora Online, dem Windows-Online-Emulator oder dem MAC OS-Online-Emulator ausgeführt werden kann
PROGRAMM:
NAME/FUNKTION
zsh-lovers – Tipps, Tricks und Beispiele für die Z-Shell
ZUSAMMENFASSUNG
Lies es einfach. ;-)
Überblick
Immer wenn wir uns das zsh-Handbuch ansehen, fragen wir uns, warum es keine Beispiele gibt oder diese einfach
Dinge im (Hüllen-)Leben. Das ZSH enthält viele Funktionen, für einige gab es jedoch keine Manpage
Beispiele (wie procmailex(5)). Aus diesem Grund haben wir diese Manpage geschrieben.
Die meisten Tricks und Oneliner stammen von den Mailinglisten zsh-users, zsh-workers, google,
Newsgroups und von uns selbst. Siehe Sektion Verbindet .
Hinweis: Diese Manpage (ZSH-Liebhaber(1)) ist nicht ein offizieller Teil der Z-Shell! Es ist einfach gerecht
zum Spaß - Manpage ;) Für Kommentare, Fehlerberichte und Feedback werfen Sie einen kurzen Blick auf die
Abschnitt Fehler.
SHELL-SCRIPTING
Dieser Abschnitt enthält einige Beispiele für häufig benötigte Shellscript-Sachen. Beachten Sie, dass Sie
sollte nicht verwendet werden, da sonst die meisten Beispiele nicht funktionieren. Parse-Optionen in Shellscripts. Beispiel
entnommen aus ZWS von Adam Chodorowski (http://www.chodorowski.com/projects/zws/):
parse_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
wenn [[ $? != 0 || "$o_help" != "" ]]; Dann
echo Verwendung: $(basename „$0“) „[-p PORT] [-r DIRECTORY]“
Beenden Sie 1
fi
port=$o_port[2]
root=$o_root[2]
log=$o_log[2]
if [[ $root[1] != '/' ]]; then root="$PWD/$root"; fi
}
# Benutze jetzt die Funktion:
parse_options $*
Beispiele:
Verfügbare Unterabschnitte sind Aliases, Abschlüsse, Unsortiert/Verschiedenes Beispiele, (Rekursiv)
Globbeln - Beispiele, Modifikatoren Verwendung, Umleitungsbeispiele, ZMV-Beispiele und
Modulbeispiele.
ALIAS
Suffix-Aliase werden in zsh seit Version 4.2.0 unterstützt. Einige Beispiele:
Alias -s tex=vim
Alias -s html=w3m
Alias -s org=w3m
Drücken Sie nun nach der Eingabe die Eingabetaste foobar.tex startet vim mit foobar.tex. Anruf bei a
HTML-Datei führt den Browser w3m aus. www.zsh.org und durch Drücken der Eingabetaste wird w3m mit dem Argument gestartet
www.zsh.org. Globale Aliase können überall in der Befehlszeile verwendet werden. Beispiel:
$ alias -g C='| wc -l'
$ grep Alias ~/.zsh/* C.
443
Einige mehr oder weniger nützliche globale Aliase (wählen Sie, ob sie für Sie nützlich sind oder nicht).
dein eigenes):
alias -g ...='../ ..'
Alias -g ....='../../..'
alias -g .....='../../../..'
alias -g CA="2>&1 | cat -A"
Alias -g C='| wc -l'
alias -g D="DISPLAY=:0.0"
Alias -g DN=/dev/null
alias -g ED="export DISPLAY=:0.0"
alias -g EG='|& egrep'
alias -g EH='|& head'
alias -g EL='|& less'
alias -g ELS='|& less -S'
alias -g ETL='|& tail -20'
alias -g ET='|& tail'
alias -g F=' | fmt -'
Alias -g G='| egrep'
Alias -g H='| Kopf'
alias -g HL='|& head -20'
alias -g Sk="*~(*.bz2|*.gz|*.tgz|*.zip|*.z)"
alias -g LL="2>&1 | weniger"
Alias -g L="| less"
Alias -g LS='| weniger -S'
Alias -g MM='| am meisten'
Alias -g M='| mehr'
alias -g NE="2> /dev/null"
Alias -g NS='| sortieren -n'
alias -g NUL="> /dev/null 2>&1"
Alias -g PIPE='|'
alias -g R=' > /c/aaa/tee.txt '
Alias -g RNS='| sort -nr'
Alias -g S='| Sortieren'
Alias -g TL='| Schwanz -20'
Alias -g T='| Schwanz'
Alias -g US='| sortieren -u'
Alias -g VM=/var/log/messages
Alias -g X0G='| xargs -0 egrep'
Alias -g X0='| xargs -0'
Alias -g XG='| xargs egrep'
Alias -g X='| xargs'
FERTIGSTELLUNG
Siehe auch man 1 zshcompctl zshcompsys zshcompwid. zshcompctl ist der alte Stil von zsh
programmierbare Vervollständigung, zshcompsys ist das neue Vervollständigungssystem, zshcompwid ist das zsh
Abschluss-Widgets.
Einige Funktionen wie _apt und _dpkg sind sehr langsam. Sie können einen Cache als Proxy verwenden
die Ergebnisliste (wie die Liste der verfügbaren Debian-Pakete) Verwenden Sie einen Cache:
zstyle ':completion:*' use-cache on
zstyle ':completion:*' Cache-Pfad ~/.zsh/cache
Verhindern Sie, dass CVS-Dateien/-Verzeichnisse vervollständigt werden:
zstyle ':completion:*:(all-|)files' ignorierte Muster '(|*/)CVS'
zstyle ':completion:*:cd:*' ignorierte Muster '(*/)#CVS'
Fuzzy-Matching von Vervollständigungen für den Fall, dass Sie sich vertippen:
zstyle ':Completion:*' Completer _Complete _Match _Approximate
zstyle ':completion:*:match:*' nur Original
zstyle ':completion:*: approximate:*' max-errors 1 numerisch
Und wenn Sie möchten, dass die Anzahl der von _ approximate zugelassenen Fehler mit der Länge zunimmt
von dem, was Sie bisher eingegeben haben:
zstyle -e ':completion:*: approximate:*' \
max-errors 'reply=($((($#PREFIX+$#SUFFIX)/3))numeric)'
Ignorieren Sie Vervollständigungsfunktionen für Befehle, die Sie nicht haben:
zstyle ':completion:*:functions' ignorierte Muster '_*'
Mit Hilfsfunktionen wie:
xdvi() { Befehl xdvi ${*:-*.dvi(om[1])} }
In vielen Fällen können Sie den Abschluss überhaupt vermeiden, aber wenn Sie dies tun, möchten Sie dies vielleicht tun
sofort in die Menüauswahl gelangen und die Wörter nach Zeit sortieren lassen:
zstyle ':completion:*:*:xdvi:*' Menü ja auswählen
zstyle ':completion:*:*:xdvi:*' Dateisortierzeit
Vervollständigen von Prozess-IDs mit Menüauswahl:
zstyle ':completion:*:*:kill:*' Menü ja auswählen
zstyle ':completion:*:kill:*' Force-List immer
Wenn Sie am Ende ein Verzeichnis als Argument verwenden, wird dadurch der abschließende Schrägstrich entfernt (nützlich).
in ln)
zstyle ':completion:*' Squeeze-Slashes true
cd wählt niemals das übergeordnete Verzeichnis aus (z. B. cd ../ ):
zstyle ':completion:*:cd:*' discover-parents parent pwd
Eine andere Methode für schnell Übernehmen Verzeichnisse. Fügen Sie dies zu Ihrem hinzu ~ / .zshrc, dann einfach eingeben
„cd ..../dir“
rationalise-dot() {
if [[ $LBUFFER = *.. ]]; Dann
LBUFFER+=/ ..
sonst
LBUFFER+=.
fi
}
zle -N rationalise-dot
bindkey . rationalisieren-Punkt
UNSORTIERT/VERSCHIEDENES Beispiele
Hinweis: Eine Liste der gültigen Glob-Qualifizierer finden Sie in zshexpn(1). Siehe „man 1 zshexpn |“.
less -p“-Qualifizierer für Details.
# Holen Sie sich die Namen aller Dateien, die *nicht* mit einem Muster *irgendwo* auf der übereinstimmen
# Datei (und ohne „-L“, weil es GNUish ist)
$ print -rl -- *(.^e{'grep -q pattern $REPLY'})
# oder
$ : *(.e{'grep -q pattern $REPLY || print -r -- $REPLY'})
# zufällige Zahlen
$ echo $[${RANDOM}%1000] # zufällig zwischen 0-999
$ echo $[${RANDOM}%11+10] # zufällig zwischen 10 und 20
$ echo ${(l:3::0:)${RANDOM}} # N Ziffern lang (3 Ziffern)
# ein Wort umkehren
$ echo "${(j::)${(@Oa)${(s::):-hello}}}"
# Neuestes Verzeichnis anzeigen
$ ls -ld *(/om[1])
# zufälliges Array-Element
$ FILES=( .../files/* )
$ feh $FILES[$RANDOM%$#FILES+1]
# cat erste Zeile in allen Dateien in diesem Verzeichnis
$ für Datei (*(ND-.)) IFS= read -re < $file
# testet, ob ein Parameter numerisch ist
$ if [[ $1 == <-> ]] ; Dann
Echo numerisch
sonst
Echo nicht numerisch
fi
# Zeigt mir alle .c-Dateien an, für die es keine .o-Datei gibt.
$ print *.c(e_'[[ ! -e $REPLY:ro ]]'_)
# Alle Dateien in /war/ die nicht Root gehören
$ ls -ld /war/*(^u:root)
# Alle Dateien, für die der Besitzer Lese- und Ausführungsrechte hat
$ echo *(f:u+rx:)
# Das Gleiche, aber auch andere haben keine Ausführungsberechtigungen
$ echo *(f:u+rx,ox:)
# Klammererweiterung – Beispiel
$ X=(ABC)
$ Y=(+ -)
$ print -r -- $^X.$^Y
A.+ A.- B.+ B.- C.+ C.-
# Rufen Sie die neueste Datei ab, die die Zeichenfolge „fgractg*.log“ enthält
# Dateiname und enthält die Zeichenfolge „ORA-“.
$ file=(fgractg*.log(Nm0om[1]))
$ (($#file)) && grep -l ORA- $file
# ohne Zsh
$ files=$( find . -name . -o -prune -name 'fgractg*>log' -mtime 0 -print )
> if [ -n "$files" ]; Dann
> IFS='
> '
> setze -f
> file=$(ls -td $files | head -1)
> grep -l ORA- "$file"
> fi
# Die angegebene Anzahl an untergeordneten Prozessen laufen lassen, bis die gesamte Aufgabe abgeschlossen ist
$ zsh -c 'sleep 1 & Sleep 3 & Sleep 2& print -rl -- $jobtexts'
# Entfernen Sie Dateien mit der Länge Null und .bak-Dateien in einem Verzeichnis
$ rm -i *(.L0) *.bak(.)
# Dateien ausdrucken, die keine Erweiterungen haben
$ printf '%s\n' ^?*.*
$ printf '%s\n' ^?*.[^.]*(D)
$ ls -d -- ^?*.*(D)
# Dateien finden, die keine bestimmte Zeichenfolge enthalten
$ print -rl file* | comm -2 -3 - <(grep -l string file*)'
$ für f (Datei*(N)) grep -q string $f || print -r $f'
# Anzeigen/Überprüfen, ob eine Option gesetzt ist oder nicht. Es funktioniert sowohl mit $options als auch mit
# mit $builtins
$ echo $options[richtig]
WOW!
$ $optionen[zle]
on
# Zählen Sie die Anzahl der Verzeichnisse auf dem Stapel
$ print $((${${(z)${(f)"$(dirs -v)"}[-1]}[1]} + 1)) # oder
$ dirs -v | awk '{n=$1}END{print n+1}'
# Passend für alle Dateien, deren Dateiname keinen Punkt enthält
$ ls *~*.*(.)
# Nur die IP-Adresse von „ifconfig device“ anzeigen
# ifconfig von Net-Tools (Linux)
$ print ${${$(LC_ALL=C / sbin / ifconfig eth0)[7]}:gs/addr://}
# ifconfig von 4.2BSD {Free,Net,Open}BSD
$ drucken ${$(/ sbin / ifconfig tun0)[6]}
# Pingen Sie alle IP-Adressen einiger Klasse-C-Adressen oder aller Hosts an
# hinein / Etc / hosts
$ für i in {1..254}; ping -c 1 192.168.13.$i; Erledigt
or
$ I=1
$ while ( [[ $I -le 255 ]] ); ping -1 2 150.150.150.$I; lass ich++; Erledigt
or
$ für i in $(sed 's/#.*//' > / Etc / hosts | awk '{print $2}')
: tun
: echo „Versuche $i ...“
: ping -c 1 $i ;
: echo '============================='
: Erledigt
# alle verfügbaren Module beim Start laden
$ Schriftsatz -U m
$ m=()
$ für md ($module_path) m=($m $md/**/*(*e:'REPLY=${REPLY#$md/}'::r))
$ zmodload -i $m
# Benennen Sie alle Dateien in einem Verzeichnis um, sodass ihre Namen eine Ziffer erhalten
# Präfix in der Standardsortierreihenfolge.
$ i=1; für j in *; do mv $j $i.$j; ((i++)); Erledigt
$ i=1; für f in *; do mv $f $(echo $i | \
awk '{ printf("%03d", $0)}').$f; ((i++)); Erledigt
$ Ganzzahl i=0; für f in *; do mv $f $[i+=1].$f; Erledigt
# Finden (und drucken) Sie alle symbolischen Links ohne Ziel innerhalb der aktuellen
# dirtree.
$ $ Datei **/*(D@) | fgrep kaputt
$ für i in **/*(D@); [[ -f $i || -d $i ]] || echo $i
$ echo **/*(@-^./=%p)
$ print -l **/*(-@)
# Listen Sie alle einfachen Dateien auf, die keine in „fignore“ aufgeführten Erweiterungen haben.
$ ls **/*~*(${~${(j/|/)fignore}})(.)
# siehe oben, aber jetzt ausführbare Dateien weglassen
$ ls **/*~*(${~${(j/|/)fignore}})(.^*)
# Dateien ausdrucken, die keine Erweiterungen haben (erfordert *setopt Extendedglob*
# und *setopt dotglob*)
$ printf '%s\n' ^?*.*
# Dateien in umgekehrter Reihenfolge nach Namen sortiert auflisten
$ print -rl -- *(Ein)
or
$ print -rl -- *(^on)
# Synonym für „ps ax |“. awk '{print $1}'''
$ print -l / proc /*/cwd(:h:t:s/self//)
# Holen Sie sich die PID eines Prozesses (ohne „ps“, „sed“, „pgrep“, ..
# (unter Linux)
$ pid2 () {
> lokal i
> für mich / proc /<->/stat
> tun
> [[ "$(< $i)" = *\((${(j:|:)~@})\)* ]] && echo $i:h:t
> fertig
> }
# für X in 'n' 'o' 'p' 'q' 'r' 's' 't' 'u' 'v' 'w' 'x' 'y'; Tun ...
$ for (( i = 36#n; i <= 36#y; i++ )); Tun
> ${$(([##36]i)):l} drucken
> fertig
# oder in Kombination mit „dc“
$ print {$((##n))..$((##y))}P\ 10P | Gleichstrom
# oder mit „eval“
$ eval print '${$(([##36]'{$((36#n))..$((36#y))}')):l}'
# foreach in einer Zeile der Shell
$ für f (*) print -r -- $f
# rekursiv ein Verzeichnis ohne Daten/Dateien kopieren
$ dirs=(**/*(/))
$ cd – $dest_root
$ mkdir -p -- $dirs
# oder ohne zsh
$ finden . -type d -exec env d="$dest_root" \
sh -c ' exec mkdir -p -- "$d/$1"' '{}' '{}' \;
# Wenn „foo=23“, dann mit 10 Ziffern und führender „0“ drucken.
$ foo=23
$ print ${(r:10::0:)foo}
# Finden Sie den Namen aller Dateien in ihrem Home-Verzeichnis, die Folgendes haben
# mehr als 20 Zeichen in ihren Dateinamen
print -rl $HOME/${(l:20::?:)~:-}*
# Arrays speichern
$ print -r -- ${(qq)m} > $nameoffile # speichern
$ eval "m=($(cat -- $nameoffile)" # oder verwenden
$ m=("${(@Q)${(z)"$(cat -- $nameoffile)"}}") # um es wiederherzustellen
# ein „ls -l“ für alle Dateien im Baum erhalten, die jünger als a sind
# angegebenes Alter (z. B. „ls -l“ alle Dateien im Baum, die wo waren
# in den letzten 2 Tagen geändert)
$ ls -tld **/*(m-2)
# Dadurch erhalten Sie eine Auflistung von 1 Datei-Perl-Zeile (nicht à la ls -R).
# Überlegen Sie sich eine einfache Möglichkeit, eine Ausgabe im „ls -R“-Stil zu erhalten
# nur Dateien, die neuer als 2 Tage alt sind.
$ für d (. ./**/*(/)) {
> print -r -- $'\n'${d}:
> cd $d && {
> l=(*(Nm-2))
> (($#l)) && ls -ltd -- $l
> cd ~-
> }
> }
# Wenn Sie möchten, dass auch Verzeichnisse einbezogen werden, auch wenn ihre mtime
# ist älter als 2 Tage:
$ für d (. ./**/*(/)) {
> print -r -- $'\n'${d}:
> cd $d && {
> l=(*(N/,m-2))
> (($#l)) && ls -ltd -- $l
> cd ~-
> }
> }
# Und wenn Sie möchten, dass nur die Verzeichnisse mit mtime < 2 Tagen aufgelistet werden:
$ für d (. ./**/*(N/m-2)) {
> print -r -- $'\n'${d}:
> cd $d && {
> l=(*(Nm-2))
> (($#l)) && ls -ltd -- $l
> cd ~-
> }
> }
# print 42 ``-''
$ echo ${(l:42::-:)}
# oder verwenden Sie „$COLUMS“
$ echo ${(l:$COLUMNS::-:)}
# und jetzt mit Farben (erfordert Autoload-Farben ;Farben)
$ echo "$bg[red]$fg[black]${(l:42::-:)}"
# Leiten Sie STDERR zu einem Befehl wie xless um, ohne auch STDOUT umzuleiten.
$ foo 2>>(xless)
# aber dadurch wird der Befehl asynchron ausgeführt. Um es synchron zu machen:
$ { { foo 1>&3 } 2>&1 | xless } 3>&1
# Benennen Sie alle MP3-Dateien von „Name mit Leerzeichen.mp3“ in „Name mit Leerzeichen.mp3“ um
$ für i in *.mp3; Tun
> mv $i ${${(C)i}:s/Mp3/mp3/}
> fertig
# Passen Sie Dateinamen an, die nur Ziffern enthalten und mit .xml enden (erforderlich).
# *setopt kshglob*)
$ ls -l [0-9]##.xml
$ ls -l <0->.xml
# Entfernen Sie alle „Nicht-TXT“-Dateien
$ rm ./^*.txt
# Verschieben Sie 200 Dateien von einem Verzeichnis in ein anderes
$ mv -- *([1,200]) /another/Dir
# Bilder konvertieren (foo.gif => foo.png):
$ für i in **/*.gif; Konvertieren Sie $i $i:r.png
# eine Sammlung von MP3-Dateien in Wave oder CDR konvertieren,
# zB file.wav -> file.mp3)
$ für i (./*.mp3){mpg321 --w - $i > ${i:r}.wav}
# Mit LaTeX2HTML erstellte Dateien herunterladen (zum Beispiel den ZSH-Guide):
$ für f in http://zsh.sunsite.dk/Guide/zshguide{,{01..08}}.html; Tun
> lynx -source $f >${f:t}
> fertig
# Verschieben Sie alle Dateien in dir1 und dir2, die eine Zeilenanzahl von mehr als 10 haben, nach
# ein anderes Verzeichnis, sagen Sie „/more10“
$ mv dir[12]/**/*.cr(-.e{'((`wc -l < $REPLY` > 10))'}) /more10
# Erstellen Sie mit dpkg eine Masterliste aller installierten Dateien
$ diff <(find / | sort) <(cat /var/lib/dpkg/info/*.list | Sortieren)
# Ersetze diese verdammten Escape-Sequenzen:
$ Farben automatisch laden; Farben
$ print „$bg[cyan]$fg[blue]Du bist ein Idiot“ >> /dev/pts/3
# ASCII-Wert eines Zeichens abrufen
$ char=N ; drucken $((#char))
# Dateiname „Erweiterung“
# Hinweis: Das (N) besagt, dass für diesen speziellen Fall die Option nullglob verwendet werden soll
# Kugelmuster.
$ für i in *.o(N); Tun
> rm $i
> fertig
# Dateien umbenennen; dh FOO zu Foo und Bar zu BAR
$ für i in *(.); mv $i ${i:l} # `FOO' zu `foo'
$ für i in *(.); mv $i ${i:u} # `bar zu `BAR'
# Alle suid-Dateien in $PATH anzeigen
$ ls -latg ${(s.:.)PATH} | grep '^...s'
# oder komplexer ;)
$ print -l ${^path}/*(Ns,S)
# oder nur ausführbare Dateien mit einem vom Benutzer angegebenen Muster anzeigen
$ print -l ${^path}/*vim*(*N)
# gzip-Dateien, wenn sie eine bestimmte Zeichenfolge enthalten
$ gzip ${(ps:\0:)"$(grep -lZ foobar ./*.txt(.))"}
# Ein kleiner Einzeiler, der von stdin liest und zuerst nach stdout ausgibt
# eindeutige Zeile, dh es werden keine zuvor gedruckten Zeilen gedruckt
# (dies ähnelt dem Befehl „unique“, kann jedoch nur „unique“ verarbeiten
# benachbarte Zeilen).
$ IFS=$'\n\n'; print -rl -- ${(Oau)${(Oa)$(cat file;echo .)[1,-2]}}
# Listet jede ausführbare Datei in PATH auf
$ print -l ${^path}/*(-*N)
# Alle .c-Dateien in allen Unterverzeichnissen mit Ausnahme aller SCCS-Unterverzeichnisse abgleichen?
$ ls **/*.c~(*/)#SCCS/*
# Alle `README'-Dateien auflisten, ohne Berücksichtigung der Groß- und Kleinschreibung mit max. ein Tippfehler
$ ls **/*(#ia2)readme
# Bei der Prüfung auf Variablen wird die Groß-/Kleinschreibung nicht beachtet
$ if [[ $OSTYPE == (#i)LINUX*(#I) ]]; Dann
> echo „Pinguin an Bord.“
> sonst
> echo „Kein Linux.“
> fi
(Rekursiv) Globbeln - Beispiele
Eine Liste der gültigen Glob-Qualifizierer finden Sie in zshexpn(1). Hinweis: **/ ist äquivalent zu
(*/)#! Zum Beispiel:
$ print (*/)#zsh_us.ps
zsh-4.2.3/Doc/zsh_us.ps
$ print **/zsh_us.ps
zsh-4.2.3/Doc/zsh_us.ps
# Suchen Sie in allen Unterverzeichnissen nach „README“.
$ ls -l **/README
# Verzeichnisse finden, die sowohl „index.php“ als auch „index.html“ enthalten, oder in
# allgemein, Verzeichnisse, die mehr als eine Datei enthalten, die mit „index.*“ übereinstimmt
$ ls **/*(D/e:'[[ -e $REPLY/index.php && -e $REPLY/index.html ]]':)
# oder
$ ls **/*(D/e:'l=($REPLY/index.*(N)); (( $#l >= 2 ))':)
# Find-Befehl zum Suchen nach dem Verzeichnisnamen anstelle des Basisnamens
$ print -rl /**/*~^*/path(|/*)
# oder - ohne Zsh
$ find / | grep -e /path/ -e '/path$'
# Geben Sie den Pfad der Verzeichnisse aus, die die zehn größten regulären C-Dateien enthalten
# im aktuellen Verzeichnis und den Unterverzeichnissen.
$ print -rl -- **/*.c(D.OL[1,10]:h) | sortieren -u
# Dateien mit der Größe == 0 finden und eine E-Mail senden
$ files=(**/*(ND.L0m+0m-2))
> (( $#files > 0 )) && print -rl -- $files | \
mailx -s „leere Dateien“ [E-Mail geschützt]
# rekursiver chmod
$ chmod 700 **/(.) # Nur Dateien
$ chmod 700 **/(/) # Nur Verzeichnisse
# alle Dateien in diesem Verzeichnis in 2 Spalten ausdrucken
$ print -rC2 -- ${1:[...]}/*(D:t)
# ^- Anzahl der Spalten
# oder – wenn Sie Bedenken wegen Sonderzeichen haben – verwenden Sie
$ list=(${1:[...]}/*(ND:t))
$ (($#list)) && print -rC2 -- ${(V)list}
# Alle Dateien durchsuchen in /Zuhause/*/*-mail/ mit der Einstellung „chmod -s“-Flag
# (rekursiv, Punktdateien einschließen) Entfernen Sie das setgid/setuid-Flag und drucken Sie
# eine Nachricht
$ chmod -s /Zuhause/*/*-mail(DNs,S) /Zuhause/*/*-mail/**/*(DNs,S))
# oder mit einem kleinen Skript
$ für Datei (/Zuhause/*/*-mail(DNs,S) /Zuhause/*/*-mail/**/*(DNs,S)) {
> print -r -- $file
> chmod -s $file && print -r $file behoben
> }
# oder verwenden Sie „zargs“ (erfordert automatisches Laden von Zargs), um auch die arg-Liste zu verhindern
# langer Fehler
$ zargs /Zuhause/*/*-mail(DNs,S) /Zuhause/*/*-mail/**/*(DNs,S)) -- chmod -s
# Dateien ab „foo23“ aufwärts auflisten (foo23, foo24, foo25, ..)
$ ls -l foo<23->
# alle Dateien abrufen, die mit den Datumszeichenfolgen vom 4. Juni bis beginnen
# 9. Juni 2004
$ ls -l 200406{04..10}*(N)
# oder wenn sie die Form 200406XX haben (erfordert „setopt erweitert_glob“)
$ ls -l 200306<4-10>.*
# Leerzeichen aus Dateinamen entfernen
$ für a in ./**/*\ *(Dod); do mv $a ${a:h}/${a:t:gs/ /_}; Erledigt
# Nur alle *.c- und *.h-Dateien anzeigen
$ ls -l *.(c|h)
# Nur alle *.c-Dateien anzeigen und „foo.c“ ignorieren
$ ls *.c~foo.c
# Daten im *wirklich* Binärformat anzeigen
$ zsh -ec 'while {} {printf %.8x $n;repeat 8 \
> {read -ku0 a printf \ %.8d $(([##2]#a))};print;((n+=8))}' < binär
# Nur weltweit lesbare Dateien anzeigen
$ ls -l *(R)
# Listendateien im aktuellen Verzeichnis sind vom Eigentümer nicht beschreibbar
$ print -l ~/*(ND.^w)
# Suchen und löschen Sie die Dateien, die älter als ein angegebener Parameter sind
# (Sekunden/Minuten/Stunden)
# löscht alle regulären Dateien in /Dir, die älter als 3 Stunden sind
$ rm -f /Dir/**/*(.mh+3)
# löscht alle Symlinks in /Dir, die älter als 3 Minuten sind
$ rm -f /Dir/**/*(@mm+3)
# löscht alle Nicht-Verzeichnisse in /Dir, die älter als 30 Sekunden sind
$ rm -f /Dir/**/*(ms+30^/)
# löscht alle Ordner, Unterordner und Dateien, die älter als eine Stunde sind
$ rm ./**/*(.Dmh+1,.DL0)
# löscht alle Dateien, die älter als 6 Stunden sind
$ rm -f **/*(mh+6)
# Entfernt alle Dateien bis auf die zehn neueren (alle bis auf die letzten 10 löschen).
# Dateien in einem Verzeichnis)
$ rm ./*(Om[1,-11])
Hinweis: Wenn Ihre Argumentliste zu lang ist, verwenden Sie den integrierten RM. Für
Beispiel:
$ zmodload zsh/files ; rm -f **/*(mh+6)
oder verwenden Sie die Zargs-Funktion:
$ autoload zargs ; zargs **/*(mh+6) -- rm -f
# Ein Benutzerhandbuch für die Z-Shell /5.9: Generierung und Muster von Dateinamen
# Matching findet alle Dateien in allen Unterverzeichnissen, rekursive Suche,
# die einen Vornamen haben, Groß-/Kleinschreibung nicht berücksichtigen, mindestens 50 KB groß sind,
# nicht älter als eine Woche, im Besitz des Root-Benutzers und zulässig
# zu einem einzelnen Fehler in der Schreibweise des Namens. Tatsächlich das erforderliche
# Ausdruck sieht so aus:
$ ls **/(#ia1)name(LK+50mw-1u0)
# Ändern Sie die UID von 102 auf 666
$ chown 666 **/*(u102)
# Alle Dateien auflisten, die seit den letzten 10 Stunden nicht aktualisiert wurden
$ print -rl -- *(Dmh+10^/)
# Nur die älteste Datei in einem Verzeichnis löschen
$ rm ./*Dateiname*(Om[1])
# Sortieren Sie die Ausgabe von „ls -l“ nach Dateigröße
$ ls -fld *(OL)
# die aktuellste Datei in einem Verzeichnis finden
$ setopt dotglob ; Verzeichnis drucken/**/*(om[1])
# Nur leere Dateien anzeigen, die weder „gruppiert“ noch „weltweit beschreibbar“ sind
$ ls *(L0f.go-w.)
# Suchen und listen Sie die zehn neuesten Dateien in Verzeichnissen und Unterverzeichnissen auf.
# (rekursiv)
$ print -rl -- **/*(Dom[1,10])
# Mit dem Befehl „ls“ nur 5 Zeilen ausgeben (wie „ls -laS | head -n 5“).
$ ls -fl *(DOL[1,5])
# Zeigt die 5–10 zuletzt geänderten Dateien an.
$ print -rl -- /path/to/dir/**/*(D.om[5,10])
# Alle Dateien ohne gültigen Besitzer finden.
$ chmod someuser /**/*(D^u:${(j.:u:.)${(f)"$(/ etc / passwd)"}%%:*}:)
# Finden Sie alle leeren Verzeichnisse in einem Baum.
$ für f in ***/*(/l2); do foo=($f/*(N)); [[ -z $foo ]] && print $f; Erledigt
# Hinweis: Seit Zsh 4.2.1 gibt der Glob-Qualifizierer F ein nicht leeres Verzeichnis an.
# Daher bezeichnet *(F) alle Unterverzeichnisse mit Einträgen, *(/^F) bedeutet alle
# Unterverzeichnisse ohne Einträge.
$ ls -ld *(/^F)
# Leere Verzeichnisse anschließend entfernen.
$ rmdir ./**/*(/od) 2> /dev/null
# Nur Dateien anzeigen, die der Gruppe „Benutzer“ gehören.
$ ls -l *(G[Benutzer])
Modifikatoren Verwendung
Modifikatoren sind ein leistungsstarker Mechanismus, mit dem Sie die von Parametern zurückgegebenen Ergebnisse ändern können.
Dateinamen- und Verlaufserweiterung. Sehen zshexpn(1) für Details.
# HINWEIS: Zsh 4.3.4 erforderlich!
$ autoload -U Alter
# Dateien wurden heute geändert
$ print *(e:age today now:)
# Dateien seit 5:XNUMX Uhr geändert
$ print *(e-age 17:00 now-)
# ... seit gestern 5 Uhr
$ print *(e-age gestern,17:00 jetzt-)
# ... vom letzten Weihnachten vor heute
$ print *(e-age 2006 heute-)
# ... Vorgestern
$ print *(e-age 1970 gestern-)
# alle Dateien, die zwischen dem Beginn dieser Daten geändert wurden
$ print *(e:age 2006 10:)
# alle an diesem Datum geänderten Dateien
$ print *(e:age 2006:)
# Lieferzeiten.
$ print *(e-age 2006/10/04:10:15 2006/10/04:10:45-)
# Entfernen Sie eine nachgestellte Pfadnamenkomponente und lassen Sie den Kopf übrig. Das funktioniert so
# `Verzeichnisname'.
$ echo =ls(:h)
/Behälter
# Entfernen Sie alle führenden Pfadnamenkomponenten und lassen Sie das Ende übrig. Das funktioniert
# wie „Basisname“.
$ echo =ls(:t)
ls
# Entfernen Sie das Suffix aus jeder Datei (*.sh in diesem Beispiel)
$f:e ist die Dateierweiterung $f
:h --> head (dirname)
:t --> tail (Basisname)
:r --> rest (Erweiterung entfernt)
$ für f (*.sh) mv $f $f:r
# Entfernen Sie eine Dateinamenerweiterung der Form „.xxx“ und lassen Sie den Stammnamen übrig.
$ echo $PWD
/usr/src/linux
$ echo $PWD:t
linux
# Alle außer der Erweiterung entfernen.
$ foo=23.42
$ echo $foo
23.42
$ echo $foo:e
42
# Geben Sie den neuen Befehl aus, führen Sie ihn jedoch nicht aus. Funktioniert nur mit Verlauf
# Erweiterung.
$ echo =ls(:h)
/Behälter
$ !echo:p
$ echo =ls(:h)
# Zitieren Sie die ersetzten Wörter und vermeiden Sie weitere Ersetzungen.
$ bar="23'42"
$ echo $bar
23'42
$ echo $bar:q
23 \ '42
# Wandeln Sie die Wörter in Kleinbuchstaben um.
$ bar=FOOBAR
$ echo $bar
FOOBAR
$ echo $bar:l
foobar
# Wandeln Sie die Wörter in Großbuchstaben um.
$ bar=foobar
$ echo $bar
foobar
$ echo $bar:u
FOOBAR
# 1. Zeichen eines Wortes in Großbuchstaben umwandeln
$ foo="eins zwei drei vier"
$ print -r -- "${(C)foo}"
Eins zwei drei vier
Umleitungsbeispiele
Weitere Informationen finden Sie auch in den zschmisc(1) für mehr Informationen (oder weniger ${^fpath}/zmv(N))
# Hängen Sie „exit 1“ am Ende aller *.sh-Dateien an
$ echo "exit 1" >> *.sh
# Dateien zu foobar.tar.gz hinzufügen
$ eval set =(gunzip < foobar.tar.gz) '
tar rf $1 Additional.txt &&gzip < $1 > foobar.tar.gz'
# Ausgabe in eine Datei umleiten UND auf dem Bildschirm anzeigen
$ foobar >&1 > Datei1 > Datei2 > ..
# Einzelnen Ausgang an mehrere Eingänge weiterleiten
$ zcat foobar.Z >> (gzip -9 > file1.gz) \
>> (bzip2 -9 > file1.bz2) \
>> (acb --best > file1.acb)
# Anhängen / etc / Dienste am Ende der Datei „foo“ und „bar“
$ Katze / etc / Dienste >> foo >> bar
# Rohr STDERR
$ echo Ein Fehler >&2 2>&1 | sed -e 's/A/I/'
# Standardausgabe eines Prozesses an Standardeingabe mehrerer Prozesse senden
# in der Rohrleitung
$ setopt multios
$ Prozess1 > >(Prozess1) > >(Prozess2)
# Eine Variable initialisieren und gleichzeitig die Terminalausgabe beibehalten
$ setopt multios
$ { a=$(command >&1 >& 3 3 > &- 2>&1);} 3>&1
# stderr zweimal umleiten
$ setopt multios ; Programm 2> Datei2 > Datei1 2>&1
# Duplizieren von stdout und stderr in eine Protokolldatei
$ exec 3>&1 > Logfile 2>&2 2>&1 >&3 3>&-
# stderr (nur) in eine Datei und zum Original umleiten. stderr:
$ command 2>&2 2>stderr
# Leiten Sie stderr und stdout in separate Dateien und beide in orig um. Standardausgabe:
$ command 2>&1 1>&1 2>stderr 1>stdout
# Leiten Sie stderr und stdout in separate Dateien und stdout in orig um. stdout
# UND stderr zu orig. stderr:
$ command 2>&2 1>&1 2>stderr 1>stdout
# Mehr Spaß mit STDERR ;)
$ ./my-script.sh 2> >(grep -v moron >error.log)|process-output >output.log
$ echo „Das ist STDOUT“ >>(sed 's/stdout/another example/' > foobar)
ZMV-Beispiele (erfordern Autoload zmv)
Hinweis: -n bedeutet keine Ausführung (einfach drucken, was passieren würde). Bei
# Entfernen Sie illegale Zeichen in einem Fat32-Dateisystem. Illegale Zeichen sind
# / : ; * ? " < > |
# HINWEIS: „-Q“ und (D) sollen versteckte Dateien einschließen.
$ unerwünschte='[:;*?\"<>|]'
$ zmv -Q "(**/)(*$~unwanted*)(D)" '$1${2//$~unwanted/}'
# Teil eines Dateinamens ändern (z. B. „file-hell.name“ -> „file-heaven.name“)
$ zmv '(*)hell(*)' '${1}heaven${2}'
# oder
$ zmv '*' '$f:s/hell/heaven/'
# Runde Klammern innerhalb von Dateinamen entfernen
# dh foo-(bar).avi -> foo-bar.avi
$ zmv '*' '${f//[()]/}'
# seriell alle Dateien (foo.foo > 1.foo, fnord.foo > 2.foo, ..)
$ zmv automatisch laden
$ ls *
1.c asd.foo bla.foo fnord.foo foo.fnord foo.foo
$ c=1 zmv '*.foo' '$((c++)).foo'
$ ls *
1.c 1.foo 2.foo 3.foo 4.foo foo.fnord
# Benennen Sie „file.with.many.dots.txt“ um, indem Sie Punkte ersetzen (mit Ausnahme des letzten
# eins!) mit einem Leerzeichen
$ touch {1..20}-file.with.many.dots.txt
$ zmv '(*.*)(.*)' '${1//./ }$2'
# Entfernen Sie die ersten 4 Zeichen aus einem Dateinamen
$ zmv -n '*' '$f[5,-1]' # HINWEIS: Die „5“ ist KEIN Schreibfehler!
# Namen aller Dateien im aktuellen Verzeichnis in Kleinbuchstaben umbenennen, aber beibehalten
# Verzeichnisnamen wie sie sind.
$ zmv -Qv '(**/)(*)(.D)' '$1${(L)2}'
# Ersetzen Sie das gesamte vierte Zeichen, das „4“ ist, durch „1“ und so weiter
$ autoload -U zmv
$ zmv '(???)1(???[1-4].txt)' '${1}2${2}'
# Entfernen Sie die ersten 15 Zeichen aus einer Zeichenfolge
$ touch 111111111111111{az}
$ zmv automatisch laden
$ zmv '*' '$f[16,-1]'
# Ersetzen Sie Leerzeichen (beliebig viele davon) durch einen einzelnen Bindestrich in Dateinamen
$ zmv laden
$ zmv -n '(**/)(* *)' '$1${2//( #-## #| ##)/-}'
# oder - mit Bash
$ finden . - Depth -Name '* *' -exec bash -c '
> shopt -s extglob
> Datei=$1
> dir=${file%/*}
> name=${file##*/}
> newname=${name//*([ -]) *([ -])/-}
> mv -i -- "$file" "$Dir/$newname"' {} {} \;
# Bereinigen Sie Dateinamen und entfernen Sie Sonderzeichen
$ zmv automatisch laden
$ zmv -n '(**/)(*)' '$1${2//[^A-Za-z0-9._]/_}'
# *.py zu einer Reihe von Python-Skripten in einem Verzeichnis hinzufügen (einige davon enden
# in *.py und geben Sie allen eine richtige Erweiterung
$ zmv automatisch laden
$ zmv -n '(**/)(con*)(#qe,file $REPLY | grep "python script")' '$1$2.py'
# Alle Erweiterungen in Kleinbuchstaben (z. B. *.JPG) inkl. Unterordner
$ zmv automatisch laden
$ zmv '(**/)(*).(#i)jpg' '$1$2.jpg'
# Oder - ohne Zsh
$ find Dir -name '*.[jJ][pP][gG]' -print | während lesen f
> tun
> case $f in
> *.jpg) ;
> *) mv "$f" "${f%.*}.jpg" loading="lazy" ;
> esac
> fertig
# führende Nullen aus der Dateierweiterung entfernen
$ zmv automatisch laden
$ls
Dateiname.001 Dateiname.003 Dateiname.005 Dateiname.007 Dateiname.009
Dateiname.002 Dateiname.004 Dateiname.006 Dateiname.008 Dateiname.010
$ zmv '(Dateiname.)0##(?*)' '$1$2'
$ls
Dateiname.1 Dateiname.10 Dateiname.2 Dateiname.3 Dateiname.4 Dateiname.5 ..
# Dateien neu nummerieren.
$ zmv automatisch laden
$ ls *
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'
$ ls *
foo_10.jpg foo_11.jpg foo_3.jpg foo_4.jpg foo_5.jpg ...
# führende Nullen zu einem Dateinamen hinzufügen (1.jpg -> 001.jpg, ..
$ zmv automatisch laden
$ zmv '(<1->).jpg' '${(l:3::0:)1}.jpg'
# Siehe oben, aber jetzt nur Dateien mit einem Dateinamen >= 30 Zeichen
$ zmv automatisch laden
$ c=1 zmv "${(l:30-4::?:)}*.foo" '$((c++)).foo'
# Ersetzen Sie Leerzeichen in Dateinamen durch einen Unterstrich
$ zmv automatisch laden
$ zmv '* *' '$f:gs/ /_'
# Ändern Sie das Suffix von *.sh in *.pl
$ zmv automatisch laden
$ zmv -W '*.sh' '*.pl'
# Fügen Sie allen Dateien in ${HOME} eine Erweiterung „.txt“ hinzu
# „-.“ dient nur zum Umbenennen regulärer Dateien oder symbolischer Links zu regulären Dateien.
# „D“ soll auch versteckte Dateien (Dotfiles) umbenennen)
$ zmv automatisch laden
$ zmv -Q '/Zuhause/**/*(D-.)' '$f.txt'
# Oder um nur Dateien umzubenennen, die keine Erweiterung haben:
$ zmv -Q '/Zuhause/**/^?*.*(D-.)' '$f.txt'
# Dateinamen rekursiv mit Zeichen ändern? [ ] / = + < > ; : " , - *
$ zmv automatisch laden
$ chars='[][?=+<>;",*-]'
$ zmv '(**/)(*)' '$1${2//$~chars/%}'
# Einfache Anführungszeichen aus Dateinamen entfernen (rekursiv)
$ zmv automatisch laden
$ zmv -Q "(**/)(*'*)(D)" "\$1\${2//'/}"
# Wenn eine neue Datei eintrifft (mit dem Namen file.txt), benennen Sie alle Dateien um
# get (z. B. Datei119.txt wird zu Datei120.txt, Datei118.txt wird zu
# file119.txt usw. endet damit, dass file.txt zu file1.txt wird
$ zmv automatisch laden
$ zmv -fQ 'file([0-9]##).txt(On)' 'file$(($1 + 1)).txt'
# Alle Dateien/Verzeichnisse in Klein-/Großbuchstaben schreiben
$ zmv automatisch laden
$ zmv '(*)' '${(L)1}' # Kleinbuchstaben
$ zmv '(*)' '${(U)1}' # Großbuchstaben
# Entfernen Sie das Suffix *.c aus allen C-Dateien
$ zmv automatisch laden
$ zmv '(*).c' '$1'
# Nur der erste Buchstabe aller *.mp3-Dateien wird in Großbuchstaben geschrieben
$ zmv automatisch laden
$ zmv '([az])(*).mp3' '${(C)1}$2.mp3'
# Kopieren Sie die Ziel-README-Datei in dasselbe Verzeichnis wie jedes Makefile.
$ zmv automatisch laden
$ zmv -C '(**/)Makefile' '${1}README'
# Einfache Anführungszeichen aus Dateinamen entfernen (rekursiv)
$ zmv automatisch laden
$ zmv -Q "(**/)(*'*)(D)" "\$1\${2//'/}"
# Benennen Sie pic1.jpg, pic2.jpg, .. in pic0001.jpg, pic0002.jpg, . um.
$ zmv automatisch laden
$ zmv 'pic(*).jpg' 'pic${(l:4::0:)1}.jpg'
$ zmv '(**/)pic(*).jpg' '$1/pic${(l:4::0:)2}.jpg' # rekursiv
Modulbeispiele
Bitte lesen Sie zshmodules(1) zuerst!
zsh/pcre (erfordern zmodload zsh/pcre)
# Dateien eines bestimmten Zeitraums kopieren (Datum im Dateinamen angegeben)
$ zmodload zsh/pcre
$ ls -d -- *(e:'[[ $REPLY -pcre-match pcre-regexp ]]':)
# oder
$ m() { [[ $1 -pcre-match pcre-regexp ]] }
$ ls -d -- *(+m)
zsh/klonen (erfordern zmodload zsh/klonen)
# Erstellt eine gespaltene Instanz der aktuellen Shell ($! ist auf Null gesetzt) und
# „Befehl“ auf /dev/tty8 ausführen (für dieses Beispiel).
$ zmodload zsh/clone
$ clone /dev/tty8 && (($! == 0)) && exec-Befehl
zsh/datetime (erfordern zmodload zsh/datetime)
$ zmodload zsh/datetime
$ alias datereplacement='strftime "%Y-%m-%d" $EPOCHSECONDS'
$ export DATE=`datereplacement`
$ echo $DATE
# Datum aus Dateinamen entfernen
$ $ zmodload zsh/datetime
$ setopt Extendedglob
$ touch aaa_bbb_20041212_c.dat eee_fff_20051019_g.dat
$ strftime -s Muster \
'???_???_<0-%Y%m%d>_?.dat' $((EPOCHSECONDS - 365 * 24 * 60 * 60 / 2))
$ print -rl -- $~pattern
aaa_bbb_20041212_c.dat
$ print -rl -- $pattern
???_???_<0-20050815>_?.dat
# Größe der Suchdateien == 0, basierend auf dem Dateinamen, der ein Datum enthält
# anstelle des „letzten Änderungsdatums“ der Datei
$ zmodload -i zsh/datetime
$ strftime -s file "abc_de_%m%d%Y.dat" $((EPOCHSECONDS - 24 * 60 * 60 ))
$ files=(**/$file(N.L0))
$ (( $#files > 0 )) && print -rl -- $files | \
mailx -s „leere Dateien“ [E-Mail geschützt]
zsh/stat (erfordern zmodload zsh/stat)
# Testen Sie, ob ein symbolischer Link auf eine bestimmte Datei verweist
$ zmodload -i zsh/stat
$! stat -LH s foo.ln || [[ $s[link] != "foo.exe" ]] || ln -sf foo.exe foo.ln
# Dateidaten vergleichen
$ zmodload zsh/stat
$ file1=foo
$ file2=bar
$ Touch Bar & Sleep 5 & Touch Foo
$ echo $file1 ist $(($(stat +mtime $file2) - \
$(stat +mtime $file1))) Sekunden älter als $file2.
bar ist 5 Sekunden älter als foo
# Listen Sie die Dateien einer Festplatte auf, die kleiner als eine andere Datei ist
$ zmodload zsh/stat
$ stat -A max +Größe einer anderen Datei
$ print -rl ./**/*(DL-$max)
# Listen Sie die 100 größten Dateien auf einer Festplatte auf
$ zmodload zsh/stat
$ ls -fld ./**/*(d`stat +device .`OL[1,100])
# Holen Sie sich nur den Benutzernamen und die Dateinamen von (wie
# ls -l * | awk '{print $3" " $8}')
$ zmodload zsh/stat
$ für Datei; Tun
> stat -sA user +uid -- "$file" &&
> print -r -- "$user" "$file"
> fertig
# Ermitteln Sie die Differenz zwischen den tatsächlichen Bytes der Datei und den zugewiesenen Bytes der Datei
$ zmodload zsh/stat
$ print $(($(stat +block -- file) * 512 - $(stat +size -- file)))
# Finden Sie die größte Datei
# „D“: um Punktdateien einzuschließen (d-Kleinbuchstabe steht für Gerät)
# „O“: umgekehrte Reihenfolge (o Kleinbuchstabe für nicht umgekehrte Reihenfolge)
# „L“: nach Dateilänge (l steht für die Anzahl der Links)
# „[1]“: Nur das erste zurückgeben
$ zmodload zsh/stat
$ stat +size ./*(DOL[1])
# Dateigröße in Bytes
$ zmodload zsh/stat
$ stat -L +Größe ~ / .zshrc
4707
# Dateien in einem Verzeichnis löschen, auf das in den letzten zehn Tagen nicht zugegriffen wurde
# und senden Sie EINE E-Mail an den Eigentümer der Dateien, in der Sie ihn über die Dateien informieren.
# Löschung.
$ zmodload zsh/stat zsh/files
$typeset -A f; f=()
$ rm -f /path/**/*(.a+10e{'stat -sA u +uidr $REPLY; f[$u]="$f[$u]$REPLY"'})
$ für Benutzer (${(k)f}) {print -rn $f[$user]|mailx -s "..." $user}
# Holen Sie sich ein „ls -l“ für alle Dateien im Baum, die jünger als a sind
# angegebenes Alter
$ zmodload zsh/stat
$ für d (. ./**/*(N/m-2))
> print -r -- $'\n'$d: && cd $d && {
> für f (*(Nm-2om))
> stat -F '%b %d %H:%M' -LsAs -- $f &&
> 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]}
> cd ~-
> }
# Dateierstellungsdatum abrufen
$ zmodload zsh/stat
$ stat -F '%d %m %Y' +mtime ~ / .zshrc
30 06 2004
$ stat -F '%D' +mtime ~ / .zshrc
06/30/04
zsh/files (erfordern zmodload zsh/files)
# Durchsuchen Sie ein Verzeichnis nach Dateien, die eine bestimmte Zeichenfolge enthalten, und kopieren Sie diese dann
# Dateien in ein anderes Verzeichnis.
$ zmodload zsh/files
$ IFS=$'\0'
$ cp $(grep -lZr foobar .) anderes Verzeichnis
zsh/mapfile (erfordern zmodload zsh/mapfile)
# sucht nach zwei Mustern
$ zmodload zsh/mapfile
$pattern1="foo"
$ pattern2="bar foo"
$ print -l ./**/*(DN.e{'z=$mapfile[$REPLY] && [[ $z = *$pattern1* && \
$z = *$pattern2* ]]'})
# oder eine Lösung in Kombination mit zsh/pcre
$ zmodload -i zsh/mapfile zsh/pcre
$pattern1="foo"
$ pattern2="bar foo"
$ pcre_compile "(?s)(?=.*?$pattern1).*?$pattern2"
$ pcre_study
$ print -l ./**/*(DN.e{'pcre_match $mapfile[$REPLY]'})
# Äquivalent für „weniger“. / etc / passwd | grep -v root''
$ zmodload zsh/mapfile
$ IFS=$'\n\n'
$ print -rl -- ${${=mapfile[/ etc / passwd]}:#*Wurzel*}
# oder - für Groß- und Kleinschreibung
$ setopt Extendedglob
$ print -rl -- ${${=mapfile[/ etc / passwd]}:#*(#i)root*}
# Wenn eine XML-Datei Dinge wie „ '' und '' '', Nummer
# diese leeren Tags (die mit „/>“ enden), also wenn sie im selben vorkommen
#-Reihenfolge würden die vorangehenden Tags zu „“ werden 1 '' Und
# `` 2 ''
$ zmodload zsh/mapfile
$ cnt=0
$ apfile[data.xml.new]=${(S)mapfile[data.xml]//\
> (#im) *<\/TAGA>/ $((++cnt))<\/TAGA>}
# Alle Dateien im Benutzer-Maildir/new entfernen, die „filename="gone.src" enthalten
$ zmodload zsh/{files,mapfile}
$ rm -f /u1/??/*/Maildir/new/100*(.e{'[[ $mapfile[$REPLY] == \
*filename=\"gone.scr\"* ]]'})
# Greifen Sie den Titel aus einer Postscript-Datei heraus und hängen Sie diesen Wert an die an
# Ende des Dateinamens
$ autoload -U zmv
$ zmodload zsh/mapfile
$ zmv '(*).ps' '$1-${${${mapfile[$f]##*%%Title: }%% *}//[^a-zA-Z0-9_]/}. ps'
zsh/mathfunc (erfordern zmodload zsh/mathfunc)
$ zmodload zsh/mathfunc
$ echo $(( sin(1/4.0)**2 + cos(1/4.0)**2 - 1 ))
-1.1102230246251565e-16
$ echo $(( pi = 4.0 * atan(1.0) ))
3.1415926535897931
$ echo $(( f = sin(0.3) ))
0.29552020666133955
$ print $((1e12 * rand48()))
847909677310.23413
$ print $(( rand48(seed) ))
0.01043488334700271
zsh/termcap (erfordern zmodload zsh/termcap)
$ zmodload -ab zsh/termcap echotc
$ GRÜN=`echotc AF 2`
$ YELLOW=`echotc AF 3`
$ RED=`echotc AF 1`
$ BRIGHTRED=`echotc md ; echotc AF 1`
$ print -l ${GREEN}grün ${YELLOW}gelb ${RED}rot ${BRIGHTRED}hellrot
zsh/zpty (erfordern zmodload zsh/zpty)
$ zmodload zsh/zpty
$ zpty PW passwd $1
$ zpty PW passwd $1
# „-r“: liest die Ausgabe des Befehlsnamens.
# „z“: Parameter
$ zpty -r PW z '*Passwort:'
# Senden Sie dem Befehlsnamen die angegebenen Zeichenfolgen als Eingabe
$ zpty -w PW $2
$ zpty -r PW z '*Passwort:'
$ zpty -w PW $2
# Das zweite Formular mit der Option -d wird zum Löschen von Befehlen verwendet
# zuvor gestartet, indem eine Liste ihrer Namen bereitgestellt wurde. Wenn keine Namen
# werden angegeben, alle Befehle werden gelöscht. Das Löschen eines Befehls führt zum HUP
# Signal, das an den entsprechenden Prozess gesendet werden soll.
$ zpty -d PW
zsh/net/socket (erfordern zmodload zsh/net/socket)
# „-l“: Öffne einen Socket, der auf den Dateinamen lauscht
# „-d“: Das Argument wird als Zieldateideskriptor für verwendet
# Verbindung
# „3“: Dateideskriptor. Siehe „Ein Benutzerhandbuch zur Z-Shell“
# (3.7.2: Dateideskriptoren)
$ zmodload zsh/net/socket
$ zsocket -l -d 3
# „-a“: Akzeptiere eine eingehende Verbindung zum Socket
$ zsocket -a -d 4 3
$ zsocket -a -d 5 3 # Eine Verbindung akzeptieren
$ echo foobar >&4
$ echo barfoo >&5
$ 4>&- 5>&- 3>&
zsh/zftp (erfordern zmodload zsh/zftp)
$ autoload -U zfinit
$ zfinit
$ zfparams www.example.invalid myuserid mypassword
$ zfopen
$ zfcd-Tipps
$ zfls -l zshtips.html
$ zfput zshtips.html
$ zfls -l zshtips.html
# Dateien automatisch per FTP mit Fehlerprüfung übertragen
$ autoload -U zfinit ; zfinit
$ zftp open host.name.invalid user passwd || Ausfahrt
$ zftp get /remote/file > /local/file; r=$?
$ zftp schließen && beenden r
# Komprimieren und FTP im laufenden Betrieb
$ autoload -U zfinit ; zfinit
$ zftp open host.name.ungültiges Benutzerkennwort
$ zftp get $file | bzip2 > ${file}.bz2
$ zftp schließen
# Rekursion „get“
$ autoload -U zfinit ; zfinit
$ zfanon cr.yp.to
$ zfcd daemontools
$ für Datei in „zfls“; Tun
> zfget $file
$ erledigt
$ zfclose
# Laden Sie alle regulären Dateien in $HOME/foobar (rekursiv) hoch, die neuer sind als
# zwei Stunden bis ftp.foobar.invalid/path/to/upload
$ autoload -U zfinit ; zfinit
$ zfopen ftp.foobar.invalid/path/to/upload
$ cd $HOME/foobar
$ zfput -r **/*(.mh-2)
$ zfclose
# lange Liste von Dateien auf einem FTP
$ autoload -U zfinit ; zfinit
$ zfopen some-host
$ zfcd /some/remote/Dir
$ cd /some/local/Dir
# Wenn sich list.txt auf dem Remote-Host befindet, wechseln Sie zu
# zfget ${(f)"$(zftp get /path/to/remote/list.txt)"}
$ zfget ${(f)"$(cat list.txt)"}
$ zfclose
zsh/zselect (erfordern zmodload zsh/zselect)
# Es ist ähnlich
,----
| $ sg=$(stty -g)
| $ stty -icanon min 0 mal 50
| $ lesen janein
| $ stty „$sg“
| $ case „$yesno“ in
| > ja) command1;;
| > *) command2;;
| > esac
`----
$ zmodload zsh/zselect
$ if zselect -t 500 -r 0 && read yesno && [ yes = "$yesno" ]; Dann
> Befehl1
> sonst
> Befehl1
> fi
OPTIONAL
Menü Optionen
auto_cd (Erlauben Sie einem, in ein Verzeichnis zu wechseln, indem Sie es als Befehl eingeben.) auto_pushd
(Verzeichnisse automatisch an die Push/Pop-Liste anhängen) pushd_ignore_dups (und nicht duplizieren
Sie).
Sonstiges
no_hup (Beim Beenden von ZSH kein HUP-Signal an Hintergrundjobs senden.) print_exit_value (zeigen
eine Nachricht mit dem Exit-Code, wenn ein Befehl mit einem Exit-Code ungleich Null zurückkehrt)
Geschichte Optionen
hist_verify (Lassen Sie den Benutzer die Befehlszeile nach der Verlaufserweiterung bearbeiten (z. B. !ls)
anstatt es sofort auszuführen) Verwenden Sie für alle Sitzungen dieselbe Verlaufsdatei: setopt
SHARE_HISTORY
Datenschutz / Sicherheit
no_clobber (oder set -C; verhindern > Umleitung vom Abschneiden der angegebenen Datei, wenn dies der Fall ist
ist bereits vorhanden)
Rechtschreibung Korrektur
und beseitigen Muskelschwäche (korrigiert automatisch die Schreibweise von Befehlen). korrekt_alle (automatisch
Korrigieren Sie die Schreibweise jedes Wortes in der Befehlszeile.) Dvorak (Dvorak-Layout)
UNSORTIERT/VERSCHIEDENES
Mailpfad: einfacher mehrfacher Mailpfad:
mailpath=($HOME/Mail/mbox'?Neue Mail in mbox'
$HOME/Mail/tux.u-strasbg'?Neue Mail in Tux'
$HOME/Mail/lilo'?Neue Mail in Lilo'
$HOME/Mail/ldap-fr'?Neue Mail in ldap-fr')
Mailpfad: dynamischer Mailpfad:
typeset -ein Mailpfad
denn ich bin ~/Mail/Listen/*(.); Tun
mailpath[$#mailpath+1]="${i}?Sie haben neue E-Mails in ${i:t}."
erledigt
Vermeiden Sie Globbing bei speziellen Befehlen:
für com im Alias expr finde mattrib mcopy mdir mdel which;
Alias $com="noglob $com"
Um Ihr Bashprompt nach ZSH zu migrieren, verwenden Sie das Skript bash2zshprompt, das sich im ZSH befindet
Quellenverteilung unter Sonstiges.
Für die Migration von (t)csh nach zsh verwenden Sie das c2z-Tool, das csh-Aliase und konvertiert
Umgebungs- und Shellvariablen nach zsh. Dazu wird csh ausgeführt und ein csh-Bericht erstellt
auf Aliase und Variablen. Das Skript konvertiert diese dann in ZSH-Startdateien. Es hat welche
Probleme und Nutzungsinformationen, die oben in diesem Skript dokumentiert sind.
Hier sind Funktionen zum Festlegen des Titels und des Hardstatus eines XTerm oder von GNU Bildschirm zu zsh und
das aktuelle Verzeichnis, wenn die Eingabeaufforderung angezeigt wird, und auf den Befehlsnamen
bzw. Rest der Befehlszeile, wenn ein Befehl ausgeführt wird:
Funktionstitel {
if [[ $TERM == "screen" ]]; Dann
# Verwenden Sie diese beiden für GNU Screen:
print -nR $' 33k'$1$' 33'\
print -nR $' 33]0;'$2$''
elif [[ $TERM == "xterm" || $TERM == "rxvt" ]]; Dann
# Verwenden Sie stattdessen dieses für XTerms:
print -nR $' 33]0;'$*$''
fi
}
Funktion precmd { title zsh "$PWD" }
Funktion preexec {
emulieren -L zsh
local -a cmd; cmd=(${(z)1})
Titel $cmd[1]:t „$cmd[2,-1]“
}
Fügen Sie die folgende Zeile in Ihr ein ~/.screenrc um diesen schicken Hardstatus zu sehen:
Bildunterschrift immer „%3n %t%? (%u)%?%?: %h%?“
Spezielle Variablen, die zugewiesen werden:
$LINENO $RANDOM $SECONDS $COLUMNS $HISTCHARS $UID
$EUID $GID $EGID $USERNAME $fignore $mailpath $cdpath
Verbindet
Primärer Standort
http://www.zsh.org/
Projektseite
http://sourceforge.net/projects/zsh/
Z-Shell-Seite bei sunsite.dk
http://zsh.sunsite.dk/
Von Bash bis Z Shell: Eroberung der Befehlszeile – das Buch
http://www.bash2zsh.com/
„Zsh – die magische Shell“ von Sven Guckes und Julius Plenz
http://zshbuch.org/
Mailinglistenarchiv
http://www.zsh.org/mla/
ZSH-FAQ
http://zsh.dotsrc.org/FAQ/
Benutzerhandbuch
http://zsh.sunsite.dk/Guide/
ZSH-Wiki
http://zshwiki.org/home/
Eine kurze Einführung von BYU
http://docs.cs.byu.edu/linux/advanced/zsh.html
Maus-Unterstützung ;)
http://stchaz.free.fr/mouse.zsh
Vorhang auf: Vorstellung der Z-Shell
http://www-128.ibm.com/developerworks/linux/library/l-z.html?dwzone=linux
ZSH-Liebhaberseite (deutsch)
http://michael-prokop.at/computer/tools_zsh_liebhaber.html
ZSH-Seite von Michael Prokop (deutsch)
http://michael-prokop.at/computer/tools_zsh.html
ZSH Schnelle Einführung
http://aperiodic.net/phil/prompt/
Adams ZSH-Seite
http://www.adamspiers.org/computing/zsh/
Zzappers Best of ZSH-Tipps
http://www.rayninfo.co.uk/tips/zshtips.html
Zsh-Webseite von Christian Schneider
http://www.strcat.de/zsh/
Die ZSH-Lovers-Webseite
http://grml.org/zsh/
IRC-Kanal
#zsh at irc.freenode.org
Die Z-Shell-Referenzkarte (im zsh-lovers-Debian-Paket enthalten)
http://www.bash2zsh.com/zsh_refcard/refcard.pdf
AUTOREN
Diese Manpage wurde von Michael Prokop, Christian, geschrieben strcat Schneider und Matthias
Kopfermann. Aber viele Ideen stammen von ZSH-Freaks, z. B. von den ZSH-Mailinglisten
(zsh-users und zsh-workers), Google, Newsgroups und das zsh-Wiki. Danke für deine coole und
unglaubliche Tipps. Wir haben viel von Ihnen gelernt!
In alphabetischer Reihenfolge:
Andrew 'zefram' Main - 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 Colemann
Stephane Chazelas - http://stephane.chazelas.free.fr/
Sven Gückes - http://www.guckes.net/
Sven Wischnowsky - http://w9y.de/zsh/zshrc
Nutzen Sie zsh-lovers online über die Dienste von onworks.net
