¿Cómo cambio los buffers rápidamente?

En Vanilla Emacs, tengo que hacer C-x by luego escribir manualmente el nombre del búfer para cambiar. Si olvido el nombre del búfer, tengo que presionar TABpara enumerar las posibles terminaciones. ¿Hay algo que pueda hacer para acelerar este proceso?

Hay modo ido que debería ayudar.

EDITAR:

pon esto en tu archivo init, para activar el modo ido por defecto:

(ido-mode 1)

Ahora, C-x ble mostraremos una lista de candidatos.

Ponga esto en su archivo de inicio, si prefiere que los elementos se muestren verticalmente:

(setq ido-separator "\n")

Cortesía de ergoemacs.

Permítanme sugerir también esta publicación hablando sobre cambiar al búfer anterior / siguiente.

Recientemente comencé a usar C-x <left>y C-x <right>. Ambos son enlaces estándar de Emacs, nada que configurar. Izquierda lo lleva de regreso al búfer anterior (inicialmente igual que C-x b RET) pero al hacerlo nuevamente lo lleva al tercer búfer visitado más recientemente. Si está apareciendo mucho entre 3 o 4 buffers, me resulta mucho más fácil que tratar de recordar los nombres de los buffers.

También acabo de descubrir C-x C-<left>y estoy C-x C-<right>obligado a las mismas funciones para que pueda mantener presionada la tecla de control y alternar entre xy las flechas para hojear los buffers. ¡Bastante agradable!

Podrías usar Helm .

En mi configuración, he cambiado C-x bpor M-l. Esto aliado helm-buffers-listhace que el proceso sea bastante rápido, al menos para mí.

Solo para agregar ajustes que uso con Ido ya 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))

También estoy usando ace-windowpara cambiar entre buffers junto con ace-jump-modepara saltar entre ventanas visibles. Viene con algo de acostumbrarse pero vale la pena intentarlo.

Lo combiné key-chord-modey golpeé sopara un salto rápido:

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

Todos los paquetes mencionados anteriormente están disponibles a través del administrador de paquetes de Melpa.

Como @kuanyui dice en un comentario, next-buffery previous-bufferson muy rápidos, si solo tiene unos pocos buffers para alternar. (Para más de unos pocos, y para más características de elección de búfer, uso icicle-buffer).

Sin embargo, de forma predeterminada, next-buffery previous-bufferestán en una tecla prefijo,C-x .

Eso significa que no son repetibles : no puedes simplemente golpear C-x <right> <right> <right>.... En su lugar, debe vincular estos comandos a teclas diferentes y repetibles, o debe usar C-x <right> C-x <right> C-x <right>..., lo que no es muy rápido.

Para las versiones repetibles de estos comandos, cargue la biblioteca misc-cmds.ely vuelva a correlacionar las versiones vainilla irrepetibles a las repetibles definidas allí:

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

(Del mismo modo, en la misma biblioteca encontrará una versión undoque se puede repetir incluso cuando se utiliza una tecla de prefijo:. undo-repeat)

Por cierto, puede hacer que casi cualquier comando sea repetible (incluso en una tecla de prefijo), utilizando la función repeat-command(from misc-cmds.el). Esto es todo lo que se necesitaba para definir la versión repetible 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))

Me sorprende que nadie lo haya mencionado iswitchbtodavía. Puede que no sea tan poderoso como ido, pero mucho antes de que ido-modenaciera iswitchb-modeya era estándar para emacs, y todavía es útil hoy en día. Para probarlo solo pon

(iswitchb-mode 1)

en sus .emacs o actívelos mediante M-x iswitchb-mode.

Use helm-buffer-list o helm-mini para seleccionar visualmente la entrada del búfer y la coincidencia difusa. Puede hacer muchas cosas fuera del cambio de buffers. Debería ver la demostración en el enlace.

Otros han discutido paquetes que son útiles para facilitar la vida con respecto al cambio de búfer / ventana / marco. (Yo personalmente uso lo helmque es fenomenal). Quiero discutir cambios más simples que pueden hacer que la experiencia de Emacs sea más agradable.

Para mí, la solución a mis problemas de buffer / frame (porque creo que C-x oes lo peor) no era un paquete; fue simplemente:

• mapeo C-;a other-window(ciclismo a través de ventanas)
• mapeo C-'a other-frame(ciclismo a través de cuadros). De hecho, comencé a usar marcos mucho más después de agregar este acceso directo).
• mapear otras combinaciones de teclas simples con una sola pulsación de tecla a funciones simples y personalizadas para manipular buffers en el marco visible. Los ejemplos incluyen: lanzar un búfer a la otra ventana (en una configuración de 2 ventanas), alternar entre el búfer actual y el último búfer en una ventana determinada, enterrar el otro búfer (este es ideal para reemplazar la helpventana que aparece (al leer páginas de manual, a propósito, etc.) con cualquier ventana que fuera visible anteriormente).

También pensé en compartir algunas ideas sobre las combinaciones de teclas que los novatos podrían encontrar útiles. (Lo siento si este es el lugar equivocado). No tengo sugerencias específicas, sino una "filosofía" que me permite mantener un conjunto efectivo de combinaciones de teclas.

1. Los comandos utilizados con poca frecuencia no merecen una combinación de teclas fácil.

   • Descargue keyfreq.ely vea lo que realmente usa mucho. Utilizo un método de supervivencia del más apto para decidir qué comandos reciben los bienes inmuebles más valiosos en mi teclado.
   • No tenga miedo de deshacerse de las combinaciones de teclas predeterminadas de Emacs, algunas de las cuales son simplemente absurdas. C-\es un gran atajo (por las razones expuestas en el # 2) ... y sería un crimen dejarlo asigna a su comando por defecto: change-input-method. (Tal vez algunos de ustedes lo usan mucho, ciertamente yo no).

2. Los siguientes factores determinan la facilidad y la velocidad de un atajo de teclado (comenzando por el más importante):

   • Continuamente presionando la tecla de modificación (sea la que sea, Ctrl, Meta, etc.). Por ejemplo, es mucho más rápido para mí golpear C-c C-l C-pque golpear C-x o. Personalmente, me parece muy inconveniente tener que levantar la Ctrltecla entre pulsaciones sucesivas de una secuencia de teclas determinada; es mucho más fácil seguir presionando el botón modificador (en este caso Ctrl). (Este ejemplo específico podría estar influenciado por el hecho de que he reasignado mi Ctrlclave y mi Caps-Lockclave).
   • Alternancia en tu amigo . Es mucho más rápido para mí golpear C-c C-l C-pque golpear C-p C-' C-;. (Pruébelo y debería ser obvio.) En términos generales, es mucho más fácil usar secuencias de teclas que usan manos alternas (o, al menos, dedos alternas en la misma mano).
   • Grado de desviación de la posición estándar de la mano. Esto no se aplica a los entusiastas de la caza y el picoteo. Pero para el resto de nosotros, nuestros métodos abreviados de teclado más utilizados deberían permitirnos volver a nuestra posición estándar de escritura táctil de forma rápida y sencilla.

Solo un par de pensamientos que pensé que podrían ser útiles para los novatos. Puedo agregar algo más más tarde.

Utilizo windmove.ely bs.elpara cambiar de búfer rápidamente. Ambos modos están incluidos con Emacs.

• windmove.el- cambia a una ventana (un búfer que se muestra actualmente) en una dirección específica, por ejemplo, izquierda, derecha, arriba, abajo.

• bs.el- Uso bs-cycle-nexty bs-cycle-previouspara cambiar al siguiente búfer que no se muestra actualmente en una ventana.

Puede windmove configuración con (windmove-default-keybindings)la cual se unirá a los comandos apropiados Shift-Left Arrow, Shift-Right Arrowetc.

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

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

La forma más rápida de cambiar buffers que conozco es con ace-jump-buffer. Una pulsación de tecla abre el menú del búfer y luego selecciona la letra junto al búfer que deseas ace-jump-line-mode. Esto funciona mejor para los 26 buffers más recientes. Para cambiar a buffers más atrás en su historial de uso, ido-switch-buffersiempre es una buena opción.

Prefiero la navegación con pestañas estilo navegador. He vinculado Ctrl + Tab y Ctrl + Shift + Tab al búfer siguiente y anterior respectivamente:

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

En términos generales, hay 2 formas de cambiar los buffers y la mayoría de las soluciones se incluirán en una de ellas.

1. Usando el mini buffer

Esto es lo que C-x bhace por defecto. Ido le brinda una buena finalización automática para que no necesite TAB TAB TAB tanto. Proyectos como timón, proyectil, etc., lo hacen más fácil al darle habilidades para trabajar con archivos en un proyecto, etc., y junto con ido, pueden ser bastante útiles.

2. Un búfer completo con todos los elementos enumerados.

Esto es útil cuando tiene tantos buffers y desea una lista de todos ellos. Puede subir y bajar el búfer y presionar enter para visitar un archivo en particular. Ibuffer es bastante bueno para eso.

Yo uso ambos y así es como puedes configurarlo.

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

Además de ido, tengo la siguiente configuración.

1. En el caso del modo malvado, use las siguientes combinaciones de teclas para cambiar los 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. Establecer el nombre del búfer como título de la ventana. Esto lo ayudará cuando navegue con las combinaciones de teclas anteriores

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

3. Si está utilizando el modo malvado, puede intentarlo evil-leader. Ate las llaves de uso frecuente al líder. Por ejemplo, puede unirse C-x ba <leader>-b.

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

4. Vincular el modo directo a C-<f8>. Ahora, cuando desee abrir el archivo en el directorio, presione C-<f8>, navegue hasta el nombre del archivo y presione en alugar de RET. Por lo tanto, el amortiguador directo se eliminará inmediatamente.

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

5. Use el recentfmodo para navegar por los archivos recientes.C-x C-r

6. Un último punto importante es: use un teclado mecánico ergonómico. Por lo tanto, puede presionar la tecla 'Ctrl' fácil y rápidamente con la muñeca en lugar de dañar el meñique.

Espero que esto pueda ayudar a alguien.

Como puede ver en las otras respuestas, hay muchas maneras de simplificar esta tarea en particular. Personalmente uso Lusty Emacs como mi aparato de conmutación de búfer, ya que maneja bastante bien la finalización difusa. Esto minimiza el número de pulsaciones de teclas necesarias para seleccionar el nuevo búfer, por ejemplo, solo necesito escribir oxr para cambiar a ox-revelar.el , o incluso solo la segunda vez, ya que también rastrea el historial de interruptores.

Si desea seguir pasando sus buffers, agregue esto a su archivo init:

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

Necesita el paquete de teclas de enlace y puede cambiar las combinaciones de teclas a su gusto, pero encontré que estas combinaciones de teclas son las más cómodas. Antes de agregar este fragmento, debe requerir la clave de enlace,

(require 'bind-key)

Utilizo C-Tab y CS-Tab como aplicaciones generales.

(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)

Esta no es una solución muy elegante (ya que usa macros en lugar de funciones) y no responde cómo saltar a cualquier búfer rápidamente, sino solo cómo saltar a los búferes usados ​​recientemente. Pero me funciona muy bien:

Tengo una serie de macros que usan ido-switch-bufferpara saltar al búfer anterior, el búfer anterior, el búfer anterior, etc. Y vinculé esas macros a las combinaciones de teclas que considero convenientes.

Para saltar al último búfer:

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

Para saltar al penúltimo buffer:

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

Para saltar al búfer antepenúltimo:

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

Etc. (puede agregar tantos anuncios como ?\C-ndesee ir tan atrás en el historial de buffers visitados como desee).

Hay una función incorporada para saltar al búfer anterior, pero la ventaja de usar macros ido-switch-bufferes que puede personalizar la variable ido-ignore-bufferspara eliminar búferes especiales como *Messages*o *scratch*y cualquier otro búfer no deseado de la lista. De esa manera, los únicos amortiguadores a los que saltas son aquellos a los que realmente estás interesado en saltar.

En mi VM, Cx ALT-RIGHT / LEFT es demasiado lento. Tengo que esperar a que Cx se registre en la barra de estado antes de poder hacer otra cosa. Además, son demasiadas teclas. Así que asigné C-TAB y CM-TAB al búfer siguiente y anterior, ya que eso es lo que hago en la mayoría de los programas de Windows de todos modos. Es fácil de hacer desde emacs: M-xte lleva a la barra de estado. Luego escriba global-set-keyque le pedirá la secuencia de teclas que desea vincular ( C-TAB) y luego el comando al que desea vincular ( next-buffer). ¡Eso es!