Lembre-se de um comando digitado pela metade enquanto eu verifico algo

Costumo me encontrar na seguinte posição: comecei a digitar um comando longo no prompt do bash, mas, no meio do processo, descobri que precisava verificar algo com outro comando. Esse é um problema quando estou no console (sem X), o que geralmente acontece, porque só tenho as seguintes maneiras insatisfatórias de fazer isso, que eu conheço:

• Pressione ctrl+ alt+ F2e faça login em outro console virtual e descubra o que eu queria, depois volte e continue
• ctrl+ a, digite echo + space+ enter, descubra o que eu queria, pressione ↑até encontrar meu comando, ctrl+ a, delx 5, ctrl+ ee continue
• Destaque o que eu digitei até agora com o mouse (se o gpm estiver em execução, o que geralmente é), pressione ctrl+ cpara interromper, descubra o que eu queria enquanto tomava cuidado para não usar o mouse para destacar coisas e pressione o botão do meio do mouse em um novo prompt e continue
• Ore aos deuses da linha de comando para que o comando semi-escrito não tenha efeitos adversos, mas simplesmente falhe, e pressione com cuidado enter, depois descubra o que eu queria, pressione para cima até recuperar meu comando e continue
• Entre na minha máquina do tempo, viaje de volta no tempo e lembre-me de começar a tela antes de começar a digitar comando, voltar ao presente, pressionar ctrl+ a c, descobrir o que eu queria, pressionar ctrl+ a ctrl+ae continuar

Então, o que eu quero saber é: existe alguma maneira mais elegante de fazer isso? Uma espécie de subshell-command ou similar?

Estou mais interessado em métodos que não exigem nenhuma preparação ou configuração para funcionar.

Uma versão um pouco mais rápida do Ctrl + A Ctrl+ de alexK (que se move para a frente da linha e depois corta tudo para a frente) é apenas usar Ctrl+ U, que corta para trás no bash e toda a linha (independentemente da sua posição atual) no zsh. Então você usa Ctrl+ Ypara colar novamente

Pressione Ctrl-A para chegar ao início da linha, adicione um hash e pressione return - dessa forma, ele permanecerá no histórico de comandos como um comentário e você poderá voltar com o cursor para cima

EDIT: apenas notei que esta é uma variante um pouco mais elegante no seu # 2;)

Pressione Ctrl+A, Ctrl+Kpara ir para o início da linha e exclua (mate) até o final. Em seguida, faça sua pesquisa e, quando estiver pronto para continuar, pressione Ctrl+Y(puxar) para colocar sua linha salva (morta) de volta.

No zsh, digite Ctrl+ Zpara "suspender" o comando que estou digitando e digite outro comando. Depois de executar esse comando (ou abortá-lo com Ctrl+ C), o comando suspenso volta para edição (mesmo lembrando a posição do cursor). Como conveniência adicional, se a linha de comando estiver vazia quando eu digitar Ctrl+ Z, a tecla chamará o interno bg(portanto, um duplo Ctrl+ Zenvia um comando em execução diretamente para o plano de fundo).

fancy-ctrl-z () {
  emulate -LR zsh
  if [[ $#BUFFER -eq 0 ]]; then
    bg
    zle redisplay
  else
    zle push-input
  fi
}
zle -N fancy-ctrl-z
bindkey '^Z'          fancy-ctrl-z

Eu não sei como fazer algo semelhante no bash.

Em qualquer shell, você pode usar o método de baixa tecnologia para adicionar um #no início da linha atual .

No bash, basta digitar Alt+ #.

Em seguida, quando estiver pronto, pressione Upem seguida, Alt+ #.

O primeiro coloca um #no início da linha para transformá-lo em um comentário e depois aceita a linha, como se você tivesse pressionado Enter.

Então, quando você faz uma segunda vez, ela vê que a linha já tem uma #no início, então a remove e a aceita, novamente salvando a Enterchave.

Se a segunda vez inserir outra #, basta digitar Alt+ - Alt+ #.

Você pode fazer o zsh fazer o mesmo colocando

bindkey -M emacs '\e#' pound-insert

no seu ~ / .zshrc.

Ou, se você estiver usando ligações do vi, poderá digitar #no modo de comando no bash e no zsh.

Um dos meus recursos favoritos zshé a função de linha de push integrada que cuida disso sem nenhuma das invasões das outras respostas aqui. Eu o vinculei a Ctrl+ lno meu .zshrcarquivo assim:

bindkey '^L' push-line

Então, quando estou digitando algum comando e preciso fazer outra coisa rapidamente, posso invocá-lo com uma tecla e obter um prompt em branco. Depois de executar o outro comando, o prompt é preenchido automaticamente com o que eu estava digitando antes.

Você pode encadear várias camadas disso e os comandos retornarão para você na ordem inversa em que você os empurrou para a fila.

Além do truque ctrl- a ctrl- k, se você estiver na tela, apenas ctrl- a dpara desconectar e reconectar comscreen -r

Você também pode simplesmente abrir outra janela com ctrl+a c

Uma maneira alternativa, porém não perfeita, pressione Ctrl-X Ctrl-E. Isso abrirá seu editor padrão contendo seu comando meio digitado. Em seguida, você pode salvar seu comando em um arquivo ou abrir um novo shell a partir do seu editor. Quando você sair do novo shell, ele retornará ao editor e o salvamento do conteúdo os executará automaticamente.

Isso não é perfeito porque não retorna ao seu shell original, mas força a execução do comando ou o descarta completamente. Mas não há seleções temporárias ou buffers de interrupção com os quais se preocupar, e também existem alguns ajustes interessantes, por exemplo, se editor = vi

:wq            # execute the command
:cq            # cancel and abort
:! command     # execute command
:shell         # open a new shell
:r filename    # insert the contents of a file for editing
:r ! command   # insert the output of a command for editing

Semelhante ao método de adição #no início da linha, existe um método sem dúvida mais simples que eu uso, que não requer retorno ao início da linha:

Basta adicionar uma cotação aberta e não fechá-la, seja simples ou dupla.

Então pressione Enter.

Então pressione CtrlC.

O comando parcial é salvo no histórico de comandos (disponível via seta para cima), mas na verdade não é executado.

Usando zsh, se você digitar <ESC> q(escape e Q), sua linha de prompt será cortada, para que você possa digitar outro comando. Você receberá automaticamente seu texto cortado no próximo prompt.

Ele pode lembrar várias linhas ao mesmo tempo, para que você possa usá-lo enquanto uma linha estiver esperando por você. Você pode até usá-lo na linha em branco para atrasar o resumo da sua linha de corte.

Não é a maneira mais eficiente se você precisar usar vários comandos para a verificação / preparação (você precisará digitar novamente <ESC> qantes de cada comando). Mas acho que é possível vinculá-lo a um atalho mais curto.

Se você quiser apenas verificar o manual, digite <ESC> h(escape e H). Isso executará o run-helpbuilt-in, com a primeira palavra da linha de comando como argumento. Você voltará a sua linha intacta quando terminar.