फ़ायरफ़ॉक्स ब्राउज़र में सीएसटी की तरह सिर्फ मारे गए बफर को फिर से कैसे खोलें?

Question

कभी कभी मैं गलती से एक बफर को मारने और इसे फिर से खोलने के लिए, बस सीएसटी की तरह फ़ायरफ़ॉक्स में पूर्ववत बंद टैब करना चाहते हैं, लेकिन कोई Emacs में अंतर्निहित है आदेश, defun undo-kill-bufferमें 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)))))

बिल्कुल काम नहीं करता है। यदि आप को पता है, तो इस समस्या को कैसे हल करें?

यदि यह बंद बफ़र्स की सूची दिखा सकता है और मैं उन्हें फिर से खोलने के लिए उनमें से एक चुन सकता हूं, तो बेहतर होगा।

Comments

अब तक दिए गए उत्तरों में से कोई भी सवाल का जवाब नहीं दिया गया है, जो कि "फिर से खोलना", या बहाल करने, एक मारे गए बफर के बारे में है। ऐसा इसलिए है क्योंकि यह बहुत असंभव है, सामान्य तौर पर - सबसे अच्छा जो किया जा सकता है वह इसे फिर से बनाना होगा। लेकिन अगर आपका मतलब केवल फाइल-विजिटिंग बफ़र्स है तो इसका उत्तर आसान है, और यहाँ दिए गए उत्तर उपयुक्त हैं। यदि ऐसा है तो कृपया इस प्रतिबंध को प्रतिबिंबित करने के लिए अपने प्रश्न को संपादित करें ।

— आकर्षित किया

एक वैकल्पिक तरीका यह है कि उन भैंसों को न मारा जाए। बरी-बफर अच्छा है। आप एक कट्टर दृष्टिकोण की भी कल्पना कर सकते हैं, उदाहरण के लिए (अभी तक परिभाषित) किल-बफर-बाद में जो तुरंत बफर को दफन कर देगा और कुछ मिनटों के बाद बफर को मारने के लिए एक टाइमर सेट करेगा। या एक किल-बफर-शायद-बाद में जो बफर को मार देगा यदि यह एक फ़ाइल पर जा रहा है, और इसकी मृत्यु में देरी करता है यदि यह नहीं है (शायद सीएक्स बी का उपयोग करते समय अव्यवस्था से बचने के लिए इसके नाम के लिए एक स्थान तैयार करें)।

— यंगफ्रॉग

@YoungFrog, वास्तव में, मैंने अपने उत्तर में इस अवसर को संबोधित किया है।

— मार्क कार्पोव

Answer 1

यहाँ एक और सरल विकल्प है, जिसकी आवश्यकता नहीं है recentf। पहले फ़ंक्शन को हुक करने kill-buffer-hookसे एक सूची में बफर से जुड़े फ़ाइलनाम को धक्का दिया जाएगा। (ध्यान दें कि, यदि आप एक बफर को मारते हैं जो किसी फ़ाइल पर नहीं जा रहा है, तो यह अच्छे के लिए चला गया है।) उत्तरार्द्ध फ़ंक्शन पॉप की फ़ाइल बंद कर देता है और उस पर जाता है:

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

ध्यान दें कि killed-file-listएक सूची है, इसलिए आप उदाहरण के लिए, उस सूची के माध्यम से चक्र करने के लिए एक अधिक जटिल फ़ंक्शन लिख सकते हैं, बल्कि यहां वर्णित सरल के बजाय: यह आपके ऊपर है कि आप इसके साथ कितना करना चाहते हैं।

संपादित करें: क्षमा करें, मैं आपके Q में उन फ़ाइलों की एक सूची को चुनने के बारे में अंतिम प्रावधान से चूक गया, जिनमें से चयन करना है। निम्न फ़ंक्शन इन्सोफ़र के ऊपर के संस्करण की तुलना में थोड़ा कट्टर है, क्योंकि यह completing-readआपको यह निर्दिष्ट करने के लिए उपयोग करता है कि आपको कौन सी वांछित फ़ाइल चाहिए। यदि आप कुछ का उपयोग कर रहे हैं ido, तो यह आपको वर्तमान सत्र में आपके द्वारा मारे गए सभी फ़ाइलों के माध्यम से साइकिल चलाने देगा, जो सबसे हाल ही में डिफ़ॉल्ट है। ध्यान दें कि यह मान लिया है कि आप पहले से ही आवश्यक है 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")))

Answer 2

मैं आपसे पूछना चाहता हूं: "क्या आप वास्तव में इसे मारना चाहते हैं?"। दरअसल, Emacs की दुनिया में एक बफर को मारना एक आम बात है, लेकिन एक बार मारे जाने के बाद, बफर खत्म हो जाता है, और जैसा कि आपका सवाल दर्शाता है, यह हमेशा वांछनीय नहीं होता है।

हालांकि, हम एक और तरीका चुन सकते हैं, ताकि आपको मारे गए बफर को पुनर्स्थापित करने की आवश्यकता न हो - बस मारने के लिए दफन करना पसंद करें। किल या बूरी अलाइव पैकेज पर एक नज़र डालें , यह एमईएलपीए के माध्यम से उपलब्ध है ।

पैकेज के विवरण से:

क्या आपने कभी कुछ बफर को मार दिया है जिसे आप जीवित छोड़ना चाहते हैं? मारने के लिए प्रेरणा आमतौर पर "अब मेरे लिए रास्ते से हट जाओ" है, और हत्या कई मामलों में सबसे अच्छा विकल्प नहीं हो सकती है जब तक कि आपकी रैम बहुत सीमित न हो। यह पैकेज Emacs को सिखाने की अनुमति देता है कि हम किन बफ़र्स को मारना चाहते हैं और जिन्हें हम जिंदा दफन करना पसंद करते हैं।

जब हम वास्तव में एक बफर को मारना चाहते हैं, तो यह पता चलता है कि सभी बफ़र्स एक ही तरह से मरना पसंद नहीं करेंगे। पैकेज यह निर्दिष्ट करने की अनुमति देता है कि विभिन्न प्रकार के बफ़र्स को कैसे मारना है। यह विशेष रूप से तब उपयोगी हो सकता है जब आप कुछ बफ़र के साथ काम कर रहे हों, जिसमें संबंधित प्रक्रिया हो, उदाहरण के लिए।

लेकिन कभी-कभी आप अधिकांश बफ़र्स से छुटकारा पा सकते हैं और Emacs को कम या ज्यादा कुंवारी अवस्था में ला सकते हैं। आप शायद स्क्रैच बफर और शायद ईआरसी से संबंधित बफ़र्स को भी मारना नहीं चाहते हैं। आप निर्दिष्ट कर सकते हैं कि किस बफ़र्स को शुद्ध करना है।

Answer 3

मैं इस एसओ पोस्ट से इस समाधान का उपयोग करता हूं और यह ठीक काम करता है।

समाधान सुरुचिपूर्ण है, लेकिन सही नहीं है; यह सक्रिय बफ़र्स की सूची संग्रहीत करता है और हाल की सूची से पहली फ़ाइल लौटाता है जो सक्रिय बफ़र्स की सूची से संबंधित नहीं है।

;; अंतिम मारे गए बफर को फिर से खोलें
;; स्रोत: https://stackoverflow.com/questions/10394213/emacs-reopen-prepret-killed-bewer
('cl' की आवश्यकता है)
(आवश्यकता 'हाल के दिनों)
(हाल ही में मोड 1)
(डिफॉन अनडू-किल-बफर)
  (सहभागी)
  (लेट (सक्रिय-फ़ाइलें) (बफर-सूची में buf के लिए लूप)
                            जब (बफर-फ़ाइल-नाम buf) इसे इकट्ठा करें)))
    (हाल की सूची में फ़ाइल के लिए लूप
          जब तक (सदस्य फ़ाइल सक्रिय-फ़ाइल) वापसी (फ़ाइल खोजें फ़ाइल)))

Answer 4

आपको चालू करने की आवश्यकता है recentf-mode। ऐसा करने के लिए, भागो M-x recentf-mode। तब, फ़ंक्शन तब तक काम नहीं कर सकता जब तक आप कुछ नए बफ़र्स खोलते या मारते नहीं हैं; मुझे नहीं लगता कि आपने recentf-listभरा होगा।

यदि आप चाहते हैं कि Emacs शुरू होने पर इसे सक्षम किया जाए, तो इसे अपनी init फ़ाइल में डालें:

(recentf-mode)

फिर defunआप वहां पाए गए आपको डाल सकते हैं , और यदि आप चाहें तो इसे एक कुंजी से बांध सकते हैं।

इस मोड के एक पहलू यह है कि हाल ही में मोड openedफ़ाइलों को ट्रैक करने के लिए बनाया गया है, न कि मारे गए लोगों के लिए। इसलिए, यदि आप दो बार फ़ंक्शन चलाते हैं, तो यह आपकी दूसरी-सबसे हाल ही में मारी गई फ़ाइल को फिर से खोल नहीं पाएगा।

Comments

हालाँकि Emacs 24 ने मामूली मोड्स के लिए इस विकल्प को प्रभावी ढंग से बनाया है, फिर भी मैं (recentf-mode 1)स्पष्ट तर्क के साथ लिखना चाहूँगा , ताकि कोई व्यक्ति Emacs 23 के तहत अपनी init फ़ाइल का पुनर्मूल्यांकन कर सके और फिर से मोड को चालू नहीं कर सके।

— फिल्स

Answer 5

ErgoEmacs का एक फंक्शन है close-current-buffer जो विशेष रूप से हाल ही में बंद किए गए बफ़र्स की सूची रखता है:

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

इसलिए इनका उपयोग करने से यह सत्र बंद बफर को फिर से खोल सकता है

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

Answer 6

संपादित करें: मैंने उत्तर देते समय ध्यान नहीं दिया, और कुछ और उत्तर दिया जो ओपी ने नहीं पूछा। एक बार फिर, मुझे क्षमा करें। आपके शब्दों के लिए धन्यवाद, @CodyChan

खैर, मैं कोई Emacs अनुभवी नहीं हूँ, और शायद यह संभवतः हाल के संस्करणों पर उपलब्ध हो गया है। मुझे पता है कि मैं कुछ साल बाद आ रहा हूं, लेकिन शायद यह दूसरों के लिए मददगार हो सकता है, क्योंकि मेरी खोज मुझे यहां मिली।

मैं Emacs v25.2.1 पर हूं, recentfपहले से ही यहां उपलब्ध है और एक तैयार फ़ंक्शन है जो आपको आवश्यक है। मैंने पुराने संस्करणों पर पहले से ही इसे सक्रिय कर दिया है, इसलिए मेरे .emacsपास:

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

और यह मेरे लिए पूरी तरह से काम करता है। बेशक, जो भी आपको अधिक पसंद आए उसके लिए शॉर्टकट बदलें।

Comments

ऐसा लगता है कि फ़ंक्शन बहुत पहले ही अस्तित्व में था, जो 2005 में Emacs स्रोत कोड ट्री में ChangeLog फ़ाइल के अनुसार है। यह काम करता है, और यह पिछले Emacs सत्र से बंद बफर को फिर से खोलने के लिए भी काम कर सकता है, लेकिन ऐसा लगता है कि यह बंद बफ़र्स को सूची से एक का चयन करने के लिए सूचीबद्ध नहीं कर सकता है।

— कोडिचन

तो यह सिर्फ विशेष रूप से मारे गए बफर को फिर से खोलना नहीं है लेकिन हाल ही में खोली गई फ़ाइलों को फिर से खोलना है।

— कोडिचन जूल

@ कोडिचन, मुझे बहुत खेद है और निश्चित रूप से आप सही हैं। वह हाल ही में खोली गई फ़ाइल होगी और आपने जो पूछा है वह नहीं। मैं जल्द ही उत्तर हटा दूंगा, मैं आपसे और अन्य साथियों से माफी मांगता हूं।

— चार्ल्स रॉबर्टो कैनाटो

अनावश्यक रूप से इस उत्तर को हटाने के लिए, हो सकता है कि कोई व्यक्ति आपके समाधान को अभी हाल ही में खोली गई फ़ाइलों को फिर से खोलना चाहता है। :)

— CodyChan