Maneiras mais rápidas de mover o cursor em uma linha de comando do terminal?

Qual é a melhor maneira de se deslocar em uma determinada linha de comando muito longa no terminal?

Digamos que usei a tecla de seta ou Ctrl-R para obter essa longa linha de comando:

./cmd --option1 --option2 --option3 --option4 --option5 --option6 --option7 --option8 --option9 --option10 --option11 --option12 --option13 --option14 --option15 --option16 --option17 --option18 --option19 --option20 --option21 --option22 --option23 --option24 --option25 --option26 --option27 --option28 --option29 --option30 --option31 --option32 --option33 --option34 --option35 --option36 --option37 --option38 --option39 --option40 --option41 --option42 --option43 --option44 --option45 --option46 --option47 --option48 --option49 --option50 

Agora eu preciso mover (a partir do início ou do final da linha) o cursor --option25para modificar algo lá.

Qual é a maneira mais rápida de chegar lá? O que eu costumo fazer é Ctrl- Achegar ao começo e repetidamente Alt- Favançar, palavra por palavra (ou Ctrl- Eir ao fim e Alt- Bdepois voltar ao passado). Mas em uma longa fila que leva muito tempo. Deve haver uma maneira de pesquisar e pular diretamente para a parte que preciso modificar, por exemplo option25?

Como isso ainda não foi fechado, aqui estão mais algumas opções.

• Use Ctrl+ xseguido de Ctrl+ epara abrir a linha atual no editor especificado por $FCEDITou$EDITOR ouemacs (tentado nessa ordem).
• Se você executou o comando anteriormente, pressione Ctrl+ rpara pesquisar no histórico reverso e digiteoption25 (neste caso). A linha será exibida. AcertarTab para começar a editar neste momento.
• Use a expansão do histórico com o s///modificador. Por exemplo !-2:s/--option25/--newoption/, execute novamente o penúltimo comando, mas substitua a opção25. Para modificar o último ./cmdcomando, use o!string sintaxe:!./cmd:s/--option25/--newoption/
  Qualquer delimitador pode ser usado no lugar de / na substituição.
• Se você editar a linha anterior, poderá usar a substituição rápida: ^--option25^--newoption
• Pesquisa de caracteres. Isso foi mencionado por Pax e pode ser feito no modo emacs regular com Ctrl+ ]para pesquisa direta e Ctrl+ Alt+ ]para pesquisa reversa.

Eu recomendo a segunda opção. Ctrl+ ré realmente prático e rápido, sem mexer nos editores, e você vê os resultados antes da execução do comando (diferente das expansões do histórico).

Para ser claro, você não deseja uma "maneira rápida de mover o cursor em uma linha de comando do terminal ". O que você realmente deseja é uma maneira rápida de navegar pela linha de comando no seu programa de shell .

Bash é um shell muito comum, por exemplo. Ele usa a biblioteca Readline para implementar a entrada da linha de comando. E por assim dizer, é muito conveniente conhecer as ligações Readline, pois elas são usadas não apenas no bash. Por exemplo, o gdb também usa o Readline para processar a entrada.

Na documentação do Readline, você pode encontrar todas as ligações relacionadas à navegação (e mais): http://www.gnu.org/software/bash/manual/bash.html#Readline-Interaction

Cópia-colar curta, se o link acima ficar inativo:

Puramente essencial

• Ctrl-b Retrocede um caractere.
• Ctrl-f Avança um caractere.
• [DEL] ou [Backspace] Exclua o caractere à esquerda do cursor.
• Ctrl-d Exclui o caractere abaixo do cursor.
• Ctrl-_ ou Cx Cu Desfaz o último comando de edição. Você pode desfazer todo o caminho de volta para uma linha vazia.

Movimento

• Ctrl-a Mover para o início da linha.
• Ctrl-e Mover para o final da linha.
• Meta-f Avança uma palavra, onde uma palavra é composta de letras e dígitos.
• Meta-b Retrocede uma palavra.
• Ctrl-l Limpa a tela, reimprimindo a linha atual na parte superior.

Matar e puxar

• Ctrl-k Mata o texto da posição atual do cursor até o final da linha.
• Md Mate do cursor até o final da palavra atual ou, se estiver entre as palavras, até o final da próxima palavra. Os limites de palavras são os mesmos que os usados ​​por Mf.
• M- [DEL] Mate do cursor o início da palavra atual ou, se houver entre as palavras, o início da palavra anterior. Os limites de palavras são iguais aos usados ​​por Mb.
• Ctrl-w Mata do cursor para o espaço em branco anterior. Isso é diferente de M- porque os limites das palavras diferem.
• Pressione a tecla Ctrl e puxe o texto morto mais recentemente de volta para o buffer no cursor.
• Meu Gire o anel da morte e arranque o novo topo. Você só pode fazer isso se o comando anterior for Cy ou My.

M é a tecla Meta. Para o Max OS X Terminal, você pode ativar "Usar opção como meta-chave" em Configurações / teclado para isso. Para Linux é mais complicado.

Atualizar

Observe também que o Readline pode operar em dois modos:

• modo emacs (que é o padrão)
• modo vi

Para alternar o Bash para usar o modo vi:

$ set -o vi

Pessoalmente, prefiro o modo vi, pois uso o vim para edição de texto.

Bônus

No aplicativo macOS Terminal (e no iTerm também), você pode clicar com a tecla Option pressionada para mover o cursor (o cursor se moverá para a posição clicada). Isso até funciona por dentro vim.

Mantenha pressionada a tecla Opção e clique no local em que deseja mover o cursor, e o Terminal direciona o cursor para o local preciso.

Eu tendem a preferir o modo de edição vi (já que essas teclas estão incorporadas na minha medula espinhal agora (o cérebro não é usado de todo), juntamente com o CTRL-K, CTRL-X do WordStar 3.3 :-). Você pode usar a linha de comando set -o vipara ativá-lo (e set -o emacsreverter).

No Vi, seria (ESC-K para alinhar primeiro, é claro) " f5;;B" (sem as aspas duplas).

Claro, você precisa entender o que está em jogo para se safar disso. Basicamente, é

f5 to find the first occurrence of "5" (in --option5).
;  to find the next one (in --option15).
;  to find the next one (in --option25).
B  to back up to the start of the word.

Vamos ver se os aficionados do emacs podem encontrar uma solução melhor, menos de cinco pressionamentos de tecla (embora eu não queira começar uma guerra religiosa).

Você já pensou se gostaria de colocar esse comando horrendamente longo em um script? :-)

Na verdade, eu posso ir melhor do que isso: " 3f5B" para encontrar a terceira ocorrência de "5" e voltar ao início da palavra.

Use Meta-b / Meta-f para retroceder / avançar uma palavra, respectivamente.

No OSX, o Meta se traduz como ESC, o que é péssimo.

Mas como alternativa, você pode abrir as preferências do terminal -> configurações -> perfil -> teclado e marcar "usar opção como meta-chave"

Depois de executar o comando uma vez, execute fc

Ele será iniciado $EDITORcom o comando anterior, e você poderá usar seu editor regular para modificar o comando. Quando você salva e sai, o arquivo será executado.

..mas, como Pax disse - a linha de comando não é particularmente boa para editar linhas absurdamente longas - por que não transformar o comando em um script?

Se você quiser avançar um certo número de palavras, pressione M-<n>( M-é para Meta e geralmente é a tecla de escape) e pressione um número. Isso envia um argumento de repetição para a linha de leitura, para que você possa repetir qualquer comando que desejar - se quiser avançar, pressione M-<n> M-fe o cursor avançará o <n>número de palavras.

Por exemplo

 $|echo "two three four five six seven"
 $ M-4
 (arg: 4) echo "two three four five six seven"
 $ M-f
 $ echo "two three four| five six seven"

Portanto, para o seu exemplo, a partir do cursor no início da linha que você tocaria, M-26 M-fe o cursor estaria no --option25|- ou - no final da linha M-26 M-b, colocaria o cursor em--|option25

Pesquisa de histórico incremental

no terminal digite:

gedit  ~/.inputrc

copie e cole e salve

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

tudo o que você precisa fazer para encontrar um comando anterior é digitar, digamos, as primeiras 2 ou 3 letras e a seta para cima o levará até lá rapidamente, dizendo que eu quero:

for f in *.mid ; do timidity "$f"; done

tudo o que eu preciso fazer é entrar

fo

e pressione o comando seta para cima aparecerá em breve

Uma opção é o uso M-x shellem emacs. Isso fornece todos os recursos de edição e pressionamentos de teclas que emacspossuem, portanto, C-spode ser usado para pesquisar o texto option25, por exemplo.

(Mas eu ainda preferiria estar no shell de terminal real, se alguém puder me indicar boas instalações de pesquisa e edição.)

Use o mouse

Às vezes, a maneira mais fácil de editar uma linha de comando é usando o mouse. Algumas respostas anteriores fornecem um comando para abrir sua linha atual no seu $ EDITOR. Para mim (zhs com grml config) essa combinação é Alt+e. Se você ativar o mouse no seu editor, poderá utilizá-lo.

Para ativar o mouse no Vim, adicione-o ao seu ~ / .vimrc

set mouse=a
set ttymouse=xterm2

Se você quiser fazer uma seleção de texto no terminal (em vez de passar o mouse para o vim), mantenha pressionada a tecla Shift ao clicar; isso é específico do terminal, é claro.

Os administradores de sistemas não devem ter medo do mouse.

No Cygwin, você pode ativar esse recurso clicando com o botão direito do mouse na janela. Na janela pop-up, selecione Opções ... -> Mouse -> ativar Cliques posicionar o cursor da linha de comando -> Aplicar.

A partir de agora, basta clicar no botão esquerdo do mouse em alguma posição na linha de comando para colocar o cursor lá.

primeiro: exportar EDITOR = 'nano -m'

então: CTRL + X CTRL + E em sequência.

Sua linha atual será aberta no editor nano com o mouse ativado. Você pode clicar em qualquer parte do texto e editar

CTRL + X para sair e y para confirmar o salvamento.

Eu criei um script para fazer o cursor da linha de comando se mover com o clique do mouse :

1. Ativar relatórios de rastreamento do mouse xterm
2. Defina as ligações da linha de leitura para consumir a sequência de escape gerada por cliques

Pode ser encontrado no github

Mais informações em outra postagem

Funcionará se echo -e "\e[?1000;1006;1015h" # Enable trackingimprimir sequências de escape no terminal ao clicar com o mouse

Pode não ser o mais rápido, mas isso precisa estar aqui, algumas leituras sobre os movimentos do cursor ANSI

As seqüências de escape ANSI permitem que você mova o cursor pela tela à vontade. Isso é mais útil para interfaces de usuário de tela cheia geradas por scripts de shell, mas também pode ser usado em prompts . As seqüências de escape de movimento são as seguintes:

- Position the Cursor:
  \033[<L>;<C>H
     Or
  \033[<L>;<C>f
  puts the cursor at line L and column C.
- Move the cursor up N lines:
  \033[<N>A
- Move the cursor down N lines:
  \033[<N>B
- Move the cursor forward N columns:
  \033[<N>C
- Move the cursor backward N columns:
  \033[<N>D

- Clear the screen, move to (0,0):
  \033[2J  or \033c
- Erase to end of line:
  \033[K

- Save cursor position:
  \033[s
- Restore cursor position:
  \033[u

(...)

Tente inserir a seguinte linha de código no prompt (é um pouco mais claro o que ele faz se o prompt estiver várias linhas no terminal quando você o inserir): echo -en "\033[7A\033[1;35m BASH \033[7B\033[6D"Isso deve mover o cursor na tela de sete linhas, imprima a palavra "BASH "e, em seguida, retorne ao local onde começou a produzir um prompt normal.

Exemplos :

Mova o cursor para trás 7 linhas:

echo -e "\033[7A"

Mova o cursor para a linha 10, coluna 5:

echo -e "\033[10;5H"

Faça eco rapidamente dos códigos de cores para colorir um programa:

echo -e "\033[35;42m" ; ifconfig