Come cambio rapidamente i buffer?

In Emacs alla vaniglia, devo fare C-x be quindi digitare manualmente il nome del buffer per passare. Se dimentico il nome del buffer, devo premere TABper elencare i possibili completamenti. C'è qualcosa che posso fare per rendere questo processo più veloce?

C'è una modalità ido che dovrebbe aiutare.

MODIFICARE:

inseriscilo nel tuo file init, per attivare la modalità ido di default:

(ido-mode 1)

Ora, C-x bti mostrerò un elenco di candidati.

Inseriscilo nel tuo file init, se preferisci che gli elementi vengano visualizzati in verticale:

(setq ido-separator "\n")

Per gentile concessione di ergoemacs

Vorrei anche suggerire questo post parlando di passare al buffer precedente / successivo.

Di recente ho iniziato a utilizzare C-x <left>e C-x <right>. Questi sono entrambi attacchi Emacs standard, niente da configurare. Sinistra ti riporta al buffer precedente (inizialmente uguale a C-x b RET) ma eseguendolo di nuovo ti porta al terzo buffer visitato più di recente. Se stai saltando avanti e indietro tra 3 o 4 buffer, allora lo trovo molto più facile che cercare di ricordare i nomi dei buffer.

Inoltre ho appena scoperto C-x C-<left>e C-x C-<right>sono legato alle stesse funzioni in modo da poter semplicemente tenere premuto il tasto di controllo e alternare tra x e le frecce per sfogliare i buffer. Molto carino!

Potresti usare Helm .

Nel mio setup, ho acceso C-x bper M-l. Questo alleato helm-buffers-listrende il processo piuttosto veloce, almeno per me.

Solo per aggiungere modifiche che uso con Ido già menzionato :

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

Sto anche usando ace-windowper passare da un buffer all'altro ace-jump-modeper saltare tra le finestre visibili. Viene fornito con alcuni abituarsi ma vale la pena provare.

L'ho combinato con key-chord-modee colpito soper il salto veloce:

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

Tutti i pacchetti sopra menzionati sono disponibili tramite il gestore pacchetti di Melpa.

Come dice @kuanyui in un commento, next-buffere previous-buffersei molto veloce, se hai solo alcuni buffer tra cui scorrere. (Per più di alcuni, e per più funzionalità di scelta del buffer, io uso icicle-buffer.)

Tuttavia, per impostazione predefinita, next-buffere previous-buffersono su una chiave prefisso,C-x .

Ciò significa che non sono ripetibili : non puoi semplicemente colpire C-x <right> <right> <right>.... È necessario invece associare questi comandi a tasti diversi e ripetibili oppure è necessario utilizzare C-x <right> C-x <right> C-x <right>..., il che non è molto rapido.

Per le versioni ripetibili di questi comandi, caricare la libreria misc-cmds.ele rimappare le versioni vanilla e non ripetibili a quelle ripetibili qui definite:

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

(Allo stesso modo, nella stessa libreria troverai una versione undoche è ripetibile anche quando su una chiave prefisso:. undo-repeat)

A proposito, puoi rendere praticamente qualsiasi comando ripetibile (anche su un tasto prefisso), usando la funzione repeat-command(da misc-cmds.el). Questo è tutto ciò che era necessario per definire la versione ripetibile di 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))

Sono sorpreso che nessuno abbia iswitchbancora menzionato . Potrebbe non essere così potente ido, ma molto prima che ido-modenascesse iswitchb-modeera già standard per emacs, ed è ancora utile al giorno d'oggi. Per provarlo basta mettere

(iswitchb-mode 1)

nel tuo .emacs o attivare tramite M-x iswitchb-mode.

Utilizzare helm-buffer-list o helm-mini per selezionare visivamente la voce buffer e la corrispondenza fuzzy. Può fare molte cose al di fuori dello scambio dei buffer. Dovresti vedere la demo nel link.

Altri hanno discusso di pacchetti che sono utili per semplificare la vita per quanto riguarda la commutazione buffer / finestra / frame. (Personalmente uso ciò helmche è fenomenale.) Voglio discutere dei cambiamenti più semplici che possono rendere l'esperienza Emacs più piacevole.

Per me, la soluzione ai miei problemi di buffer / frame (perché penso C-x osia la peggiore) non era un pacchetto; era semplicemente:

• mappatura C-;su other-window(scorrere le finestre)
• mappatura C-'su other-frame(scorrere i fotogrammi). In realtà ho iniziato a usare i frame molto di più dopo aver aggiunto questo collegamento).
• associando altre semplici combinazioni di tasti con una singola pressione di tasti a funzioni semplici e personalizzate per manipolare i buffer nel frame visibile. Gli esempi includono: lanciare un buffer nell'altra finestra (in una configurazione a 2 finestre), alternare tra il buffer corrente e l'ultimo buffer in una determinata finestra, seppellire l'altro buffer (questo è ottimo per sostituire la helpfinestra che si apre) (durante la lettura di pagine man, a proposito, ecc.) con qualsiasi finestra precedentemente visibile).

Ho anche pensato di condividere alcuni pensieri sui vincoli chiave che i neofiti potrebbero trovare utili. (Scusate se questo è il posto sbagliato.) Non ho suggerimenti specifici ma, piuttosto, una "filosofia" che mi consente di mantenere un insieme efficace di combinazioni di tasti per me stesso.

1. I comandi usati non di rado non meritano facili combinazioni di tasti.

   • Scarica keyfreq.ele vedi cosa usi davvero molto. Uso un metodo di sopravvivenza del più adatto per decidere quali comandi ricevono il bene immobile più prezioso sulla mia tastiera.
   • Non aver paura di sbarazzarti delle combinazioni di tasti predefinite di Emacs, alcune delle quali sono semplicemente assurde. C-\è una grande scelta rapida (per le ragioni discusse a # 2) ... e sarebbe un delitto lasciarlo mappato al suo comando predefinito: change-input-method. (Forse alcuni di voi lo usano molto, io sicuramente no.)

2. I seguenti fattori determinano la facilità e la velocità di una scorciatoia da tastiera (a partire dalla più importante):

   • Premendo continuamente il tasto di modifica (qualunque esso sia, Ctrl, Meta, etc.). Ad esempio, è molto più veloce per me colpire C-c C-l C-pche colpire C-x o. Personalmente trovo molto scomodo dover sollevare la Ctrlchiave tra sequenze di tasti successive di una determinata sequenza di tasti; è molto più semplice continuare a premere il pulsante modificatore (in questo caso Ctrl). (Questo esempio specifico potrebbe essere influenzato dal fatto che ho rimappato la mia Ctrlchiave e la mia Caps-Lockchiave.)
   • Alternanza nel tuo amico . È molto più veloce per me colpire C-c C-l C-pche colpire C-p C-' C-;. (Provalo e dovrebbe essere ovvio.) In generale, è molto più facile usare sequenze di tasti che usano mani alternate (o almeno dita alternate sulla stessa mano).
   • Grado di partenza dalla posizione standard della mano. Questo non si applica agli appassionati di caccia e beccata là fuori. Ma per il resto di noi, le nostre scorciatoie da tastiera utilizzate più frequentemente dovrebbero consentirci di tornare alla nostra posizione standard di digitazione tattile in modo rapido e semplice.

Solo un paio di pensieri che pensavo potessero essere utili ai neofiti. Potrei aggiungerne un po 'più tardi.

Uso windmove.ele bs.elper passare rapidamente i buffer. Entrambe le modalità sono incluse in Emacs.

• windmove.el- passa a una finestra (un buffer attualmente visualizzato) in una direzione specificata, ad esempio sinistra, destra, su, giù.

• bs.el- Uso bs-cycle-nexte bs-cycle-previousper passare al buffer successivo che non è attualmente mostrato in una finestra.

È possibile impostare windmove con (windmove-default-keybindings)cui si legano i comandi appropriati per Shift-Left Arrow, Shift-Right Arrowecc

Per l'installazione bs.el, qualcosa del genere funzionerà:

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

Il modo più veloce per cambiare buffer di cui sono a conoscenza è con ace-jump-buffer. Un tasto premuto apre il menu del buffer e quindi seleziona la lettera accanto al buffer desiderato ace-jump-line-mode. Funziona meglio con i 26 buffer più recenti. Per passare ai buffer più indietro nella cronologia di utilizzo, ido-switch-bufferè sempre una buona scelta.

Preferisco la navigazione con schede in stile browser. Ho associato Ctrl + Tab e Ctrl + Maiusc + Tab rispettivamente ai buffer successivi e precedenti:

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

A grandi linee, ci sono 2 modi per cambiare buffer e la maggior parte delle soluzioni rientrerà in una di queste.

1. Utilizzando il mini buffer

Questo è ciò che C-x bfa per impostazione predefinita. Ido ti dà un bel completamento automatico in modo che non sia necessario TAB TAB TAB così tanto. Progetti come helm, proiettile ecc rendono più semplice dandoti la capacità di lavorare con i file in un progetto ecc. E, insieme a ido, possono essere piuttosto utili.

2. Un intero buffer con tutti gli elementi elencati.

Questo è utile quando si hanno così tanti buffer e si desidera un elenco di tutti. Puoi andare su e giù nel buffer e premere Invio per visitare un determinato file. Ibuffer è abbastanza buono per questo.

Uso entrambi ed è così che puoi configurarlo.

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

Oltre a ido, ho la seguente configurazione.

1. In caso di modalità malvagia, utilizzare le seguenti combinazioni di tasti per cambiare buffer

   (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. Imposta il nome del buffer come titolo della finestra. Questo ti aiuterà durante la navigazione con i tasti sopra indicati

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

3. Se stai usando la modalità malvagia, puoi provare evil-leader. Associa le chiavi usate di frequente al leader. Ad esempio è possibile associare C-x ba <leader>-b.

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

4. Associa la modalità diretta a C-<f8>. Ora quando vuoi aprire il file nella directory, premi C-<f8>, vai al nome del file e premi ainvece di RET. Quindi il buffer diretto verrà ucciso immediatamente.

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

5. Utilizzare la recentfmodalità per navigare tra i file recenti.C-x C-r

6. Un ultimo punto importante è: utilizzare la tastiera meccanica ergonomica. Quindi puoi premere il tasto 'ctrl' facilmente e rapidamente con il polso invece di ferire il mignolo.

Spero che questo possa aiutare qualcuno.

Come puoi vedere dalle altre risposte, ci sono molti modi per semplificare questa particolare attività. Personalmente uso Lusty Emacs come dispositivo di commutazione del buffer poiché gestisce il completamento fuzzy abbastanza bene. Ciò riduce al minimo il numero di tasti premuti per selezionare il nuovo buffer, ad esempio ho solo bisogno di digitare oxr per passare a ox-rivelare.el , o anche solo la seconda volta, poiché tiene traccia anche della cronologia degli switch.

Se vuoi continuare a sfogliare i tuoi buffer, aggiungi questo al tuo file init:

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

Hai bisogno del pacchetto bind-key e puoi cambiare le combinazioni di tasti secondo i tuoi desideri, ma ho trovato che queste combinazioni di tasti sono le più comode. Prima di aggiungere questo snippet, devi richiedere il bind-key da,

(require 'bind-key)

Uso C-Tab e CS-Tab come applicazioni generali.

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

Questa non è una soluzione molto elegante (poiché utilizza le macro anziché le funzioni) e non risponde come saltare rapidamente a un buffer, ma solo come saltare ai buffer utilizzati di recente. Ma funziona molto bene per me:

Ho una serie di macro che usano ido-switch-bufferper passare al buffer precedente, al buffer prima di quello, al buffer prima di quello, ecc. E ho associato quelle macro a combinazioni di tasti che trovo convenienti.

Per saltare all'ultimo buffer:

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

Per saltare al penultimo buffer:

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

Per saltare al buffer antepenultimate:

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

Ecc. (Puoi pubblicizzare quanti ?\C-nne vuoi andare indietro nella storia dei buffer visitati che vuoi).

Esiste una funzione integrata per passare al buffer precedente, ma il vantaggio dell'uso di macro ido-switch-bufferè che è possibile personalizzare la variabile ido-ignore-buffersper rimuovere buffer speciali come *Messages*o *scratch*e qualsiasi altro buffer indesiderato dall'elenco. In questo modo, gli unici buffer a cui salti sono quelli a cui sei veramente interessato a saltare.

Sulla mia macchina virtuale, Cx ALT-DESTRA / SINISTRA è troppo lento. Devo aspettare che Cx si registri nella barra di stato prima di poter fare qualsiasi altra cosa. inoltre sono troppi tasti. Quindi ho mappato C-TAB e CM-TAB sul buffer successivo e precedente, come è comunque quello che faccio nella maggior parte dei programmi Windows. È facile da fare all'interno di emacs: M-xti porta alla barra di stato. Quindi digitare global-set-keyquale ti chiederà la sequenza di tasti che desideri associare ( C-TAB) e quindi il comando a cui desideri associarlo ( next-buffer). Questo è tutto!