Повторно открыть * scratch * buffer в Emacs?

Если я случайно закрыл буфер с нуля в Emacs, как мне создать новый буфер нуля?

ОТВЕТЫ

Ответ 1

GNU Emacs привязки по умолчанию:

C-x b *scratch* RET

или, более verbosely

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

Буфер *scratch* - это буфер, выбранный при запуске, и имеет основной режим Lisp Взаимодействие. Примечание: режим буфера *scratch* управляется переменной initial-major-mode.

В общем, вы можете создать столько "царапин" буферов, сколько хотите, и назовите их, но вы выберете.

C-x b NAME RET

переключается в буфер NAME, создавая его, если он не существует. Новый буфер не связан с файлом на диске, пока вы не будете использовать C-x C-w (или M-x write-file RET), чтобы выбрать файл, в котором он должен быть сохранен.

M-x text-mode RET

изменяет текущий основной режим буфера на режим Text. Чтобы найти все доступные режимы (то есть без каких-либо новых пакетов), вы можете получить список, набрав:

M-x apropos-command -mode$ RET

Ответ 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, но он не убивает его, просто помещайте его в конец списка буферов, поэтому мне это нужно в следующий раз, когда мне не нужно создавать новые один.

Ответ 4

C-x b *scratch* RET y RET с включенным режимом iswitchb.

Только C-x b *scratch* RET в противном случае.

Ответ 5

Я нашел это лет назад, когда впервые начал использовать emacs; Я понятия не имею, где сейчас, но у него всегда был дом в моих личных файлах .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)
;;;----------------------------------------------------------------------

Ответ 6

Раньше я использовал решение dwj, и я был очень доволен этим, пока не понял, что он не удался, когда вы фактически переименовали буфер нуля (например, сохраните его).

Затем я принял это, что хорошо работает для меня:

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

Ответ 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

Ответ 8

Это то, что я использую - это связано с удобным нажатием клавиши. Он отправляет вас в буфер *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)))

Ответ 9

Я предпочитаю, чтобы мой буфер нуля был фактическим файлом, который автоматически сохраняется, а повторное открытие - так же просто, как открытие файла. При запуске я убиваю значение по умолчанию и нахожу свое собственное.

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

У меня есть пользовательская функция kill-buffer, которая делает практически то же самое - снова открывает мой файл с сохраненной записью и убивает по умолчанию, если я убил последний видимый буфер.

Я настроил несколько из функций 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) ))

Ответ 10

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

Это не только быстро переключится на буфер *scratch* (так как я делаю это часто), но заново создаст буфер *scratch* и включит lisp-interaction-mode автоматически, если вы случайно его убьете. Измените привязку, как вам нравится.

Ответ 11

Просто отметить пакет emacs unkillable-scratch в MELPA сделает это. Существует также scratch-persist, который автоматически сохранит и восстановит буфер между сеансами.

Ответ 12

Как и в docstring, эта функция будет:

Переключитесь на буфер нуля. Если буфер не существует, создайте его и напишите в него начальное сообщение. "

Это приведет к появлению нового нуля буфера, который выглядит как исходный буфер нуля.

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

Ответ 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))

So --startup-directory всегда будет возвращать базовый каталог вашего файла makefile, TODO файла и т.д. Если нет рабочего стола (--no-desktop commandline-switch или no desktop-file), переменная --scratch-directory будет содержать директорию Emacs, которая была когда-то запущена.

Ответ 15

Чтобы добавить к принятому ответу, если у вас включен режим ILO (и он автоматически заполняется после C-x b, что не позволяет вам писать *scratch*), попробуйте:

C-x b C-b *scratch* RET

Cx b Cb *scratch* RET

Ответ 16

C-x b, а затем введите *scratch* ↩︎

чтобы создать новый буфер, который также находится в режиме взаимодействия lisp.