ฉันจะเปลี่ยนบัฟเฟอร์ได้อย่างรวดเร็วได้อย่างไร

ใน Vanilla Emacs ฉันต้องทำC-x bแล้วพิมพ์ชื่อบัฟเฟอร์เพื่อสลับ ถ้าฉันลืมชื่อของบัฟเฟอร์ฉันต้องกดปุ่มTABเพื่อแสดงรายการความสำเร็จที่เป็นไปได้ มีอะไรที่ฉันสามารถทำได้เพื่อทำให้กระบวนการนี้เร็วขึ้นหรือไม่?

มีโหมดidoที่ควรช่วยได้

แก้ไข:

ใส่สิ่งนี้ในไฟล์ init ของคุณเพื่อเปิดใช้งานโหมด ido โดยค่าเริ่มต้น:

(ido-mode 1)

ตอนนี้C-x bจะแสดงรายการของผู้สมัคร

วางสิ่งนี้ในไฟล์ init ของคุณหากคุณต้องการให้รายการปรากฏในแนวตั้ง:

(setq ido-separator "\n")

ความอนุเคราะห์จากergoemacs

ให้ฉันแนะนำโพสต์นี้พูดคุยเกี่ยวกับเปลี่ยนไปที่บัฟเฟอร์ก่อนหน้า / ถัดไป

ผมได้เริ่มต้นเมื่อเร็ว ๆ นี้โดยใช้และC-x <left> C-x <right>สิ่งเหล่านี้เป็นทั้งการผูก Emac มาตรฐาน - ไม่มีสิ่งใดที่จะกำหนดค่า Left จะนำคุณกลับไปยังบัฟเฟอร์ก่อนหน้า (เริ่มแรกเหมือนกันC-x b RET) แต่การทำอีกครั้งจะนำคุณไปยังบัฟเฟอร์ที่เข้าชมล่าสุดอันดับ 3 หากคุณ popping ไปมาระหว่าง 3 หรือ 4 บัฟเฟอร์มากแล้วฉันคิดว่ามันง่ายกว่าการพยายามจำชื่อบัฟเฟอร์

นอกจากนี้ฉันเพิ่งค้นพบC-x C-<left>และC-x C-<right>ถูกผูกไว้กับฟังก์ชั่นเดียวกันเพื่อให้คุณสามารถกดปุ่มควบคุมและสลับระหว่าง x และลูกศรเพื่อพลิกดูบัฟเฟอร์ ค่อนข้างดี!

คุณสามารถใช้หางเสือ

ในการตั้งค่าของฉันฉันได้เปลี่ยนสำหรับC-x b M-lพันธมิตรนี้helm-buffers-listทำให้กระบวนการค่อนข้างเร็วอย่างน้อยสำหรับฉัน

เพียงเพิ่ม tweaks ที่ฉันใช้กับIdo ที่ได้กล่าวไปแล้ว:

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

ฉันยังใช้ace-windowเพื่อสลับระหว่างบัฟเฟอร์พร้อมกับace-jump-modeเพื่อข้ามระหว่างหน้าต่างที่มองเห็นได้ มาพร้อมกับความคุ้นเคยบางอย่าง แต่ก็คุ้มค่าที่จะลอง

ฉันได้รวมเข้ากับkey-chord-modeและกดsoเพื่อกระโดดอย่างรวดเร็ว:

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

แพคเกจทั้งหมดที่กล่าวถึงข้างต้นสามารถใช้ได้ผ่านทางผู้จัดการแพ็คเกจจาก Melpa

@kuanyui พูดในความคิดเห็นว่าnext-buffer& previous-bufferรวดเร็วมากถ้าคุณมีเพียงไม่กี่บัฟเฟอร์ที่จะวนรอบ (มากกว่าสองสามครั้งและสำหรับคุณสมบัติการเลือกบัฟเฟอร์เพิ่มเติมฉันใช้icicle-buffer)

อย่างไรก็ตามโดยค่าเริ่มต้นnext-bufferและprevious-bufferC-xอยู่ในคีย์คำนำหน้า

นั่นหมายความว่าพวกเขาไม่สามารถทำซ้ำได้ : คุณไม่สามารถตีC-x <right> <right> <right>...ได้ คุณต้องผูกคำสั่งเหล่านี้กับคีย์ที่แตกต่างกันทำซ้ำได้หรือคุณต้องใช้C-x <right> C-x <right> C-x <right>...ซึ่งไม่รวดเร็วมาก

สำหรับเวอร์ชันที่ทำซ้ำได้ของคำสั่งเหล่านี้โหลดmisc-cmds.elไลบรารี่และทำการแมปวานิลลาใหม่

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

(ในทำนองเดียวกันในไลบรารีเดียวกันคุณจะพบเวอร์ชันundoที่ทำซ้ำได้แม้ในคีย์นำหน้า: undo-repeat.)

BTW คุณสามารถทำซ้ำคำสั่งใด ๆ (แม้ในคีย์คำนำหน้า) โดยใช้ฟังก์ชั่นrepeat-command(จากmisc-cmds.el) นี่คือทั้งหมดที่จำเป็นในการกำหนดเวอร์ชันที่ทำซ้ำได้ของ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))

ฉันประหลาดใจที่iswitchbยังไม่มีใครพูดถึง มันอาจจะไม่ทรงพลังเท่าidoแต่ก่อนido-modeเกิดมาiswitchb-modeเป็นมาตรฐานสำหรับ emacs แล้วและยังคงมีประโยชน์ในปัจจุบัน หากต้องการลองใส่

(iswitchb-mode 1)

เข้า .emacs M-x iswitchb-modeหรือเปิดใช้งานผ่านทาง

ใช้helm-buffer-list หรือ helm-miniสำหรับการเลือกรายการบัฟเฟอร์และการจับคู่แบบคลุมเครือ มันสามารถทำสิ่งต่างๆมากมายนอกเหนือจากการสลับบัฟเฟอร์ คุณควรเห็นตัวอย่างในลิงค์

คนอื่น ๆ ได้พูดถึงแพคเกจที่มีประโยชน์เพื่อทำให้ชีวิตง่ายขึ้นเกี่ยวกับการเปลี่ยนบัฟเฟอร์ / หน้าต่าง / เฟรม (ฉันใช้เป็นการส่วนตัวhelmซึ่งเป็นปรากฎการณ์) ฉันต้องการพูดคุยเกี่ยวกับการเปลี่ยนแปลงที่ง่ายกว่าซึ่งสามารถทำเพื่อประสบการณ์ที่สนุกยิ่งขึ้นของ Emacs

สำหรับฉันวิธีแก้ปัญหาบัฟเฟอร์ / เฟรมของฉัน (เพราะฉันคิดว่าC-x oแย่ที่สุด) ไม่ใช่แพ็คเกจ มันเป็นเพียง:

• การจับคู่C-;กับother-window(ขี่จักรยานผ่านหน้าต่าง)
• การแมปC-'ไปยังother-frame(ขี่จักรยานผ่านเฟรม) ฉันเริ่มใช้เฟรมมากขึ้นหลังจากเพิ่มทางลัดนี้)
• การจับคู่การกดแป้นพิมพ์ลัดเดี่ยวอื่น ๆ กับฟังก์ชันที่กำหนดเองง่าย ๆ สำหรับจัดการบัฟเฟอร์ในเฟรมที่มองเห็นได้ ตัวอย่างรวมถึง: การโยนบัฟเฟอร์ไปที่หน้าต่างอื่น (ในการตั้งค่า 2 หน้าต่าง) สลับระหว่างบัฟเฟอร์ปัจจุบันและบัฟเฟอร์สุดท้ายในหน้าต่างที่กำหนดการฝังบัฟเฟอร์อื่น (อันนี้ดีมากสำหรับการแทนที่helpหน้าต่างที่ปรากฏขึ้น (เมื่ออ่าน man pages, apropos, ฯลฯ ) ด้วยหน้าต่างที่มองเห็นได้ก่อนหน้านี้)

ฉันยังคิดว่าฉันจะแบ่งปันความคิดบางอย่างเกี่ยวกับการผูกคีย์ซึ่งมือใหม่อาจมีประโยชน์ (ขออภัยถ้านี่เป็นสถานที่ที่ไม่ถูกต้อง) ฉันไม่มีคำแนะนำเฉพาะ แต่เป็น "ปรัชญา" ที่ให้ฉันรักษาชุดของการโยงคีย์ที่มีประสิทธิภาพสำหรับตัวเอง

1. คำสั่งที่ใช้อย่างไม่เหมาะสมไม่สมควรได้รับการผูกคีย์อย่างง่าย

   • ดาวน์โหลดkeyfreq.elและดูว่าคุณจริงๆใช้เป็นจำนวนมาก ฉันใช้วิธีการเอาตัวรอดเพื่อตัดสินว่าคำสั่งใดให้รางวัลอสังหาริมทรัพย์ที่มีค่ามากที่สุดบนคีย์บอร์ดของฉัน
   • อย่ากลัวที่จะกำจัด keybindings Emacs เริ่มต้นซึ่งบางส่วนก็ไร้สาระ C-\เป็นทางลัดที่ดี (ด้วยเหตุผลที่กล่าวถึงใน # 2) ... change-input-methodและมันจะเป็นความผิดทางอาญาที่จะปล่อยให้มันเป็นแมปไปยังคำสั่งเริ่มต้นของมัน: (บางทีคุณบางคนใช้มันมากฉันก็ทำไม่ได้)

2. ปัจจัยต่อไปนี้พิจารณาความง่ายและความเร็วของแป้นพิมพ์ลัด (เริ่มจากสิ่งที่สำคัญที่สุด):

   • อย่างต่อเนื่องกดปุ่มเครื่องปรับ (สิ่งที่มันอาจจะCtrl, Metaฯลฯ ) ยกตัวอย่างเช่นมันเป็นวิธีที่เร็วกว่าสำหรับผมที่จะตีกว่าก็คือการตีC-c C-l C-p C-x oโดยส่วนตัวแล้วฉันรู้สึกว่ามันไม่สะดวกที่จะต้องยกCtrlกุญแจออกมาระหว่างการกดแป้นตามลำดับของลำดับคีย์ที่กำหนด มันง่ายกว่ามากเพียงแค่ทำการ mashing ปุ่มตัวดัดแปลง (ในกรณีนี้Ctrl) (ตัวอย่างที่เฉพาะเจาะจงนี้อาจได้รับอิทธิพลจากความจริงที่ว่าฉันได้ทำCtrlรหัสกุญแจและCaps-Lockกุญแจของฉันใหม่)
   • สลับกันในเพื่อนของคุณ มันเป็นวิธีที่เร็วกว่าสำหรับผมที่จะตีกว่าก็คือการตีC-c C-l C-p C-p C-' C-;(ลองดูและควรจะชัดเจน) โดยทั่วไปแล้วมันง่ายกว่ามากที่จะใช้ลำดับการกดแป้นพิมพ์ที่ใช้มือสลับกัน (หรืออย่างน้อยก็สลับนิ้วมือในมือเดียวกัน)
   • ระดับของการออกเดินทางจากตำแหน่งมือมาตรฐาน สิ่งนี้ใช้ไม่ได้กับผู้ที่ชื่นชอบการล่าสัตว์และจิกกัดที่นั่น แต่สำหรับส่วนที่เหลือของเราแป้นพิมพ์ลัดที่ใช้บ่อยที่สุดของเราควรอนุญาตให้เรากลับไปที่ตำแหน่งการพิมพ์แบบสัมผัสมาตรฐานของเราอย่างรวดเร็วและง่ายดาย

แค่สองสามความคิดที่ฉันคิดว่าอาจเป็นประโยชน์กับมือใหม่ ฉันอาจเพิ่มอีกในภายหลัง

ฉันใช้windmove.elและbs.elเปลี่ยนบัฟเฟอร์อย่างรวดเร็ว ทั้งสองโหมดนั้นมาพร้อมกับ Emacs

• windmove.el- สลับไปที่หน้าต่าง (บัฟเฟอร์ที่ปรากฏขึ้นในปัจจุบัน) ในทิศทางที่ระบุเช่นซ้าย, ขวา, ขึ้น, ลง

• bs.el- ฉันใช้bs-cycle-nextและbs-cycle-previousเพื่อสลับไปยังบัฟเฟอร์ถัดไปที่ไม่ปรากฏในหน้าต่างปัจจุบัน

คุณสามารถตั้งค่า windmove ด้วย(windmove-default-keybindings)ซึ่งจะผูกคำสั่งที่เหมาะสมเพื่อShift-Left Arrow, Shift-Right Arrowฯลฯ

สำหรับการตั้งค่าbs.elบางอย่างเช่นนี้จะทำงาน:

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

ace-jump-bufferวิธีที่เร็วที่สุดที่จะเปลี่ยนบัฟเฟอร์ฉันรู้อยู่กับ ace-jump-line-modeหนึ่งจังหวะสำคัญจะเปิดเมนูบัฟเฟอร์แล้วเลือกตัวอักษรที่อยู่ติดกับกันชนที่คุณต้องการด้วย วิธีนี้ทำงานได้ดีที่สุดสำหรับบัฟเฟอร์ 26 หรือมากกว่านั้น สำหรับการเปลี่ยนไปใช้บัฟเฟอร์ไกลออกไปในประวัติการใช้งานของคุณido-switch-bufferเป็นตัวเลือกที่ดีเสมอ

ฉันชอบการนำทางแท็บสไตล์เบราว์เซอร์ ฉันผูก Ctrl + Tab และ Ctrl + Shift + Tab ไปที่บัฟเฟอร์ถัดไปและก่อนหน้าตามลำดับ:

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

การพูดอย่างกว้างขวางมี 2 วิธีในการเปลี่ยนบัฟเฟอร์และวิธีแก้ปัญหาส่วนใหญ่จะตกอยู่ในหนึ่งในวิธีเหล่านี้

1. การใช้ mini buffer

นี่คือสิ่งที่C-x bทำตามค่าเริ่มต้น Ido ให้การเติมข้อมูลอัตโนมัติที่ดีแก่คุณเพื่อให้คุณไม่จำเป็นต้อง TAB TAB TAB มากนัก โปรเจ็กต์อย่าง helm, projectile ฯลฯ ช่วยให้คุณสามารถทำงานกับไฟล์ในโปรเจ็กต์อื่น ๆ ได้ง่ายขึ้นและด้วย ido พวกมันมีประโยชน์มาก

2. บัฟเฟอร์ทั้งหมดพร้อมด้วยรายการทั้งหมดที่ระบุไว้

สิ่งนี้มีประโยชน์เมื่อคุณมีบัฟเฟอร์จำนวนมากและคุณต้องการรายการทั้งหมด คุณสามารถขึ้นและลงบัฟเฟอร์และกด Enter เพื่อเยี่ยมชมไฟล์เฉพาะ Ibuffer ค่อนข้างดีสำหรับสิ่งนั้น

ฉันใช้ทั้งสองและนี่คือวิธีที่คุณสามารถตั้งค่า

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

นอกเหนือจาก ido ฉันมีการตั้งค่าต่อไปนี้

1. ในกรณีของโหมดที่ไม่ดีให้ใช้การเชื่อมโยงคีย์เพื่อสลับบัฟเฟอร์

   (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. ตั้งชื่อบัฟเฟอร์เป็นหัวเรื่องของหน้าต่าง สิ่งนี้จะช่วยคุณในการนำทางด้วยปุ่มลัดข้างบน

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

3. evil-leaderหากคุณกำลังใช้โหมดความชั่วร้ายที่คุณสามารถลอง ผูกกุญแจที่ใช้บ่อยกับผู้นำ เช่นคุณสามารถผูกไปC-x b<leader>-b

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

4. โหมด dired C-<f8>เชื่อมโยงกับ ตอนนี้เมื่อคุณต้องการที่จะเปิดไฟล์ในไดเรกทอรีกดC-<f8>นำทางไปยังชื่อไฟล์และกดแทนa RETดังนั้นบัฟเฟอร์ที่ตายแล้วจะถูกฆ่าทันที

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

5. ใช้recentfโหมดเพื่อนำทางไฟล์ล่าสุดC-x C-r

6. จุดสำคัญสุดท้ายสุดท้ายคือ - ใช้แป้นพิมพ์เชิงกล ดังนั้นคุณสามารถกดปุ่ม 'ctrl' ได้อย่างง่ายดายและรวดเร็วพร้อมกับข้อมือแทนที่จะทำร้ายพิ้งกี้

หวังว่านี่อาจช่วยใครซักคน

อย่างที่คุณเห็นจากคำตอบอื่น ๆ มีหลายวิธีในการทำให้งานนี้คล่องตัวขึ้น โดยส่วนตัวฉันใช้Lusty Emacsเป็นเครื่องมือเปลี่ยนบัฟเฟอร์ของฉันเพราะมันจัดการกับความสมบูรณ์ของฟัซซีค่อนข้างดี สิ่งนี้ช่วยลดจำนวนของการกดแป้น - ครั้งที่จำเป็นในการเลือกบัฟเฟอร์ใหม่ตัวอย่างเช่นฉันต้องการเพียงพิมพ์ oxr เพื่อสลับไปที่ox-reve.elหรือแม้แต่แค่รอบที่สองเช่นเดียวกับการติดตามประวัติของสวิตช์เช่นกัน

หากคุณต้องการเพียงแค่แปรงในบัฟเฟอร์ของคุณเพิ่มสิ่งนี้ไปยังไฟล์ init ของคุณ:

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

คุณต้องการแพ็คเกจการผูกกุญแจและคุณสามารถเปลี่ยนการผูกกุญแจตามความต้องการของคุณได้ แต่ฉันพบว่าการโยงคีย์เหล่านี้จะสบายที่สุด ก่อนที่จะเพิ่มตัวอย่างนี้คุณจำเป็นต้องมีการเชื่อมโยงคีย์โดย

(require 'bind-key)

ฉันใช้ C-Tab และ CS-Tab เหมือนกับแอปพลิเคชันทั่วไป

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

นี่ไม่ใช่วิธีการแก้ปัญหาที่สง่างามมาก (เนื่องจากใช้มาโครแทนฟังก์ชั่น) และมันไม่ตอบวิธีการข้ามไปยังบัฟเฟอร์ใด ๆอย่างรวดเร็ว แต่มีเพียงวิธีการข้ามไปยังบัฟเฟอร์ที่ใช้ล่าสุด แต่มันใช้งานได้ดีสำหรับฉัน:

ฉันมีชุดของแมโครที่ใช้ido-switch-bufferเพื่อข้ามไปยังบัฟเฟอร์ก่อนหน้าบัฟเฟอร์ก่อนหน้านั้นบัฟเฟอร์ก่อนหน้านั้น ฯลฯ และฉันผูกแมโครเหล่านั้นกับการผูกคีย์ที่ฉันพบว่าสะดวก

หากต้องการข้ามไปยังบัฟเฟอร์สุดท้าย:

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

ในการข้ามไปยังบัฟเฟอร์ถัดไป:

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

วิธีข้ามไปยังบัฟเฟอร์ antepenultimate:

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

อื่น ๆ (คุณสามารถโฆษณาได้มาก?\C-nเท่าที่คุณต้องการย้อนกลับไปที่ประวัติของบัฟเฟอร์ที่เยี่ยมชมเท่าที่คุณต้องการ)

มีฟังก์ชันในตัวเพื่อข้ามไปยังบัฟเฟอร์ก่อนหน้านี้ แต่ข้อดีของการใช้แมโครด้วยido-switch-bufferคือคุณสามารถปรับแต่งตัวแปรido-ignore-buffersเพื่อลบบัฟเฟอร์พิเศษเช่น*Messages*หรือหรือ*scratch*บัฟเฟอร์ที่ไม่ต้องการอื่น ๆ จากรายการ ด้วยวิธีนี้บัฟเฟอร์เดียวที่คุณข้ามไปคือสิ่งที่คุณสนใจในการกระโดดไป

บน VM ของฉัน Cx ALT-RIGHT / LEFT ช้าเกินไป ฉันต้องรอให้ Cx ลงทะเบียนในแถบสถานะก่อนที่ฉันจะทำอะไรได้อีก รวมถึงปุ่มที่มากเกินไป ดังนั้นฉันจึงแมป C-TAB และ CM-TAB ไปที่บัฟเฟอร์ถัดไปและก่อนหน้านั่นคือสิ่งที่ฉันทำในโปรแกรม windows ส่วนใหญ่อยู่แล้ว มันง่ายที่จะทำจากภายใน emacs: M-xนำคุณไปที่แถบสถานะ จากนั้นพิมพ์global-set-keyว่าจะให้คุณใส่ลำดับคีย์ที่คุณต้องการผูก ( C-TAB) จากนั้นสำหรับคำสั่งที่คุณต้องการผูกให้กับ ( next-buffer) แค่นั้นแหละ!