Emacs में * ओपन * स्क्रैच * बफर?

Question

यदि मैंने एमएसीएस में गलती से स्क्रैच बफर को बंद कर दिया है, तो मैं एक नया स्क्रैच बफर कैसे बनाऊं ?

Answer 1

ग्नू एमएसीएस डिफ़ॉल्ट बाइंडिंग:

C-xb *scratch* RET

या, अधिक मौखिक रूप से

M-x switch-to-buffer *scratch* RET

*scratch*बफर बफर स्टार्टअप पर चयन किया है और प्रमुख मोड है लिस्प इंटरेक्शन । नोट: *scratch*बफर के लिए मोड चर द्वारा नियंत्रित किया जाता है initial-major-mode।

सामान्य तौर पर आप जितने चाहें उतने "स्क्रैच" बफ़र्स बना सकते हैं, और उन्हें नाम दें, हालांकि आप चुनते हैं।

C-xb NAME RET

NAMEयदि यह मौजूद नहीं है, तो एक बफ़र पर स्विच करता है। एक नया बफर डिस्क पर एक फ़ाइल के साथ जुड़ा नहीं है जब तक कि आप एक फ़ाइल का चयन करने के लिए C-xC-w(या M-x write-file RET) का उपयोग नहीं करते हैं जहां इसे सहेजा जाना चाहिए।

M-x text-mode RET

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

M-x apropos-command -mode$ RET

Comments

ध्यान दें कि खरोंच के बारे में कुछ विशेष है , कम से कम जीएनयू एमॅक्स 21 और बाद में: एक नए स्क्रैच बफर पर स्विच करने से यह लिस्प इंटरेक्शन मोड में वापस आ जाएगा।

— पीटर एस

बस इस के लिए एक त्वरित अनुवर्ती के रूप में, अगर आपके .emacsएक अलग डिफ़ॉल्ट खरोंच परिभाषित करता है मोड है, तो यह एक नया स्क्रैच का मोड होगा - लिस्ट इंटरेक्शन मोड नहीं।

— ओसोडो

Answer 2

मैं अपने .emacs में निम्नलिखित जोड़ता हूं:

;; bury *scratch* buffer instead of kill it
(defadvice kill-buffer (around kill-buffer-around-advice activate)
  (let ((buffer-to-kill (ad-get-arg 0)))
    (if (equal buffer-to-kill "*scratch*")
        (bury-buffer)
      ad-do-it)))

अगर मैं खरोंच बफर नहीं देखना चाहता हूं तो मैं Cx Ck दबाता हूं, लेकिन यह इसे नहीं मारता है, बस बफर सूची के अंत में जगह है, इसलिए तब मुझे अगली बार इसकी आवश्यकता है मुझे नया नहीं बनाना है।

Comments

जब मैं "आइबफ़र" से इस सलाह की कोशिश करता हूं, तो सलाह को नजरअंदाज कर दिया जाता है। लेकिन जैसा कि सबसे अच्छा मैं बता सकता हूं, "ibuffer" "किल-बफर" का उपयोग कर रहा है। क्या आप मेरी मदद कर सकते हैं?

— A.Eletlet

खैर, ग्राफिकल इंटरफेस स्क्रैच में "क्लोज बफर" मारकर डिलीट कर दिया जाता है। यह केवल Cx k के लिए काम करता है,

— मॉरीज़ियो लोरेटी

Answer 3

इस EmacsWiki पृष्ठ पर युक्तियों का एक पूरा समूह है ।

यहाँ पहले वाला है:

खरोंच बफर को फिर से बनाने के लिए एक बहुत ही सरल कार्य:

(defun create-scratch-buffer nil
   "create a scratch buffer"
   (interactive)
   (switch-to-buffer (get-buffer-create "*scratch*"))
   (lisp-interaction-mode))             

Answer 4

Cx b *scratch* RET y RET iswitchb-mode सक्षम के साथ।

बस Cx b *scratch*RET अन्यथा।

Comments

डिफ़ॉल्ट बाइंडिंग के साथ, 'y RET' की जरूरत नहीं है और सिर्फ एक 'y' और नई स्क्रैच बफर में एक नई पंक्ति सम्मिलित करता है ।

— ट्रे जैक्सन

ऊओप्स, शायद यह iswitchb- मोड से है। उसके लिए माफ़ करना। एक अन्य विषय पर, iswitchb-mode;)

— आज़माएं

एक भी नहीं होना चाहिए, नाम खरोंच के बारे में कुछ खास नहीं है । कोई भी "खरोंच" बफ़र्स बनाने के लिए मनमाने ढंग से नामों के साथ Cx b का उपयोग कर सकता है।

— क्रिस कॉनवे

वहाँ है नाम * खरोंच * (स्वीकार किए जाते हैं जवाब में बताया गया है) के बारे में कुछ खास - अगर आप एक बफर * खरोंच * प्रमुख मोड के अनुसार निर्धारित किया जाएगा बनाएं जिसका नाम initial-major-modeचर (तुतलाना-बातचीत मोड डिफ़ॉल्ट रूप से)।

— फिल्स

Answer 5

मुझे यह साल पहले मिला था जब मैंने पहली बार एमएसीएस का उपयोग शुरू किया था; मुझे पता नहीं है कि अब कहाँ है, लेकिन यह हमेशा मेरी व्यक्तिगत .el फ़ाइलों में एक घर रहा है। यह Google खोजों में पॉप अप करता है।

;;; Prevent killing the *scratch* buffer -- source forgotten
;;;----------------------------------------------------------------------
;;; Make the *scratch* buffer behave like "The thing your aunt gave you,
;;; which you don't know what is."
(save-excursion
  (set-buffer (get-buffer-create "*scratch*"))
  (make-local-variable 'kill-buffer-query-functions)
  (add-hook 'kill-buffer-query-functions 'kill-scratch-buffer))

(defun kill-scratch-buffer ()
  ;; The next line is just in case someone calls this manually
  (set-buffer (get-buffer-create "*scratch*"))

  ;; Kill the current (*scratch*) buffer
  (remove-hook 'kill-buffer-query-functions 'kill-scratch-buffer)
  (kill-buffer (current-buffer))

  ;; Make a brand new *scratch* buffer
  (set-buffer (get-buffer-create "*scratch*"))
  (lisp-interaction-mode)
  (make-local-variable 'kill-buffer-query-functions)
  (add-hook 'kill-buffer-query-functions 'kill-scratch-buffer)

  ;; Since we killed it, don't let caller do that.
  nil)
;;;----------------------------------------------------------------------

Answer 6

मैं dwj के समाधान का उपयोग करता था, और मैं इसके बारे में काफी खुश था, जब तक मुझे एहसास नहीं हुआ कि यह तब विफल हो गया जब आप वास्तव में स्क्रैच बफर का नाम बदल देते हैं (उदाहरण के लिए इसे सहेजकर)।

फिर मैंने इसे अपनाया, जो मेरे लिए अच्छा काम करता है:

  (run-with-idle-timer 1 t
    '(lambda () (get-buffer-create "*scratch*")))

Answer 7

मेरे पास scratchएक नया स्क्रैच बफर खोलने के लिए एक इंटरैक्टिव कमांड के रूप में है (मुझे कई पसंद हैं):

(defun scratch ()
  "create a new scratch buffer to work in. (could be *scratch* - *scratchX*)"
  (interactive)
  (let ((n 0)
        bufname)
    (while (progn
             (setq bufname (concat "*scratch"
                                   (if (= n 0) "" (int-to-string n))
                                   "*"))
             (setq n (1+ n))
             (get-buffer bufname)))
  (switch-to-buffer (get-buffer-create bufname))
  (if (= n 1) initial-major-mode))) ; 1, because n was incremented

से अपनाया गया: http://everything2.com/index.pl?node_id=1038451

Comments

यह कैसे एक नए बफर (Cx b bufnameRET) पर स्विच करने के लिए बेहतर है ?

— मई'15

@bignose: मैं उपयोग करता हूं ido-modeऔर आमतौर पर काफी कुछ बफ़र्स खुले हैं। एक नया बफर बनाना C-x bवास्तव में थकाऊ होगा। मुझे एक अनूठे नाम के साथ आना होगा जो वर्तमान में मौजूद बफ़र्स में से किसी से मेल नहीं खाता है।

— पैपरिका

Answer 8

(global-set-key (kbd "C-x M-z")
                '(lambda ()
                   (interactive)
                   (switch-to-buffer "*scratch*")))

यह न केवल *scratch*बफर पर जल्दी से स्विच करेगा (क्योंकि मैं अक्सर ऐसा करता हूं), लेकिन एक *scratch*बफर को फिर से बनाएँ और lisp-interaction-modeयदि आप इसे गलती से मारते हैं तो स्वचालित रूप से सक्षम करें । अपनी पसंद के अनुसार बाइंडिंग बदलें।

Answer 9

unkillable-scratchMELPA में सिर्फ emacs पैकेज को नोट करने के लिए ऐसा करेंगे। ऐसा भी scratch-persistहै जो सत्रों के बीच बफर को स्वचालित रूप से बचाएगा और पुनर्स्थापित करेगा।

Answer 10

जैसे डॉकस्ट्रिंग कहता है, यह कार्य करेगा:

स्क्रैच बफर पर स्विच करें। यदि बफर मौजूद नहीं है, तो इसे बनाएं और इसमें प्रारंभिक संदेश लिखें। "

यह एक नया स्क्रैच बफर लाएगा जो शुरुआती स्क्रैच बफर की तरह दिखता है।

(defun switch-buffer-scratch ()
  "Switch to the scratch buffer. If the buffer doesn't exist,
create it and write the initial message into it."
  (interactive)
  (let* ((scratch-buffer-name "*scratch*")
         (scratch-buffer (get-buffer scratch-buffer-name)))
    (unless scratch-buffer
      (setq scratch-buffer (get-buffer-create scratch-buffer-name))
      (with-current-buffer scratch-buffer
        (lisp-interaction-mode)
        (insert initial-scratch-message)))
    (switch-to-buffer scratch-buffer)))

(global-set-key "\C-cbs" 'switch-buffer-scratch)

Answer 11

यह वही है जो मैं उपयोग करता हूं - मेरे पास एक सुविधाजनक कीस्ट्रोक है। यह आपको *scratch*बफर में भेजता है , भले ही यह पहले से मौजूद हो या न हो, और इसे अंदर जाने के लिए सेट करता हैlisp-interaction-mode

(defun eme-goto-scratch () 
  "this sends you to the scratch buffer"
  (interactive)
  (let ((eme-scratch-buffer (get-buffer-create "*scratch*")))
    (switch-to-buffer eme-scratch-buffer)
    (lisp-interaction-mode)))

Answer 12

मैं अपने स्क्रैच बफर को एक वास्तविक फ़ाइल होना पसंद करता हूं जो स्वचालित रूप से सहेजा जाता है, और इसे फिर से खोलना फ़ाइल खोलने के समान सरल है। स्टार्टअप पर, मैं डिफ़ॉल्ट को मारता हूं और अपना खुद का ऐसा ढूंढता हूं।

(add-hook 'emacs-startup-hook
  (lambda ()
    (kill-buffer "*scratch*")
    (find-file "/Users/HOME/Desktop/.scratch")))

मेरे पास एक कस्टम किल-बफर फ़ंक्शन है जो अनिवार्य रूप से एक ही काम करता है - मेरी व्यक्तिगत स्क्रैच सहेजी गई फ़ाइल को फिर से खोल देता है और डिफ़ॉल्ट खरोंच को मारता है यदि मैं अंतिम दृश्य बफर हूं ।

मैंने बाद मेंdesktop.el लोड करने के लिए कुछ कार्यों को अनुकूलित किया और (kill-buffer "*scratch*")(find-file "/Users/HOME/Desktop/.scratch") ताकि Emacs से बाहर निकलने पर दिखाई देने वाली फ़ाइल डिफ़ॉल्ट खरोंच द्वारा दफन न हो जाए या Emacs को लॉन्च करते समय मेरे कस्टम खरोंच द्वारा दफन न हो जाए।

मैं उपयोग करने का आनंद लेता हूं auto-save-buffers-enhanced, जो स्वचालित रूप से किसी भी फ़ाइल एक्सटेंशन को बचाता है जिसे विशेष रूप से बाहर नहीं किया गया है:

https://github.com/kentaro/auto-save-buffers-enhanced/blob/master/auto-save-buffers-enhanced.el

(require 'auto-save-buffers-enhanced)
(auto-save-buffers-enhanced t)
(setq auto-save-buffers-enhanced-save-scratch-buffer-to-file-p 1)
(setq auto-save-buffers-enhanced-exclude-regexps '("\\.txt" "\\.el" "\\.tex"))

जब मैं कोई बफर फ़ाइल नहीं बनाना चाहता, तो मैं @paprika द्वारा फ़ंक्शन की थोड़ी भिन्नता का उपयोग करता हूं:

(defun lawlist-new-buffer ()
  "Create a new buffer -- \*lawlist\*"
(interactive)
  (let* (
    (n 0)
    bufname)
  (catch 'done
    (while t
      (setq bufname (concat "*lawlist"
        (if (= n 0) "" (int-to-string n))
          "*"))
      (setq n (1+ n))
      (if (not (get-buffer bufname))
        (throw 'done nil)) ))
  (switch-to-buffer (get-buffer-create bufname))
  (text-mode) ))

Answer 13

मैंने अब तक पोस्ट किए गए समाधानों को एक फ़ंक्शन में जोड़ा है:

(defun --scratch-buffer(&optional reset)
  "Get the *scratch* buffer object.
Make new scratch buffer unless it exists. 
If RESET is non-nil arrange it that it can't be killed."
  (let ((R (get-buffer "*scratch*")))
    (unless R
      (message "Creating new *scratch* buffer")
      (setq R (get-buffer-create "*scratch*") reset t))
        (when reset
          (save-excursion
            (set-buffer R)
            (lisp-interaction-mode)
            (make-local-variable 'kill-buffer-query-functions)
            (add-hook 'kill-buffer-query-functions '(lambda()(bury-buffer) nil)
          )))
    R))

इस फ़ंक्शन को अपने .emacs उपयोग में लागू करने के लिए:

(--scratch-buffer t)
(run-with-idle-timer 3 t '--scratch-buffer)

यह स्क्रैच बफर को पहले स्थान पर अविनाशी बना देगा, और अगर बचाया गया तो इसे फिर से बनाया जाएगा। इसके अतिरिक्त हम scratchबफर को जल्दी लाने के लिए एक शॉर्टकट फ़ंक्शन का उपयोग कर सकते हैं :

(defun scratch()
  "Switch to *scratch*.  With prefix-arg delete its contents."
  (interactive)
  (switch-to-buffer (--scratch-buffer))
  (if current-prefix-arg
      (delete-region (point-min) (point-max))
    (goto-char (point-max))))

अतीत में यह मूल स्टार्टअप-निर्देशिका को जानने के लिए उपयोगी साबित हुआ है जिसमें से Emacs शुरू किया गया था। यह या तो खरोंच-बफर desktop-dirnameके default-directoryस्थानीय चर का मान है :

(defvar --scratch-directory
  (save-excursion (set-buffer "*scratch*") default-directory)
  "The `default-directory' local variable of the *scratch* buffer.")

(defconst --no-desktop (member "--no-desktop" command-line-args)
  "True when no desktop file is loaded (--no-desktop command-line switch set).")

(defun --startup-directory ()
  "Return directory from which Emacs was started: `desktop-dirname' or the `--scratch-directory'.
Note also `default-minibuffer-frame'."
  (if (and (not --no-desktop) desktop-dirname) 
      desktop-dirname
    --scratch-directory))

तो --स्टार्टअप-डायरेक्टरी हमेशा आपके मेकफाइल , TODO-file आदि की बेस डायरेक्टरी को लौटाएगी । यदि कोई डेस्कटॉप नहीं है ( -कोई-डेस्कटॉप कमांडलाइन-स्विच या कोई डेस्कटॉप-फाइल नहीं) तो --scratch-directoryवैरिएबल डाइरेक्टरी को पकड़ लेगा Emacs एक बार था के तहत शुरू किया।

Answer 14

EmacsWiki में उत्तर प्राप्त करें: http://www.emacswiki.org/emacs/RecreateScratchBuffer

(defun create-scratch-buffer nil
   "create a scratch buffer"
   (interactive)
   (switch-to-buffer (get-buffer-create "*scratch*"))
   (lisp-interaction-mode))

Answer 15

स्वीकृत उत्तर में जोड़ने के लिए, यदि आपके पास ILO मोड है (और इसके बाद यह स्वतः पूर्ण हो रहा है C-x b, इस प्रकार आपको लिखने नहीं देता है *scratch*), तो प्रयास करें:

C-xb C-b*scratch* RET

C-x b C-b *scratch* RET

Answer 16

C-xb और फिर टाइप करें *scratch* ↩︎

एक नया बफर बनाने के लिए जो लिस्प इंटरैक्शन मोड में भी है।