Qual é o seu truque de linha de comando mais favorito usando o Bash? [fechadas]

Todos sabemos como usar <ctrl>-R para reverter a pesquisa no histórico, mas você sabia que pode usar <ctrl>-Spara encaminhar a pesquisa, se você definir stty stop ""? Além disso, você já tentou executar o bind -p para ver todos os atalhos de teclado listados? Existem mais de 455 no Mac OS X por padrão.

Qual é o seu truque obscuro mais favorito, atalho de teclado ou configuração do shopt usando bash?

Renomeando / movendo arquivos com sufixos rapidamente:
cp /home/foo/realllylongname.cpp{,-old}

Isso se expande para:
cp /home/foo/realllylongname.cpp /home/foo/realllylongname.cpp-old

cd -

É o equivalente na linha de comando do botão Voltar (leva você ao diretório anterior em que você estava).

Outro favorito:

!!

Repete o seu último comando. Mais útil no formato:

sudo !!

Meu favorito é '^ string ^ string2', que pega o último comando, substitui a string pela string2 e a executa

$ ehco foo bar baz
bash: ehco: command not found
$ ^ehco^echo
foo bar baz

Guia de histórico da linha de comando do Bash

renomear

Exemplo:

$ ls
this_has_text_to_find_1.txt
this_has_text_to_find_2.txt
this_has_text_to_find_3.txt
this_has_text_to_find_4.txt

$ rename 's/text_to_find/been_renamed/' *.txt
$ ls
this_has_been_renamed_1.txt
this_has_been_renamed_2.txt
this_has_been_renamed_3.txt
this_has_been_renamed_4.txt

Tão útil

Eu sou um fã dos !$, !^e !*expandos, retornando, a partir da linha mais recente de comando apresentados: o último item, o item primeiro não-comando, e todos os itens não-comando. A saber (observe que o shell imprime o comando primeiro):

$ echo foo bar baz
foo bar baz
$ echo bang-dollar: !$ bang-hat: !^ bang-star: !*
echo bang-dollar: baz bang-hat: foo bang-star: foo bar baz
bang-dollar: baz bang-hat: foo bang-star: foo bar baz

Isto vem a calhar quando você, por exemplo ls filea fileb, e quer editar um deles: vi !$ou ambos: vimdiff !*. Também pode ser generalizado para o " nargumento th", assim:

$ echo foo bar baz
$ echo !:2
echo bar
bar

Por fim, com nomes de caminho, você pode acessar partes do caminho anexando :he :ta qualquer uma das expansões acima:

$ ls /usr/bin/id
/usr/bin/id
$ echo Head: !$:h  Tail: !$:t
echo Head: /usr/bin Tail: id
Head: /usr/bin Tail: id

Ao executar comandos, às vezes vou querer executar um comando com os argumentos anteriores. Para fazer isso, você pode usar este atalho:

$ mkdir /tmp/new
$ cd !!:*

Ocasionalmente, em vez de usar o find, separarei um loop de uma linha se precisar executar vários comandos em uma lista de arquivos.

for file in *.wav; do lame "$file" "$(basename "$file" .wav).mp3" ; done;

Configurar as opções do histórico da linha de comando no meu .bash_login (ou .bashrc) é realmente útil. A seguir, é apresentado um quadro de configurações que eu uso no meu Macbook Pro.

Definir o seguinte faz com que o bash apague comandos duplicados no seu histórico:

export HISTCONTROL="erasedups:ignoreboth"

Também elevo o tamanho da minha história bem alto também. Por que não? Parece não retardar nada nos microprocessadores atuais.

export HISTFILESIZE=500000
export HISTSIZE=100000

Outra coisa que faço é ignorar alguns comandos da minha história. Não há necessidade de lembrar o comando exit.

export HISTIGNORE="&:[ ]*:exit"

Você definitivamente deseja definir o histappend. Caso contrário, o bash substituirá seu histórico quando você sair.

shopt -s histappend

Outra opção que eu uso é o cmdhist. Isso permite salvar comandos de várias linhas no histórico como um comando.

shopt -s cmdhist

Por fim, no Mac OS X (se você não estiver usando o modo vi), convém redefinir <CTRL> -S para parar a rolagem. Isso impede que o bash possa interpretá-lo como pesquisa direta.

stty stop ""

Como listar apenas subdiretórios no atual?

ls -d */

É um truque simples, mas você não saberia quanto tempo eu precisava para encontrar esse!

ESC.

Insere os últimos argumentos do seu último comando bash. É mais útil do que você pensa.

cp file /to/some/long/path

CD ESC.

Claro, você pode " diff file1.txt file2.txt", mas o Bash suporta a substituição de processos , o que permite diffa saída de comandos.

Por exemplo, digamos que eu queira ter certeza de que meu script me dê a saída que espero. Posso apenas envolver meu script em <() e alimentá-lo diffpara obter um teste de unidade rápido e sujo:

$ cat myscript.sh
#!/bin/sh
echo -e "one\nthree"
$
$ ./myscript.sh 
one
three
$
$ cat expected_output.txt
one
two
three
$
$ diff <(./myscript.sh) expected_output.txt
1a2
> two
$

Como outro exemplo, digamos que desejo verificar se dois servidores têm a mesma lista de RPMs instalados. Em vez de fazer o sshing para cada servidor, escrever cada lista de RPMs para separar arquivos e executar um diffdesses arquivos, eu posso fazer isso na diffminha estação de trabalho:

$ diff <(ssh server1 'rpm -qa | sort') <(ssh server2 'rpm -qa | sort')
241c240
< kernel-2.6.18-92.1.6.el5
---
> kernel-2.6.18-92.el5
317d315
< libsmi-0.4.5-2.el5
727,728d724
< wireshark-0.99.7-1.el5
< wireshark-gnome-0.99.7-1.el5
$

Há mais exemplos no Advanced Bash-Scripting Guide em http://tldp.org/LDP/abs/html/process-sub.html .

Meu comando favorito é "ls -thor"

Convoca o poder dos deuses para listar os arquivos modificados mais recentemente em um formato convenientemente legível.

Mais uma novidade, mas é inteligente ...

Os 10 principais comandos usados:

$ history | awk '{print $2}' | awk 'BEGIN {FS="|"}{print $1}' | sort | uniq -c | sort -nr | head

Saída de amostra:

 242 git
  83 rake
  43 cd
  33 ss
  24 ls
  15 rsg
  11 cap
  10 dig
   9 ping
   3 vi

^ R pesquisa inversa. Pressione ^ R, digite um fragmento do comando anterior que você deseja corresponder e pressione ^ R até encontrar o que deseja. Não preciso me lembrar de comandos usados ​​recentemente que ainda estão no meu histórico. Não exclusivamente bash, mas também: ^ E para final de linha, ^ A para início de linha, ^ U e ^ K para excluir antes e depois do cursor, respectivamente.

Muitas vezes tenho aliases para vi, ls, etc., mas às vezes você deseja escapar do alias. Basta adicionar uma barra invertida ao comando à frente:

Por exemplo:

$ alias vi=vim
$ # To escape the alias for vi:
$ \vi # This doesn't open VIM

Legal, não é?

Aqui estão alguns ajustes na configuração:

~/.inputrc:

"\C-[[A": history-search-backward
"\C-[[B": history-search-forward

Isso funciona da mesma maneira que ^Rcom as teclas de seta. Isso significa que eu posso digitar (por exemplo) cd /media/e pressionar a seta para cima para ir para a última coisa que eu cdfaria dentro do/media/ pasta.

(Eu uso o Gnome Terminal, pode ser necessário alterar os códigos de escape para outros emuladores de terminal.)

A conclusão do Bash também é incrivelmente útil, mas é uma adição muito mais sutil. Em ~/.bashrc:

if [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
fi

Isso permitirá o preenchimento de tabulação por programa (por exemplo, tentar concluir a tabulação quando a linha de comando iniciar com evince mostrará apenas arquivos que podem ser abertos, e também opções de linha de comando completas).

Funciona bem com isso também em ~/.inputrc:

set completion-ignore-case on
set show-all-if-ambiguous on
set show-all-if-unmodified on

Eu uso muito o seguinte:

O :pmodificador para imprimir um resultado do histórico. Por exemplo

!!:p

Irá imprimir o último comando para que você possa verificar se está correto antes de executá-lo novamente. Basta entrar!! para executá-lo.

Na mesma linha:

!?foo?:p

Pesquisará em seu histórico o comando mais recente que continha a string 'foo' e a imprimirá.

Se você não precisar imprimir,

!?foo

faz a pesquisa e a executa imediatamente.

Eu tenho uma arma secreta: shell-fu.

Existem milhares de dicas inteligentes, truques legais e receitas eficientes que na maioria das vezes cabem em uma única linha.

Um que eu amo (mas trapaceio um pouco desde que uso o fato de o Python estar instalado na maioria dos sistemas Unix agora):

alias webshare='python -m SimpleHTTPServer'

Agora, toda vez que você digitar "compartilhamento na web", o diretório atual estará disponível através da porta 8000. Muito bom quando você deseja compartilhar arquivos com amigos em uma rede local sem chave USB ou diretório remoto. O streaming de vídeo e música também funcionará.

E, claro, a clássica bomba de garfo que é completamente inútil, mas ainda muito divertida:

$ :(){ :|:& };:

Não tente isso em um servidor de produção ...

Você pode usar o comando watch em conjunto com outro comando para procurar alterações. Um exemplo disso foi quando eu estava testando meu roteador e queria obter números atualizados sobre coisas como a relação sinal / ruído, etc.

watch --interval=10 lynx -dump http://dslrouter/stats.html

type -a PROG

para encontrar todos os locais onde o PROG está disponível, geralmente em algum lugar em ~ / bin, em vez daquele em / usr / bin / PROG que poderia ser esperado.

Eu gosto de construir comandos com eco e canalizá-los para o shell:

$ find dir -name \*~ | xargs echo rm
...
$ find dir -name \*~ | xargs echo rm | ksh -s

Por quê? Porque me permite ver o que será feito antes de fazê-lo. Dessa forma, se eu tiver um erro horrível (como remover meu diretório inicial), posso detectá-lo antes que aconteça. Obviamente, isso é mais importante para ações destrutivas ou irrevogáveis.

Ao baixar um arquivo grande, geralmente faço:

while ls -la <filename>; do sleep 5; done

E então, basta pressionar Ctrl + c quando terminar (ou se lsretornar diferente de zero). É semelhante ao watchprograma, mas usa o shell, portanto, funciona em plataformas semwatch .

Outra ferramenta útil é o netcat, ou nc. Se você fizer:

nc -l -p 9100 > printjob.prn

Em seguida, você pode configurar uma impressora em outro computador, mas usar o endereço IP do computador que está executando o netcat. Quando o trabalho de impressão é enviado, é recebido pelo computador que está executando o netcat e despejado printjob.prn.

pushde popdquase sempre são úteis

Uma maneira preferida de navegar quando estou usando vários diretórios em locais amplamente separados em uma hierarquia de árvore é usar o acf_func.sh (listado abaixo). Uma vez definido, você pode fazer

cd -

para ver uma lista de diretórios recentes, com um menu numérico

cd -2

para ir para o segundo diretório mais recente.

Muito fácil de usar, muito útil.

Aqui está o código:

# do ". acd_func.sh"
# acd_func 1.0.5, 10-nov-2004
# petar marinov, http:/geocities.com/h2428, this is public domain

cd_func ()
{
  local x2 the_new_dir adir index
  local -i cnt

  if [[ $1 ==  "--" ]]; then
    dirs -v
    return 0
  fi

  the_new_dir=$1
  [[ -z $1 ]] && the_new_dir=$HOME

  if [[ ${the_new_dir:0:1} == '-' ]]; then
    #
    # Extract dir N from dirs
    index=${the_new_dir:1}
    [[ -z $index ]] && index=1
    adir=$(dirs +$index)
    [[ -z $adir ]] && return 1
    the_new_dir=$adir
  fi

  #
  # '~' has to be substituted by ${HOME}
  [[ ${the_new_dir:0:1} == '~' ]] && the_new_dir="${HOME}${the_new_dir:1}"

  #
  # Now change to the new dir and add to the top of the stack
  pushd "${the_new_dir}" > /dev/null
  [[ $? -ne 0 ]] && return 1
  the_new_dir=$(pwd)

  #
  # Trim down everything beyond 11th entry
  popd -n +11 2>/dev/null 1>/dev/null

  #
  # Remove any other occurence of this dir, skipping the top of the stack
  for ((cnt=1; cnt <= 10; cnt++)); do
    x2=$(dirs +${cnt} 2>/dev/null)
    [[ $? -ne 0 ]] && return 0
    [[ ${x2:0:1} == '~' ]] && x2="${HOME}${x2:1}"
    if [[ "${x2}" == "${the_new_dir}" ]]; then
      popd -n +$cnt 2>/dev/null 1>/dev/null
      cnt=cnt-1
    fi
  done

  return 0
}

alias cd=cd_func

if [[ $BASH_VERSION > "2.05a" ]]; then
  # ctrl+w shows the menu
  bind -x "\"\C-w\":cd_func -- ;"
fi

Expanda linhas complicadas antes de pressionar o temido enter

• Alt+ Ctrl+ e- shell-expandir-line (pode precisar usar Esc, Ctrl+e no teclado)
• Ctrl+ _- desfazer
• Ctrl+ x, *- palavra de expansão glob

$ echo !$ !-2^ * Alt+ Ctrl+ e
$ echo aword someotherword * Ctrl+ _
$ echo !$ !-2^ * Ctrl+ x, *
$echo !$ !-2^ LOG Makefile bar.c foo.h

& c.

Eu sempre fui parcial em:

ctrl-E # move cursor to end of line
ctrl-A # move cursor to beginning of line

Eu também uso shopt -s cdable_vars, então você pode criar variáveis ​​bash para diretórios comuns. Portanto, para a árvore de fontes da minha empresa, crio várias variáveis ​​como:

export Dcentmain="/var/localdata/p4ws/centaur/main/apps/core"

então eu posso mudar para esse diretório por cd Dcentmain.

pbcopy

Isso copia para a área de transferência do sistema Mac. Você pode canalizar comandos para ele ... tente:

pwd | pbcopy

$ touch {1,2}.txt
$ ls [12].txt
1.txt  2.txt
$ rm !:1
rm [12].txt
$ history | tail -10
...
10007  touch {1,2}.txt
...
$ !10007
touch {1,2}.txt
$ for f in *.txt; do mv $f ${f/txt/doc}; done

O uso de 'set -o vi' na linha de comando, ou melhor, em .bashrc, coloca você no modo de edição vi na linha de comando. Você inicia no modo 'inserir' para digitar e retroceder normalmente, mas se cometer um erro 'grande', poderá pressionar a tecla esc e, em seguida, usar 'b' e 'f' para se movimentar como no vi. cw para mudar uma palavra. Particularmente útil depois que você abre um comando de histórico que deseja alterar.

Semelhante a muitos acima, meu favorito atual é o pressionamento de tecla [alt]. (Alt e "." Juntas) são o mesmo que $! (Insere o último argumento do comando anterior), exceto que é imediato e para mim é mais fácil digitar. (Apenas não pode ser usado em scripts)

por exemplo:

mkdir -p /tmp/test/blah/oops/something
cd [alt].

Coloque vários comandos juntos usando o comando && :

./run.sh && tail -f log.txt

ou

kill -9 1111 && ./start.sh