Quais são seus recursos ou truques favoritos da linha de comando?
Compartilhe seus recursos e truques da linha de comando para Unix/Linux. Tente manter o Shell/distro agnóstico, se possível. Interessado em ver aliases, one-liners, atalhos de teclado, pequenos scripts Shell, etc.
Isso se expande um pouco no !! truque mencionado em esta resposta . Na verdade, existem vários comandos relacionados à história que tendem a ser esquecidos (as pessoas tendem a esfaquear Up 100 vezes procurando um comando que eles sabem que digitaram).
- O comando
historymostrará uma lista de comandos executados recentemente com um designador de eventos à esquerda !Nsubstituirá o comando associado ao designador de eventoN!-Nsubstituirá oNº comando mais recente; por exemplo.!-1substituirá o comando mais recente,!-2o segundo mais recente etc.- Como mencionado na outra resposta,
!!é uma abreviação de!-1, para substituir rapidamente o último comando !stringsubstituirá o comando mais recente que começa comstring!?string?substituirá o comando mais recente que contémstring
Os designadores de palavras podem ser adicionados a um ! comando histórico para modificar os resultados. Dois pontos separam o evento e os designadores do Word, por exemplo !!:0. O designador de evento !! pode ser abreviado para apenas ! ao usar um designador do Word, então !!:0 é equivalente a !:0.
!:0obterá o comando que foi executado!:1obterá o primeiro argumento (e!:2o segundo, etc.)!:2-3obterá o segundo e o terceiro argumentos!:^é outra maneira de obter o primeiro argumento.!:$receberá o último!:*obterá todos os argumentos (mas não o comando)
Modificadores também podem ser anexados a um ! comando history, cada um prefixado por dois pontos. Qualquer número pode ser empilhado (por exemplo, !:t:r:p).
h- alinhe até o nome do arquivo baset- Apenas o nome do arquivo baser- alinhe até a extensão do nome do arquivoe- Apenas a extensão do nome do arquivos/search/replacement- Substitua a primeira ocorrência desearchporreplacementgs/search/replacement- Substitua todas as ocorrências desearchporreplacement
bash - insira o parâmetro final da linha anterior
alt-. a combinação de teclas mais útil de todos os tempos, experimente e veja, por algum motivo, ninguém sabe sobre esse.
pressione-o repetidamente para selecionar os últimos parâmetros mais antigos.
ótimo quando você quer fazer algo mais com o argumento/arquivo que você usou apenas um momento atrás.
Meu favorito é
man 7 ascii
Simples e muito útil.
Oct Dec Hex Char Oct Dec Hex Char
────────────────────────────────────────────────────────────────────────
000 0 00 NUL '\0' (null character) 100 64 40 @
001 1 01 SOH (start of heading) 101 65 41 A
002 2 02 STX (start of text) 102 66 42 B
003 3 03 ETX (end of text) 103 67 43 C
004 4 04 EOT (end of transmission) 104 68 44 D
005 5 05 ENQ (enquiry) 105 69 45 E
006 6 06 ACK (acknowledge) 106 70 46 F
007 7 07 BEL '\a' (bell) 107 71 47 G
010 8 08 BS '\b' (backspace) 110 72 48 H
011 9 09 HT '\t' (horizontal tab) 111 73 49 I
012 10 0A LF '\n' (new line) 112 74 4A J
013 11 0B VT '\v' (vertical tab) 113 75 4B K
014 12 0C FF '\f' (form feed) 114 76 4C L
015 13 0D CR '\r' (carriage ret) 115 77 4D M
016 14 0E SO (shift out) 116 78 4E N
017 15 0F SI (shift in) 117 79 4F O
020 16 10 DLE (data link escape) 120 80 50 P
021 17 11 DC1 (device control 1) 121 81 51 Q
022 18 12 DC2 (device control 2) 122 82 52 R
023 19 13 DC3 (device control 3) 123 83 53 S
024 20 14 DC4 (device control 4) 124 84 54 T
025 21 15 NAK (negative ack.) 125 85 55 U
026 22 16 SYN (synchronous idle) 126 86 56 V
027 23 17 ETB (end of trans. blk) 127 87 57 W
030 24 18 CAN (cancel) 130 88 58 X
031 25 19 EM (end of medium) 131 89 59 Y
032 26 1A SUB (substitute) 132 90 5A Z
033 27 1B ESC (escape) 133 91 5B [
034 28 1C FS (file separator) 134 92 5C \ '\\'
035 29 1D GS (group separator) 135 93 5D ]
036 30 1E RS (record separator) 136 94 5E ^
037 31 1F US (unit separator) 137 95 5F _
040 32 20 SPACE 140 96 60 `
041 33 21 ! 141 97 61 a
042 34 22 " 142 98 62 b
043 35 23 # 143 99 63 c
044 36 24 $ 144 100 64 d
045 37 25 % 145 101 65 e
046 38 26 & 146 102 66 f
047 39 27 ' 147 103 67 g
050 40 28 ( 150 104 68 h
051 41 29 ) 151 105 69 i
052 42 2A * 152 106 6A j
053 43 2B + 153 107 6B k
054 44 2C , 154 108 6C l
055 45 2D - 155 109 6D m
056 46 2E . 156 110 6E n
057 47 2F / 157 111 6F o
060 48 30 0 160 112 70 p
061 49 31 1 161 113 71 q
062 50 32 2 162 114 72 r
063 51 33 3 163 115 73 s
064 52 34 4 164 116 74 t
065 53 35 5 165 117 75 u
066 54 36 6 166 118 76 v
067 55 37 7 167 119 77 w
070 56 38 8 170 120 78 x
071 57 39 9 171 121 79 y
072 58 3A : 172 122 7A z
073 59 3B ; 173 123 7B {
074 60 3C < 174 124 7C |
075 61 3D = 175 125 7D }
076 62 3E > 176 126 7E ~
077 63 3F ? 177 127 7F DEL
Dê uma olhada neste site commandlinefu.com .
Você também pode dar uma olhada nestes quatro artigos de Peteris Krumins em seu blog
Execute o último comando como root:
Sudo !!
Não tenho certeza se isso conta como um "truque", mas as pessoas parecem desconhecer as teclas de atalho padrão da linha de leitura. De uso particular em conchas:
- Ctrl+U - Cortar a linha atual
- Ctrl+Y - Cole uma linha cortada com Ctrl+U
- Ctrl+L - Limpe a tela e redesenhe a linha atual
- Ctrl+G - Obtenha uma nova linha e abandone a atual
CTRL+R no BASH para pesquisar/ativar comandos executados anteriormente (o conteúdo de ~/.bash_history).
Isso geralmente é extremamente útil. A execução desse alias servirá o PWD por HTTP (indexado) na porta 8000:
alias webserver="python -m SimpleHTTPServer"
E como eu corro make o tempo todo, digito e digito rápido demais, esses aliases são provavelmente os mais usados (sério):
alias maek=make
alias mkae=make
alias meak=make
alias amka=make
alias akme=make
E provavelmente o meu pedaço de BASH usado com mais frequência é um script simples que chamo de upload. Eu o uso para misturar qualquer tipo de conteúdo ao meu Linode e ele copia o URL HTTP resultante para a minha área de transferência (clique no meio). Muito útil para colar coisas para pessoas no IRC:
scp -r $* [email protected]$Host:public_html && {
URL="http://$Host/~$user/$(basename $1)"
echo "$URL"
xselection -replace PRIMARY "$URL"
}
Apenas um par. Posso postar muito mais tarde, preciso voltar ao trabalho!
diff a saída de dois comandos sem criar um arquivo temporário manualmente (bash):
diff <(ls dir1) <(ls dir2)
Bastante básico, mas as pessoas parecem não saber, retorna ao diretório anterior:
cd -
A expansão de chaves é um mecanismo pelo qual cadeias arbitrárias podem ser geradas.
Permite substituir linhas tediosas como:
mv loong/and/complex/file/name loong/and/complex/file/name.bacukup
com uma instância mais curta
mv loong/and/complex/file/name{,backup}
alguns outros usos
# to display the diff between /etc/rc.conf and /etc/rc.conf.pacsave
diff /etc/rc.conf{,.pacsave}
# to list files in both /usr/share and /usr/local/share
ls /usr/{,local}/share
Expansão aritmética :
A expansão aritmética permite a avaliação de uma expressão aritmética e a substituição do resultado. O formato para expansão aritmética é:
$((expression))A expressão é tratada como se estivesse entre aspas duplas, mas as aspas duplas entre parênteses não são tratadas especialmente. Todos os tokens na expressão passam por expansão de parâmetro, expansão de cadeia, substituição de comando e remoção de cotação. Expansões aritméticas podem ser aninhadas.
$ a=1
$ b=2
$ echo $(( a+(b*2) ))
5
Isso geralmente está no meu script de inicialização (.bashrc, .profile, qualquer que seja)
shopt Deus, verifique os comentários:
shopt -s cdspell # try to correct typos in path
shopt -s dotglob # include dotfiles in path expansion
shopt -s hostcomplete # try to autocomplete hostnames
Um alias que salva as teclas digitadas: mkdir e cd nele:
mkcd () { mkdir -p "[email protected]" && cd "[email protected]"; }
E por último mas não menos importante, eu desisti de memorizar a sintaxe do tar, então:
extract () {
if [ -f $1 ] ; then
case $1 in
*.tar.bz2) tar xjf $1 ;;
*.tar.gz) tar xzf $1 ;;
*.bz2) bunzip2 $1 ;;
*.rar) rar x $1 ;;
*.gz) gunzip $1 ;;
*.tar) tar xf $1 ;;
*.tbz2) tar xjf $1 ;;
*.tgz) tar xzf $1 ;;
*.Zip) unzip $1 ;;
*.Z) uncompress $1 ;;
*) echo "'$1' cannot be extracted via extract()" ;;
esac
else
echo "'$1' is not a valid file"
fi
}
Duas funções do bash que me salvam muitos pressionamentos de tecla.
Faça automaticamente um ls após cada CD com êxito:
function cd {
builtin cd "[email protected]" && ls
}
Suba n níveis:
# Usage .. [n]
function .. (){
local arg=${1:-1};
local dir=""
while [ $arg -gt 0 ]; do
dir="../$dir"
arg=$(($arg - 1));
done
cd $dir #>&/dev/null
}
Como geralmente estou na metade da linha de comando antes de querer pesquisar (CTRL-R no bash), tenho o seguinte no meu .bashrc
bind '"\e[A"':history-search-backward
bind '"\e[B"':history-search-forward
Isso significa que, se eu digitar cd, pressione as teclas para cima e para baixo, posso ver todas as opções para as quais tenho o cd. Basicamente, eu uso isso para dirs frequentemente usados. Como "cd w" e acabo passando por todos os espaços de trabalho que uso bastante.
Uma coisa que me poupa muito tempo são os comandos pushd/popd. Esses caras permitem criar uma pilha de diretórios e reduzir muito a digitação:
/foobar/ > pushd /src/whatever/foo/test
/foobar/src/whatever/foo/test > make run
/foobar/src/whatever/foo/test > popd
/foobar/ > make
O screencomando . Basicamente, salva sua sessão de linha de comando para quando você voltar. É uma espécie de gerenciador de terminal, como um gerenciador de janelas. Dessa forma, em uma única sessão de terminal, você pode ter vários terminais virtuais em funcionamento. É muito legal.
Se alguém usar screen, esta função Shell (coloque-a em .bashrc) é extremamente útil:
function scr {
if screen -ls | grep -q Main; then
# reattach to Main:
screen -xr Main
else
# name session "Main":
screen -S Main
fi
}
ao digitar scr, ele verificará se a sua sessão principal existe e será anexada a ela. Caso contrário, ele será criado.
Se você precisar editar uma linha de comando particularmente longa no bash
^X^E (Ctrl-X Ctrl-E)
irá abri-lo no editor ($ EDITOR).
No zsh, você pode obter o mesmo comportamento adicionando isso ao .zshrc:
autoload edit-command-line
zle -N edit-command-line
bindkey '^X^e' edit-command-line
Se você é um datilógrafo rápido, estes são úteis:
alias grpe='grep --color=tty'
alias gpre='grep --color=tty'
alias rgep='grep --color=tty'
alias gerp='grep --color=tty'
Essa macro ajuda a calcular os totais de uma coluna de saída: tamanhos de arquivo, bytes, pacotes, tudo o que você precisa fazer é especificar a coluna que você deseja adicionar:
total ()
{
if [ x$1 = x ]; then set `echo 1`; fi
awk "{total += \$$1} END {print total}"
}
Você o usa assim, por exemplo, sem argumentos, adiciona o total da primeira coluna:
du | total
Se você fornecer o argumento, ele somará a coluna, por exemplo, o número total de bytes usados por todos os arquivos C # em/tmp:
ls -l /tmp/*cs | total 5
Às vezes, seu console fica bagunçado porque você visualizou acidentalmente um arquivo binário (cat/bin/ls, por exemplo). É possível restaurar o terminal com esta função Shell:
restaura ()
{
Perl -e 'print "\e)B";'
}
Gosto do meu sl para usar caracteres para distinguir a classe de arquivos e também para ocultar os arquivos de backup gerados pelo meu editor (os arquivos de backup terminam com o caractere ~):
alias ls='ls -FB'
alias s='Sudo'
alias r='rake' # i'm a Ruby developer
alias ..='cd ..' # although with autocd feature for zsh this comes packed.
Um dos meus favoritos quando eu esqueço s:
$ s !! # last command with super user priviledges
Se um comando receber entrada stdin, você poderá ler a entrada de um arquivo com <filename. Isso pode aparecer em qualquer lugar do comando, portanto, essas linhas são equivalentes:
cat filename
cat <filename
<filename cat
Isso é particularmente útil para grep, pois permite colocar a expressão no final da linha, para que você possa modificar rapidamente um comando grep pressionando Up, sem precisar rolar para a esquerda para passar o nome do arquivo:
<filename grep 'expression'
Você pode usar CDPATH para configurar o diretório equivalente a PATH; se você tentar cd foo e não há foo no diretório atual, o Shell verificará cada um dos diretórios em CDPATH procurando por foo neles e alternará para o primeiro encontra:
export CDPATH="/usr"
cd bin # switches to 'bin' if there is one in the current directory, or /usr/bin otherwise
vi `which scriptname`
Pois quando você não sabe onde algo vive, e também não se importa.
O e comercial. Ele coloca seu comando em segundo plano, para que você possa continuar digitando.
$> Sudo updatedb &
Trabalhando junto e depois de um tempo, você vê:
[1] 17403
E seu processo está concluído! Ótimo para coisas em que você não precisa esperar que elas terminem.
Conclusão da guia. Quão ruim seria ruim se você tivesse que digitar todos os caracteres de todos os caminhos?
Eu tenho isso no meu .bashrc
#shortcut for CTRL+C and CTRL+V
alias c-c='xclip -sel clip'
alias c-v='xclip -o -sel clip'
function find-all() {
python -c "import re
import sys
for i in re.findall('$1', sys.stdin.read()):
if type(i) == type(''):
print i
else:
print i[0]"
}
E quando tenho o código-fonte html na área de transferência e quero encontrar todos os links que uso
c-v | find-all 'href="([^"]*)"' | c-c
E eu tenho todos os URLs na área de transferência
Eu também tenho essa função
function lsq(){
ls -lh [email protected] | tr -s ' ' | cut -d' ' -f5,8
}
qual tamanho de exibição (legível por humanos) e nome do arquivo.
alias temp='cat /proc/acpi/thermal_zone/THRM/temperature'
este apelido é para mostrar temerature
function separate() {
python -c "import sys,re; print '$1'.join(re.split('\s*', sys.stdin.read().strip()))";
}
com esta função eu posso calcular produto ou soma de argumentos.
alias sum='separate + | bc'
alias product='separate * | bc'
function split-join() {
python -c "import sys,re; print '$2'.join(re.split('$1', sys.stdin.read().strip()))";
}
Esta é uma função útil que divide a entrada padrão separada por regex e depois junta o resultado.
function factorial() {
seq -s* $1 | bc
}
função fatorial
function wiki() { Dig +short txt $1.wp.dg.cx; }
Esta função exibe texto wiki sobre DNS
Eu também tenho três funções de cores
function blue() {
echo -e "\x1b[34m\x1b[1m"[email protected]"\x1b[0m";
}
function green() {
echo -e "\x1b[32m\x1b[1m"[email protected]"\x1b[0m";
}
function red() {
echo -e "\x1b[31m\x1b[1m"[email protected]"\x1b[0m";
}
function md5check() {
test `md5sum $2 | cut -d' ' -f1` = "$1" && green [OK] || red [FAIL]
}
Esta função valida o hash do arquivo md5.
isso mostrará uma mensagem de erro para um determinado código
function strerror() { python -c "import os; print os.strerror($1)"; }
Você pode imprimir todas as mensagens com
alias all-errors='for i in `seq 131`; do echo -n "$i: "; strerror $i; done'
Umount último dispositivo montado:
mount /media/whatever
...
u!mo
!mo expande para o último comando iniciado com mo (pelo menos no bash). Às vezes alguém faz mv no meio, então u!m não funcionará com tanta frequência.
Outro truque útil do ZSH:
Trate a saída de um comando como um arquivo:
emacs =(hg cat -r 100 somefile)
Isso abre uma versão antiga de um arquivo rastreado pelo Mercurial no emacs para visualização com destaque em sintaxe. Sem isso, eu teria que mexer com hg revert, hg archive, ou envie explicitamente hg cat gera um arquivo temporário.
Obviamente, isso funciona com qualquer programa que abra arquivos e com qualquer programa que imprima na saída padrão.
Um recurso específico do ZSH são aliases de sufixo, configurados fornecendo alias o -s sinalizador:
alias -s ext=program
Se uma determinada extensão tiver um alias de sufixo, você poderá executar um arquivo com essa extensão diretamente, e o ZSH iniciará o programa especificado e passará o nome do arquivo como argumento. Portanto, se o alias acima estiver em vigor, essas linhas serão equivalentes:
/path/to/foo.ext
program /path/to/foo.ext
Um dos meus recursos favoritos de todos os tempos do ZSH é chamado de diretório. Você pode exportar uma variável com um nome determinado, com um valor que aponte para um determinado caminho:
export foo=/usr/bin
Agora você pode usar ~foo em um comando para se referir a /usr/bin:
cd ~foo
~foo/ls
cat ~foo/filename
O comando do-nothing
:como emwhile :; do :; doneExpanda a cinta em combinação com os loops for:
for c in {1..3}; do :; done!operadores e operadores de curto-circuito||e&&[ -d /tmp/dir ] || mkdir /tmp/dir if ! ping 34.41.34.1; then :; fiusando subcascas em vez de pop/Push (é útil em scripts)
~$ ( cd /tmp; echo $PWD ) /tmp ~$o tipo de o que é comando
type~$ type type type is a Shell builtin ~$ type ls ls is aliased to `ls --color=auto' ~$ f(){ :; } ~$ type f f is a function f () { : }também muito bom: aqui-cordas
~$ cat <<<"here $PWD" here /home/yourname ~$e meu favorito: redirecionamento em uma lista de comandos
{ w; ps; ls /tmp; } 2>/dev/null |less
Veja isto pergunta.
Quando você executa ps ax | grep string:
[[email protected] ~]$ ps ax | grep 'openbox'
3363 ? Ss 0:00 /usr/bin/openbox
3382 ? Ss 0:00 /usr/bin/ssh-agent -- /usr/bin/openbox-session
3386 ? S 0:00 /bin/sh /usr/bin/openbox-session
3388 ? S 0:00 /bin/sh /usr/bin/openbox-session
3389 ? S 0:00 /bin/sh /usr/bin/openbox-session
3390 ? S 0:00 /bin/sh /usr/bin/openbox-session
5100 pts/0 S+ 0:00 grep openbox
a última linha que contém grep é algo um pouco irritante
Você pode se livrar disso executando ps ax | grep '[s]tring':
[[email protected] ~]$ ps ax | grep '[o]penbox'
3363 ? Ss 0:00 /usr/bin/openbox
3382 ? Ss 0:00 /usr/bin/ssh-agent -- /usr/bin/openbox-session
3386 ? S 0:00 /bin/sh /usr/bin/openbox-session
3388 ? S 0:00 /bin/sh /usr/bin/openbox-session
3389 ? S 0:00 /bin/sh /usr/bin/openbox-session
3390 ? S 0:00 /bin/sh /usr/bin/openbox-session
atualização : ou apenas execute pgrep string
Às vezes, as configurações do bash são tais que rm são alias para rm -i e, portanto, requer confirmação para cada arquivo que está sendo excluído. Quando trabalho ocasionalmente nessa conta, uso \rm para recuperar o comportamento original de rm sem alterar a configuração do usuário.
Adoro jogar o máximo de coisas possível no meu PS1. Algumas coisas úteis para lembrar:
\e[s e \e[u salve e salve a posição do cursor, respectivamente. Eu uso isso para criar uma 'barra de informações' na parte superior da tela, com algumas linhas, que pode caber em mais coisas. Exemplo:
PS1='\[\e[s\e[7m\e[1;1H\]\w\n\t \j / \! / \#\[\e[u\e[0m\e[33;1m\][\[email protected]\h \[\e[34m\]\W]\[\e[0m\]\$ '
Combina com alias clear='echo -e "\e[2J\n"'. Experimente!
Também o Prompt_COMMAND variável define um comando para executar sempre antes do PS1.
Outro é o comando bg. Se você esquecer de colocar & no final de um comando, basta pressionar ^Z e digite bg e é executado em segundo plano.
Exibir ramo e status do Git no prompt
exportar GIT_PS1_SHOWDIRTYSTATE = true
se ["$ color_Prompt" = yes]; então
PS1 = '$ {debian_chroot: + ($ debian_chroot)}\[\ 033 [01; 32m \]\u @\h\[\ 033 [00m \]:\[\ 033 [01; 34m \]\w\[\ 033 [00m \] $ (__ git_ps1 "#% s")\$ '
Else
PS1 =' $ {debian_chroot: + ($ debian_chroot)}\u @\h:\w $ (__ git_ps1 "#% s")\$ '
fi
Meu comando favorito é 'find', eu o uso em qualquer lugar ... exemplos:
find . -name "*.log" -exec ls -l {} \; | grep "$(find . -name "*.log" -exec ls -l {} \;| nawk '{print $5}' | sort -n | tail )"
Apenas exiba os arquivos mais pesados no formato ls -l (long).
Então, se você precisar do seu código com permissões 0640, basta procurar:
find . \( \( ! -perm 0640 \) -a \( -name "*.cpp" -o -name "*.h" \) \) -ls | nawk '{print $3"\t"$11}'
ou substitua:
find . \( -name "*.cpp" -o -name "*.h" \) | xargs chmod 640
Então, você precisa de um símbolo e não sabe onde está?
(
for myObj in $(find . -name "*.o"); do
gotSym=$(dump -Xany -t $myObj | grep .MY_SYMBOL)
if ! test "x$gotSym" = "x"
then
echo "OBJECT [$myObj] ========================"
echo "$gotSym"
echo "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"^
fi
done
)
Arquivos mais recentes que o XFILE ??
find . -newer XFILE -type f
Sim, "encontre" rulez!
Muitas vezes, quando você digita um comando longo e antes de finalizá-lo, percebe que ele não funcionará imediatamente, porque você precisa executar outra coisa antes (por exemplo, inseriu git commit -m "long commit message here"), você pode pressionar ^A^K para ir para o início da linha e matá-lo (salvando em um buffer), execute um comando para corrigir as coisas e, finalmente, ^Y para colar o comando morto e continue. Economiza muita re-digitação. Tudo isso, é claro, é quando readline está no modo Emacs.
Outra economia de tempo: mkdir -p some/nested/dirs/to/be/created cria todos os diretórios em um caminho, se estiverem ausentes.
Exibe uma bela arte ascii da árvore de processos atual, com o processo mais intensivo da CPU destacado.
while true; do
clear;
pstree $( ps -eo pid --sort %cpu | tail -n 1 );
sleep 1;
done
Mate-o com Ctrl + C
Veja a saída do comando atualizada a cada n segundos
watch -n 60 df -h (displays df -h every 60 seconds)
Mostrar estatísticas sobre o dispositivo de rede wlan0
ip -s link ls wlan0
Mostrar tabela de roteamento para o dispositivo eth1
ip route ls dev eth1
Exibir estatísticas para todos os pacotes de roteadores percorridos até alcançar o Host
mtr --interval 5 HOSTNAME
Consulte registros DNS reversos para obter nomes de host na NETWORK
nmap -sL NETWORK
Avaliar um site
ab
Obter todos os links de uma página da web
lynx -dump http://www.yahoo.com | awk '/http/{print $2}'
Mostrar gateway padrão
netstat -rn | awk '/UG/{print $2}'
Gravar erro padrão em um arquivo
foo 2> errors.txt
Redirecionar stderr para stdout
foo 2>&1
Redirecione stderr e stdout para o mesmo arquivo.
foo > file.txt 2>&1
# change chmod to file dowloaded --> $_
wget -c http://link/to/file -O /path/to/save/namefile && chmod 0755 $_
# extract tar.bz2 or tar.gz whit less work
# this avoids having to unpack and then move the files to another location, in this case have # already extracted in the desired location
tar jxvf file.tar.bz2 -C /pat/to/extract
# calculator with bc - in bashrc
calc(){ echo "scale=2;[email protected]" | bc;}
# set magic-space in bashrc
bind Space:magic-space # !pin<space> expand last cmd pin...
# alias to open last edited file in vim
alias lvim="vim -c \"normal '0\""
# alias to show your path set
alias path='echo -e ${PATH//:/\\n}'
Substitua partes do comando anterior:
^procurar^substituir
$ echo a b c d
a b c d
$ ^b c^X
echo a X d
a X d
Ótimo para erros de digitação:
$ mkae
-bash: mkae: command not found
$ ^ka^ak
make
[...]
Resuma o tamanho do diretório, com o tamanho humano decrescente
du -hs */ | sort -hr
por exemplo.
10.2G foo/
4M bar/
expansão em estrela dupla com zsh (que desce recursivamente a árvore de diretórios, não apenas um nível, algo semelhante a $(find ! -type d):
grep string **/*.cc
meu recurso favorito é SEM CORES! =)
TERM = xterm-mono ou TERM = linux-m depende do sistema operacional ...
Eu realmente gosto de IRSSI, mc em preto e branco e qualquer outra ferramenta "Interface de usuário de texto"
O ZSH possui aliases globais. Ele expande o alias em qualquer lugar na linha de comando. Eu achei isso útil para nomes de host:
Por exemplo.:
alias -g sub='sub.domain.tld'
Então, eu posso fazer, por exemplo:
sftp sub
ssh sub
etc.
Não é realmente uma linha, mas acho que é útil. Converta muitos arquivos em maiúsculas, por exemplo file_to_upper *php *c. Existem muitos casos semelhantes, como converter para inferior, renomear todos os arquivos por sufixo/prefixo, etc.
file_to_upper ()
{
for file in "[email protected]"
do
if [ ! -f "$file" ]; then
echo "File $file does not exist";
else
mv -f "$file" "`echo "$file" | tr '[a-z]' '[A-Z]'`"
fi
done
return 0
}
obtenha o nome do arquivo com o registro de data e hora mais recente no diretório atual:
latest () { ls -lrt | tail -1 | awk '{print $NF}' }
function calc() { echo $* p | dc }
dc é uma calculadora RPN; Essa função permite que eu digite a expressão como os argumentos do comando:
$ calc 5 3 +
8
Exiba um prompt em que o nome do host é negrito. Tentei as instruções de cores por um tempo, mas às vezes a cor fica ruim dependendo do plano de fundo. O negrito funciona para mim para fundo claro, fundo escuro, fundo azul, etc.
Isto está no meu .bashrc:
bold=$(tput bold)
reset=$(tput sgr0)
export PS1="\[email protected]\[$bold\]\h\[$reset\]:\w \$ "
Eu achei o seguinte útil ao alternar constantemente entre Windows e Unix/Linux:
alias dir="ls -l"
alias copy="cp"
alias del="rm"
Isto é para zsh, não bash, fyi (se você não o usou, não se arrependerá de experimentá-lo). Isso é realmente útil para digitar rapidamente caminhos longos para transferências de scp. Funciona como se estivesse usando para completar ou listar nomes de arquivos/diretórios disponíveis.
Exemplo
scp [email protected]:/home/webdev/domains/example.com/http.public/long<tab>
completará o caminho para /home/webdev/domains/example.com/http.public/longdirname.
Sou péssimo em exemplos, mas isso deve lhe dar uma idéia. Experimente, ele pode realmente poupar os dedos da digitação.
# SSH Completion
zstyle ':completion:*:scp:*' tag-order \
files users 'hosts:-Host hosts:-domain:domain hosts:-ipaddr"IP\ Address *'
zstyle ':completion:*:scp:*' group-order \
files all-files users hosts-domain hosts-Host hosts-ipaddr
zstyle ':completion:*:ssh:*' tag-order \
users 'hosts:-Host hosts:-domain:domain hosts:-ipaddr"IP\ Address *'
zstyle ':completion:*:ssh:*' group-order \
hosts-domain hosts-Host users hosts-ipaddr
zstyle '*' single-ignored show
ReTTY , que permite mover um programa em execução de um terminal para outro. Dessa forma, se você tiver um programa ncurses em execução fora da tela, tmux ou ssh, poderá anexá-lo a uma sessão ssh ou a uma tela em rede ou sessão do tmux executando o ReTTY no terminal em que deseja usar o programa em questão. Em outras palavras, é semelhante ao screen e tmux, mas com as exceções de que (a) ele pode executar apenas um programa por vez e (b) pode ser executado após você inicia o processo filho.
O meu favorito é usar o comando python para criar o servidor http temporário:
python -m SimpleHTTPServer
e acessar arquivos desta máquina pela LAN como:
Outra é baixar o arquivo tar na forma extraída como:
wget -qO - http://192.168.1.70:8000/test.bz2 | tar xjvf -
Aqui, o link pode estar no www e o bz2 pode ser o próprio gz, tgz ou bz2.
Faça backup de seus arquivos de ponto sofisticados automaticamente
Modular .bashrc -> .bashrc.d
mkdir -p ~/.bashrc.d
cat<<'EOF' >> ~/.bashrc
echo ""
echo -n ".bashrc.d warming up: "
for script in ~/.bashrc.d/* ; do
if [ -x "$script" ] ; then
echo -n "${script##*/} "
. "$script"
fi
done
echo ""
echo ""
echo " All systems are go."
echo ""
EOF
Rm mais seguro, compatível com Linux e Mac OS X
rm() {
local src
local final_status=0
for src in "[email protected]"; do
# Process only non command-line arguments.
if [[ "$src" != -* ]]; then
local trash="$HOME/.Trash"
if [ ! -e "$src" ]; then
echo "Safer rm: $src: No such file or directory."
final_status=1
fi
# Create the trash directory if needed.
if [ ! -d "$trash" ]; then
# Assume Mac trash, but it'll work on *nix too.
mkdir -p "$trash"
if [ ! -d "$trash" ]; then
echo "Safer rm: Unable to create trash directory $trash"
echo ""
echo " Nothing moved or deleted. Consider carefully:"
echo ""
echo " /bin/rm -rf $src"
return 1
fi
fi
local dest="$trash/${src##*/}"
# Find a filename combination which does not already exist.
if [ -e "$dest" ]; then
# Try appending ISO datetime.
dest="$dest.$(date +%Y-%m-%dT%H-%M-%S)"
if [ -e "$dest" ]; then
local n=1
# Try increasing monotony.
while [ -e "$dest.$n" ]; do
n = $[n + 1]
done
dest="$dest.$n"
fi
fi
echo -n "Safer rm: Trashing $src to $dest ..."
/bin/mv "$src" "$dest"
echo " done."
echo ""
echo " To restore: /bin/mv '$dest' '$src'"
echo ""
echo " To purge: /bin/rm -rf '$dest'"
echo ""
echo ""
fi
done
return $final_status
}
Ação super quente 'cd' up
# Don't ask why I need 15 levels of cd ..
alias ..='cd ..'
alias .2='cd ../..'
alias ...='.2'
alias .3='cd ../../..'
alias .4='cd ../../../..'
alias .5='cd ../../../../..'
alias .6='cd ../../../../../..'
alias .7='cd ../../../../../../..'
alias .8='cd ../../../../../../../..'
alias .9='cd ../../../../../../../../..'
alias .10='cd ../../../../../../../../../..'
alias .11='cd ../../../../../../../../../../..'
alias .12='cd ../../../../../../../../../../../..'
alias .13='cd ../../../../../../../../../../../../..'
alias .14='cd ../../../../../../../../../../../../../..'
alias .15='cd ../../../../../../../../../../../../../../..'
Readline é o seu único deus verdadeiro.
bind -p | egrep -v '(not|self)' # No existential jokes included.
Fontes de terminal
Depois de observar bilhões de fontes, eu uso 14 pt Monaco, Anti-aliased com iTerm2.
No Mac (aplicativos): tente este aplicativo que fornece combinações de teclas.
KeyCue (tm) (r) (c) ($) fornece o contexto de quase QUALQUER aplicativo em execução, simplesmente mantendo command.
o recurso pushd automático do zsh:
setopt autopushd
e junto com isso:
alias dirs='dirs -v'
Para que, a qualquer momento, eu possa digitar dirs e obtenha o histórico de onde estive:
0 /var/log
1 /tmp
2 /usr/local/bin
3 ~
e então posso cd voltar para, por exemplo /usr/local/bin digitando:
cd ~2
Nenhum dos seguintes 'truques' é tecnicamente desafiador ou impressionante, mas eles têm algum impacto sobre a outra pessoa. Se não podemos usar nossos empregos para tornar nossa vida mais feliz, devemos pensar novamente em algumas coisas.
Eu gosto de alias. Meu truque favorito é editar as ~/.bash_aliases no computador do meu gf, pois ela está ausente e adicionar uma linha como:
alias gfname='echo Myname is thinking of you'
ou outra citação romântica.
Outro "truque" de que gosto especialmente é:
#!/bin/bash
xaa=123`
for ((a=1; a <= xaa; a++))
do
#sleep 1;
mail -s "Happy Birthday $a" [email protected] < mails.txt
done
exit 0`
onde 123 é a pessoa para quem eu gostaria de parabéns e mails.txt contém a mensagem que eu gostaria de escrever como o corpo do email. Dormir 1; às vezes é necessário, pois há um limite no fork (). Você também pode usar argumentos de linha de comando $1 etc ...
Tenho pastas nomeadas na minha pasta pessoal como Documento, Downloads, Temp, etc., com a primeira letra em maiúscula. Quando eu trabalho no terminal, é irritante mudar de tecla e pressionar a primeira tecla quando você estiver entrando em um diretório. Basta digitar o seguinte no seu terminal e o bash corrige automaticamente o caso para você.
shopt -s nocaseglob
Usar pgrep foo ao invés de ps aux | grep foo se você quiser descobrir quantas instâncias de foo estão em execução e seus pids:
por exemplo. ao invés de ps aux | grep firefox, usar pgrep firefox
Não posso viver sem
set editing-mode vi
set blink-matching-paren on
no meu ~/.inputrc.
Ativa-os em todos os aplicativos ativados para leitura de linha. A ativação da edição da linha de comando vi no Shell funciona apenas através de:
set -o vi
Assim, pressionar ESC ou CTRL + [fornece o conhecido modo de comando vi. E você pode usar comandos vi poderosos em qualquer lugar!
Existe um ótimo site para isso em: http://www.commandlinefu.com/commands/browse
Meu favorito pessoal é
find . -name <i>filename</i> | xargs grep -in '<i>pattern to search for</i>'
O que o comando acima faz é encontrar um arquivo com o nome x e, em seguida, procura no arquivo por qualquer padrão que você esteja procurando. Incrivelmente útil se você estiver procurando por um pedaço específico de código em um arquivo que esteja em algum lugar nos seus subdiretórios.
find path expr -exec ls -ld {} \;
Uma maneira fácil e agradável de ver propriedade, permissões, tamanhos (se arquivos) e outras características de qualquer que seja a expressão 'localizar' retornada.
Costumo notar, logo após iniciar um comando de 15 minutos, que gostaria de adicionar outras coisas à linha de comando usando &&. Em vez de interromper o trabalho já em execução, costumo usar at para enfileirar o segundo, dando a mim mesmo um tempo maior que não preciso assistir ao terminal.
Geralmente, at enfileira tarefas para execução em um determinado momento:
$ at 14:30
> myscript
> anotherscript
> <CTRL-D>
As entradas da fila podem ser visualizadas com atq e removidas com atrm.
Outra adição às dicas de personalização do prompt do bash: eu gosto de inverter o prompt, pois isso fornece boas dicas visuais onde a saída do comando começa e termina em longas listagens de terminais. Isso funciona bem para fundos claros e escuros.
export PS1="\[\e[7m\][\[email protected]\h \w]\[\e[0m\]$ "
sincronização; sincronização; sincronização; reinicialização
às vezes pode ser realmente útil. Seja cuidadoso !
Acho que entender que os pressionamentos de teclas do bash levam a um bombardeio mais eficiente e que muitos deles são diretos do emacs esclarece seu uso (ou seja, que meta-XXX é a versão big brother de ctrl-XXX comando normalmente).
A tecla "meta" geralmente é a tecla "alt", mas também pode ser a tecla "esc". por exemplo. meta-f pode ser obtido com alt-f ou esc f.
Para que os mapeamentos das teclas alt funcionem, talvez seja necessário desmarcar "teclas de acesso ao menu" ou seu equivalente nas opções do console. Basicamente, se você pressionar alt-f e acessar o menu Arquivo Prompt, desative os menus de acesso com a tecla alt.
ctrl-a / ctrl-e : move to start / end of line básico que você não pode prescindir
ctrl-f, meta-f : forward char/Word pressionando alt-f, você avança "1 Word", que na linha de comando é praticamente um comando ou argumento
ctrl-b, meta-b : backwards char/Word o mesmo que alt-f, mas para trás, para pular para trás na linha de comando
ctrl-d, meta-d : delete char/Word pressionando alt-d excluirá (até o final) o Word atual sob o cursor. muito mais rápido do que pressionar Delete por 30 segundos. Útil quando você conclui a guia no meio de algo e deseja encaminhar a exclusão para o final do Word.
ctrl-k : kill line exclui no final da linha
ctrl-u : undo por exemplo. digitando uma senha e você sabe que está errado em algum lugar, em vez de voltar 20 vezes ao backspace, basta pressionar Ctrl-u. também limpa a linha de comando atual.
meta-# : insert comment isso é ótimo para manter sua linha de comando que você está construindo como um comentário antes de executá-lo, se precisar fazer outra coisa primeiro. ele entrará no seu histórico de comandos, mas não será executado.
ctrl-r : reverse search pesquisando para trás no histórico do Shell (ctrl-r repetido para a próxima partida)
ctrl-g : abort se você estiver no meio de ctrl-r e deseja voltar ao local em que estava digitando, aborte sua pesquisa com ctrl-g
meta-space / ctrl-x ctrl-x : set mark and jump to mark se você precisar pular rapidamente para uma posição na sua linha de comando, primeiro defina a marca e depois volte para ela com ctrl-x ctrl-x. Observe que você pode precisar usar esc-space para obter a marca definida como alt-space muitas vezes é obrigado a abrir o menu do console.
ctrl-] <char> : quick jump to <char> salta para o caractere digitado após o ctrl-] na linha de comando. O irmão mais velho Meta-ctrl-] <char> pula para trás.
Meus favoritos estão abaixo. Eu uso a maioria deles regularmente
df -k (verifique os sistemas de arquivos) kill ou kill -9 (execute um processo) set -o vi (defina sua linha de comando para vi) topas (ferramenta de desempenho) mount/desmonte
ah sim e como eu poderia esquecer o> (para redirecionar a saída para um arquivo) ls> /tmp/tmp.txt
Muitos mais, mas alguns em cima da minha cabeça.