it-swarm.com.de

* Scratch * -Puffer in Emacs erneut öffnen?

Wenn ich versehentlich den scratch buffer in Emacs geschlossen habe, wie erstelle ich einen neuen scratch buffer?

161
Fortepianissimo

GNU Emacs Standardbindungen:

C-xb *scratch* RET

oder ausführlicher

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

Der *scratch*-Puffer ist der beim Start ausgewählte Puffer und hat den Hauptmodus LISP-Interaktion . Hinweis: Der Modus für den *scratch*-Puffer wird durch die Variable initial-major-mode gesteuert.

Im Allgemeinen können Sie so viele "Scratch" -Puffer erstellen, wie Sie möchten, und diese nach Belieben benennen.

C-xb NAMEname__ RET

wechselt zu einem Puffer NAMEname__, der erstellt wird, wenn er nicht vorhanden ist. Ein neuer Puffer wird erst mit einer Datei auf der Festplatte verknüpft, wenn Sie ihn verwenden C-xC-w (oder M-x write-file RET), um eine Datei auszuwählen, in der sie gespeichert werden soll.

M-x text-mode RET

ändert den Hauptmodus des aktuellen Puffers in den Textmodus. Um alle verfügbaren Modi zu finden (dh ohne dass neue Pakete erforderlich sind), können Sie eine Liste abrufen, indem Sie Folgendes eingeben:

M-x apropos-command -mode$ RET

197
Trey Jackson

Ich füge folgendes in meinen .emacs hinzu:

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

Wenn ich scratch buffer nicht sehen möchte, drücke ich Cx Ck, aber es tötet es nicht, sondern fügt es in das Ende der Pufferliste ein, also brauche ich es das nächste Mal, wenn ich es nicht erstellen muss ein neues.

22
user45273

Es gibt eine ganze Reihe von Tipps auf dieser EmacsWiki-Seite .

Hier ist der erste:

Eine sehr einfache Funktion, um den Arbeitsspeicher neu zu erstellen:

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

C-x b *scratch* RET y RET mit aktiviertem iswitchb-Modus.

Ansonsten nur C-x b *scratch* RET.

8
Steven Huwig

Ich fand das vor Jahren, als ich mit Emacs anfing; Ich habe keine Ahnung, wo jetzt, aber in meinen persönlichen .el-Dateien immer ein Zuhause war. Es erscheint bei Google-Suchen.

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

Ich habe scratch als interaktiven Befehl zum Öffnen eines neuen Scratch-Puffers (ich habe gerne mehrere):

(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

angenommen von: http://everything2.com/index.pl?node_id=1038451

3
paprika

Ich habe früher die Lösung von dwj verwendet und war ziemlich glücklich darüber, bis ich merkte, dass es fehlgeschlagen ist, als Sie tatsächlich den Scratch-Puffer umbenennen (zum Beispiel durch Speichern).

Dann habe ich das übernommen, was für mich gut funktioniert:

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

Nur um das Emacs-Paket unkillable-scratch in MELPA zu beachten, wird dies getan. Es gibt auch scratch-persist, der den Puffer zwischen Sitzungen automatisch speichert und wiederherstellt.

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

Dadurch wird nicht nur schnell zum *scratch*-Puffer gewechselt (da ich dies häufig mache), sondern auch einen *scratch*-Puffer neu erstellen und LISP-interaction-mode automatisch aktivieren, wenn Sie ihn versehentlich beenden. Ändern Sie die Bindung nach Belieben.

2
CodyChan

Das ist was ich benutze - ich habe dies an einen bequemen Tastenanschlag gebunden. Es sendet Sie an den *scratch*-Puffer, unabhängig davon, ob er bereits vorhanden ist oder nicht, und legt fest, dass er sich in LISP-interaction-mode befindet.

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

Ich ziehe es vor, dass mein Scratch-Puffer eine tatsächliche Datei ist, die automatisch gespeichert wird. Das erneute Öffnen ist so einfach wie das Öffnen einer Datei. Beim Start töte ich den Standard und finde meinen eigenen.

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

Ich habe eine benutzerdefinierte Kill-Buffer-Funktion, die im Wesentlichen das Gleiche tut - öffnet meine persönliche, von Scratch gespeicherte Datei wieder und beendet den Standard-Scratch , wenn der letzte sichtbare Puffer getötet wurde.

Ich habe einige der desktop.el-Funktionen angepasst, um after(kill-buffer "*scratch*") und (find-file "/Users/HOME/Desktop/.scratch") zu laden, damit die beim Beenden von Emacs zuletzt sichtbare Datei nicht durch den Standard-Scratch oder durch meinen benutzerdefinierten Scratch beim Starten von Emacs verdeckt wird.

Ich nutze auto-save-buffers-enhanced gerne, um automatisch alle Dateierweiterungen zu speichern, die nicht ausdrücklich ausgeschlossen sind:

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

Ich verwende eine geringfügige Variation der Funktion von @paprika, wenn ich einen No-File-Besuchspuffer erstellen möchte:

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

Ich habe die bisher veröffentlichten Lösungen zu einer Funktion zusammengefasst:

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

Um diese Funktion in Ihrer .emacs use anzuwenden:

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

Dadurch wird der Scratch-Puffer zunächst unzerstörbar, und wenn er gespeichert wird, wird er neu erstellt. Zusätzlich können wir eine Abkürzungsfunktion scratch verwenden, um den Puffer schnell aufzurufen:

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

In der Vergangenheit hat es sich als nützlich erwiesen, das ursprüngliche Startverzeichnis zu kennen, von dem aus Emacs gestartet wurde. Dies ist entweder der Wert von desktop-dirname oder die lokale Variable default-directory des Scratch-Puffers:

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

Also gibt --startup-directory immer das Basisverzeichnis Ihres Makefiles, der TODO-Datei usw. zurück. Falls kein Desktop vorhanden ist ( --no-desktop commandline-switch oder keine Desktop-Datei) Die Variable --scratch-directory enthält das Verzeichnis, in dem Emacs einmal gestartet wurde.

1

Wie der docstring sagt, wird diese Funktion:

Wechseln Sie zum Scratch-Puffer. Wenn der Puffer nicht vorhanden ist, erstellen Sie ihn und schreiben Sie die erste Nachricht in den Puffer. "

Dadurch wird ein neuer Scratch-Puffer aufgerufen, der dem ursprünglichen Scratch-Puffer ähnelt.

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

antwort finden Sie in 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))
0
Qian

Hinzufügen zu der akzeptierten Antwort, wenn Sie den ILO-Modus aktiviert haben (und dieser nachher automatisch vervollständigt wird) C-xb, so dass Sie nicht *scratch*) schreiben können, dann versuchen Sie:

C-xbC-b*scratch* RET

C-x b C-b *scratch* RET

0
petre