zsh-lovers - En ligne dans le Cloud

PROGRAMME:

Nom

zsh-lovers - trucs, astuces et exemples pour le shell Z

SYNOPSIS

Lisez-le simplement. ;-)

APERÇU

Chaque fois que nous regardons le manuel de zsh, nous nous demandons pourquoi il n'y a pas d'exemples ou ceux simplement
choses dans (coquille) la vie. Le zsh contient de nombreuses fonctionnalités, mais il n'y avait pas de page de manuel avec certains
exemples (comme procmailex(5)). C'est pourquoi nous avons écrit cette page de manuel.

La plupart des astuces et oneliner proviennent des listes de diffusion zsh-users, zsh-workers, google,
newsgroups et de nous-mêmes. Voir section LIENS pour en savoir plus.

Remarque : Cette page de manuel (zsh-amoureux(1)) est pas une partie officielle de la coque Z ! C'est juste un juste
pour le plaisir - page de manuel ;) Pour les commentaires, les rapports de bogues et les retours, jetez un œil rapide
BOGUES.

SCELLAGE DE COQUILLE

Cette section fournit quelques exemples de scripts shell souvent nécessaires. Remarquez que vous
ne devrait pas utiliser sinon la plupart des exemples ne fonctionneront pas. Options d'analyse dans les scripts shell. Exemple
extrait de ZWS par 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
si [[ $ ? != 0 || "$o_help" != "" ]]; alors
echo Utilisation : $(basename "$0") "[-p PORT] [-r REPERTOIRE]"
sortie 1
fi

port=$o_port[2]
racine=$o_root[2]
log=$o_log[2]

if [[ $root[1] != '/' ]]; puis root="$PWD/$root" ; Fi
}
# utilisez maintenant la fonction :
parse_options $*

EXEMPLES

Les sous-sections disponibles sont Alias, Aboutissement, Non trié/Divers exemples, (Récursif)
Globber - Exemples, Modificateurs usage, Redirection-Exemples, Exemples ZMV et
Exemples de modules.

ALIASES
Les alias de suffixe sont pris en charge dans zsh depuis la version 4.2.0. Quelques exemples:

alias -s tex=vim
alias -s html=w3m
alias -s org=w3m

Appuyez maintenant sur la touche retour après avoir entré foobar.tex démarre vim avec foobar.tex. Appeler un
html-file exécute le navigateur w3m. www.zsh.org et en appuyant sur Entrée, w3m démarre avec l'argument
www.zsh.org. Les alias globaux peuvent être utilisés n'importe où dans la ligne de commande. Exemple:

$ alias -g C='| wc -l'
$ grep alias ~/.zsh/*C
443

Quelques alias globaux plus ou moins utiles (choisissez s'ils vous sont utiles ou non sur
le tien):

alias -g ...='../ ..'
alias -g ....='../../..'
alias -g .....='../../../..'
alias -g CA="2>&1 | chat -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='|& tête'
alias -g EL='|& moins'
alias -g ELS='|& moins -S'
alias -g ETL='|& queue -20'
alias -g ET='|& queue'
alias -g F=' | fmt -'
alias -g G='| egrep'
alias -g H='| diriger'
alias -g HL='|& tête -20'
alias -g Sk="*~(*.bz2|*.gz|*.tgz|*.zip|*.z)"
alias -g LL="2>&1 | moins"
alias -g L="| moins"
alias -g LS='| moins -S'
alias -g MM='| plus'
alias -g M='| Suite'
alias -g NE="2> /dev/null"
alias -g NS='| trier -n'
alias -g NUL="> /dev/null 2>&1"
alias -g PIPE='|'
alias -g R=' > /c/aaa/tee.txt '
alias -g RNS='| trier -nr'
alias -g S='| sorte'
alias -g TL='| queue -20'
alias -g T='| queue'
alias -g US='| trier -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'

ACHÈVEMENT
Voir aussi man 1 zshcompctl zshcompsys zshcompwid. zshcompctl est l'ancien style de zsh
complétion programmable, zshcompsys est le nouveau système de complétion, zshcompwid sont les zsh
widgets d'achèvement.

Certaines fonctions, comme _apt et _dpkg, sont très lentes. Vous pouvez utiliser un cache afin de proxy
la liste des résultats (comme la liste des paquets Debian disponibles) Utilisez un cache :

zstyle ':completion:*' use-cache on
zstyle ':completion:*' chemin du cache ~/.zsh/cache

Empêcher l'achèvement des fichiers/répertoires CVS :

zstyle ':completion:*:(all-|)files' ignoré-patterns '(|*/)CVS'
zstyle ':completion:*:cd:*' ignoré-patterns '(*/)#CVS'

Correspondance approximative des complétions lorsque vous les saisissez mal :

zstyle ':completion:*' completer _complete _match _approximate
zstyle ':completion:*:match:*' original uniquement
zstyle ':completion:*:approximate:*' max-errors 1 numérique

Et si vous voulez que le nombre d'erreurs autorisées par _approximate augmente avec la longueur
de ce que vous avez tapé jusqu'à présent :

zstyle -e ':completion:*:approximate:*' \
max-errors 'reply=($((($#PREFIX+$#SUFFIX)/3))numeric)'

Ignorez les fonctions de complétion pour les commandes que vous n'avez pas :

zstyle ':completion:*:functions' ignoré-patterns '_*'

Avec des fonctions d'assistance telles que :

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

vous pouvez éviter d'avoir à remplir du tout dans de nombreux cas, mais si vous le faites, vous voudrez peut-être
tomber immédiatement dans la sélection de menu et pour que les mots soient triés par heure :

zstyle ':completion:*:*:xdvi:*' menu yes select
zstyle ':completion:*:*:xdvi:*' heure de tri du fichier

Compléter les ID de processus avec la sélection de menu :

zstyle ':completion:*:*:kill:*' menu yes select
zstyle ':completion:*:kill:*' force-list toujours

Si vous finissez par utiliser un répertoire comme argument, cela supprimera la barre oblique de fin (utile
en ln)

zstyle ':completion:*' squeeze-slash true

cd ne sélectionnera jamais le répertoire parent (ex : cd ../ ):

zstyle ':completion:*:cd:*' ignore-parents parent pwd

Une autre méthode pour rapide Change répertoires. Ajoutez ceci à votre ~ / .zshrc, puis entrez simplement
"cd ..../dir"

rationaliser-point() {
if [[ $LBUFFER = *.. ]]; alors
LBAMPOR+=/ ..
d'autre
LBAMPOR+=.
fi
}
zle -N rationaliser-point
clé de liaison. rationaliser-point

NON TRIÉ/DIVERS exemples
Astuce : Une liste des qualificatifs glob valides peut être trouvée dans zshexpn(1). Voir « homme 1 zshexpn |
less -p" Qualificatifs pour plus de détails.

# Obtenez les noms de tous les fichiers qui *ne correspondent pas* à un modèle *n'importe où* sur le
# fichier (et sans ``-L'' parce que c'est GNUish)
$ print -rl -- *(.^e{'grep -q motif $REPLY'})
# ou
$ : *(.e{'grep -q motif $REPLY || print -r -- $REPLY'})

# nombres aléatoires
$ echo $[${RANDOM}%1000] # aléatoire entre 0-999
$ echo $[${RANDOM}%11+10] # aléatoire entre 10-20
$ echo ${(l:3::0:)${RANDOM}} # N chiffres (3 chiffres)

# inverser un mot
$ echo "${(j::)${(@Oa)${(s::):-hello}}}"

# Afficher le répertoire le plus récent
$ ls -ld *(/om[1])

# élément de tableau aléatoire
$ FICHIERS=( .../fichiers/* )
$ feh $FILES[$RANDOM%$#FILES+1]

# cat première ligne dans tous les fichiers de ce répertoire
$ pour le fichier (*(ND-.)) IFS= read -re < $file

# teste si un paramètre est numérique
$ si [[ $1 == <-> ]] ; alors
écho numérique
d'autre
écho non numérique
fi

# Montrez-moi tous les fichiers .c pour lesquels il n'existe pas de fichier .o.
$ print *.c(e_'[[ ! -e $REPLY:ro ]]'_)

# Tous les fichiers dans / var / qui n'appartiennent pas à root
$ ls -ld / var /*(^u:racine)

# Tous les fichiers pour lesquels le propriétaire a des autorisations de lecture et d'exécution
$ écho *(f:u+rx :)

# Le même, mais aussi d'autres n'ont pas d'autorisations d'exécution
$ echo *(f:u+rx,ox:)

# extension d'accolade - exemple
$ X=(ABC)
$Y=(+ -)
$ print -r -- $^X.$^Y

A.+ A.- B.+ B.- C.+ C.-
# Récupère le fichier le plus récent contenant la chaîne 'fgractg*.log' dans le
# nom de fichier et contient la chaîne 'ORA-'
$ fichier=(fgractg*.log(Nm0om[1]))
$ (($#fichier)) && grep -l ORA- $fichier
# sans Zsh
$ files=$( find . -name . -o -prune -name 'fgractg*>log' -mtime 0 -print )
> if [ -n "$fichiers" ]; alors
> IFS='
> '
> définir -f
> fichier=$(ls -td $fichiers | tête -1)
> grep -l ORA- "$fichier"
> fi

# garde le nombre spécifié de processus enfants en cours d'exécution jusqu'à la fin de la tâche entière
$ zsh -c 'sommeil 1 & sommeil 3 & sommeil 2& print -rl -- $jobtexts'

# Supprimer les fichiers de longueur nulle et .bak dans un répertoire
$ rm -i *(.L0) *.bak(.)

# imprime les fichiers qui n'ont pas d'extensions
$ printf '%s\n' ^?*.*
$ printf '%s\n' ^?*.[^.]*(D)
$ ls -d -- ^?*.*(D)

# Recherche de fichiers qui ne contiennent pas de chaîne spécifique
$ print -rl fichier* | comm -2 -3 - <(grep -l string file*)'
$ pour f (fichier*(N)) grep -q chaîne $f || imprimer -r $f'

# Afficher/Vérifier si une option est définie ou non. Cela fonctionne à la fois avec $options comme
# avec $builtins
$ echo $options[correct]
de rabais
$ $options[zle]
on

# Compter le nombre de répertoires sur la pile
$ print $((${${(z)${(f)"$(dirs -v)"}[-1]}[1]} + 1)) # ou
$ dirs -v | awk '{n=$1}END{print n+1}'

# Faire correspondre tous les fichiers qui n'ont pas de point dans le nom de fichier
$ ls *~*.*(.)

# Afficher uniquement l'adresse IP de `` périphérique ifconfig''
# ifconfig de net-tools (Linux)
$ imprimer ${${$(LC_ALL=C / sbin / ifconfig eth0)[7]}:gs/addr://}
# ifconfig de 4.2BSD {Free,Net,Open}BSD
$ imprimer ${$(/ sbin / ifconfig accord0)[6]}

# Ping toutes les adresses IP dans quelques classes C ou tous les hôtes
# dans / Etc / hosts
$ pour i dans {1..254} ; faire ping -c 1 192.168.13.$i; terminé
or
$ je = 1
$ while ( [[ $I -le 255 ]] ) ; faire ping -1 2 150.150.150.$I; laissez I++; terminé
or
$ pour i dans $(sed 's/#.*//' > / Etc / hosts | awk '{print $2}')
: faire
: echo "Essayer $i ... "
: ping -c 1 $i ;
: echo '=============================='
: terminé

# charger tous les modules disponibles au démarrage
$ composer -U m
$m=()
$ pour md ($chemin_module) m=($m $md/**/*(*e:'REPLY=${REPLY#$md/}'::r))
$ zmodload -i $ m

# Renommez tous les fichiers d'un répertoire de manière à ce que leurs noms soient numérotés
# préfixe dans l'ordre de tri par défaut.
$ i=1 ; pour j dans * ; faire mv $j $i.$j ; ((i++)); terminé
$ i=1 ; pour f dans * ; do mv $f $(écho $i | \
awk '{ printf("%03d", $0)}').$f; ((i++)); terminé
$ entier i=0 ; pour f dans * ; faire mv $f $[i+=1].$f; terminé

# Recherchez (et imprimez) tous les liens symboliques sans cible dans le
# saleté d'arbre.
$ $ fichier **/*(D@) | fgrep cassé
$ pour i dans **/*(D@); [[ -f $i || -d $i ]] || écho $i
$ echo **/* (@-^./=%p)
$ imprimer -l **/*(-@)

# Liste tous les fichiers simples qui n'ont pas d'extensions répertoriées dans `figore'
$ ls **/*~*(${~${(j/|/)figore}})(.)
# voir ci-dessus, mais maintenant omettre les exécutables
$ ls **/*~*(${~${(j/|/)figore}})(.^*)

# Imprimez les fichiers qui n'ont pas d'extensions (nécessite *setopt extendedglob*
# et *setopt dotglob*)
$ printf '%s\n' ^?*.*

# Liste des fichiers dans l'ordre inverse triés par nom
$ print -rl -- *(Activé)
or
$ print -rl -- *(^on)

# Synonyme de ``ps ax | awk '{print $1}'''
$ imprimer -l / proc /*/cwd(:h:t:s/self//)

# Récupère le PID d'un processus (sans ``ps'', ``sed'', ``pgrep'', ..
# (sous Linux)
$pid2(){
> local je
> pour moi dans / proc /<->/stat
> faire
> [[ "$(< $i)" = *\((${(j:|:)~@})\)* ]] && echo $i:h:t
> fait
> }

# pour X dans 'n' 'o' 'p' 'q' 'r' 's' 't' 'u' 'v' 'w' 'x' 'y' ; faire ...
$ pour (( i = 36#n; i <= 36#y; i++ )); faire
> imprimer ${$(([##36]i)):l}
> fait
# ou en combinaison avec ``dc''
$ print {$((##n))..$((##y))}P\ 10P | courant continu
# ou avec ``eval''
$ eval print '${$(([##36]'{$((36#n))..$((36#y))}')):l}'

# foreach dans une ligne de shell
$ pour f (*) print -r -- $f

# copier un répertoire de manière récursive sans données/fichiers
$ répertoires=(**/*(/))
$cd -- $dest_root
$ mkdir -p -- $dirs
# ou sans zsh
$ trouver . -type d -exec env d="$dest_root" \
sh -c ' exec mkdir -p -- "$d/$1"' '{}' '{}' \;

# Si `foo=23'', imprimez avec 10 chiffres avec un '0' en tête.
$foo=23
$ imprimer ${(r:10::0:)foo}

# trouver le nom de tous les fichiers dans leur répertoire personnel qui ont
# plus de 20 caractères dans leurs noms de fichiers
print -rl $HOME/${(l:20::?:)~:-}*

# Enregistrer les tableaux
$ print -r -- ${(qq)m} > $nameoffile # enregistrez-le
$ eval "m=($(cat -- $nameoffile)" # ou utilisez
$ m=("${(@Q)${(z)"$(cat -- $nameoffile)"}}") # pour le restaurer

# obtient un "ls -l" sur tous les fichiers de l'arborescence qui sont plus jeunes qu'un
# âge spécifié (par exemple "ls -l" tous les fichiers de l'arborescence où
# modifié au cours des 2 derniers jours)
$ ls -tld **/*(m-2)
# Cela vous donnera une liste de 1 ligne de fichier perl (pas à la ls -R).
# Pensez à un moyen simple d'avoir une sortie de style "ls -R" avec
# uniquement les fichiers de moins de 2 jours.
$ pour d (. ./**/*(/)) {
> print -r -- $'\n'${d} :
> cd $d && {
> l=(*(Nm-2))
> (($#l)) && ls -ltd -- $l
> cd ~-
> }
> }
# Si vous souhaitez également que les répertoires soient inclus même si leur mtime
# a plus de 2 jours :
$ pour d (. ./**/*(/)) {
> print -r -- $'\n'${d} :
> cd $d && {
> l=(*(N/,m-2))
> (($#l)) && ls -ltd -- $l
> cd ~-
> }
> }
# Et si vous voulez que seuls les répertoires avec mtime < 2 jours soient listés :
$ pour d (. ./**/*(N/m-2)) {
> print -r -- $'\n'${d} :
> cd $d && {
> l=(*(Nm-2))
> (($#l)) && ls -ltd -- $l
> cd ~-
> }
> }

# print 42 ``-''
$ écho ${(l:42::-:)}
# ou utilisez ``$COLUMS''
$ echo ${(l:$COLONNES::-:)}
# et maintenant avec des couleurs (nécessite un chargement automatique des couleurs ; couleurs)
$ echo "$bg[rouge]$fg[noir]${(l:42::-:)}"

# Rediriger STDERR vers une commande comme xless sans rediriger également STDOUT.
$ foo 2>>(xless)
# mais cela exécute la commande de manière asynchrone. Pour le faire de manière synchrone :
$ { { truc 1>&3 } 2>&1 | sans x } 3>&1

# Renommez tous les fichiers MP3 du nom avec espaces.mp3 en nom avec espaces.mp3
$ pour i dans *.mp3 ; faire
> mv $i ${${(C)i}:s/Mp3/mp3/}
> fait

# Faites correspondre les noms de fichiers contenant uniquement des chiffres et se terminant par .xml (nécessite
# *setopt kshglob*)
$ ls -l [0-9]##.xml
$ ls -l <0->.xml

# Supprimer tous les fichiers "non txt"
$ rm ./^*.txt

# Déplacer 200 fichiers d'un répertoire vers un autre
$ mv -- *([1,200 XNUMX]) /autre/Dir

# Convertir des images (foo.gif => foo.png):
$ pour i dans **/*.gif ; convertir $i $i:r.png

# convertir une collection de fichiers mp3 en wave ou cdr,
# par exemple fichier.wav -> fichier.mp3)
$ pour i (./*.mp3){mpg321 --w - $i > ${i:r}.wav}

# Téléchargez avec les fichiers créés LaTeX2HTML (par exemple le ZSH-Guide):
$ pour f dans http://zsh.sunsite.dk/Guide/zshguide{,{01..08}}.html; faire
> lynx -source $f >${f:t}
> fait

# Déplacez tous les fichiers dans dir1 et dir2 qui ont un nombre de lignes supérieur à 10 vers
# un autre répertoire dit "/more10"
$ mv dir[12]/**/*.cr(-.e{'((`wc -l < ​​$REPLY` > 10))'}) /more10

# Faire avec dpkg une liste principale de tous les fichiers qu'il a installés
$ diff <(trouver / | trier) <(cat /var/lib/dpkg/info/*.list | sorte)

# Remplacez ces putains de séquences d'échappement :
$ chargement automatique des couleurs ; couleurs
$ print "$bg[cyan]$fg[blue]Tu es un idiot" >> /dev/pts/3

# Récupère la valeur ASCII d'un caractère
$ char=N ; imprimer $((#char))

# Nom de fichier "Erweiterung"
# Remarque : Le (N) indique d'utiliser l'option nullglob pour ce
# modèle de globe.
$ pour i dans *.o(N); faire
> rm $i
> fait

# Renommer les fichiers ; c'est-à-dire FOO à foo et bar à BAR
$ pour i dans *(.); mv $i ${i:l} # `FOO' à `foo'
$ pour i dans *(.); mv $i ${i:u} # `bar à `BAR'

# Afficher tous les fichiers suid dans $PATH
$ ls -latg ${(s.:.)CHEMIN} | grep '^...s'
# ou plus complexe ;)
$ print -l ${^chemin}/*(Ns,S)
# ou afficher uniquement les exécutables avec un modèle donné par l'utilisateur
$ print -l ${^chemin}/*vim*(*N)

# fichiers gzip contenant une certaine chaîne
$ gzip ${(ps:\0:)"$(grep -lZ foobar ./*.txt(.))"}

# Un petit one-liner, qui lit à partir de stdin et s'imprime sur stdout le premier
# ligne unique, c'est-à-dire n'imprime pas les lignes qui ont été imprimées auparavant
# (c'est similaire à la commande unique, mais unique ne peut gérer que
# lignes adjacentes).
$ IFS=$'\n\n'; print -rl -- ${(Oau)${(Oa)$(cat file;echo .)[1,-2]}}

# Répertorie tous les exécutables dans PATH
$ print -l ${^chemin}/*(-*N)

# Faire correspondre tous les fichiers .c dans tous les sous-répertoires, _sauf_ tous les sous-répertoires SCCS ?
$ ls **/*.c~(*/)#SCCS/*

# Liste tous les `README' - fichiers insensibles à la casse avec max. une faute de frappe
$ ls **/*(#ia2)lisezmoi

# vérification des variables insensible à la casse
$ if [[ $OSTYPE == (#i)LINUX*(#I) ]]; alors
> echo "Pingouin à bord."
> sinon
> echo "Pas un Linux."
> fi

(Récursif) Globber - Exemples
Une liste des qualificatifs glob valides peut être trouvée dans zshexpn (1). Remarque: **/ est équivalent à
(*/)#! Par exemple:

$ print(*/)#zsh_us.ps
zsh-4.2.3/Doc/zsh_us.ps
$ imprimer **/zsh_us.ps
zsh-4.2.3/Doc/zsh_us.ps

# Recherchez `README' dans tous les sous-répertoires
$ ls -l **/LISEZMOI

# trouver les répertoires qui contiennent à la fois "index.php" et "index.html", ou dans
# général, répertoires contenant plusieurs fichiers correspondant à "index.*"
$ ls **/*(D/e:'[[ -e $REPLY/index.php && -e $REPLY/index.html ]]' :)
# ou
$ ls **/*(D/e:'l=($REPLY/index.*(N)); (( $#l >= 2 ))':)

# Commande Find pour rechercher le nom du répertoire au lieu du nom de base
$ print -rl /**/*~^*/chemin(|/*)
# ou - sans Zsh
$ trouver / | grep -e /chemin/ -e '/chemin$'

# Imprimer le chemin des répertoires contenant les dix plus gros fichiers C réguliers
# dans le répertoire et les sous-répertoires courants.
$ print -rl -- **/*.c(D.OL[1,10]:h) | trier -u

# Trouvez les fichiers de taille == 0 et envoyez un mail
$ fichiers=(**/*(ND.L0m+0m-2))
> (( $#files > 0 )) && print -rl -- $files | \
mailx -s "fichiers vides" [email protected]

# chmod récursif
$ chmod 700 **/(.) # Uniquement les fichiers
$ chmod 700 **/(/) # Uniquement les répertoires

# affiche tous les fichiers de ce répertoire sur 2 colonnes
$ print -rC2 -- ${1:[...]}/*(D:t)
# ^- nombre de colonnes ob
# ou - si vous vous sentez concerné par les caractères spéciaux - utilisez
$ liste=(${1:[...]}/*(ND:t))
$ (($#list)) && print -rC2 -- ${(V)list}

# Rechercher tous les fichiers dans /maison/*/*-mail/ avec un paramètre ``chmod -s'' flag
# (récursif, inclure les fichiers dot) supprime le drapeau setgid/setuid et imprime
# un message
$ chmod -s /maison/*/*-mail(DN,S) /maison/*/*-mail/**/*(DN,S))
# ou avec un petit script
$ pour le fichier (/maison/*/*-mail(DN,S) /maison/*/*-mail/**/*(DN,S)) {
> print -r -- $file
> chmod -s $file && print -r fixed $file
> }
# ou utilisez ``zargs'' (nécessite le chargement automatique des zargs) empêche également la liste des arguments
# erreur longue
$ zargs /maison/*/*-mail(DN,S) /maison/*/*-mail/**/*(DN,S)) -- chmod -s

# Liste les fichiers commençant à `foo23' (foo23, foo24, foo25, ..)
$ ls -l foo<23->

# obtenir tous les fichiers commençant par les chaînes de date du 4 juin au
# 9 juin 2004
$ ls -l 200406{04..10}*(N)
# ou s'ils sont de la forme 200406XX (require ``setopt extended_glob''
$ ls -l 200306<4-10>.*

# supprime les espaces des noms de fichiers
$ pour un dans ./**/*\ *(Dod); faire mv $a ${a:h}/${a:t:gs/ /_} ; terminé

# Afficher uniquement tous les fichiers *.c et *.h -
$ ls -l *.(c|h)

# Afficher uniquement tous les fichiers *.c et ignorer `foo.c'
$ ls *.c~foo.c

# afficher les données au format binaire *vraiment*
$ zsh -ec 'while {} {printf %.8x $n;repeat 8 \
> {read -ku0 a printf \ %.8d $(([##2]#a))};print;((n+=8))}' < binaire

# Afficher uniquement les fichiers lisibles par le monde
$ ls -l *(R)

# Les fichiers de liste dans le répertoire actuel ne sont pas accessibles en écriture par le propriétaire
$ print -l ~/*(ND.^w)

# recherche et supprime les fichiers plus anciens qu'un paramètre donné
# (secondes/minutes/heures)
# supprime tous les fichiers normaux dans /Dir datant de plus de 3 heures
$ rm -f /Dir/**/*(.mh+3)
# supprime tous les liens symboliques dans /Dir datant de plus de 3 minutes
$ rm -f /Rep/**/*(@mm+3)
# supprime tous les non-répertoires dans /Dir datant de plus de 30 secondes
$ rm -f /Dir/**/*(ms+30^/)
# supprime tous les dossiers, sous-dossiers et fichiers de plus d'une heure
$ rm ./**/*(.Dmh+1,.DL0)
# supprime tous les fichiers de plus de 6 heures
$ rm -f **/*(mh+6)
# supprime tous les fichiers sauf les dix plus récents (supprime tous sauf les 10 derniers
# fichiers dans un répertoire)
$rm ./*(Om[1,-11])
Remarque : si vous obtenez une liste d'arguments trop longue, vous utilisez le rm intégré. Pour
Exemple:
$ zmodload zsh/fichiers ; rm -f **/*(mh+6)
ou utilisez la fonction zargs :
$ chargement automatique des zargs ; zargs **/*(mh+6) -- rm -f

# Un guide de l'utilisateur du Z-Shell /5.9 : Génération et modèle de nom de fichier
# Recherche de correspondance tous les fichiers dans tous les sous-répertoires, recherche récursive,
# qui ont un nom donné, insensible à la casse, font au moins 50 Ko,
# pas plus d'une semaine et appartenant à l'utilisateur root, et permettant
# à une seule erreur dans l'orthographe du nom. En effet, le requis
# expression ressemble à ceci :
$ ls **/(#ia1)nom(LK+50mw-1u0)

# Changez l'UID de 102 à 666
$chown 666 **/*(u102)

# Liste tous les fichiers qui n'ont pas été mis à jour depuis les 10 dernières heures
$ print -rl -- *(Dmh+10^/)

# ne supprime que le fichier le plus ancien d'un répertoire
$ rm ./*nom_fichier*(Om[1])

# Trier la sortie de `ls -l' par taille de fichier
$ ls -fld *(OL)

# trouver le fichier le plus récent dans un répertoire
$ setopt dotglob ; imprimer le répertoire/**/*(om[1])

# Afficher uniquement les fichiers vides qui ne sont ni « groupes » ni « inscriptibles dans le monde »
$ ls *(L0f.go-w.)

# Trouvez - et répertoriez - les dix fichiers les plus récents dans les répertoires et sous-répertoires.
# (récursif)
$ print -rl -- **/*(Dom[1,10])

# Affiche seulement 5 lignes par la commande "ls" (comme ``ls -laS | head -n 5'').
$ ls -fl *(DOL[1,5])

# Affiche les 5 à 10 derniers fichiers modifiés.
$ print -rl -- /chemin/vers/rép/**/*(D.om[5,10])

# Trouver tous les fichiers sans propriétaire valide.
$ chmod someuser /**/*(D^u:${(j.:u:.)${(f)"$(/ Etc / passwd)"}%% :*} :)

# Trouver tous les répertoires vides dans un arbre.
$ pour f dans ***/*(/l2) ; faire foo=($f/*(N)); [[ -z $foo ]] && print $f; terminé
# Remarque : depuis Zsh 4.2.1, le qualificatif glob F indique un répertoire non vide.
# Par conséquent, *(F) indique tous les sous-répertoires avec des entrées, *(/^F) signifie tous
# sous-répertoires sans entrées.
$ ls -ld *(/^F)

# Supprimez les répertoires vides par la suite.
$ rmdir ./**/*(/od) 2> /dev/null

# Afficher uniquement les fichiers appartenant au groupe 'users'.
$ ls -l *(G[utilisateurs])

Modificateurs usage
Les modificateurs sont un mécanisme puissant qui vous permet de modifier les résultats renvoyés par paramètre,
extension du nom de fichier et de l'historique. Voir zshexpn(1) pour plus de détails.

# REMARQUE : Zsh 4.3.4 nécessaire !
$ chargement automatique -U âge
# fichier modifié aujourd'hui
$ print *(e:age today now :)
# fichiers modifiés depuis 5h
$ print *(âge 17:00 maintenant-)
# ... depuis 5 heures hier
$ print *(âge hier, 17:00 maintenant-)
# ... de Noël dernier avant aujourd'hui
$ print *(e-age 2006/12/25 aujourd'hui-)
# ... avant-hier
$ print *(e-age 1970/01/01 hier-)
# tous les fichiers modifiés entre le début de ces dates
$ print *(e:âge 2006/10/04 2006/10/09:)
# tous les fichiers modifiés à cette date
$ imprimer *(e:âge 2006/10/04:)
# Délais d'approvisionnement.
$ print *(e-age 2006/10/04:10:15 2006/10/04:10:45-)

# Supprime un composant de nom de chemin de fin, laissant la tête. Cela fonctionne comme
# `répertoire'.
$ echo =ls(:h)
/ bin

# Supprimez tous les composants de chemin d'accès principaux, en laissant la queue. Cela marche
# comme `basename'.
$ echo =ls(:t)
ls

# Supprimer le suffixe de chaque fichier (*.sh dans cet exemple)
$f:e est l'extension de fichier $f
:h --> tête (dirname)
:t --> queue (nom de base)
:r --> rest (extension supprimée)
$ pour f (*.sh) mv $f $f:r

# Supprimez une extension de nom de fichier de la forme `.xxx', en laissant le nom racine.
$ écho $PWD
/usr/src/linux
$ écho $PWD:t
linux

# Supprimez tout sauf l'extension.
$foo=23.42
$ écho $foo
23.42
$ echo $foo:e
42

# Affiche la nouvelle commande mais ne l'exécute pas. Fonctionne uniquement avec l'historique
# extension.
$ echo =ls(:h)
/ bin
$ !écho:p
$ echo =ls(:h)

# Citez les mots substitués, en évitant d'autres substitutions.
$ bar="23'42"
$ écho $ barre
23'42
$ écho $bar:q
23 \ '42

# Convertissez les mots en minuscules.
$ barre=FOOBAR
$ écho $ barre
BARRE FOOB
$ echo $bar:l
Foobar

# Convertissez les mots en majuscules.
$bar=foobar
$ écho $ barre
Foobar
$ echo $bar:u
BARRE FOOB

# convertir le 1er caractère d'un mot en majuscule
$ foo="un deux trois quatre"
$ print -r -- "${(C)foo}"
Un deux trois quatre

Redirection-Exemples
See zshmisc(1) pour plus d'informations (ou moins ${^fpath}/zmv(N))

# Ajouter 'exit 1' à la fin de tous les fichiers *.sh
$ echo "sortie 1" >> *.sh

# ajouter des fichiers à foobar.tar.gz
$ eval set =(gunzip < foobar.tar.gz) '
tar rf $1 supplémentaire.txt &&gzip < $1 > foobar.tar.gz'

# Rediriger la sortie vers un fichier ET afficher à l'écran
$ foobar >&1 > fichier1 > fichier2 > ..

# canaliser une seule sortie vers plusieurs entrées
$ zcat foobar.Z >> (gzip -9 > fichier1.gz) \
>> (bzip2 -9 > fichier1.bz2) \
>> (acb --best > fichier1.acb)

# Ajouter / etc / services à la fin du fichier `foo' et `bar'
$ chat / etc / services >> foo >> bar

# Tuyau STDERR
$ echo Une erreur >&2 2>&1 | sed -e 's/A/I/'

# envoyer la sortie standard d'un processus à l'entrée standard de plusieurs processus
# en cours
$ arrêter les multios
$ process1 > >(process1) > >(process2)

# initialiser une variable et conserver simultanément la sortie du terminal
$ arrêter les multios
$ { a=$(commande >&1 >& 3 3 > &- 2>&1);} 3>&1

# redirige stderr deux fois
$ setopt multios ; programme 2> fichier2 > fichier1 2>&1

# Duplication de stdout et stderr dans un fichier journal
$ exec 3>&1 > fichier journal 2>&2 2>&1 >&3 3>&-

# redirige stderr (uniquement) vers un fichier et vers orig. stderr :
$ commande 2>&2 2>stderr
# redirige stderr et stdout vers des fichiers séparés et les deux vers orig. sortie standard :
$ commande 2>&1 1>&1 2>stderr 1>stdout
# redirige stderr et stdout vers des fichiers séparés et stdout vers orig. sortie standard
# ET stderr vers orig. stderr :
$ commande 2>&2 1>&1 2>stderr 1>stdout

# Plus de fun avec STDERR ;)
$ ./my-script.sh 2> >(grep -v crétin >error.log)|process-output >output.log
$ echo "C'est STDOUT" >>(sed 's/stdout/un autre exemple/' > foobar)

Exemples ZMV (exiger chargement automatique zmv)
Remarque: -n signifie aucune exécution (imprimez simplement ce qui se passerait). À

# Supprimez les caractères illégaux dans un système de fichiers fat32. Les caractères illégaux sont
# / : ; * ? " < > |
# REMARQUE : ``-Q'' et (D) est d'inclure les fichiers cachés.
$ indésirable='[:;*?\"<>|]'
$ zmv -Q "(**/)(*$~indésirable*)(D)" '$1${2//$~indésirable/}'

# Modification d'une partie d'un nom de fichier (c'est-à-dire "file-hell.name" -> "file-heaven.name")
$ zmv '(*)l'enfer(*)' '${1}le paradis${2}'
# ou
$ zmv '*' '$f:s/enfer/paradis/'

# supprimer les crochets dans les noms de fichiers
# c'est-à-dire foo-(bar).avi -> foo-bar.avi
$ zmv '*' '${f//[()]/}'

# en série tous les fichiers (foo.foo > 1.foo, fnord.foo > 2.foo, ..)
$ charger automatiquement zmv
$ 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

# Renommez "file.with.many.dots.txt" en substituant des points (sauf pour le dernier
# un !) avec un espace
$ touchez {1..20}-file.with.many.dots.txt
$ zmv '(*.*)(.*)' '${1//./ }$2'

# Supprimer les 4 premiers caractères d'un nom de fichier
$ zmv -n '*' '$f[5,-1]' # REMARQUE : Le "5" n'est PAS une erreur d'écriture !

# Renommez les noms de tous les fichiers sous le répertoire actuel en minuscules, mais gardez
# dirnames tel quel.
$ zmv -Qv '(**/)(*)(.D)' '$1${(L)2}'

# remplacer tout le 4ème caractère, qui est "1", par "2" et ainsi de suite
$ chargement automatique -U zmv
$ zmv '(???)1(???[1-4].txt)' '${1}2${2}'

# Supprimer les 15 premiers caractères d'une chaîne
$ toucher 111111111111111{az}
$ charger automatiquement zmv
$ zmv '*' '$f[16,-1]'

# Remplacez les espaces (n'importe quel nombre) par un seul tiret dans les noms de fichiers
$ zmv à chargement automatique
$ zmv -n '(**/)(* *)' '$1${2//( #-## #| ##)/-}'
# ou - avec Bash
$ trouver . -depth -name '* *' -exec bash -c '
> shopt -s extglob
> fichier=$1
> dir=${fichier%/*}
> nom=${fichier##*/}
> nouveaunom=${nom//*([ -]) *([ -])/-}
> mv -i -- "$file" "$Dir/$newname"' {} {} \;

# Nettoyer les noms de fichiers et supprimer les caractères spéciaux
$ charger automatiquement zmv
$ zmv -n '(**/)(*)' '$1${2//[^A-Za-z0-9._]/_}'

# Ajoutez *.py à un tas de scripts python dans un répertoire (certains d'entre eux se terminent
# dans *.py et donnez-leur à tous une extension appropriée
$ charger automatiquement zmv
$ zmv -n '(**/)(con*)(#qe,file $REPLY | grep "script python",)' '$1$2.py'

# minuscules toutes les extensions (c'est-à-dire *.JPG) incl. sous-dossiers
$ charger automatiquement zmv
$ zmv '(**/)(*).(#i)jpg' '$1$2.jpg'
# Ou - sans Zsh
$ find Dir -name '*.[jJ][pP][gG]' -print | en lisant f
> faire
> cas $f dans
> *.jpg) ;
> *) mv "$f" "${f%.*}.jpg" loading="lazy" ;
> esac
> fait

# supprime les zéros non significatifs de l'extension de fichier
$ charger automatiquement zmv
$ls
nom de fichier.001 nom de fichier.003 nom de fichier.005 nom de fichier.007 nom de fichier.009
nom de fichier.002 nom de fichier.004 nom de fichier.006 nom de fichier.008 nom de fichier.010
$ zmv '(nom de fichier.)0##(?*)' '$1$2'
$ls
nom de fichier.1 nom de fichier.10 nom de fichier.2 nom de fichier.3 nom de fichier.4 nom de fichier.5 ..

# renuméroter les fichiers.
$ charger automatiquement zmv
$ ls *
truc_10.jpg truc_2.jpg truc_3.jpg truc_4.jpg truc_5.jpg truc_6.jpg ..
$ zmv -fQ 'foo_(<0->).jpg(.nOn)' 'foo_$(($1 + 1)).jpg'
$ ls *
truc_10.jpg truc_11.jpg truc_3.jpg truc_4.jpg truc_5.jpg ...

# ajout de zéros non significatifs à un nom de fichier (1.jpg -> 001.jpg, ..
$ charger automatiquement zmv
$ zmv '(<1->).jpg' '${(l:3::0:)1}.jpg'

# Voir ci-dessus, mais maintenant uniquement les fichiers avec un nom de fichier >= 30 caractères
$ charger automatiquement zmv
$ c=1 zmv "${(l:30-4::?:)}*.foo" '$((c++)).foo'

# Remplacez les espaces dans les noms de fichiers par un soulignement
$ charger automatiquement zmv
$ zmv '* *' '$f:gs/ /_'

# Changez le suffixe de *.sh en *.pl
$ charger automatiquement zmv
$ zmv -W '*.sh' '*.pl'

# Ajoutez une extension "".txt" à tous les fichiers dans ${HOME}
# ``-.'' est de renommer uniquement les fichiers normaux ou les liens symboliques en fichiers normaux,
# ``D'' est de renommer également les fichiers cachés (dotfiles))
$ charger automatiquement zmv
$ zmv -Q '/maison/**/*(D-.)' '$f.txt'
# Ou pour ne renommer que les fichiers qui n'ont pas d'extension :
$ zmv -Q '/maison/**/^?*.*(D-.)' '$f.txt'

# Changer récursivement les noms de fichiers avec des caractères ? [ ] / = + < > ; : " , - *
$ charger automatiquement zmv
$ chars='[][?=+<>;",*-]'
$ zmv '(**/)(*)' '$1${2//$~cars/%}'

# Suppression des guillemets simples des noms de fichiers (récursivement)
$ charger automatiquement zmv
$ zmv -Q "(**/)(*'*)(D)" "\$1\${2//'/}"

# Lorsqu'un nouveau fichier arrive (nommé file.txt) renommer tous les fichiers afin de
# get (par exemple file119.txt devient file120.txt, file118.txt devient
# file119.txt et ainsi de suite se terminant par file.txt devenant file1.txt
$ charger automatiquement zmv
$ zmv -fQ 'fichier([0-9]##).txt(On)' 'fichier$(($1 + 1)).txt'

# minuscule/majuscule tous les fichiers/répertoires
$ charger automatiquement zmv
$ zmv '(*)' '${(L)1}' # minuscule
$ zmv '(*)' '${(U)1}' # majuscule

# Supprimer le suffixe *.c de tous les fichiers C
$ charger automatiquement zmv
$ zmv '(*).c' '$1'

# En majuscules uniquement la première lettre de tous les fichiers *.mp3
$ charger automatiquement zmv
$ zmv '([az])(*).mp3' '${(C)1}$2.mp3'

# Copiez le `README' cible dans le même répertoire que chaque `Makefile'
$ charger automatiquement zmv
$ zmv -C '(**/)Makefile' '${1}README'

# Suppression des guillemets simples des noms de fichiers (récursivement)
$ charger automatiquement zmv
$ zmv -Q "(**/)(*'*)(D)" "\$1\${2//'/}"

# Renommez pic1.jpg, pic2.jpg, .. en pic0001.jpg, pic0002.jpg, ..
$ charger automatiquement zmv
$ zmv 'pic(*).jpg' 'pic${(l:4::0:)1}.jpg'
$ zmv '(**/)pic(*).jpg' '$1/pic${(l:4::0:)2}.jpg' # récursivement

Exemples de modules
Lisez s'il vous plait zshmodules(1) d'abord !

zsh/pcre (exiger zmodload zsh/pcre)
# Copier des fichiers d'une certaine période (date indiquée dans les noms de fichiers)
$ zmodload zsh/pcre
$ ls -d -- *(e:'[[ $REPLY -pcre-match pcre-regexp ]]' :)
# ou
$ m() { [[ $1 -pcre-match pcre-expression régulière ]] }
$ ls -d -- *(+m)

zsh/cloner (exiger zmodload zsh/cloner)
# Crée une instance fork du shell courant ($! est mis à zéro) et
# exécuter la ``commande'' sur /dev/tty8 (pour cet exemple).
$ zmodload zsh/clone
$ clone /dev/tty8 && (($! == 0)) && exec commande

zsh/dateheure (exiger zmodload zsh/dateheure)
$ zmodload zsh/dateheure
$ alias datereplacement='strftime "%Y-%m-%d" $EPOCHSECONDS'
$ export DATE=`dateremplacement`
$ écho $DATE

# supprimer la date du nom de fichier
$ $ zmodload zsh/dateheure
$ settopt étenduglob
$ toucher aaa_bbb_20041212_c.dat eee_fff_20051019_g.dat
$ strftime -s motif \
'???_???_<0-%Y%m%d>_?.dat' $((EPOCHSECONDS - 365 * 24 * 60 * 60 / 2))
$ print -rl -- $~motif
aaa_bbb_20041212_c.dat
$ print -rl -- $motif
???_???_<0-20050815>_?.dat

# Taille des fichiers de recherche == 0, à baser sur le nom du fichier contenant une date
# plutôt que la date de "dernière modification" du fichier
$ zmodload -i zsh/dateheure
$ strftime -s fichier "abc_de_%m%d%Y.dat" $((EPOCHSECONDS - 24 * 60 * 60 ))
$ fichiers=(**/$fichier(N.L0))
$ (( $#files > 0 )) && print -rl -- $files | \
mailx -s "fichiers vides" [email protected]

zsh/stat (exiger zmodload zsh/stat)
# teste si un lien symbolique renvoie à un certain fichier
$ zmodload -i zsh/stat
$ ! stat -LH s foo.ln || [[ $s[link] != "foo.exe" ]] || ln -sf truc.exe truc.ln

# comparaison des dates des fichiers
$ zmodload zsh/stat
$ file1=toto
$ file2=barre
$ touch bar & sleep 5 & touch foo
$ echo $file1 est $(($(stat +mtime $file2) - \
$(stat +mtime $file1))) secondes antérieures à $file2.
bar a 5 secondes de plus que foo

# liste les fichiers d'un disque plus petit qu'un autre fichier
$ zmodload zsh/stat
$ stat -A max +taille un-autre-fichier
$ print -rl ./**/*(DL-$max)

# Lister les 100 plus gros fichiers d'un disque
$ zmodload zsh/stat
$ ls -fld ./**/*(d`stat +appareil .`OL[1,100])

# Obtenez uniquement le nom d'utilisateur et les noms de fichiers de (comme
# ls -l * | awk '{print $3" " $8}')
$ zmodload zsh/stat
$ pour le fichier ; faire
> stat -sA user +uid -- "$file" &&
> print -r -- "$utilisateur" "$fichier"
> fait

# obtenir la différence entre les octets réels du fichier et les octets alloués du fichier
$ zmodload zsh/stat
$ print $(($(stat +bloc -- fichier) * 512 - $(stat +taille -- fichier)))

# Trouver le plus gros fichier
# ``D'' : pour inclure les fichiers de points (d minuscule est pour le périphérique)
# ``O'' : ordre inversé (o minuscule pour l'ordre non inversé)
# ``L'' : par longueur de fichier (l est pour le nombre de liens)
# ``[1]'': retourne seulement le premier
$ zmodload zsh/stat
$ stat +taille ./*(DOL[1])

# taille de fichier en octets
$ zmodload zsh/stat
$ stat -L +taille ~ / .zshrc
4707

# Supprimer les fichiers dans un répertoire qui n'a pas été consulté au cours des dix derniers jours
# et envoyer UN courrier au propriétaire des fichiers l'informant des fichiers'
# suppression.
$ zmodload zsh/stat zsh/fichiers
$ composer -A f; f=()
$ rm -f /chemin/**/*(.a+10e{'stat -sA u +uidr $REPLY; f[$u]="$f[$u]$REPLY"'})
$ pour l'utilisateur (${(k)f}) {print -rn $f[$user]|mailx -s "..." $user}

# Obtient un "ls -l" sur tous les fichiers de l'arborescence qui sont plus jeunes qu'un
# âge spécifié
$ zmodload zsh/stat
$ pour d (. ./**/*(N/m-2))
> print -r -- $'\n'$d: && cd $d && {
> pour 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 ~-
> }

# obtenir la date de création du fichier
$ zmodload zsh/stat
$ stat -F '%d %m %Y' +mtime ~ / .zshrc
30 06 2004
$ stat -F '%D' +mtime ~ / .zshrc
06/30/04

zsh/fichiers (exiger zmodload zsh/fichiers)
# rechercher dans un répertoire les fichiers contenant une certaine chaîne puis les copier
# fichiers dans un autre répertoire.
$ zmodload zsh/fichiers
$ IFS=$'\0'
$ cp $(grep -lZr foobar .) autrerépertoire

zsh/fichier cartographique (exiger zmodload zsh/fichier map)
# à la recherche de deux motifs
$ zmodload zsh/mapfile
$ pattern1="toto"
$ pattern2="bar toto"
$ print -l ./**/*(DN.e{'z=$mapfile[$REPLY] && [[ $z = *$pattern1* && \
$z = *$motif2* ]]'})
# ou une solution en combinaison avec zsh/pcre
$ zmodload -i zsh/mapfile zsh/pcre
$ pattern1="toto"
$ pattern2="bar toto"
$ pcre_compile "(?s)(?=.*?$motif1).*?$motif2"
$ étude_pcre
$ print -l ./**/*(DN.e{'pcre_match $mapfile[$REPLY]'})

# équivalent pour ``moins / Etc / passwd | grep -v racine''
$ zmodload zsh/mapfile
$ IFS=$'\n\n'
$ print -rl -- ${${=fichiermap[/ Etc / passwd]}:#*racine*}
# ou - pour insensible à la casse
$ settopt étenduglob
$ print -rl -- ${${=fichiermap[/ Etc / passwd]} :#*(#i)racine*}

# Si un fichier XML contient des éléments comme `` '' et '' '', numéro
# ces balises vides (celles se terminant par '/>') donc si elles sont rencontrées dans le même
# ordre, les balises précédentes deviendraient `` 1 '' et
# `` 2 ''
$ zmodload zsh/mapfile
$cnt=0
$apfile[data.xml.new]=${(S)mapfile[data.xml]//\
> (#je) *<\/TAGA>/ $((++cnt))<\/TAGA>}

# suppression de tous les fichiers des utilisateurs Maildir/new qui contiennent ``filename="gone.src''
$ zmodload zsh/{fichiers,mapfile}
$ rm -f /u1/??/*/Maildir/new/100*(.e{'[[ $mapfile[$REPLY] == \
*filename=\"gone.scr\"* ]]'})

# Extrayez le titre d'un fichier postscript et ajoutez cette valeur au
# fin du nom de fichier
$ chargement automatique -U zmv
$ zmodload zsh/mapfile
$ zmv '(*).ps' '$1-${${${mapfile[$f]##*%%Titre : }%% *}//[^a-zA-Z0-9_]/}. ps'

zsh/foncmath (exiger zmodload zsh/foncmath)
$ 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
$ imprimer $((1e12 * rand48()))
847909677310.23413
$ print $(( rand48(graine) ))
0.01043488334700271

zsh/termcap (exiger zmodload zsh/termcap)
$ zmodload -ab zsh/termcap echotc
$ VERT=`echoc AF 2`
$ JAUNE=`echoc AF 3`
$ ROUGE=`echotc AF 1`
$ BRIGHTRED=`echotc md ; échotc AF 1`
$ print -l ${GREEN}vert ${YELLOW}jaune ${RED}rouge ${BRIGHTRED}brightred

zsh/zpty (exiger zmodload zsh/zpty)
$ zmodload zsh/zpty
$ zpty PW mot de passe $1
$ zpty PW mot de passe $1
# ``-r'' : lit la sortie du nom de la commande.
# ``z'' : Paramètre
$ zpty -r PW z '*mot de passe :'
# envoie le nom de la commande to les chaînes données en entrée
$ zpty -w PW $2
$ zpty -r PW z '*mot de passe :'
$ zpty -w PW $2
# La deuxième forme, avec l'option -d, est utilisée pour supprimer des commandes
# déjà commencé, en fournissant une liste de leurs noms. Si pas de noms
# sont donnés, toutes les commandes sont supprimées. La suppression d'une commande provoque le HUP
# signal à envoyer au processus correspondant.
$ zpty -d PW

zsh/net/socket (exiger zmodload zsh/net/socket)
# ``-l'': ouvre une socket écoutant le nom de fichier
# ``-d'' : l'argument sera pris comme descripteur de fichier cible pour le
# lien
# ``3'' : descripteur de fichier. Voir ``Guide de l'utilisateur du Z-Shell''
# (3.7.2 : Descripteurs de fichiers)
$ zmodload zsh/net/socket
$ zsocket -l -d 3
# ``-a'' : accepte une connexion entrante vers la socket
$ zsocket -a -d 4 3
$ zsocket -a -d 5 3 # accepte une connexion
$ echo foobar >&4
$ echo barfoo >&5
$ 4>&- 5>&- 3>&

zsh/zftp (exiger zmodload zsh/zftp)
$ chargement automatique -U zfinit
$ zfini
$ zfparams www.example.invalid myuserid mypassword
$ zfopen
$ zfcd pourboires
$ zfls -l zshtips.html
$ zfput zshtips.html
$ zfls -l zshtips.html

# Transférer automatiquement des fichiers via FTP avec vérification des erreurs
$ chargement automatique -U zfinit ; zfinit
$ zftp open host.name.invalid user passwd || sortir
$ zftp get /remote/file > /local/file ; r=$?
$ zftp fermer && quitter r

# compresser et ftp à la volée
$ chargement automatique -U zfinit ; zfinit
$ zftp open host.name.mot de passe utilisateur invalide
$ zftp récupère $fichier | bzip2 > ${fichier}.bz2
$ zftp fermer

# Récursivité ``get''
$ chargement automatique -U zfinit ; zfinit
$ zfanon cr.yp.to
$ zfcd démontools
$ pour le fichier dans `zfls` ; faire
> zfget $fichier
$ fait
$ zffermer

# Téléchargez tous les fichiers réguliers dans $HOME/foobar (récursifs) qui sont plus récents que
# deux heures pour ftp.foobar.invalid/path/to/upload
$ chargement automatique -U zfinit ; zfinit
$ zfopen ftp.foobar.invalid/path/to/upload
$ cd $HOME/barre
$ zfput -r **/*(.mh-2)
$ zffermer

# longue liste de fichiers sur un ftp
$ chargement automatique -U zfinit ; zfinit
$ zfopen quelque-hôte
$ zfcd /some/distant/Dir
$ cd /certains/local/Dir
# Si le list.txt se trouve sur l'hôte distant, remplacez-le par
# zfget ${(f)"$(zftp get /path/to/remote/list.txt)"}
$ zfget ${(f)"$(cat list.txt)"}
$ zffermer

zsh/zselect (exiger zmodload zsh/zselect)
# C'est similaire à
,----
| $sg=$(stty -g)
| $ stty -icanon min 0 fois 50
| $ lu oui non
| $ stty "$sg"
| $ case "$oui" dans
| > oui) command1;;
| > *) commande2;;
| > esac
`----
$ zmodload zsh/zselect
$ if zselect -t 500 -r 0 && read yesno && [ yes = "$yesno" ]; alors
> commande1
> sinon
> commande1
> fi

OPTIONS

Navigation Options
auto_cd (permet de passer à un répertoire en le saisissant comme une commande). auto_pushd
(ajoutez automatiquement les répertoires à la liste push/pop) pushd_ignore_dups (et ne dupliquez pas
leur).

Divers
non_hup (n'envoyez pas de signal HUP aux tâches d'arrière-plan lorsque vous quittez ZSH). print_exit_value (spectacle
un message avec le code de sortie lorsqu'une commande revient avec un code de sortie différent de zéro)

Histoire Options
hist_verifier (laissez l'utilisateur éditer la ligne de commande après l'expansion de l'historique (par exemple !ls)
au lieu de l'exécuter immédiatement) Utilisez le même fichier historique pour toutes les sessions : arrêter
PARTAGE_HISTOIRE

Politique / Sécurité
no_clobber (ou définir -C ; empêcher > redirection de tronquer le fichier donné s'il
existe déjà)

Orthographe de la plateforme prothétique
correct (corriger automatiquement l'orthographe des commandes). tout_correct (automatiquement
corriger l'orthographe de chaque mot sur la ligne de commande) Dvorak (mise en page dvorak)

NON TRIÉ/DIVERS

Mailpath : simple mailpath multiple :

mailpath=($HOME/Mail/mbox'?nouveau courrier dans mbox'
$HOME/Mail/tux.u-strasbg'?nouveau courrier en tux'
$HOME/Mail/lilo'?nouveau courrier dans lilo'
$HOME/Mail/ldap-fr'?nouveau mail dans ldap-fr')

Chemin de messagerie : chemin de messagerie dynamique :

composer -a mailpath
pour moi dans ~/Courriel/Listes/*(.); faire
mailpath[$#mailpath+1]="${i}?Vous avez un nouveau courrier dans ${i:t}."
fait

Évitez de globuler sur des commandes spéciales :

pour com dans alias expr trouver mattrib mcopy mdir mdel qui;
alias $com="noglob $com"

Pour migrer votre bashprompt vers zsh utilisez le script bash2zshprompt situé dans le zsh
distribution de la source sous Divers.

Pour la migration de (t)csh vers zsh, utilisez l'outil c2z qui convertit les alias csh et
variables d'environnement et shell à zsh. Il le fait en exécutant csh et en ayant un rapport csh
sur les alias et les variables. Le script les convertit ensuite en fichiers de démarrage zsh. Il a quelques
les problèmes et les informations d'utilisation qui sont documentés en haut de ce script.

Voici des fonctions pour définir le titre et le hardstatus d'un XTerm ou du GNU pour écran à zsh et
le répertoire courant, respectivement, lorsque l'invite est affichée, et au nom de la commande
et le reste de la ligne de commande, respectivement, lorsqu'une commande est exécutée :

titre de la fonction {
if [[ $TERM == "écran" ]]; alors
# Utilisez ces deux pour l'écran GNU :
print -nR $' 33k'$1$' 33'\
print -nR $' 33]0;'$2$''
elif [[ $TERM == "xterm" || $TERM == "rxvt" ]]; alors
# Utilisez celui-ci à la place pour les XTerms :
print -nR $' 33]0;'$*$''
fi
}
function precmd { titre zsh "$PWD" }
fonction preexec {
émuler -L zsh
local -a cmd ; cmd=(${(z)1})
titre $cmd[1]:t "$cmd[2,-1]"
}

Mettez la ligne suivante dans votre ~/.screenrc pour voir ce hardstatus fantaisie :

légende toujours "%3n %t%? (%u)%?%?: %h%?"

Variables spéciales qui sont affectées :

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

LIENS

Site principal

http://www.zsh.org/

Projet-page

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

Page du shell Z sur sunsite.dk

http://zsh.sunsite.dk/

De Bash à Z Shell : à la conquête de la ligne de commande - le livre

http://www.bash2zsh.com/

"Zsh - die magische Shell" (livre allemand sur Zsh) de Sven Guckes et Julius Plenz

http://zshbuch.org/

Archive de la liste de diffusion

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

FAQ ZSH

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

Mode d'emploi

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

Wiki ZSH

http://zshwiki.org/home/

Une courte introduction de BYU

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

Prise en charge de la souris ;)

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

Rideaux levés : présentation de la coque Z

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

ZSH-Liebhaberseite (allemand)

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

ZSH-Seite von Michael Prokop (allemand)

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

Présentation rapide de ZSH

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

La page ZSH d'Adam

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

Zzappers Le meilleur des conseils ZSH

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

Page Web Zsh par Christian Schneider

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

La page Web des amateurs de zsh

http://grml.org/zsh/

Canal IRC

#zsh at irc.freenode.org

La carte de référence du shell Z (incluse dans le paquet debian zsh-lovers)

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

AUTEURS

Cette page de manuel a été écrite par Michael Prokop, Christian strcat Schneider et Matthias
Köpfermann. Mais de nombreuses idées ont été tirées de zsh-geeks, par exemple des zsh-mailinglists
(zsh-users et zsh-workers), google, les groupes de discussion et le zsh-Wiki. Merci pour votre sang-froid et
conseils incroyables. Nous avons beaucoup appris de vous !

Par ordre alphabétique :

Andrew 'zefram' Main - http://www.fysh.org/~zefram/
Barton E. Schäfer - http://www.well.com/user/barts/
Matthias Kopfermann - http://www.infodrom.north.de/~matthi/
Olivier Kiddle - http://people.freenet.de/opk/
Paul Falstad- http://www.falstad.com/
Pierre Stephenson - http://homepage.ntlworld.com/p.w.stephenson/
Richard Colman
Stéphane Chazelas - http://stephane.chazelas.free.fr/
Sven Gückes - http://www.guckes.net/
Sven Wischnowski - http://w9y.de/zsh/zshrc

Utilisez zsh-lovers en ligne en utilisant les services onworks.net