bash - raspbian - Como usar argumentos do comando anterior?



command-line keyboard-shortcuts (7)

Para inserir argumentos anteriores:

  • Alt + . : insira o último argumento do último comando (repita para voltar ao histórico)
  • Alt + # + . : insere #nth último argumento do último comando (repete para voltar no histórico)
  • Alt + - , # , Alt + . , zsh: Alt + - + # + . : insere #nth primeiro argumento do último comando (repete para voltar no histórico)

Exemplo:

Último comando é:

mv foo bar
  • Alt + 0 + . : inserir primeiro argumento do último comando = mv
  • Alt + 2 + . : insira o último segundo argumento do último comando = foo
  • para cima , Ctrl + w : último comando sem a última palavra = mv foo

Atalhos gerais

  • Ctrl + w : remove a última palavra do cursor
  • Ctrl + k : remove tudo depois do cursor
  • Ctrl + _ : desfaz a última edição (muito útil quando exceder Ctrl + w )
  • Ctrl + left : move o cursor para a última palavra
  • Ctrl + right : move o cursor para a próxima palavra
  • home ou Ctrl + a : move o cursor para o início do comando
  • end ou Ctrl + e : move o cursor para o final do comando
  • Ctrl + u : limpa o comando inteiro

Para percorrer os argumentos em um comando anterior

só funciona em zsh

execute ou adicione isso ao seu ~/.zshrc

autoload -Uz copy-earlier-word
zle -N copy-earlier-word
bindkey "^[:" copy-earlier-word

Agora use Alt + . para ir o quanto quiser, use Alt + : para iterar os argumentos

Assumindo o último comando é

echo 1 2 3 4 5
  • Alt + . : 5
  • Alt + . +:: 4
  • Alt + . + : +:: 3
  • Alt + . + : + : +:: 2
  • Alt + . + : + : + : +:: 1
  • Alt + . + : + : + : + : +:: echo

fonte: https://stackoverflow.com/a/34861762/3163120

Para ver todos os atalhos disponíveis

  • bash: bind -lp
  • zsh: bindkey -L

https://src-bin.com

Eu sei disso Esc + . dá-lhe o último argumento do último comando.

Mas estou interessado no primeiro argumento do último comando. Existe uma ligação de chave para fazer isso?

Nas mesmas linhas, existe uma maneira genérica de obter o enésimo argumento do último comando? Eu sei que em um script bash, você pode usar $0 , $1 etc., mas estes não funcionam na linha de comando.

Além disso, que sobre iterar através do 0º argumento de comandos anteriores, como podemos fazer com o último argumento, pressionando continuamente Esc + . ?


Answer #1

! ^ pode ser o comando para o primeiro argumento. Não tenho certeza se existe uma maneira de obter o enésimo.


Answer #2

Assim como M-. (meta-ponto ou esc-ponto ou alt-ponto) é a função readline yank-last-arg , MCy (meta-controle-y ou esc-ctrl-y ou ctrl-alt-y) é a função readline yank-nth-arg . Sem especificar n , ele pega o primeiro argumento do comando anterior.

Para especificar um argumento, pressione Escape e um número ou segure Alt e pressione um número. Você pode fazer Alt - - para começar a especificar um número negativo, em seguida, solte Alt e pressione o dígito (isso contará a partir do final da lista de argumentos.

Exemplo:

Digite o seguinte comando

$ echo a b c d e f g
a b c d e f g

Agora, no próximo prompt, digite echo (com um espaço a seguir) e, em seguida,

Pressione Alt - Ctrl - y e você verá agora:

$ echo a

sem pressionar Enter ainda, faça o seguinte

Pressione Alt - 3 Alt - Ctrl - y

Pressione Alt - - 2 Alt - Ctrl - y

Agora você vai ver:

$ echo ace

By the way, você poderia ter colocado o echo na linha, selecionando o argumento 0:

Pressione Alt - 0 Alt - Ctrl - y

Editar:

Para responder à pergunta que você adicionou ao seu original:

Você pode pressionar Alt - 0 e pressionar repetidamente Alt - . para percorrer os comandos anteriores (arg 0). Da mesma forma Alt - - depois repetindo Alt - . permitir-lhe-ia percorrer os últimos-a-últimos argumentos anteriores.

Se não houver argumento apropriado em uma linha em particular na história, o sino será tocado.

Se houver uma combinação específica usada com frequência, você poderá definir uma macro para que uma tecla seja executada. Este exemplo chamará o segundo argumento de comandos anteriores pressionando Alt - Shift - Y. Você pode escolher qualquer tecla que você preferir em vez desta. Você pode pressioná-lo repetidamente para percorrer os anteriores.

Para experimentá-lo, insira a macro em um prompt do Bash:

bind '"\eY": "\e2\e."'

Para torná-lo persistente, adicione esta linha ao seu arquivo ~/.inputrc :

"\eY": "\e2\e."

Infelizmente, isso não parece funcionar para arg 0 ou números de argumentos negativos.


Answer #3

Basicamente, ele tem um uso em puxar argumentos anteriores (do comando).

Por exemplo, se o seguinte comando for emitido:

echo Hello, world how are you today?

então, Hello, será o primeiro argumento e today? o sexto , esse é o último; o que significa que pode ser referenciado digitando:

Alt + 6 seguido por Ctrl-Alt-6

Ctrl é tradicionalmente indicado como um caractere de chapéu ^ prefixado aos nomes das teclas, e Alt como M- que é o prefixo M eta.

Então, o atalho acima pode ser redefinido como ^My to yank.

Além disso, há um atalho de substituição de chapéus na linha de comando:

echo Hello, world!

^Hello^Bye

Bye, world!

para substituir a primeira string correspondente do comando anterior, significando:

Hello, world! Hello, people!

^Hello^Bye

resultaria em:

Bye, world! Hello, people!

deixando a segunda partida ( hello ) inalterada.

Nota: Não deixe espaço entre os chapéus , ou a operação não funcionará.

O acima é apenas um atalho para:

!:s/Hello/Bye

substituição de nível de evento (*) pela primeira string encontrada (correspondida) no comando anterior, enquanto o prefixo da primeira parte com a opção g será aplicado à linha inteira globalmente:

echo Hello, world! Hello, people!

!:gs/Hello/Bye

Bye, world! Bye, people!

como geralmente está sendo feito em outros comandos relacionados, como sed , vi , e em regex (expressão regular) - uma maneira padrão de pesquisar ( string de correspondência ).

Não, você não pode fazer !:sg/Hello/Bye ou !:s/Hello/Bye/g aqui, essa é a sintaxe !

  • ! é para eventos; evento pode ser entendido como saída de comando ou operação realizada no histórico de comandos.

Isso é o que eu entendo, usando-me e tentando coisas por conta própria que li de várias fontes, incluindo páginas de manual, blogs e fóruns.

Espero que ele lance alguma luz em maneiras misteriosas de bash , o shell Bourne-Again (um shell sh , que por si só é chamado de shell Bourne após o nome do seu inventor), que é shell padrão em muitas distribuições, incluindo servidores .


Answer #4

O método descrito no final da resposta aceita também funciona com o argumento zeroth para mim. Eu tenho essas linhas no meu ~/.inputrc :

"\en": "\e0\e."
"\em": "\e1\e."
"\e,": "\e2\e."

\e2\e. tem a vantagem sobre \e2\e\Cy que percorre os comandos anteriores se for pressionado repetidamente em vez de inserir o segundo argumento do comando anterior várias vezes.

Para inserir todo o comando anterior, você pode digitar !!\e^ . \e^ history-expand-line é history-expand-line .


Answer #5

Para usar o primeiro argumento, você pode usar !^ Ou !:1

Exemplo:

$ echo a b c d e 
a b c d e
$ echo !^
echo a
a

$ echo a b c d e 
a b c d e
$ echo !:1
echo a
a

Como sua pergunta é sobre o uso de outros argumentos, aqui estão alguns úteis:

!^      first argument
!$      last argument
!*      all arguments
!:2     second argument

!:2-3   second to third arguments
!:2-$   second to last arguments
!:2*    second to last arguments
!:2-    second to next to last arguments

!:0     the command
!!      repeat the previous line

As primeiras quatro formas são mais usadas. O formulário !:2- é um pouco contra-intuitivo, pois não inclui o último argumento.


Answer #6

!$ obtém o último elemento do argumento da linha de comandos anterior.





input-history