* Scratch * -Puffer in Emacs erneut öffnen?

Wenn ich die versehentlich geschlossene Kratzer Puffer in Emacs, wie erstelle ich einen neuen Scratch - Puffer?

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 von der Variablen gesteuert initial-major-mode.

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

C-xb NAME RET

wechselt zu einem Puffer NAMEund erstellt ihn, wenn er nicht vorhanden ist. Ein neuer Puffer wird einer Datei auf der Festplatte erst zugeordnet, wenn Sie mit C-xC-w(oder M-x write-file RET) eine Datei auswä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 neue Pakete zu benötigen), können Sie eine Liste abrufen, indem Sie Folgendes eingeben:

M-x apropos-command -mode$ RET

Ich füge in meinen .emacs Folgendes 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 will nicht sehen , Kratzer Puffer I drücken Cx Ck, aber es ist es nicht töten, nur Platz am Ende der Pufferliste, so ist, dann muss ich es beim nächsten Mal , wenn ich muss nicht neu erstellen.

Auf dieser EmacsWiki-Seite gibt es eine ganze Reihe von Tipps .

Hier ist der erste:

Eine sehr einfache Funktion zum Neuerstellen des Arbeitspuffers:

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

Cx b *scratch*RET y RET mit aktiviertem iswitchb-Modus.

Nur Cx b *scratch*RET sonst.

Ich habe es vor Jahren gefunden, als ich anfing, Emacs zu verwenden. Ich habe keine Ahnung, wo jetzt, aber es hat immer ein Zuhause in meinen persönlichen .el-Dateien gehabt. Es erscheint in 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)
;;;----------------------------------------------------------------------

Ich habe die Lösung von dwj verwendet und war ziemlich glücklich darüber, bis mir klar wurde, dass sie fehlgeschlagen ist, als Sie sie tatsächlich umbenannten den Scratch - Puffer (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*")))

Ich habe scratchals interaktiven Befehl zum Öffnen eines neuen Arbeitspuffers (ich möchte mehrere haben):

(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

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

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

Dadurch wird nicht nur schnell auf *scratch*Puffer umgeschaltet (da ich dies häufig mache), sondern es wird auch ein *scratch*Puffer neu erstellt und lisp-interaction-modeautomatisch aktiviert , wenn Sie ihn versehentlich beenden. Ändern Sie die Bindung nach Ihren Wünschen.

Nur um zu beachten, Emacs-Paket unkillable-scratchin MELPA wird dies tun. Außerdem wird scratch-persistder Puffer zwischen den Sitzungen automatisch gespeichert und wiederhergestellt.

Wie der Docstring sagt, wird diese Funktion:

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

Dadurch wird ein neuer Scratch-Puffer aufgerufen, der dem anfä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)

Dies ist, was ich benutze - ich habe dies an einen bequemen Tastendruck gebunden. Es sendet Sie an den *scratch*Puffer, unabhängig davon, ob er bereits vorhanden ist oder nicht, und setzt ihn auf "In"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)))

Ich möchte, dass mein Arbeitspuffer eine tatsächliche Datei ist, die automatisch gespeichert wird, und das erneute Öffnen ist so einfach wie das Öffnen einer Datei. Beim Start töte ich die Standardeinstellung und finde meine eigene so.

(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 dasselbe tut - öffnet meine persönliche gespeicherte Scratch-Datei erneut und beendet den Standard-Scratch, wenn ich den letzten sichtbaren Puffer getötet habe.

Ich habe einige der desktop.elFunktionen angepasst, die nach (kill-buffer "*scratch*") und geladen werden sollen(find-file "/Users/HOME/Desktop/.scratch") damit die Datei zuletzt sichtbar auf Emacs verlass nicht durch die Standard - Kratzer oder begraben durch meine benutzerdefinierten Kratzer begraben werden , wenn Emacs starten.

Ich benutze es gerne auto-save-buffers-enhanced , wodurch automatisch alle Dateierweiterungen gespeichert werden, 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 Besuchspuffer ohne Datei 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) ))

Ich habe die bisher veröffentlichten Lösungen in 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 Ihren .emacs anzuwenden, verwenden Sie:

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

Dadurch wird der Arbeitspuffer in erster Linie unzerstörbar, und wenn er gespeichert wird, wird er neu erstellt. Zusätzlich können wir eine Verknüpfungsfunktion verwenden scratch, 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 desktop-dirnameoder die default-directorylokale Variable 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))

So --startup-Verzeichnis wird immer wieder zurückkehren das Basisverzeichnis Ihrer Make - Datei, TODO-Datei usw. Im Fall gibt es keine Desktop ( --no-Desktop - Commandline -Switch oder keine Desktop-Datei) die --scratch-directoryVariable halten Verzeichnis Emacs war einmal begann unter.

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

Um die akzeptierte Antwort zu ergänzen , versuchen Sie Folgendes, wenn Sie den ILO-Modus aktiviert haben (und dieser nachher automatisch vervollständigt wird und Sie C-x bdaher nicht schreiben können *scratch*):

C-xb C-b*scratch* RET

C-x b C-b *scratch* RET

C-xb und geben Sie dann ein *scratch* ↩︎

um einen neuen Puffer zu erstellen, der sich ebenfalls im Lisp-Interaktionsmodus befindet.