Eu gostaria de executar o comando
foo --bar=baz <16 zeroes>
Como digito os 16 zeros com eficiência *? Se eu segurar Alte pressionar 1 6 0, repetirá a próxima coisa 160 vezes, o que não é o que eu quero. No emacs eu posso usar Alt-[number]or Ctrl-u 1 6 Ctrl-u 0, mas no bash Ctrl-umata a linha atualmente sendo digitada e o próximo zero apenas adiciona um 0 à linha.
Se eu fizer
foo --bar=baz $(printf '0%.0s' {1..16})
Então history
mostra exatamente o acima, e não foo --bar=baz 0000000000000000
; ou seja, o bash não se comporta da maneira que eu quero. ( Edit : point being, quero inserir algum número de zeros sem usar a $(...)
substituição de comandos)
(*) Acho que uma definição técnica de "eficientemente" é "com O (log n) pressionamentos de tecla", de preferência um número de pressionamentos de tecla igual ao número de dígitos em 16 (para todos os valores de 16) mais talvez uma constante; o exemplo emacs é qualificado como eficiente por esta definição.
fonte
know what you want to do
. Em um comando aninhado complexo, como o bash saberia quais partes você queria ver o resultado da execução no histórico em oposição ao próprio comando? E as variáveis? Em resumo, o bash sempre terácode
o histórico, não o resultado da execução do código.Alt
por si só, não envia nenhum personagem, então pressionar e liberar alt não terá nenhum efeito no que dizbash
respeito.history
é que eu gostaria de inserir dígitos sem usar a substituição de comandos.Respostas:
Experimentar
São 6 toques de tecla (assumindo pelo menos um teclado QWERTY dos EUA / Reino Unido) para inserir esses 16 zeros (você pode pressionar Alt1 e 6).
Você também pode usar o
vi
modo padrão (set -o vi
) e digitar:(também 6 pressionamentos de tecla).
O
emacs
modo equivalente e que poderia ser usado para repetir mais de um caractere ( ) funciona , mas não dentro .echo 0Ctrl+WAlt+1Alt+6Ctrl+Y
zsh
bash
Todos eles também trabalharão com
zsh
(e detcsh
onde isso vem). Comzsh
, você também pode usar sinalizadores de expansão variável de preenchimento e expandi-los com Tab:(Muito mais teclas, obviamente).
Com
bash
, você também podebash
expandir o seu$(printf '0%.0s' {1..16})
com Ctrl+Alt+E. Observe, porém, que ele expandirá tudo (mas não globs) na linha.Para jogar o jogo com o menor número de toques de tecla, você pode vincular a alguma tecla um widget que se expanda
<some-number>X
para temposX
repetidos<some-number>
. E tenha<some-number>
na base 36 para reduzi-lo ainda mais.Com
zsh
(vinculado a F8):Em seguida, para 16 zeros, você digita:
(3 batidas de tecla), onde
g
é16
em base 36.Agora podemos reduzi-lo ainda mais a uma chave que insere esses 16 zeros, embora isso seja trapaça. Poderíamos vincular F2a dois
0
s (ou dois$STRING
, 0 por padrão), F3a 30
s, F1F6a 160
s ... até 19 ... as possibilidades são infinitas quando você pode definir widgets arbitrários.Talvez eu deva mencionar que, se você pressionar e segurar a 0tecla, poderá inserir quantos zeros quiser com apenas um toque de tecla :-)
fonte
vi
e outros!Presumindo que o emulador de terminal não pressione a tecla (por exemplo, para alternar entre guias) - basta que o xterm funcione - você pode pressionar Alt-1 6 Ctrl-V 0. O controle-V é necessário para dividir o número e o caractere a repetir (se você estivesse repetindo uma letra, não precisaria).
(Esse é um recurso de linha de leitura conhecido como
digit-argument
, portanto, você poderábind
alterar as chaves modificadoras envolvidas)fonte
No Emacs, eu normalmente usaria C-qpara separar o argumento do prefixo da entrada de dígitos.
O Bash usa, em Ctrl+vvez de C-q, para evitar problemas com o controle de fluxo XON / XOFF.
Então você pode usar Alt+1 Alt+6 Ctrl+v 0.
fonte
outra opção é digitar quatro zeros e, em seguida, use o mouse para copiar e colar mais três vezes. clique duas vezes para selecionar, clique no meio x 3 para colar.
fonte
Brincando com macros:
Ligue a tecla de função F8para multiplicar por duas a última palavra (no espaço anterior) (código da tecla F8 encontrado usando
Ctrl-V F8
):Isso pode ser permanente enviando o mesmo texto para
~/.inputrc
então digite:
para obter 2 ^ 4 vezes o zero. (ainda cinco pressionamentos de tecla).
ou digite:
para obter 2 ^ 3 palavras no livro.
Ainda mais rápido:
Multiplique por 4:
3 pressionamento de tecla.
Multiplique por 8 (o mesmo número da tecla de função)
Ainda 3 pressionamentos de tecla.
Enganação?
Trapaça ao multiplicar por 16.
Apenas 2 teclas pressionadas. (e ainda uma função simples e útil)
^^^^^^^^^^^^^^^^ (base 36? Hah!) :-P
Claramente trapaceando:
Apenas 1 (sim: um ) pressionamento de tecla.
Alterando a ligação para ctrl+U:
Envie para
~/.inputrc
:Releia o
~/.inputrc
arquivo:faça como de costume no emacs (como você queria):
7 teclas (após a "configuração").
Um pouco mais curto:
Use o padrão "multiplique por 4" de "argumento universal" e termine com
Apenas 5 chaves.
Usando o alt+nacesso a (arg: n)
São 6 chaves para obter os 16 zeros.
Não alterando nenhum atalho de teclado:
Se em sua festa você tem
bash C-u kills the currently-being-typed line
.Isso é porque
"\C-u":
está vinculadounix-line-discard
.Mas isso também pode ajudar:
quando, o que é antes do cursor ser apagado, ele também é colocado no "anel de matança".
Então
ctrl+u
apaga ectrl+y
puxa de volta o que foi apagado.Em uma linha limpa: Digite
00
apague-o e puxe-o novamente duas vezes para fazê-lo0000
.Repita para obter
00000000
(8 zeros), finalmente digite o comando e retroceda duas vezes.O primeiro conjunto (7 teclas são mantidas ctrlpressionadas):
O segundo conjunto (5 teclas)
Isso receberá oito zeros no anel de apagamento e digite o que você deseja:
para obter:
Depois de ter a idéia, você também pode digitar o que precisa, ir para o início da linha ( ctrl-Y), fazer o acima (até oito zeros) até o final ( ctrl-E) e puxar duas vezes.
São 15 chaves (além do próprio comando).
Não é curto, eu sei, mas isso funciona apenas com o que estava disponível.
Isso é um pouco mais curto:
São 11 chaves
fonte
F<n>
duplicar as últimas palavras<n>
.^[[19~
). Consulte"$(tput kf8)"
para obter as informações do banco de dados terminfo (ou do$terminfo
hash inzsh
).ctrl-v F8
Como uma variação da resposta de cas , digite
e use o mouse para copiar e colar (uma vez). Indiscutivelmente, esse é O (log n), mas como é (len (str (n)) + 20), você pode considerá-lo ineficiente. Mas observe:%.s
parece se comportar da mesma maneira que%.0s
.0000000000000000
como argumento, faça isso apenas uma vez.glenn jackman ressalta que (onde número é um número inteiro positivo) imprimirá uma sequência de números zeros (e uma nova linha), conforme o asterisco no formato diz para tirar a largura do campo dos argumentos. Especificamente, imprimirá 16 zeros. Mas este é um caso especial que lida apenas . será impressa e será impressa e uma mensagem de erro. Por outro lado, os outros comandos nesta resposta produzirão seqüências de caracteres como or (e veja abaixo para ).
printf "%0*d\n" number 0
printf
printf "%0*d" 16 0
0
printf "%0*d" 16 12345
0000000000012345
printf "%0*d" 16 foo
0000000000000000
123451234512345…
foofoofoo…
7%7%7%...
Se você fizer isso com frequência, poderá simplificá-lo definindo uma função shell:
Notas:
$(seq 1 "$2")
vez de(1.."$2"}
porque o último não funcionará - veja isto , isto , isto e isto . Observe que algumas das respostas para essas perguntas sugerem o usoeval
, mas isso geralmente não é recomendado.$1%.0s
) deve estar entre aspas duplas (em vez de aspas simples) porque contém um parâmetro ($1
).--
é para proteger contra$1
valores começando com-
."%.0s$1"
vez de"$1%.0s"
.$1
valor que contenha%
fará com que ele se engasgue.Se você precisar lidar com
$1
valores que contêm%
, façaAlém disso, depois de definir essa função, você pode fazer coisas como
que é um pouco menos digitado que
"$(printf '0%.0s' {1..16})"
.fonte
printf "%0*d" 16 0
, imprimirá 16 zeros. O asterisco no formato terá a largura do campo a partir dos argumentos