Firefox Tarayıcı'daki CST gibi az önce öldürülmüş bir arabellek nasıl yeniden açılır?

Bazen yanlışlıkla bir tampon öldürmek ve sadece CST gibi Firefox'ta geri alma kapalı sekmesine, yeniden açmak istiyorum, ama hiç orada yerleşik olan komuta Emacs, defun undo-kill-bufferiçinde http://www.emacswiki.org/RecentFiles :

(defun undo-kill-buffer (arg)
  "Re-open the last buffer killed.  With ARG, re-open the nth buffer."
  (interactive "p")
  (let ((recently-killed-list (copy-sequence recentf-list))
     (buffer-files-list
      (delq nil (mapcar (lambda (buf)
                  (when (buffer-file-name buf)
                (expand-file-name (buffer-file-name buf)))) (buffer-list)))))
    (mapc
     (lambda (buf-file)
       (setq recently-killed-list
         (delq buf-file recently-killed-list)))
     buffer-files-list)
    (find-file
     (if arg (nth arg recently-killed-list)
       (car recently-killed-list)))))

hiç çalışmıyor Elisp biliyorsanız, bu sorunu nasıl çözeceksiniz?

Kapalı arabelleklerin bir listesini gösterebilir ve yeniden açılacak onlardan birini seçebilirim, bu daha iyi olur.

İşte gerektirmeyen başka, basit bir alternatif recentf. İlk işlevin içine takılması kill-buffer-hook, arabellekle ilişkili dosya adını bir listeye itecektir. (Bir dosyayı ziyaret etmeyen bir arabellek öldürürseniz, bunun iyi gittiğini unutmayın.) İkinci işlev, o dosyayı listeden çıkarır ve onu ziyaret eder:

(defvar killed-file-list nil
  "List of recently killed files.")

(defun add-file-to-killed-file-list ()
  "If buffer is associated with a file name, add that file to the
`killed-file-list' when killing the buffer."
  (when buffer-file-name
    (push buffer-file-name killed-file-list)))

(add-hook 'kill-buffer-hook #'add-file-to-killed-file-list)

(defun reopen-killed-file ()
  "Reopen the most recently killed file, if one exists."
  (interactive)
  (when killed-file-list
    (find-file (pop killed-file-list))))

Bunun killed-file-listbir liste olduğuna dikkat edin , bu nedenle, örneğin, burada listelenen basit değil, bu listede dolaşmak için daha karmaşık bir işlev yazabilirsiniz: ne kadar yapmak istediğinize bağlı.

EDIT: pardon, Q'nuzdaki seçeceğiniz dosyaların bir listesini isteme konusundaki son hükmü kaçırdım. Aşağıdaki işlev, completing-readistediğiniz öldürülen dosyalardan hangisini istediğinizi belirtmenize izin vermek için kullandığı sürece yukarıdaki sürümden biraz daha belirgindir . Gibi bir şey kullanıyorsanız ido, geçerli oturumda öldürdüğünüz tüm dosyalar arasında geçiş yaparak, en son varsayılanı seçmenizi sağlar. Zaten gerekli olduğunu varsaydığını unutmayın cl-lib:

(defun reopen-killed-file-fancy ()
  "Pick a file to revisit from a list of files killed during this
Emacs session."
  (interactive)
  (if killed-file-list
      (let ((file (completing-read "Reopen killed file: " killed-file-list
                                   nil nil nil nil (car killed-file-list))))
        (when file
          (setq killed-file-list (cl-delete file killed-file-list :test #'equal))
          (find-file file)))
    (error "No recently-killed files to reopen")))

Size sormak istiyorum: “Gerçekten öldürmek istiyor musunuz?”. Gerçekten de, bir tamponu öldürmek Emacs dünyasında çok yaygın bir şeydir, ancak bir kez öldürüldüğünde, tampon gitmiştir ve sorunuzun gösterdiği gibi, her zaman arzu edilmez.

Bununla birlikte, başka bir yol seçebiliriz, böylece öldürülmüş tamponu asla geri yüklemenize gerek kalmaz - sadece öldürmeyi gömmeyi tercih edin. Bir göz atın The Kill or Alive Bury paketi, bu kadar MELPA yoluyla ulaşılabilir .

Paketin tanımından:

Hayatta bırakmak isteyebileceğiniz bazı tamponları hiç öldürdün mü? Öldürme motivasyonu genellikle “şimdilik yolumdan çekiliyor” ve RAM'iniz çok sınırlı değilse, çoğu durumda öldürme en iyi seçenek olmayabilir. Bu paket Emacs'a öldürmek istediğimiz tamponları ve hangilerini canlı gömmeyi tercih ettiğimizi öğretir.

Bir tamponu gerçekten öldürmek istediğimizde, tüm tamponların aynı şekilde ölmek istemediği ortaya çıktı. Paket, çeşitli tampon türlerinin nasıl öldürüleceğini belirlemeye izin verir . Bu, örneğin ilişkili bir sürece sahip bazı tamponlarla çalışırken özellikle yararlı olabilir.

Fakat bazen çoğu tampondan kurtulmak ve Emac'ları az ya da çok bakir bir duruma getirmek isteyebilirsiniz. Muhtemelen çizik tamponunu ve belki de ERC ile ilişkili tamponları da öldürmek istemezsin. Hangi arabellekleri temizleyeceğinizi belirleyebilirsiniz.

Bu SO yazıdan bu çözümü kullanıyorum ve iyi çalışıyor.

Çözüm, zarif ama mükemmel değil; etkin arabelleklerin bir listesini saklar ve ilk arabellek listesinden aktif arabellek listesine ait olmayan ilk dosyayı döndürür.

;; Son öldürülen arabelleği yeniden aç
;; Kaynak: https://stackoverflow.com/questions/10394213/emacs-reopen-previous-killed-buffer
('cl gerektir)
('fir 'gerektirir)
(yeni mod 1)
(defun undo-kill-buffer ()
  (İnteraktif)
  (let ((active-files (buf için döngü (arabellek listesi))
                            ne zaman (buffer-file-name buf) topla)))
    (recentf listesindeki dosya için döngü
          sürece (üye dosya aktif dosyaları) return (dosya bul dosyası))))

Açman gerek recentf-mode. Bunu yapmak için koş M-x recentf-mode. Ardından, bazı yeni arabellekleri açana ya da öldürene kadar işlev çalışmayabilir; Dolduracağını sanmıyorum recentf-list.

Emacs başladığında bunun etkinleştirilmesini istiyorsanız, bunu init dosyanıza koyun:

(recentf-mode)

Daha sonra defunorada bulunanı bulabilir ve isterseniz bir anahtara bağlayabilirsiniz.

Bu kipin bir dezavantajı, son kipin openedöldürülenleri değil dosyaları izlemek için yapıldığı görünüyor . Bu nedenle, işlevi iki kez çalıştırırsanız, en son öldürülen ikinci dosyanızı yeniden açmaz.

ErgoEmacs, close-current-bufferözellikle son zamanlarda kapalı olan tamponların bir listesini tutan bir fonksiyona sahiptir:

(defvar recently-closed-buffers (cons nil nil) "A list of recently closed buffers. The max number to track is controlled by the variable recently-closed-buffers-max.")
(defvar recently-closed-buffers-max 10 "The maximum length for recently-closed-buffers.")

(defun close-current-buffer ()
"Close the current buffer.

Similar to (kill-buffer (current-buffer)) with the following addition:

• prompt user to save if the buffer has been modified even if the buffer is not associated with a file.
• make sure the buffer shown after closing is a user buffer.
• if the buffer is a file, add the path to the list recently-closed-buffers.

A emacs buffer is one who's name starts with *.
Else it is a user buffer."
 (interactive)
 (let (emacsBuff-p isEmacsBufferAfter)
   (if (string-match "^*" (buffer-name))
       (setq emacsBuff-p t)
     (setq emacsBuff-p nil))

   ;; offer to save buffers that are non-empty and modified, even for non-file visiting buffer. (because kill-buffer does not offer to save buffers that are not associated with files)
   (when (and (buffer-modified-p)
              (not emacsBuff-p)
              (not (string-equal major-mode "dired-mode"))
              (if (equal (buffer-file-name) nil) 
                  (if (string-equal "" (save-restriction (widen) (buffer-string))) nil t)
                t
                )
              )
     ;; (progn ;; I'VE ADDED THIS LINE
     ;;   (switch-to-buffer (buffer-name)) ;; AND THIS LINE
     (if (y-or-n-p
          (concat "Buffer " (buffer-name) " modified; Do you want to save?"))
         (save-buffer)
       (set-buffer-modified-p nil))
     ;; ) ;; AND ALSO A PARENTHESIS HERE
     )

   ;; save to a list of closed buffer
   (when (not (equal buffer-file-name nil))
     (setq recently-closed-buffers
           (cons (cons (buffer-name) (buffer-file-name)) recently-closed-buffers))
     (when (> (length recently-closed-buffers) recently-closed-buffers-max)
           (setq recently-closed-buffers (butlast recently-closed-buffers 1))
           )
     )

   ;; close
   (kill-buffer (current-buffer))

   ;; if emacs buffer, switch to a user buffer
   (if (string-match "^*" (buffer-name))
       (setq isEmacsBufferAfter t)
     (setq isEmacsBufferAfter nil))
   (when isEmacsBufferAfter
     (next-user-buffer)
     )
   )
 )

Böylece bunları kullanarak bu oturumu kapalı tamponu tekrar açabilirsiniz.

;; undo close this-session buffer:
(defun ergo-undo-close-buffer ()
  "Opens some this-session closed buffer."
  (interactive)
  (let* ((mylist (delq nil (delete-dups (mapcar 'car recently-closed-buffers))))
         (baseName (ido-completing-read "Open this session closed buffer: " mylist))
         (fileName (cdr (assoc baseName recently-closed-buffers))))
    (find-file fileName)))

EDIT: Cevap verirken dikkat etmedim ve OP'nin sormadığı bir şeyi cevapladım. Bir kez daha özür dilerim. Sözlerin için teşekkür ederim, @CodyChan.

Eh, ben Emacs gazisi değilim ve belki de bu sadece son sürümlerinde mümkün olmuştur. Birkaç yıl sonra geleceğimi biliyorum, ama araştırmam beni buraya getirdiğinden beri, belki de diğerleri için yardımcı olabilir.

Emacs v25.2.1'deyim, recentfburada zaten var ve ihtiyacınız olanı yapan hazır bir işlevi var. Daha önce eski sürümlerde daha önce etkinleştirdim, bu yüzden benim .emacs:

(recentf-mode 1)
(global-set-key (kbd "C-S-t") 'recentf-open-most-recent-file)

Ve bu benim için mükemmel çalıştı. Elbette, sizi daha çok memnun eden şeyin kısayolunu değiştirin.