Como alterno os buffers rapidamente?

No Emacs baunilha, tenho que fazer C-x be digitar manualmente o nome do buffer para alternar. Se eu esquecer o nome do buffer, tenho que clicar TABpara listar as possíveis conclusões. Há algo que eu possa fazer para tornar esse processo mais rápido?

Existe o modo ido que deve ajudar.

EDITAR:

coloque isso no seu arquivo init, para ativar o modo ido por padrão:

(ido-mode 1)

Agora, C-x bmostrará uma lista de candidatos.

Coloque isso no seu arquivo init, se você preferir que os itens sejam exibidos verticalmente:

(setq ido-separator "\n")

Cortesia de ergoemacs

Deixe-me também sugerir este post falando sobre a mudança para o buffer anterior / seguinte.

Eu comecei recentemente a usar C-x <left>e C-x <right>. Essas são as ligações padrão do Emacs - nada para configurar. Esquerda leva você de volta ao buffer anterior (inicialmente o mesmo que C-x b RET), mas fazê-lo novamente leva ao terceiro buffer visitado mais recentemente. Se você está alternando bastante entre 3 ou 4 buffers, acho muito mais fácil do que tentar lembrar os nomes dos buffers.

Também acabei de descobrir C-x C-<left>e estou C-x C-<right>vinculado às mesmas funções para que você possa simplesmente manter pressionada a tecla Control e alternar entre x e as setas para alternar entre os buffers. Muito bom!

Você poderia usar o Helm .

Na minha configuração, mudei C-x bpara M-l. Isso aliado helm-buffers-listtorna o processo muito rápido, pelo menos para mim.

Apenas para adicionar ajustes que eu uso com o Ido já mencionado :

(require 'ido)
(require 'ido-hacks)
(require 'flx-ido)
(require 'ido-vertical-mode)

(ido-mode 1)
(flx-ido-mode 1)
(ido-hacks-mode 1)
(ido-everywhere 1)
(ido-vertical-mode 1)

(setq ido-enable-flex-matching t
      ido-use-filename-at-point 'guess
      ido-vertical-define-keys 'C-n-C-p-up-down-left-right))

Também estou usando ace-windowpara alternar entre buffers e ace-jump-modepara pular entre janelas visíveis. Vem com alguns se acostumando, mas vale a pena tentar.

Eu o combinei com key-chord-modee pulei sopara o salto rápido:

(key-chord-define-global "so" 'ace-window)

Todos os pacotes mencionados acima estão disponíveis através do gerenciador de pacotes da Melpa.

Como @kuanyui diz em um comentário, next-buffere previous-buffersão muito rápidos, se você tiver apenas alguns buffers para circular entre. (Para mais de alguns e para mais recursos de seleção de buffer, eu uso icicle-buffer.)

No entanto, por padrão, next-buffere previous-bufferestão em uma chave de prefixoC-x ,.

Isso significa que eles não são repetíveis : você não pode simplesmente bater C-x <right> <right> <right>.... Em vez disso, você deve vincular esses comandos a chaves diferentes e repetíveis, ou deve usar C-x <right> C-x <right> C-x <right>..., o que não é muito rápido.

Para versões repetíveis desses comandos, carregue a biblioteca misc-cmds.ele remapeie as versões irrepetíveis e vanilla, para as repetíveis definidas lá:

(global-set-key [remap previous-buffer] 'previous-buffer-repeat)
(global-set-key [remap next-buffer]     'next-buffer-repeat)

(Da mesma forma, na mesma biblioteca, você encontrará uma versão undorepetível mesmo quando estiver em uma tecla de prefixo:. undo-repeat)

BTW, você pode tornar praticamente qualquer comando repetível (mesmo em uma tecla de prefixo), usando a função repeat-command(from misc-cmds.el). Isso é tudo o que foi necessário para definir a versão repetível de next-buffer:

(defun previous-buffer-repeat ()
  "Switch to the previous buffer in the selected window.
You can repeat this by hitting the last key again..."
  (interactive)
  (require 'repeat nil t) ; Library `repeat.el' is in Emacs 22.1 and later
  (repeat-command 'next-buffer))

Estou surpreso que ninguém iswitchbtenha mencionado ainda. Pode não ser tão poderoso quanto ido, mas muito antes do ido-modenascimento iswitchb-modejá era padrão para o emacs, e ainda é útil hoje em dia. Para tentar basta colocar

(iswitchb-mode 1)

no seu .emacs ou ativar via M-x iswitchb-mode.

Use helm-buffer-list ou helm-mini para selecionar visualmente a entrada do buffer e a correspondência difusa. Pode fazer muitas coisas fora dos buffers de comutação. Você deve ver a demonstração no link.

Outros discutiram pacotes úteis para facilitar a vida com relação à troca de buffer / janela / quadro. (Eu pessoalmente uso o helmque é fenomenal.) Quero discutir mudanças mais simples que podem tornar a experiência do Emacs mais agradável.

Para mim, a solução para meus problemas de buffer / quadro (porque acho que C-x oé o pior) não era um pacote; era simplesmente:

• mapeando C-;para other-window(alternando entre janelas)
• mapeamento C-'para other-frame(alternando entre quadros). Na verdade, comecei a usar quadros muito mais depois de adicionar este atalho).
• mapeando outras combinações fáceis de teclas de pressionamento de tecla simples para funções personalizadas personalizadas para manipular buffers no quadro visível. Os exemplos incluem: jogar um buffer para outra janela (em uma configuração de 2 janelas), alternar entre o buffer atual e o último buffer em uma determinada janela, enterrando o outro buffer (esse é ótimo para substituir a helpjanela que aparece) (ao ler páginas de manual, propósitos, etc) com qualquer janela anteriormente visível).

Também pensei em compartilhar algumas idéias sobre combinações de teclas que os novatos podem achar úteis. (Desculpe se este é o lugar errado.) Não tenho sugestões específicas, mas uma "filosofia" que me permite manter um conjunto eficaz de combinações de teclas para mim.

1. Comandos usados ​​com pouca freqüência não merecem fácil combinação de teclas.

   • Faça o download keyfreq.ele veja o que você realmente usa muito. Uso um método de sobrevivência do mais apto para decidir quais comandos recebem os imóveis mais valiosos do meu teclado.
   • Não tenha medo de se livrar das combinações de teclas padrão do Emacs, algumas das quais são simplesmente absurdas. C-\é um grande atalho (pelas razões discutidas em # 2) ... e seria um crime deixá-la mapeado para seu comando padrão: change-input-method. (Talvez alguns de vocês usem muito, eu certamente não.)

2. Os seguintes fatores determinam a facilidade e a velocidade de um atalho de teclado (começando pelo mais importante):

   • Continuamente pressionando a tecla modificador (seja ela qual for, Ctrl, Meta, etc.). Por exemplo, é muito mais rápido para eu acertar C-c C-l C-pdo que acertar C-x o. Pessoalmente, acho muito inconveniente ter que tirar a Ctrltecla entre os pressionamentos sucessivos de uma determinada sequência de teclas; é muito mais fácil continuar pressionando o botão modificador (neste caso Ctrl). (Este exemplo específico pode ser influenciado pelo fato de eu ter remapeado minha Ctrlchave e minha Caps-Lockchave.)
   • Alternância no seu amigo . É muito mais rápido para eu acertar C-c C-l C-pdo que acertar C-p C-' C-;. (Tente e deve ser óbvio.) De um modo geral, é muito mais fácil usar sequências de pressionamento de tecla que usam mãos alternadas (ou, pelo menos, dedos alternados na mesma mão).
   • Grau de partida da posição padrão da mão. Isso não se aplica aos entusiastas de caçar e beijar por aí. Porém, para o resto de nós, nossos atalhos de teclado usados ​​com mais frequência devem permitir que retornemos à nossa posição de digitação por toque de maneira rápida e fácil.

Apenas alguns pensamentos que pensei que poderiam ser úteis para iniciantes. Eu posso adicionar um pouco mais tarde.

Eu uso windmove.ele bs.elpara alternar buffers rapidamente. Ambos os modos estão incluídos no Emacs.

• windmove.el- muda para uma janela (um buffer que é exibido no momento) em uma direção especificada, por exemplo, esquerda, direita, cima, baixo.

• bs.el- Eu uso bs-cycle-nexte bs-cycle-previouspara alternar para o próximo buffer que atualmente não é mostrado em uma janela.

Você pode configurar windmove com (windmove-default-keybindings)que irá ligar os comandos apropriados para Shift-Left Arrow, Shift-Right Arrow, etc.

Para configurar bs.el, algo como isto funcionará:

 (global-set-key [(f9)]   'bs-cycle-previous)
 (global-set-key [(f10)]  'bs-cycle-next)

A maneira mais rápida de alternar buffers que eu conheço é com ace-jump-buffer. Um toque de tecla abre o menu do buffer e, em seguida, selecione a letra ao lado do buffer que você deseja ace-jump-line-mode. Isso funciona melhor para os 26 ou mais buffers mais recentes. Para alternar para buffers mais antigos no seu histórico de uso, ido-switch-bufferé sempre uma boa escolha.

Eu prefiro a navegação na guia no estilo do navegador. Liguei Ctrl + Tab e Ctrl + Shift + Tab aos buffers seguintes e anteriores, respectivamente:

(global-set-key [C-tab] 'next-buffer)
(global-set-key [C-S-tab] 'previous-buffer)

Em termos gerais, existem duas maneiras de alternar buffers e a maioria das soluções se enquadra em uma delas.

1. Usando o mini buffer

É o que C-x bfaz por padrão. O Ido oferece uma boa conclusão automática, para que você não precise tanto TAB TAB TAB. Projetos como leme, projétil etc tornam mais fácil, dando a você a capacidade de trabalhar com arquivos em um projeto etc, e junto com o ido, eles podem ser bastante úteis.

2. Um buffer inteiro com todos os itens listados.

Isso é útil quando você tem tantos buffers e deseja uma lista de todos eles. Você pode subir e descer o buffer e pressionar enter para visitar um arquivo específico. Ibuffer é muito bom para isso.

Eu uso os dois e é assim que você pode configurá-lo.

 (global-set-key (kbd "C-x C-b") 'ido-switch-buffer)
 (global-set-key (kbd "C-x b") 'ibuffer)`

Além de ido, eu tenho a seguinte configuração.

1. No caso de modo maligno, use as seguintes combinações de teclas para alternar os buffers

   (define-key evil-normal-state-map (kbd "C-j") 'next-buffer)
   (define-key evil-normal-state-map (kbd "C-k") 'previous-buffer)
   (define-key evil-normal-state-map (kbd "C-S-h") 'evil-window-left)
   (define-key evil-normal-state-map (kbd "C-S-j") 'evil-window-down)
   (define-key evil-normal-state-map (kbd "C-S-k") 'evil-window-up)
   (define-key evil-normal-state-map (kbd "C-S-l") 'evil-window-right)
   

2. Defina o nome do buffer como título da janela. Isso ajudará você a navegar com as combinações de teclas acima

   (setq frame-title-format "%b")
   

3. Se você estiver usando o modo maligno, poderá tentar evil-leader. Vincule as chaves usadas com frequência ao líder. Por exemplo, você pode vincular C-x ba <leader>-b.

   (global-evil-leader-mode)
   (evil-leader/set-leader ",")
   (evil-leader/set-key
    "b" 'switch-to-buffer)
   

4. Vincule o modo direcionado para C-<f8>. Agora, quando desejar abrir um arquivo no diretório, pressione C-<f8>, navegue até o nome do arquivo e pressione em avez de RET. O buffer direcionado será eliminado imediatamente.

   (global-set-key (kbd "C-<f8>")
           (lambda ()
             (interactive)
             (dired default-directory)))
   (put 'dired-find-alternate-file 'disabled nil)
   

5. Use o recentfmodo para navegar pelos arquivos recentes.C-x C-r

6. Um último ponto importante é - use o teclado mecânico ergonômico. Assim, você pode pressionar a tecla 'ctrl' com facilidade e rapidez com o pulso, em vez de machucar o dedo mindinho.

Espero que isso possa ajudar alguém.

Como você pode ver nas outras respostas, existem várias maneiras de otimizar essa tarefa específica. Eu pessoalmente uso o Lusty Emacs como meu equipamento de comutação de buffer, pois ele lida com a conclusão difusa muito bem. Isso minimiza o número de pressionamentos de tecla necessários para selecionar o novo buffer, por exemplo, eu preciso apenas digitar oxr para alternar para ox-revelou.el , ou mesmo apenas na segunda vez em que ele também controla o histórico dos switches.

Se você quiser apenas continuar escovando seus buffers, adicione isso ao seu arquivo init:

(bind-key* "M-l" 'next-buffer)
(bind-key* "M-k" 'previous-buffer)

Você precisa do pacote de chaves de ligação e pode alterar as ligações de acordo com seu desejo, mas eu achei essas ligações de teclas mais confortáveis. Antes de adicionar esse snippet, você precisa exigir a chave de ligação,

(require 'bind-key)

Eu uso C-Tab e CS-Tab como aplicativos gerais.

(defun change-buffer-until-normal (change-fn)
  (let (current (buffer-name))
    (funcall change-fn)
    (while (and (string-prefix-p "*" (buffer-name))
        (not (eq current (buffer-name))))
      (funcall change-fn))))

(defun my-next-buffer ()
  (interactive)
  (change-buffer-until-normal 'next-buffer))

(defun my-prev-buffer ()
  (interactive)
  (change-buffer-until-normal 'previous-buffer))

(global-set-key [C-tab] 'my-next-buffer)
(global-set-key [C-S-iso-lefttab] 'my-prev-buffer)

Essa não é uma solução muito elegante (pois usa macros em vez de funções) e não responde como pular rapidamente para qualquer buffer, mas apenas como pular para buffers usados ​​recentemente. Mas funciona muito bem para mim:

Eu tenho uma série de macros usando ido-switch-bufferpara pular para o buffer anterior, o buffer antes disso, o buffer antes disso, etc. E vinculei essas macros às combinações de teclas que considero convenientes.

Para pular para o último buffer:

(fset 'my-goto-previous-buffer
      [?\C-x ?b return])

Para pular para o penúltimo buffer:

(fset 'my-goto-previous-buffer
      [?\C-x ?b ?\C-n return])

Para pular para o buffer antepenúltimo:

(fset 'my-goto-previous-buffer
      [?\C-x ?b ?\C-n ?\C-n return])

Etc. (você pode anunciar quantos ?\C-nquiser voltar até o histórico de buffers visitados).

Há uma função interna para ir para o buffer anterior, mas a vantagem de usar macros ido-switch-bufferé que você pode personalizar a variável ido-ignore-bufferspara remover buffers especiais como *Messages*ou *scratch*qualquer outro buffer indesejado da lista. Dessa forma, os únicos buffers para os quais você pula são os que realmente estão interessados ​​em pular.

Na minha VM, Cx ALT-RIGHT / LEFT está muito lento. Eu tenho que esperar o Cx se registrar na barra de status antes de poder fazer qualquer outra coisa. além de suas chaves demais. Então, mapeei C-TAB e CM-TAB para o buffer anterior e anterior, pois é o que faço na maioria dos programas do Windows. É fácil de fazer no emacs: M-xleva você à barra de status. Em seguida, digite o global-set-keyque solicitará a sequência de teclas que você deseja ligar ( C-TAB) e, em seguida, o comando ao qual deseja ligá-lo ( next-buffer). É isso aí!