it-swarm-pt.com

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.

93
cmcginty

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 history mostrará uma lista de comandos executados recentemente com um designador de eventos à esquerda
  • !N substituirá o comando associado ao designador de evento N
  • !-N substituirá o N º comando mais recente; por exemplo. !-1 substituirá o comando mais recente, !-2 o segundo mais recente etc.
  • Como mencionado na outra resposta, !! é uma abreviação de !-1, para substituir rapidamente o último comando
  • !string substituirá o comando mais recente que começa com string
  • !?string? substituirá o comando mais recente que contém string

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.

  • !:0 obterá o comando que foi executado
  • !:1 obterá o primeiro argumento (e !:2 o segundo, etc.)
  • !:2-3 obterá 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 base
  • t - Apenas o nome do arquivo base
  • r - alinhe até a extensão do nome do arquivo
  • e - Apenas a extensão do nome do arquivo
  • s/search/replacement - Substitua a primeira ocorrência de search por replacement
  • gs/search/replacement - Substitua todas as ocorrências de search por replacement
88
Michael Mrozek

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.

64
chillitom

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

49
Moeb

Execute o último comando como root:

Sudo !!
46
Alex B

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
42
Michael Mrozek

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!

36
Aaron Bockover

diff a saída de dois comandos sem criar um arquivo temporário manualmente (bash):

diff <(ls dir1) <(ls dir2)
31
Alex B

Bastante básico, mas as pessoas parecem não saber, retorna ao diretório anterior:

cd -
30
Robert Swisher

Expansão de chaves :

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
29
Stefan

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
}
29
Sygo

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
}
21
Maik

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.

17
mendicant

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
17
jacksonh

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.

14
user394

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 
13
redacted

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'
12
miguel.de.icaza
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
11
Eimantas

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'
10
Michael Mrozek

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
9
Michael Mrozek
vi `which scriptname`

Pois quando você não sabe onde algo vive, e também não se importa.

9
Matt Simmons

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.

9
user394

Conclusão da guia. Quão ruim seria ruim se você tivesse que digitar todos os caracteres de todos os caminhos?

8
user394

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'
7
jcubic

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.

7
Roberto Bonvallet

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.

6
Matthew Flaschen

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
5
Michael Mrozek

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
5
Michael Mrozek
  • O comando do-nothing : como em

    while :; do :; done
    
  • Expanda 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 :; fi
    
  • usando 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
    
4
artistoex

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

4
Stefan

À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.

3
mouviciel

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.

3
Lucas Jones

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 
3
Bauna

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!

3
D4RIO

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.

3
alex

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

3
Stefan

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
2
boardstretcher
# 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}'
2
SergioAraujo

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
[...]
2
user6362

Resuma o tamanho do diretório, com o tamanho humano decrescente

du -hs */ | sort -hr

por exemplo.

10.2G   foo/
4M      bar/
2
Eric Fortis

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
2
Andre Holzner

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"

2
holms

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.

2
Matthew Flaschen

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
}
1
sakisk

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}' }

1
Moses Xu
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
1
André Paramés

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 \$ "
1
Stefan Lasiewski

Eu achei o seguinte útil ao alternar constantemente entre Windows e Unix/Linux:

alias dir="ls -l"
alias copy="cp"
alias del="rm"
1
artdanil

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
1
pho3nixf1re

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.

1
mmirate

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:

http://192.168.1.70:80

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.

1
SHW

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.

1
dhchdhd

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
1
Andre Holzner

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 ...

1
Dimitris Leventeas

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
1
tsudot

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

1
user1888

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!

1
maxschlepzig

Existe um ótimo site para isso em: http://www.commandlinefu.com/commands/browse

1
Andrew Stern

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.

0
Mark D
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.

0
TCKMusing

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\]$ "
0
jstarek

sincronização; sincronização; sincronização; reinicialização

às vezes pode ser realmente útil. Seja cuidadoso !

0
Tony Lambert

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.

0
markf

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.

0
vegasbrianc