Este é o comando zsh-lovers que pode ser executado no provedor de hospedagem gratuita OnWorks usando uma de nossas várias estações de trabalho online gratuitas, como Ubuntu Online, Fedora Online, emulador online do Windows ou emulador online do MAC OS
PROGRAMA:
NOME
zsh-lovers - dicas, truques e exemplos para o shell Z
SINOPSE
Apenas leia. ;-)
VISÃO GERAL
Sempre que olhamos para o manual zsh, nos perguntamos por que não há exemplos ou simplesmente
coisas na (casca) vida. O zsh contém muitos recursos, mas não havia nenhuma página de manual com alguns
exemplos (como procmailex(5)). É por isso que escrevemos esta página de manual.
A maioria dos truques e oneliner vêm das listas de e-mail zsh-users, zsh-workers, google,
newsgroups e de nós mesmos. Veja a seção LINKS para obter detalhes.
Nota: Esta página de manual (amantes de zsh(1)) é não uma parte oficial do shell Z! É apenas um
for fun - manpage;) Para comentários, relatórios de bugs e feedback, dê uma olhada rápida no
seção INSETOS.
SHELL-SCRITING
Esta seção fornece alguns exemplos de shellscript-stuff frequentemente necessários. Observe que você
não deve ser usado, caso contrário, a maioria dos exemplos não funcionará. Opções de análise em shellscripts. Exemplo
retirado do ZWS por 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
se [[$? ! = 0 || "$ o_help"! = ""]]; então
echo Uso: $ (basename "$ 0") "[-p PORT] [-r DIRETÓRIO]"
sair 1
fi
porta = $ o_port [2]
root = $ o_root [2]
log = $ o_log [2]
if [[$ root [1]! = '/']]; então root = "$ PWD / $ root"; fi
}
# agora use a função:
parse_options $ *
EXEMPLOS
As subseções disponíveis são Alias, Realização, Não classificado / Misc exemplos, (Recursivo)
Globulação - Exemplos, Modificadores uso, Exemplos de redirecionamento, Exemplos ZMV e
Exemplos-Módulo.
ALIASES
Aliases de sufixo são suportados no zsh desde a versão 4.2.0. Alguns exemplos:
alias -s tex = vim
alias -s html = w3m
alias -s org = w3m
Agora pressionando a tecla de retorno após entrar foobar.tex inicia o vim com foobar.tex. Chamando um
arquivo html executa o navegador w3m. www.zsh.org e pressionar enter inicia w3m com argumento
www.zsh.org. Aliases globais podem ser usados em qualquer lugar na linha de comando. Exemplo:
$ alias -g C = '| wc -l '
$ grep alias ~ / .zsh /*C
443
Alguns aliases globais mais ou menos úteis (escolha se são úteis ou não para você em
seu próprio):
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 = "exportar DISPLAY =: 0.0"
alias -g EG = '| & egrep'
alias -g EH = '| & head'
alias -g EL = '| e menos'
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 = '| cabeça'
alias -g HL = '| & head -20'
alias -g Sk = "* ~ (*. bz2 | * .gz | * .tgz | * .zip | * .z)"
alias -g LL = "2> & 1 | menos"
alias -g L = "| menos"
alias -g LS = '| menos -S '
alias -g MM = '| maioria'
alias -g M = '| mais'
alias -g NE = "2> / dev / null"
alias -g NS = '| sort -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 = '| ordenar'
alias -g TL = '| cauda -20 '
alias -g T = '| cauda'
alias -g US = '| sort -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 '
CONCLUSÃO
Consulte também man 1 zshcompctl zshcompsys zshcompwid. zshcompctl é o estilo antigo de zsh
conclusão programável, zshcompsys é o novo sistema de conclusão, zshcompwid é o zsh
widgets de conclusão.
Algumas funções, como _apt e _dpkg, são muito lentas. Você pode usar um cache para fazer proxy
a lista de resultados (como a lista de pacotes debian disponíveis) Use um cache:
zstyle ': complete: *' use-cache on
zstyle ': conclusão: *' cache-path ~ / .zsh / cache
Impedir que arquivos / diretórios CVS sejam completados:
zstyle ': conclusão: * :( todos- |) arquivos' ignorados-padrões '(| * /) CVS'
zstyle ': conclusão: *: cd: *' ignorados-padrões '(* /) # CVS'
Correspondência difusa de conclusões para quando você digitá-las incorretamente:
zstyle ': Completation: *' completer _complete _match _approximate
zstyle ': conclusão: *: correspondência: *' original apenas
zstyle ': conclusão: *: aproximado: *' erros máximos 1 numérico
E se você quiser que o número de erros permitidos por _approximate aumente com o comprimento
do que você digitou até agora:
zstyle -e ': conclusão: *: aproximado: *' \
max-errors 'reply = ($ ((($ # PREFIX + $ # SUFFIX) / 3)) numérico)'
Ignore as funções de preenchimento para comandos que você não possui:
zstyle ': conclusão: *: funções' padrões ignorados '_ *'
Com funções auxiliares como:
xdvi () {command xdvi $ {*: - *. dvi (om [1])}}
você pode evitar ter que completar em muitos casos, mas se o fizer, você pode querer
cair na seleção do menu imediatamente e ter as palavras classificadas por tempo:
zstyle ': conclusão: *: *: xdvi: *' menu sim selecionar
zstyle ': conclusão: *: *: xdvi: *' tempo de classificação de arquivo
Preenchimento de IDs de processo com seleção de menu:
zstyle ': conclusão: *: *: kill: *' menu sim selecionar
zstyle ': complete: *: kill: *' force-list sempre
Se você acabar usando um diretório como argumento, isto irá remover a barra final (útil
em ln)
zstyle ': complete: *' squeeze-slashes true
cd nunca selecionará o diretório pai (por exemplo: cd ../ ):
zstyle ': conclusão: *: cd: *' ignorar-pais pai pwd
Outro método para rápido alterar diretórios. Adicione isto ao seu ~ / .zshrc, então é só entrar
“Cd .... / dir”
racionalize-ponto () {
se [[$ LBUFFER = * ..]]; então
LBUFFER + =/ ..
outro
LBUFFER + =.
fi
}
zle -N racionalize-ponto
bindkey. racionalizar ponto
NÃO ORDENADO / MISC exemplos
Dica: uma lista de qualificadores glob válidos pode ser encontrada em zshexpn(1). Veja “man 1 zshexpn |
less -p ”Qualificadores para obter detalhes.
# Obtenha os nomes de todos os arquivos que * não * correspondem a um padrão * em qualquer lugar * no
# arquivo (e sem `` -L '' porque é GNUish)
$ print -rl - * (. ^ e {'grep -q pattern $ REPLY'})
# ou
$: * (. e {'grep -q pattern $ REPLY || print -r - $ REPLY'})
# Números aleatórios
$ echo $ [$ {RANDOM}% 1000] # aleatório entre 0-999
$ echo $ [$ {RANDOM}% 11 + 10] # aleatório entre 10-20
$ echo $ {(l: 3 :: 0:) $ {RANDOM}} # N dígitos de comprimento (3 dígitos)
# inverter uma palavra
$ echo "$ {(j ::) $ {(@ Oa) $ {(s ::): - hello}}}"
# Mostrar o diretório mais recente
$ ls -ld * (/ om [1])
# elemento de array aleatório
$ FILES = (... / arquivos / *)
$ feh $ FILES [$ RANDOM% $ # FILES + 1]
# cat primeira linha em todos os arquivos neste diretório
$ para arquivo (* (ND-.)) IFS = ler -re <$ arquivo
# testar se um parâmetro é numérico
$ if [[$ 1 == <->]]; então
eco numérico
outro
eco não numérico
fi
# Mostre-me todos os arquivos .c para os quais não existe um arquivo .o.
$ print * .c (e _ '[[! -e $ REPLY: ro]]' _)
# Todos os arquivos em / var / que não são propriedade do root
$ ls-ld / var /* (^ u: root)
# Todos os arquivos para os quais o proprietário pode ler e executar permissões
$ echo * (f: u + rx :)
# O mesmo, mas também outros não têm permissão de execução
$ echo * (f: u + rx, ox :)
# expansão de cinta - exemplo
$ X = (ABC)
$ Y = (+ -)
$ print -r - $ ^ X. $ ^ Y
A. + A.- B. + B.- C. + C.-
# Busque o arquivo mais recente contendo a string 'fgractg * .log' no
# nome do arquivo e contém a string 'ORA-' nele
$ file = (fgractg * .log (Nm0om [1]))
$ (($ # arquivo)) && grep -l ORA- $ arquivo
# sem Zsh
$ files = $ (find. -name. -o -prune -name 'fgractg *> log' -mtime 0 -print)
> if [-n "$ arquivos"]; então
> IFS = '
> '
> set -f
> arquivo = $ (ls -td $ arquivos | cabeça -1)
> grep -l ORA- "$ arquivo"
> fi
# mantém o número especificado de processos filho em execução até que toda a tarefa seja concluída
$ zsh -c 'sleep 1 & sleep 3 & sleep 2 & print -rl - $ jobtexts'
# Remova arquivos de comprimento zero e .bak em um diretório
$ rm -i * (. L0) * .bak (.)
# imprime arquivos que não têm extensões
$ printf '% s \ n' ^? *. *
$ printf '% s \ n' ^? *. [^.] * (D)
$ ls -d - ^? *. * (D)
# Encontrar arquivos que não contêm uma string específica
$ print -rl arquivo * | comm -2 -3 - <(arquivo de string grep -l *) '
$ para f (arquivo * (N)) grep -q string $ f || imprimir -r $ f '
# Mostrar / Verificar se uma opção está definida ou não. Funciona tanto com $ options como
# com $ builtins
$ echo $ options [correto]
WOW!
$ $ options [zle]
on
# Conte o número de diretórios na pilha
$ print $ (($ {$ {(z) $ {(f) "$ (dirs -v)"} [- 1]} [1]} + 1)) # ou
$ dirs -v | awk '{n = $ 1} FIM {imprimir n + 1}'
# Corresponde a todos os arquivos que não têm um ponto no nome do arquivo
$ ls * ~ *. * (.)
# Mostra apenas o endereço IP do `` dispositivo ifconfig ''
# ifconfig do net-tools (Linux)
$ imprimir $ {$ {$ (LC_ALL = C / sbin / ifconfig eth0) [7]}: gs / addr: //}
# ifconfig de 4.2BSD {Free, Net, Open} BSD
$ print $ {$ (/ sbin / ifconfig tun0) [6]}
# Faça ping em todos os endereços IP em algumas classes C ou em todos os hosts
# em / Etc / hosts
$ para i em {1..254}; faça ping -c 1 192.168.13. $ i; feito
or
$ I = 1
$ while ([[$ I -le 255]]); faça ping -1 2 150.150.150. $ I; let I ++; feito
or
$ para i em $ (sed 's /#.*//'> / Etc / hosts | awk '{print $ 2}')
: Faz
: echo "Tentando $ i ..."
: ping -c 1 $ i;
: echo '================================='
: feito
# carregue todos os módulos disponíveis na inicialização
$ tipografia -U m
$ m = ()
$ para md ($ module_path) m = ($ m $ md / ** / * (* e: 'REPLY = $ {REPLY # $ md /}' :: r))
$ zmodload -i $ m
# Renomeie todos os arquivos dentro de um diretório de forma que seus nomes recebam um numeral
# prefixo na ordem de classificação padrão.
$ i = 1; para j em *; fazer mv $ j $ i. $ j; ((i ++)); feito
$ i = 1; para f em *; fazer mv $ f $ (echo $ i | \
awk '{printf ("% 03d", $ 0)}'). $ f; ((i ++)); feito
$ inteiro i = 0; para f em *; faça mv $ f $ [i + = 1]. $ f; feito
# Encontre (e imprima) todos os links simbólicos sem um alvo dentro do atual
# sujeira.
$ $ arquivo ** / * (D @) | fgrep quebrado
$ para i em ** / * (D @); [[-f $ i || -d $ i]] || echo $ i
$ echo ** / * (@ - ^. / =% p)
$ print -l ** / * (- @)
# Liste todos os arquivos simples que não possuem extensões listadas em `fignore '
$ ls ** / * ~ * ($ {~ $ {(j / | /) fignore}}) (.)
# veja acima, mas agora omita os executáveis
$ ls ** / * ~ * ($ {~ $ {(j / | /) fignore}}) (. ^ *)
# Imprime arquivos que não têm extensões (requerem * setopt extendedglob *
# e * setopt dotglob *)
$ printf '% s \ n' ^? *. *
# Lista os arquivos em ordem reversa, classificados por nome
$ print -rl - * (On)
or
$ print -rl - * (^ on)
# Sinônimo de `` ps ax | awk '{print $ 1}' ''
$ imprimir -l / proc /* / cwd (: h: t: s / self //)
# Obtenha o PID de um processo (sem `` ps '', `` sed '', `` pgrep '', ..
# (no Linux)
$ pid2() {
> local i
> para eu em / proc /<-> / stat
> fazer
> [["$ (<$ i)" = * \ (($ {(j: |:) ~ @}) \) *]] && echo $ i: h: t
> feito
>}
# para X em 'n' 'o' 'p' 'q' 'r' 's' 't' 'u' 'v' 'w' 'x' 'y'; Faz ...
$ para ((i = 36 # n; i <= 36 # y; i ++)); Faz
> imprimir $ {$ (([## 36] i)): l}
> feito
# ou em combinação com `` dc ''
$ print {$ ((## n)) .. $ ((## y))} P \ 10P | dc
# ou com `` eval ''
$ eval print '$ {$ (([## 36]' {$ ((36 # n)) .. $ ((36 # y))} ')): l}'
# foreach em uma linha de shell
$ para f (*) imprimir -r - $ f
# copia um diretório recursivamente sem dados / arquivos
$ dirs = (** / * (/))
$ cd - $ dest_root
$ mkdir -p - $ dirs
# ou sem zsh
$ find. -tipo d -exec env d = "$ dest_root" \
sh -c 'exec mkdir -p - "$ d / $ 1"' '{}' '{}' \;
# Se `foo = 23 '', então imprima com 10 dígitos com '0' à esquerda.
$ foo = 23
$ print $ {(r: 10 :: 0:) foo}
# encontre o nome de todos os arquivos em seu diretório inicial que tenham
# mais de 20 caracteres em seus nomes de arquivo
imprimir -rl $ HOME / $ {(l: 20 ::? :) ~: -} *
# Salvar matrizes
$ print -r - $ {(qq) m}> $ nameoffile # salve-o
$ eval "m = ($ (cat - $ nameoffile)" # ou use
$ m = ("$ {(@ Q) $ {(z)" $ (cat - $ nameoffile) "}}") # para restaurá-lo
# obtenha um "ls -l" em todos os arquivos na árvore que são mais jovens que um
# idade especificada (por exemplo, "ls -l" todos os arquivos na árvore que foram
# modificado nos últimos 2 dias)
$ ls -tld ** / * (m-2)
# Isso lhe dará uma lista de 1 linha de perl de arquivo (não à la ls -R).
# Pense em uma maneira fácil de ter uma saída de estilo "ls -R" com
# somente arquivos com mais de 2 dias.
$ para d (. ./**/*(/)) {
> imprimir -r - $ '\ n' $ {d}:
> cd $ d && {
> l = (* (Nm-2))
> (($ # l)) && ls -ltd - $ l
> cd ~ -
>}
>}
# Se você também deseja que diretórios sejam incluídos, mesmo que seu mtime
# tem mais de 2 dias:
$ para d (. ./**/*(/)) {
> imprimir -r - $ '\ n' $ {d}:
> cd $ d && {
> l = (* (N /, m-2))
> (($ # l)) && ls -ltd - $ l
> cd ~ -
>}
>}
# E se você quiser que apenas os diretórios com mtime <2 dias sejam listados:
$ para d (. ./**/*(N/m-2)) {
> imprimir -r - $ '\ n' $ {d}:
> cd $ d && {
> l = (* (Nm-2))
> (($ # l)) && ls -ltd - $ l
> cd ~ -
>}
>}
# print 42 `` - ''
$ echo $ {(l: 42 :: - :)}
# ou use `` $ COLUMS ''
$ echo $ {(l: $ COLUMNS :: - :)}
# e agora com cores (requer carregamento automático de cores; cores)
$ echo "$ bg [vermelho] $ fg [preto] $ {(l: 42 :: - :)}"
# Redirecione STDERR para um comando como xless sem redirecionar STDOUT também.
$ foo 2 >> (xless)
# mas isso executa o comando de forma assíncrona. Para fazer isso de forma síncrona:
$ {{foo 1> & 3} 2> & 1 | xless} 3> & 1
# Renomeie todos os arquivos MP3 de name with spaces.mp3 para Name With Spaces.mp3
$ para i em * .mp3; Faz
> mv $ i $ {$ {(C) i}: s / Mp3 / mp3 /}
> feito
# Corresponder nomes de arquivo contendo apenas dígitos e terminando com .xml (requer
# * setopt kshglob *)
$ ls -l [0-9] ##. xml
$ ls -l <0-> .xml
# Remova todos os arquivos "não txt"
$rm./^*.txt
# Mova 200 arquivos de um diretório para outro
$ mv - * ([1,200]) / outro / Dir
# Converter imagens (foo.gif => foo.png):
$ para i em ** / *. gif; converter $ i $ i: r.png
# converter uma coleção de arquivos mp3 para wave ou cdr,
# eg file.wav -> file.mp3)
$ para i (./*.mp3){mpg321 --w - $ i> $ {i: r} .wav}
# Baixe com os arquivos criados em LaTeX2HTML (por exemplo, o ZSH-Guide):
$ para f em http://zsh.sunsite.dk/Guide/zshguide{, {01..08}}. Html; Faz
> lynx -source $ f> $ {f: t}
> feito
# Mova todos os arquivos em dir1 e dir2 que têm contagens de linha maiores que 10 para
# outro diretório diga "/ more10"
$ mv dir [12] / ** / *. cr (-. e {'((`wc -l <$ REPLY`> 10))'}) / more10
# Faça com o dpkg uma lista-mestre de todos os arquivos que ele instalou
$ diff <(localizar / | ordenar) <(cat / var / lib / dpkg / info /* .list | ordenar)
# Substitua esta merda de sequências de escape:
$ autoload cores; cores
$ print "$ bg [cyan] $ fg [blue] Você é um idiota" >> / dev / pts / 3
# Obtém o valor ASCII de um caractere
$ char = N; imprimir $ ((# char))
# Nome do arquivo "Erweiterung"
# Nota: O (N) diz para usar a opção nullglob para este particular
# padrão glob.
$ para i em * .o (N); Faz
> rm $ i
> feito
# Renomear arquivos; ou seja, FOO para foo e bar para BAR
$ para i em * (.); mv $ i $ {i: l} # `FOO 'para` foo'
$ para i em * (.); mv $ i $ {i: u} # `bar para` BAR '
# Mostra todos os arquivos suid em $ PATH
$ ls -latg $ {(s.:.)PATH} | grep '^ ... s'
# ou mais complexo;)
$ print -l $ {^ path} / * (Ns, S)
# ou mostra apenas executáveis com um determinado padrão do usuário
$ print -l $ {^ path} / * vim * (* N)
# arquivos gzip contendo uma determinada string
$ gzip $ {(ps: \ 0 :) "$ (grep -lZ foobar ./*. txt (.))"}
# Um pequeno one-liner, que lê do stdin e imprime no stdout o primeiro
# linha única, ou seja, não imprime linhas que foram impressas antes
# (é semelhante ao comando exclusivo, mas exclusivo só pode manipular
# linhas adjacentes).
$ IFS = $ '\ n \ n'; print -rl - $ {(Oau) $ {(Oa) $ (arquivo cat; echo.) [1, -2]}}
# Lista todos os executáveis em PATH
$ print -l $ {^ path} / * (- * N)
# Corresponder a todos os arquivos .c em todos os subdiretórios, _except_ qualquer subdiretório SCCS?
$ ls ** / *. c ~ (* /) # SCCS / *
# Liste todos os arquivos `README '- sem distinção entre maiúsculas e minúsculas com no máx. um erro de digitação
Leia-me $ ls ** / * (# ia2)
# verificação sem distinção entre maiúsculas e minúsculas para variáveis
$ if [[$ OSTYPE == (#i) LINUX * (# I)]]; então
> echo "Pinguim a bordo."
> mais
> echo "Não é um Linux."
> fi
(Recursivo) Globulação - Exemplos
Uma lista de qualificadores glob válidos pode ser encontrada em zshexpn(1). Nota: **/ é equivalente a
(* /) #! Por exemplo:
$ print (* /) # zsh_us.ps
zsh-4.2.3 / Doc / zsh_us.ps
$ print ** / zsh_us.ps
zsh-4.2.3 / Doc / zsh_us.ps
# Procure por `README 'em todos os subdiretórios
$ ls -l ** / README
# encontre diretórios que contenham "index.php" e "index.html", ou em
# geral, diretórios que contêm mais de um arquivo correspondente a "index. *"
$ ls ** / * (D / e: '[[-e $ REPLY / index.php && -e $ REPLY / index.html]]' :)
# ou
$ ls ** / * (D / e: 'l = ($ REPLY / index. * (N)); (($ # l> = 2))' :)
# Encontre o comando para pesquisar o nome do diretório em vez do nome de base
$ print -rl / ** / * ~ ^ * / caminho (| / *)
# ou - sem Zsh
$ find / | grep -e / caminho / -e '/ caminho $'
# Imprime o caminho dos diretórios que contêm os dez maiores arquivos C regulares
# no diretório e subdiretórios atuais.
$ print -rl - ** / *. c (D.OL [1,10]: h) | sort -u
# Encontre arquivos com tamanho == 0 e envie um e-mail
$ files = (** / * (ND.L0m + 0m-2))
> (($ # arquivos> 0)) && print -rl - $ arquivos | \
mailx -s "arquivos vazios" [email protected]
# chmod recursivo
$ chmod 700 ** / (.) # Apenas arquivos
$ chmod 700 ** / (/) # Apenas diretórios
# imprime todos os arquivos naquele diretório em 2 colunas
$ print -rC2 - $ {1: [...]} / * (D: t)
# ^ - número ob colunas
# ou - se você se sentir preocupado com os caracteres especiais - use
$ list = ($ {1: [...]} / * (ND: t))
$ (($ # lista)) && imprimir -rC2 - $ {(V) lista}
# Pesquisar todos os arquivos em /casa/* / * - mail / com um sinalizador de configuração `` chmod -s ''
# (recursivo, incluir dotfiles) remove o sinalizador setgid / setuid e imprime
# uma mensagem
$chmod-s /casa/* / * - correio (DNs, S) /casa/* / * - mail / ** / * (DNs, S))
# ou com um pequeno script
$ para arquivo (/casa/* / * - correio (DNs, S) /casa/* / * - mail / ** / * (DNs, S)) {
> imprimir -r - $ arquivo
> chmod -s $ file && print -r fixed $ file
>}
# ou use `` zargs '' (requer autoload zargs) para prevenir a lista de argumentos também
# erro longo
$zargs /casa/* / * - correio (DNs, S) /casa/* / * - mail / ** / * (DNs, S)) - chmod -s
# Lista os arquivos começando em `foo23 'para cima (foo23, foo24, foo25, ..)
$ ls -l foo <23->
# obter todos os arquivos que começam com as sequências de datas de 4 de junho a
# 9 de junho de 2004
$ ls -l 200406 {04..10} * (N)
# ou se eles são da forma 200406XX (requer `` setopt extended_glob ''
$ ls -l 200306 <4-10>. *
# remove os espaços dos nomes dos arquivos
$ para um em ./**/* \ * (Dod); fazer mv $ a $ {a: h} / $ {a: t: gs / / _}; feito
# Mostrar apenas todos os arquivos * .c e * .h
$ ls -l *. (c | h)
# Mostra apenas todos os arquivos * .c e ignora `foo.c '
$ ls * .c ~ foo.c
# mostra os dados para o formato * realmente * binário
$ zsh -ec 'enquanto {} {printf% .8x $ n; repetir 8 \
> {ler -ku0 a printf \% .8d $ (([## 2] #a))}; imprimir; ((n + = 8))} '<binário
# Mostrar apenas arquivos legíveis por todos
$ ls -l * (R)
# Os arquivos de lista no diretório atual não podem ser gravados pelo proprietário
$ print -l ~ / * (ND. ^ w)
# encontre e apague os arquivos mais antigos do que um determinado parâmetro
# (segundos / minutos / horas)
# exclui todos os arquivos regulares em / Dir com mais de 3 horas
$ rm -f /Dir/**/*(.mh+3)
# apaga todos os links simbólicos em / Dir com mais de 3 minutos
$ rm -f / Dir / ** / * (@ mm + 3)
# exclui todos os não diretórios em / Dir com mais de 30 segundos
$ rm -f / Dir / ** / * (ms + 30 ^ /)
# exclui todas as pastas, subpastas e arquivos com mais de uma hora
$ rm ./**/*(.Dmh+1,.DL0)
# exclui todos os arquivos com mais de 6 horas
$ rm -f ** / * (mh + 6)
# remove todos os arquivos, exceto os dez mais recentes (exclui todos, exceto os 10 últimos
# arquivos em um diretório)
$rm./*(Om[1,-11])
Nota: Se você obtiver uma lista de argumentos muito longa, use o rm embutido. Para
exemplo:
$ zmodload zsh / files; rm -f ** / * (mh + 6)
ou use a função zargs:
$ autoload zargs; zargs ** / * (mh + 6) - rm -f
# Um Guia do Usuário para o Z-Shell /5.9: Geração e Padrão de Nome de Arquivo
# Matching encontre todos os arquivos em todos os subdiretórios, pesquisando recursivamente,
# que têm um determinado nome, não diferencia maiúsculas de minúsculas, têm pelo menos 50 KB,
# não tem mais de uma semana e é de propriedade do usuário root, e permitindo
# a um único erro na grafia do nome. Na verdade, o necessário
# expressão tem a seguinte aparência:
$ ls ** / (# ia1) nome (LK + 50mw-1u0)
# Altere o UID de 102 para 666
$ chown 666 ** / * (u102)
# Liste todos os arquivos que não foram atualizados nas últimas 10 horas
$ print -rl - * (Dmh + 10 ^ /)
# excluir apenas o arquivo mais antigo em um diretório
$ rm ./*nome do arquivo*(Om[1])
# Classifique a saída de `ls -l 'por tamanho de arquivo
$ ls -fld * (OL)
# encontra o arquivo mais recente em um diretório
$ setopt dotglob; diretório de impressão / ** / * (om [1])
# Mostra apenas arquivos vazios que não são "agrupados" ou "graváveis por todo o mundo"
$ ls * (L0f.go-w.)
# Encontre - e liste - os dez arquivos mais recentes em diretórios e subdiretórios.
# (recursivo)
$ print -rl - ** / * (Dom [1,10])
# Imprime apenas 5 linhas pelo comando "ls" (como `` ls -laS | head -n 5 '').
$ ls -fl * (DOL [1,5])
# Exibe os últimos 5 a 10 arquivos modificados.
$ print -rl - /path/to/dir/**/*(D.om[5,10])
# Encontre todos os arquivos sem um proprietário válido.
$ chmod someuser / ** / * (D ^ u: $ {(j.:u:.) $ {(f) "$ (/ Etc / passwd) "} %%: *} :)
# Encontre todos os diretórios vazios em uma árvore.
$ para f em *** / * (/ l2); fazer foo = ($ f / * (N)); [[-z $ foo]] && print $ f; feito
# Nota: Desde Zsh 4.2.1, o qualificador glob F indica um diretório não vazio.
# Portanto, * (F) indica todos os subdiretórios com entradas, * (/ ^ F) significa todos
# subdiretórios sem entradas.
$ ls -ld * (/ ^ F)
# Remova os diretórios vazios em seguida.
$ rmdir ./**/*(/od) 2> / dev / null
# Mostra apenas os arquivos que são propriedade dos 'usuários' do grupo.
$ ls -l * (G [usuários])
Modificadores uso
Os modificadores são um mecanismo poderoso que permite modificar os resultados retornados pelo parâmetro,
expansão de nome de arquivo e histórico. Ver zshexpn(1) para obter detalhes.
# NOTA: Zsh 4.3.4 necessário!
$ autoload -U idade
# arquivos modificados hoje
$ print * (e: idade hoje :)
# arquivos modificados desde as 5h
$ print * (e-age 17:00 agora-)
# ... desde as 5 horas yesterda
$ print * (e-era ontem, 17:00 agora-)
# ... do último Natal até hoje
$ print * (e-age 2006/12/25 hoje-)
# ... antes de ontem
$ print * (e-age 1970/01/01 ontem)
# todos os arquivos modificados entre o início dessas datas
$ print * (e: idade 2006/10/04 2006/10/09 :)
# todos os arquivos modificados nessa data
$ print * (e: idade 2006/10/04 :)
# Tempos de abastecimento.
$ print *(e-age 2006/10/04:10:15 2006/10/04:10:45-)
# Remova um componente final do nome do caminho, deixando o cabeçalho. Isso funciona como
# `dirname '.
$ echo = ls (: h)
/ bin
# Remova todos os componentes principais do nome do caminho, deixando a cauda. Isso funciona
# como `basename '.
$ echo = ls (: t)
ls
# Remova o sufixo de cada arquivo (* .sh neste exemplo)
$ f: e é a extensão de arquivo $ f
: h -> head (dirname)
: t -> cauda (nome de base)
: r -> resto (extensão removida)
$ para f (* .sh) mv $ f $ f: r
# Remova uma extensão de nome de arquivo no formato `.xxx ', deixando o nome do root.
$ echo $ PWD
/ usr / src / linux
$ echo $ PWD: t
linux
# Remova tudo, exceto a extensão.
$ foo = 23.42
$ echo $ foo
23.42
$ echo $ foo: e
42
# Imprime o novo comando, mas não o executa. Só funciona com história
# expansão.
$ echo = ls (: h)
/ bin
$! echo: p
$ echo = ls (: h)
# Cite as palavras substituídas, evitando outras substituições.
$ bar = "23'42"
$ echo $ bar
23'42
$ echo $ bar: q
23 \ '42
# Converta as palavras em letras minúsculas.
$ bar = FOOBAR
$ echo $ bar
FOOBAR
$ echo $ bar: l
foobar
# Converta as palavras em maiúsculas.
$ bar = foobar
$ echo $ bar
foobar
$ echo $ bar: u
FOOBAR
# converter o primeiro caractere de uma palavra em maiúsculas
$ foo = "um dois três quatro"
$ print -r - "$ {(C) foo}"
Um dois três quatro
Exemplos de redirecionamento
See zshmisc(1) para mais informações (ou menos $ {^ fpath} / zmv (N))
# Anexe `exit 1 'no final de todos os arquivos * .sh
$ echo "exit 1" >> * .sh
# adicionando arquivos a foobar.tar.gz
$ eval set = (gunzip <foobar.tar.gz) '
tar rf $ 1 additional.txt && gzip <$ 1> foobar.tar.gz '
# Redirecionar a saída para um arquivo E exibir na tela
$ foobar> & 1> arquivo1> arquivo2> ..
# canaliza uma saída única para várias entradas
$ zcat foobar.Z >> (gzip -9> file1.gz) \
>> (bzip2 -9> arquivo1.bz2) \
>> (acb --best> arquivo1.acb)
# Anexar / etc / services no final do arquivo `foo 'e` bar'
$ gato / etc / services >> foo >> bar
# Tubo STDERR
$ echo Um erro> & 2 2> & 1 | sed -e 's / A / I /'
# enviar saída padrão de um processo para entrada padrão de vários processos
# no pipeline
$ settop multios
$ processo1>> (processo1)>> (processo2)
# inicializar uma variável e simultaneamente manter a saída do terminal
$ settop multios
$ {a = $ (comando> & 1> & 3 3> & - 2> & 1);} 3> & 1
# redirect stderr duas vezes
$ setopt multios; programa 2> arquivo2> arquivo1 2> e 1
# Duplicando stdout e stderr para um arquivo de log
$ exec 3> & 1> arquivo de log 2> & 2 2> & 1> & 3 3> & -
# redireciona stderr (apenas) para um arquivo e para orig. stderr:
$ command 2> & 2 2> stderr
# redireciona stderr e stdout para arquivos separados e ambos para orig. stdout:
$ command 2> & 1 1> & 1 2> stderr 1> stdout
# redireciona stderr e stdout para arquivos separados e stdout para orig. stdout
# E stderr para orig. stderr:
$ command 2> & 2 1> & 1 2> stderr 1> stdout
# Mais divertido com STDERR;)
$ ./my-script.sh 2>> (grep -v moron> error.log) | process-output> output.log
$ echo "Thats STDOUT" >> (sed 's / stdout / outro exemplo /'> foobar)
Exemplos ZMV (requer autoload zmv)
Nota: -n significa nenhuma execução (apenas imprimir o que aconteceria). No
# Remova caracteres ilegais em um sistema de arquivos fat32. Personagens ilegais são
# /:; *? "<> |
# NOTA: `` -Q '' e (D) deve incluir arquivos ocultos.
$ indesejado = '[:; *? \ "<> |]'
$ zmv -Q "(** /) (* $ ~ indesejado *) (D)" '$ 1 $ {2 // $ ~ indesejado /}'
# Alterar parte de um nome de arquivo (ou seja, "file-hell.name" -> "file-heaven.name")
$ zmv '(*) inferno (*)' '$ {1} céu $ {2}'
# ou
$ zmv '*' '$ f: s / inferno / céu /'
# remove o colchete dentro dos nomes dos arquivos
# ie foo- (bar) .avi -> foo-bar.avi
$ zmv '*' '$ {f // [()] /}'
# serialmente todos os arquivos (foo.foo> 1.foo, fnord.foo> 2.foo, ..)
$ carregamento automático zmv
$l*
1.c asd.foo bla.foo fnord.foo foo.fnord foo.foo
$ c = 1 zmv '* .foo' '$ ((c ++)). foo'
$l*
1.c 1.foo 2.foo 3.foo 4.foo foo.fnord
# Renomeie "file.with.many.dots.txt" substituindo os pontos (exceto pelo último
# um!) com um espaço
$ touch {1..20} -file.with.many.dots.txt
$ zmv '(*. *) (. *)' '$ {1 //./ } $ 2 '
# Remova os primeiros 4 caracteres de um nome de arquivo
$ zmv -n '*' '$ f [5, -1]' # NOTA: O "5" NÃO é um erro de escrita!
# Renomeie os nomes de todos os arquivos no diretório atual para minúsculas, mas mantenha
# dirnames no estado em que se encontra.
$ zmv -Qv '(** /) (*) (. D)' '$ 1 $ {(L) 2}'
# substitua todo o quarto caractere, que é "4", por "1" e assim por diante
$ carregamento automático -U zmv
$ zmv '(???) 1 (??? [1-4] .txt)' '$ {1} 2 $ {2}'
# Remova os primeiros 15 caracteres de uma string
$ touch 111111111111111 {az}
$ carregamento automático zmv
$ zmv '*' '$ f [16, -1]'
# Substitua os espaços (qualquer número) por um único traço nos nomes dos arquivos
$ autocarregar zmv
$ zmv -n '(** /) (* *)' '$ 1 $ {2 // (# - ## # | ##) / -}'
# ou - com Bash
$ find. -depth -name '* *' -exec bash -c '
> shopt -s extglob
> arquivo = $ 1
> dir = $ {arquivo% / *}
> nome = $ {arquivo ## * /}
> newname = $ {name // * ([-]) * ([-]) / -}
> mv -i - "$ file" "$ Dir / $ newname" '{} {} \;
# Limpe os nomes dos arquivos e remova os caracteres especiais
$ carregamento automático zmv
$ zmv -n '(** /) (*)' '$ 1 $ {2 // [^ A-Za-z0-9 ._] / _}'
# Adicione * .py a um monte de scripts Python em um diretório (alguns deles terminam
# em * .py e dê a todos eles uma extensão adequada
$ carregamento automático zmv
$ zmv -n '(** /) (con *) (# qe, arquivo $ REPLY | grep "script python",)' '$ 1 $ 2.py'
# todas as extensões em letras minúsculas (ou seja, * .JPG) incl. subpastas
$ carregamento automático zmv
$ zmv '(** /) (*). (# i) jpg' '$ 1 $ 2.jpg'
# Ou - sem Zsh
$ find Dir -nome '*. [jJ] [pP] [gG]' -impressão | enquanto lê f
> fazer
> caso $ f em
> * .jpg);
> *) mv "$ f" "$ {f%. *}. jpg" loading = "preguiçoso";
> esac
> feito
# remove os zeros à esquerda da extensão do arquivo
$ carregamento automático zmv
$ls
nomedoarquivo.001 nomedoarquivo.003 nomedoarquivo.005 nomedoarquivo.007 nomedoarquivo.009
nomedoarquivo.002 nomedoarquivo.004 nomedoarquivo.006 nomedoarquivo.008 nomedoarquivo.010
$ zmv '(nome do arquivo.) 0 ## (? *)' '$ 1 $ 2'
$ls
nomedoarquivo.1 nomedoarquivo.10 nomedoarquivo.2 nomedoarquivo.3 nomedoarquivo.4 nomedoarquivo.5 ..
# renumerar arquivos.
$ carregamento automático zmv
$l*
foo_10.jpg foo_2.jpg foo_3.jpg foo_4.jpg foo_5.jpg foo_6.jpg ..
$ zmv -fQ 'foo_ (<0->) .jpg (.nOn)' 'foo _ $ (($ 1 + 1)). jpg'
$l*
foo_10.jpg foo_11.jpg foo_3.jpg foo_4.jpg foo_5.jpg ...
# adicionar zeros à esquerda a um nome de arquivo (1.jpg -> 001.jpg, ..
$ carregamento automático zmv
$ zmv '(<1->) .jpg' '$ {(l: 3 :: 0:) 1} .jpg'
# Veja acima, mas agora apenas arquivos com nome de arquivo> = 30 caracteres
$ carregamento automático zmv
$ c = 1 zmv "$ {(l: 30-4 ::?:)} *. foo" '$ ((c ++)). foo'
# Substitua os espaços nos nomes dos arquivos por um sublinhado
$ carregamento automático zmv
$ zmv '* *' '$ f: gs / / _'
# Altere o sufixo de * .sh para * .pl
$ carregamento automático zmv
$ zmv -W '* .sh' '* .pl'
# Adicione uma extensão "" .txt "a todos os arquivos em $ {HOME}
# `` -. '' é apenas renomear arquivos regulares ou links simbólicos para arquivos regulares,
# `` D '' é também renomear arquivos ocultos (dotfiles))
$ carregamento automático zmv
$ zmv -Q '/casa/** / * (D-.) '' $ F.txt '
# Ou apenas para renomear arquivos que não tenham extensão:
$ zmv -Q '/casa/** / ^? *. * (D-.) '' $ F.txt '
# Alterar recursivamente os nomes dos arquivos com caracteres? [] / = + <>; : ", - *
$ carregamento automático zmv
$ chars = '[] [? = + <>; ", * -]'
$ zmv '(** /) (*)' '$ 1 $ {2 // $ ~ chars /%}'
# Removendo aspas simples de nomes de arquivos (recursivamente)
$ carregamento automático zmv
$ zmv -Q "(** /) (* '*) (D)" "\ $ 1 \ $ {2 //' /}"
# Quando um novo arquivo chegar (chamado file.txt), renomeie todos os arquivos para
# get (por exemplo, arquivo119.txt torna-se arquivo120.txt, arquivo118.txt torna-se
# file119.txt e assim por diante, terminando com file.txt tornando-se file1.txt
$ carregamento automático zmv
$ zmv -fQ 'file ([0-9] ##). txt (On)' 'file $ (($ 1 + 1)). txt'
# minúsculas / maiúsculas todos os arquivos / diretórios
$ carregamento automático zmv
$ zmv '(*)' '$ {(L) 1}' # minúsculas
$ zmv '(*)' '$ {(U) 1}' # maiúsculas
# Remova o sufixo * .c de todos os arquivos C
$ carregamento automático zmv
$ zmv '(*). c' '$ 1'
# Maiúscula apenas a primeira letra de todos os arquivos * .mp3
$ carregamento automático zmv
$ zmv '([az]) (*). mp3' '$ {(C) 1} $ 2.mp3'
# Copie o `README 'de destino no mesmo diretório de cada` Makefile'
$ carregamento automático zmv
$ zmv -C '(** /) Makefile' '$ {1} README'
# Removendo aspas simples de nomes de arquivos (recursivamente)
$ carregamento automático zmv
$ zmv -Q "(** /) (* '*) (D)" "\ $ 1 \ $ {2 //' /}"
# Renomear pic1.jpg, pic2.jpg, .. para pic0001.jpg, pic0002.jpg, ..
$ carregamento automático zmv
$ zmv 'pic (*). jpg' 'pic $ {(l: 4 :: 0:) 1} .jpg'
$ zmv '(** /) pic (*). jpg' '$ 1 / pic $ {(l: 4 :: 0:) 2} .jpg' # recursivamente
Exemplos-Módulo
Leia por favor módulos zsh(1) primeiro!
zsh / pcre (requer zmodload zsh / pcre)
# Copiar arquivos de um determinado período (data indicada nos nomes dos arquivos)
$ zmodload zsh / pcre
$ ls -d - * (e: '[[$ REPLY -pcre-match pcre-regexp]]' :)
# ou
$ m () {[[$ 1 -pcre-match pcre-regexp]]}
$ ls -d - * (+ m)
zsh / clone (requer zmodload zsh / clone)
# Cria uma instância bifurcada do shell atual ($! É definido como zero) e
# execute o `` comando '' em / dev / tty8 (para este exemplo).
$ zmodload zsh / clone
$ clone / dev / tty8 && (($! == 0)) && comando exec
zsh / datetime (requer zmodload zsh / datetime)
$ zmodload zsh / datetime
$ alias datereplacement = 'strftime "% Y-% m-% d" $ EPOCHSECONDS'
$ export DATE = `datereplacement`
$ echo $ DATE
# tira data do nome do arquivo
$ zmodload zsh / datetime
$ setopt Extendedglob
$ toque aaa_bbb_20041212_c.dat eee_fff_20051019_g.dat
$ strftime -s padrão \
'??? _ ??? _ <0-% Y% m% d> _ ?. dat' $ ((ÉPOCOS - 365 * 24 * 60 * 60/2))
$ print -rl - $ ~ padrão
aaa_bbb_20041212_c.dat
$ print -rl - $ padrão
??? _ ??? _ <0-20050815> _ ?. dat
# Search files size == 0, para ser baseado no nome do arquivo que contém uma data
# em vez da data da "última modificação" do arquivo
$ zmodload -i zsh / datetime
$ strftime -s file "abc_de_% m% d% Y.dat" $ ((EPOCHSECONDS - 24 * 60 * 60))
$ files = (** / $ file (N.L0))
$ (($ # arquivos> 0)) && print -rl - $ arquivos | \
mailx -s "arquivos vazios" [email protected]
zsh / stat (requer zmodload zsh / stat)
# testar se um link simbólico leva a um determinado arquivo
$ zmodload -i zsh / stat
$! stat -LH s foo.ln || [[$ s [link]! = "foo.exe"]] || ln -sf foo.exe foo.ln
# comparando datas de arquivo
$ zmodload zsh / stat
$ file1 = foo
$ file2 = bar
$ touch bar & sleep 5 & touch foo
$ echo $ arquivo1 é $ (($ (stat + mtime $ arquivo2) - \
$ (stat + mtime $ file1))) segundos mais antigos que $ file2.
bar é 5 segundos mais velho que foo
# lista os arquivos de um disco menor do que algum outro arquivo
$ zmodload zsh / stat
$ stat -A max + size some-other-file
$ print -rl ./**/*(DL-$max)
# Liste os 100 maiores arquivos em um disco
$ zmodload zsh / stat
$ ls -fld ./**/*(d`stat + device .`OL [1,100])
# Obtenha apenas o nome do usuário e os nomes dos arquivos de (como
# ls -l * | awk '{print $ 3 "" $ 8}')
$ zmodload zsh / stat
$ para arquivo; Faz
> stat -sA usuário + uid - "$ arquivo" &&
> imprimir -r - "$ user" "$ file"
> feito
# obtém a diferença entre bytes reais do arquivo e bytes alocados do arquivo
$ zmodload zsh / stat
$ print $ (($ (stat + bloco - arquivo) * 512 - $ (stat + tamanho - arquivo)))
# Encontre o maior arquivo
# `` D '': para incluir arquivos dot (d minúsculas é para o dispositivo)
# `` O '': ordem reversa (o minúsculas para ordem não reversa)
# `` L '': por comprimento do arquivo (l é para o número de links)
# `` [1] '': retorna apenas o primeiro
$ zmodload zsh / stat
$ stat + size ./*(DOL[1])
# tamanho do arquivo em bytes
$ zmodload zsh / stat
$ stat -L + tamanho ~ / .zshrc
4707
# Exclua arquivos em um diretório que não foi acessado nos últimos dez dias
# e envie UM e-mail para o dono dos arquivos informando-o dos arquivos '
# exclusão.
$ zmodload zsh / stat zsh / files
$ typeset -A f; f = ()
$ rm -f /path/**/*(.a+10e{'stat -sA u + uidr $ REPLY; f [$ u] = "$ f [$ u] $ REPLY" '})
$ para o usuário ($ {(k) f}) {imprimir -rn $ f [$ user] | mailx -s "..." $ user}
# Obtenha um "ls -l" em todos os arquivos na árvore que são mais jovens que um
# idade especificada
$ zmodload zsh / stat
$ para d (. ./**/*(N/m-2))
> imprimir -r - $ '\ n' $ d: && cd $ d && {
> para f (* (Nm-2om))
> stat -F '% b% d% H:% M' -LsAs - $ f &&
> imprimir -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 ~ -
>}
# obter data de criação do arquivo
$ zmodload zsh / stat
$ stat -F '% d% m% Y' + m hora ~ / .zshrc
30 06 2004
$ stat -F '% D' + mtime ~ / .zshrc
06/30/04
zsh / arquivos (requer zmodload zsh / files)
# pesquise um diretório por arquivos que contenham uma determinada string e, em seguida, copie-os
# arquivos para outro diretório.
$ zmodload zsh / files
$ IFS = $ '\ 0'
$ cp $ (grep -lZr foobar.) outro diretório
zsh / mapfile (requer zmodload zsh / mapfile)
# grepping para dois padrões
$ zmodload zsh / mapfile
$ pattern1 = "foo"
$ pattern2 = "bar foo"
$ print -l ./**/*(DN.e{'z=$mapfile[$REPLY] && [[$ z = * $ pattern1 * && \
$ z = * $ pattern2 *]] '})
# ou uma solução em combinação com 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] '})
# equivalente para `` menos / Etc / passwd | grep -v root ''
$ zmodload zsh / mapfile
$ IFS = $ '\ n \ n'
$ print -rl - $ {$ {= mapfile [/ Etc / passwd]}:#*raiz*}
# ou - para não diferenciar maiúsculas de minúsculas
$ setopt Extendedglob
$ print -rl - $ {$ {= mapfile [/ Etc / passwd]}: # * (# i) root *}
# Se um arquivo XML contém coisas como `` '' e `` '', número
# estas tags vazias (aquelas que terminam em '/>'), portanto, se encontradas nas mesmas
# ordem, as tags anteriores se tornariam `` 1 '' e
# `` 2 ''
$ zmodload zsh / mapfile
$ cnt = 0
$ apfile [data.xml.new] = $ {(S) mapfile [data.xml] // \
> (#im) * <\ / TAGA> / $ ((++ cnt)) <\ / TAGA>}
# removendo todos os arquivos em usuários Maildir / new que contenham `` filename = "gone.src ''
$ zmodload zsh / {arquivos, mapfile}
$ rm -f / u1 / ?? / * / Maildir / new / 100 * (. e {'[[$ mapfile [$ REPLY] == \
* filename = \ "gone.scr \" *]] '})
# Retire o título de um arquivo postscript e acrescente esse valor ao
# fim do nome do arquivo
$ carregamento automático -U zmv
$ zmodload zsh / mapfile
$ zmv '(*). ps' '$ 1 - $ {$ {$ {mapfile [$ f] ## * %% Title:} %% *} // [^ a-zA-Z0-9 _] /}. ps '
zsh / mathfunc (requer 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 (requer zmodload zsh / termcap)
$ zmodload -ab zsh / termcap echotc
$ VERDE = `echotc AF 2`
$ YELLOW = `echotc AF 3`
$ RED = `echotc AF 1`
$ BRIGHTRED = `echotc md; echotc AF 1`
$ print -l $ {GREEN} verde $ {YELLOW} amarelo $ {RED} vermelho $ {BRIGHTRED} brightred
zsh / zpty (requer zmodload zsh / zpty)
$ zmodload zsh / zpty
$ zpty PW passwd $ 1
$ zpty PW passwd $ 1
# `` -r '': lê a saída do nome do comando.
# `` z '': Parâmetro
$ zpty -r PW z '* senha:'
# envia o comando to para nomear as strings fornecidas como entrada
$ zpty -w PW $ 2
$ zpty -r PW z '* senha:'
$ zpty -w PW $ 2
# A segunda forma, com a opção -d, é usada para deletar comandos
# iniciado anteriormente, fornecendo uma lista de seus nomes. Se não houver nomes
# são fornecidos, todos os comandos são excluídos. A exclusão de um comando faz com que o HUP
# sinal a ser enviado ao processo correspondente.
$ zpty -d PW
zsh / net / socket (requer zmodload zsh / net / socket)
# `` -l '': abre um soquete ouvindo o nome do arquivo
# `` -d '': o argumento será tomado como o descritor de arquivo alvo para o
# conexão
# `` 3 '': descritor de arquivo. Consulte o `` Guia do usuário para o Z-Shell ''
# (3.7.2: descritores de arquivo)
$ zmodload zsh / net / socket
$ zsocket -l -d 3
# `` -a '': aceita uma conexão de entrada para o soquete
$ zsocket -a -d 4 3
$ zsocket -a -d 5 3 # aceitar uma conexão
$ echo foobar> & 4
$ echo barfoo> & 5
$ 4> & - 5> & - 3> &
zsh / zftp (requer zmodload zsh / zftp)
$ autoload -U zfinit
$ zfinit
$ zfparams www.example.invalid meuuserid minhasenha
$zfopen
dicas $ zfcd
$ zfls -l zshtips.html
$ zfput zshtips.html
$ zfls -l zshtips.html
# Transferir arquivos automaticamente usando FTP com verificação de erros
$ autoload -U zfinit; zfinit
$ zftp open host.name.invalid user passwd || saída
$ zftp get / remote / file> / local / file; r = $?
$ zftp close && exit r
# compress e ftp em tempo real
$ autoload -U zfinit; zfinit
$ zftp abre host.name.senha de usuário inválida
$ zftp get $ file | bzip2> $ {arquivo} .bz2
$ zftp fechar
# Recursice `` get ''
$ autoload -U zfinit; zfinit
$ zfanon cr.yp.to
$ zfcd daemontools
$ para arquivo em `zfls`; Faz
> zfget $ file
$ feito
$ zf fechar
# Carregue todos os arquivos regulares em $ HOME / foobar (recursivo) que são mais recentes que
# duas horas para ftp.foobar.invalid / path / to / upload
$ autoload -U zfinit; zfinit
$ zfopen ftp.foobar.invalid / path / to / upload
$ cd $ HOME / foobar
$ zfput -r ** / * (. mh-2)
$ zf fechar
# lista longa de arquivos em um ftp
$ autoload -U zfinit; zfinit
$ zfopen algum-host
$ zfcd / some / remote / Dir
$ cd / some / local / Dir
# Se list.txt estiver localizado no host remoto, mude para
# zfget $ {(f) "$ (zftp get /path/to/remote/list.txt)"}
$ zfget $ {(f) "$ (cat list.txt)"}
$ zf fechar
zsh / zselect (requer zmodload zsh / zselect)
# É semelhante a
, ----
| $ sg = $ (stty -g)
| $ stty -icanon min 0 vez 50
| $ leia sim não
| $ stty "$ sg"
| $ case "$ yesno" em
| > sim) comando1 ;;
| > *) command2 ;;
| > esac
`----
$ zmodload zsh / zselect
$ if zselect -t 500 -r 0 && ler yesno && [yes = "$ yesno"]; então
> command1
> mais
> command1
> fi
OPÇÕES
Navegação opções
auto_cd (permite que alguém mude para um diretório digitando-o como um comando). auto_pushd
(anexa automaticamente dirs à lista push / pop) pushd_ignore_dups (e não duplique
eles).
misc
não_hup (não envie o sinal HUP para trabalhos em segundo plano ao sair do ZSH). imprimir_exit_value (exposição
uma mensagem com o código de saída quando um comando retorna com um código de saída diferente de zero)
História opções
hist_verify (deixe o usuário editar a linha de comando após a expansão do histórico (por exemplo,! ls)
em vez de executá-lo imediatamente) Use o mesmo arquivo de histórico para todas as sessões: settop
SHARE_HISTORY
Política de / Segurança
não_clobber (ou definir -C; evitar > redirecionamento de truncar o arquivo fornecido se ele
já existe)
Ortografia correção
correta (corrige automaticamente a grafia dos comandos). correto_tudo (automaticamente
corrija a grafia de cada palavra na linha de comando) dvorak (layout dvorak)
NÃO ORDENADO / MISC
Mailpath: mailpath múltiplo simples:
mailpath = ($ HOME / Mail / mbox '? novo correio na mbox'
$ HOME / Mail / tux.u-strasbg '? Novo correio no tux'
$ HOME / Mail / lilo '? Novo e-mail no lilo'
$ HOME / Mail / ldap-fr '? Novo correio em ldap-fr')
Caminho de correio: caminho de correio dinâmico:
typeset -a caminho de correio
para eu em ~ / Mail / Listas /* (.); Faz
mailpath [$ # mailpath + 1] = "$ {i}? Você tem um novo e-mail em $ {i: t}."
feito
Evite globbing em comandos especiais:
para com no alias expr encontre mattrib mcopy mdir mdel which;
alias $ com = "noglob $ com"
Para migrar seu bashprompt para zsh, use o script bash2zshprompt localizado no zsh
distribuição de fonte em misc.
Para a migração de (t) csh para zsh, use a ferramenta c2z que converte aliases de csh e
variáveis de ambiente e shell para zsh. Ele faz isso executando csh, e tendo o relatório csh
em aliases e variáveis. O script então os converte em arquivos de inicialização zsh. Tem algum
problemas e informações de uso documentados no início deste script.
Aqui estão as funções para definir o título e o status de um Xtermo ou de GNU Peneira para zsh e
o diretório atual, respectivamente, quando o prompt é exibido, e para o nome do comando
e o resto da linha de comando, respectivamente, quando um comando é executado:
título da função {
if [[$ TERM == "tela"]]; então
# Use estes dois para o GNU Screen:
imprimir -nR $ '33k' $ 1 $ '33' \
imprimir -nR $ '33] 0;' $ 2 $ ''
elif [[$ TERM == "xterm" || $ TERM == "rxvt"]]; então
# Use este para XTerms:
imprimir -nR $ '33] 0;' $ * $ ''
fi
}
função precmd {title zsh "$ PWD"}
função preexec {
emular -L zsh
local -a cmd; cmd = ($ {(z) 1})
título $ cmd [1]: t "$ cmd [2, -1]"
}
Coloque a seguinte linha em seu ~ / .screenrc para ver este hardstatus sofisticado:
legenda sempre "% 3n% t%? (% u)%?% ?:% h%?"
Variáveis especiais que são atribuídas:
$ LINENO $ RANDOM $ SECONDS $ COLUMNS $ HISTCHARS $ UID
$ EUID $ GID $ EGID $ USERNAME $ fignore $ mailpath $ cdpath
LINKS
Site primário
http://www.zsh.org/
Página do projeto
http://sourceforge.net/projects/zsh/
Página do shell Z em sunsite.dk
http://zsh.sunsite.dk/
Do Bash ao Z Shell: Conquistando a linha de comando - o livro
http://www.bash2zsh.com/
"Zsh - die magische Shell" (livro alemão sobre Zsh) de Sven Guckes e Julius Plenz
http://zshbuch.org/
Arquivo de lista de correspondência
http://www.zsh.org/mla/
ZSH-FAQ
http://zsh.dotsrc.org/FAQ/
Guia de usuario
http://zsh.sunsite.dk/Guide/
ZSH Wiki
http://zshwiki.org/home/
Uma breve introdução da BYU
http://docs.cs.byu.edu/linux/advanced/zsh.html
Suporte para mouse;)
http://stchaz.free.fr/mouse.zsh
Cortinas levantadas: apresentando a concha Z
http://www-128.ibm.com/developerworks/linux/library/l-z.html? dwzone = linux
ZSH-Liebhaberseite (alemão)
http://michael-prokop.at/computer/tools_zsh_liebhaber.html
ZSH-Seite de Michael Prokop (alemão)
http://michael-prokop.at/computer/tools_zsh.html
Introdução ao prompt do ZSH
http://aperiodic.net/phil/prompt/
Página ZSH de Adam
http://www.adamspiers.org/computing/zsh/
Zzappers Melhores dicas de ZSH
http://www.rayninfo.co.uk/tips/zshtips.html
Zsh Webpage por Christian Schneider
http://www.strcat.de/zsh/
A página zsh-lovers
http://grml.org/zsh/
Canal IRC
#zsh at irc.freenode.org
O cartão de referência do shell Z (incluído no pacote debian zsh-lovers)
http://www.bash2zsh.com/zsh_refcard/refcard.pdf
AUTORES
Esta página de manual foi escrita por Michael Prokop, Christian strcat Schneider e Matthias
Kopfermann. Mas muitas idéias foram tiradas de zsh-geeks, por exemplo, das listas de e-mail zsh
(zsh-users e zsh-workers), google, newsgroups e zsh-Wiki. Obrigado pela sua calma e
dicas incríveis. Aprendemos muito com você!
Em ordem alfabética:
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/
Paulo Falstad - http://www.falstad.com/
Peter Stephenson- http://homepage.ntlworld.com/p.w.stephenson/
Richard Coleman
Stéphane Chazelas http://stephane.chazelas.free.fr/
Sven Gucks - http://www.guckes.net/
Sven Wischnowsky http://w9y.de/zsh/zshrc
Use zsh-lovers online usando os serviços onworks.net
