Czy ponownie otworzyć bufor * scratch * w Emacsie?

Gdybym przypadkowo zamknął zarysowania bufor w Emacsa, jak mogę utworzyć nowy zarysowania bufor?

Domyślne powiązania GNU Emacsa:

C-xb *scratch* RET

lub bardziej dosłownie

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

*scratch*Bufor jest wybrany podczas ładowania, bufor, i jest główną trybu Lisp interakcji . Uwaga: tryb *scratch*bufora jest kontrolowany przez zmienną initial-major-mode.

Ogólnie rzecz biorąc, możesz utworzyć dowolną liczbę buforów „scratch” i nadać im dowolne nazwy.

C-xb NAME RET

przełącza się na bufor NAME, tworząc go, jeśli nie istnieje. Nowy bufor nie jest powiązany z plikiem na dysku, dopóki nie użyjesz C-xC-w(lub M-x write-file RET) do wybrania pliku, w którym ma zostać zapisany.

M-x text-mode RET

zmienia tryb główny bieżącego bufora na tryb tekstowy. Aby znaleźć wszystkie dostępne tryby (to znaczy nie wymagając żadnych nowych pakietów), możesz uzyskać listę, wpisując:

M-x apropos-command -mode$ RET

Dodaję w moim .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)))

Jeśli nie chcesz widzieć zadrapanie bufor naciśnięciu Cx Ck, ale nie zabić, po prostu miejsce na końcu listy bufora, więc to muszę to następnym razem nie trzeba tworzyć nowego.

Na tej stronie EmacsWiki znajduje się cała masa wskazówek .

Oto pierwszy:

Bardzo prosta funkcja do odtworzenia bufora magazynującego:

(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 z włączonym trybem iswitchb.

W *scratch*przeciwnym razie po prostu Cx b RET.

Znalazłem to lata temu, kiedy zacząłem używać emacsa; Nie mam pojęcia, gdzie teraz, ale zawsze miał miejsce w moich osobistych plikach .el. Pojawia się w wyszukiwaniach 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)
;;;----------------------------------------------------------------------

Kiedyś korzystałem z rozwiązania dwj i byłem z niego całkiem zadowolony, aż do dnia, w którym zdałem sobie sprawę, że zawiodło, kiedy faktycznie zmieniasz nazwę bufora magazynującego (na przykład zapisując go).

Potem przyjąłem to, co dobrze mi pasuje:

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

Mam scratchjako interaktywną komendę do otwierania nowego bufora na zarysowania (lubię mieć kilka):

(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

zaczerpnięte z: http://everything2.com/index.pl?node_id=1038451

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

To nie tylko szybko przełączy się na *scratch*bufor (ponieważ robię to często), ale ponownie utworzę *scratch*bufor i włączy się lisp-interaction-modeautomatycznie, jeśli zabijesz go przypadkowo. Zmień wiązanie, jak chcesz.

Wystarczy zauważyć, że pakiet emacsa unkillable-scratchw MELPIE zrobi to. Jest też to, scratch-persistże automatycznie zapisuje i przywraca bufor między sesjami.

Jak mówi dokumentacja, ta funkcja:

Przełącz się na bufor magazynujący. Jeśli bufor nie istnieje, utwórz go i zapisz w nim początkową wiadomość ”.

Spowoduje to podniesienie nowego bufora magazynującego, który wygląda jak początkowy bufor magazynujący.

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

Tego właśnie używam - mam to związane z wygodnym naciśnięciem klawisza. Wysyła cię do *scratch*bufora, niezależnie od tego, czy już istnieje, i ustawia go nalisp-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)))

Wolę, aby mój bufor magazynujący był rzeczywistym plikiem, który jest automatycznie zapisywany, a ponowne otwarcie jest tak proste, jak otwarcie pliku. Podczas uruchamiania zabijam domyślne i znajduję własne w ten sposób.

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

Mam niestandardową funkcję zabijania bufora, która zasadniczo robi to samo - ponownie otwiera mój osobisty zapisany plik z zadrapaniami i zabija domyślną zarysowanie, jeśli zabiłem ostatni widoczny bufor.

Dostosowałem kilka desktop.elfunkcji do wczytywania później (kill-buffer "*scratch*") i (find-file "/Users/HOME/Desktop/.scratch")tak, aby plik ostatnio widoczny po wyjściu z Emacsa nie został zakopany przez domyślne zadrapanie lub przez moje niestandardowe zadrapanie podczas uruchamiania Emacsa.

Lubię używać auto-save-buffers-enhanced, który automatycznie zapisuje każde rozszerzenie pliku, które nie jest wyraźnie wykluczone:

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

Używam niewielkiej odmiany funkcji @paprika, gdy chcę utworzyć bufor odwiedzający bez plików:

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

Zgłoszone do tej pory rozwiązania połączyłem w jedną funkcję:

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

Aby zastosować tę funkcję w swoim .emacs, użyj:

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

To spowoduje, że bufor magazynowania będzie niezniszczalny, a jeśli zostanie zapisany, zostanie odtworzony. Dodatkowo możemy użyć funkcji skrótu, scratchaby szybko wywołać bufor:

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

W przeszłości przydatna była znajomość oryginalnego katalogu startowego, z którego został uruchomiony Emacs. To jest wartość desktop-dirnamelub default-directoryzmienna lokalna bufora magazynującego:

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

Tak więc --startup-directory zawsze zwróci katalog podstawowy twojego makefile, pliku TODO itp. W przypadku braku pulpitu ( --no-desktop commandline-switch lub brak pliku desktop) --scratch-directoryzmienna będzie przechowywać katalog, w którym kiedyś był Emacs zaczął pod.

znajdź odpowiedź w 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))

Aby dodać do zaakceptowanej odpowiedzi, jeśli masz włączony tryb ILO (i jest on automatycznie uzupełniany po C-x b, więc nie pozwala ci pisać *scratch*), spróbuj:

C-xb C-b*scratch* RET

C-x b C-b *scratch* RET

C-xb a następnie wpisz *scratch* ↩︎

aby utworzyć nowy bufor, który jest również w trybie interakcji Lisp.