Buka kembali * awal * buffer di Emacs?

Jika saya secara tidak sengaja menutup buffer awal di Emacs, bagaimana cara membuat buffer awal yang baru ?

Binding default GNU Emacs:

C-xb *scratch* RET

atau, lebih tepatnya

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

The *scratch*buffer buffer yang dipilih pada startup, dan memiliki besar modus Lisp Interaksi . Catatan: mode untuk *scratch*buffer dikendalikan oleh variabel initial-major-mode.

Secara umum Anda dapat membuat buffer "scratch" sebanyak yang Anda inginkan, dan beri nama sesuka Anda.

C-xb NAME RET

beralih ke buffer NAME, membuatnya jika tidak ada. Buffer baru tidak dikaitkan dengan file pada disk hingga Anda menggunakan C-xC-w(atau M-x write-file RET) untuk memilih file yang harus disimpan.

M-x text-mode RET

mengubah mode utama buffer saat ini ke mode Teks. Untuk menemukan semua mode yang tersedia (yaitu, tanpa memerlukan paket baru), Anda bisa mendapatkan daftar dengan mengetik:

M-x apropos-command -mode$ RET

Saya menambahkan berikut ini di .emacs saya:

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

Jika saya tidak ingin melihat scratch buffer saya menekan Cx Ck, tetapi tidak mematikannya, cukup tempatkan di akhir daftar buffer, jadi saya membutuhkannya lain kali saya tidak perlu membuat yang baru.

Ada banyak tips di halaman EmacsWiki ini .

Inilah yang pertama:

Fungsi yang sangat sederhana untuk membuat ulang buffer awal:

(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 dengan mode iswitchb diaktifkan.

Cx b *scratch*RET sebaliknya.

Saya menemukan ini tahun lalu ketika saya mulai menggunakan emacs; Saya tidak tahu di mana sekarang tetapi selalu memiliki rumah di file .el pribadi saya. Itu muncul dalam pencarian 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)
;;;----------------------------------------------------------------------

Saya dulu menggunakan solusi dwj, dan saya cukup senang tentang hal itu, sampai hari saya menyadari bahwa itu gagal ketika Anda benar-benar mengganti nama buffer awal (misalnya dengan menyimpannya).

Lalu saya mengadopsi ini, yang bekerja dengan baik untuk saya:

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

Saya memiliki scratchsebagai perintah interaktif untuk membuka buffer awal yang baru (saya ingin memiliki beberapa):

(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

diadopsi dari: http://everything2.com/index.pl?node_id=1038451

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

Ini tidak hanya akan dengan cepat beralih ke *scratch*buffer (karena saya sering melakukan ini), tetapi membuat ulang *scratch*buffer dan mengaktifkan lisp-interaction-modesecara otomatis jika Anda membunuhnya secara tidak sengaja. Ubah ikatan yang Anda inginkan.

Sekadar diketahui paket emacs unkillable-scratchdi MELPA akan melakukan ini. Ada juga scratch-persistyang secara otomatis akan menyimpan dan mengembalikan buffer antar sesi.

Seperti kata docstring, fungsi ini akan:

Beralih ke buffer awal. Jika buffer tidak ada, buat dan tulis pesan awal ke dalamnya. "

Ini akan membawa buffer awal baru yang terlihat seperti buffer awal awal.

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

Inilah yang saya gunakan - saya memiliki keystroke yang nyaman ini. Ini mengirim Anda ke *scratch*buffer, terlepas dari apakah sudah ada atau belum, dan mengaturnya untuk masuklisp-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)))

Saya lebih suka memiliki buffer awal saya menjadi file aktual yang disimpan secara otomatis, dan membuka kembali itu semudah membuka file. Saat startup, saya mematikan default dan menemukan sendiri seperti ini.

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

Saya memiliki fungsi kill-buffer kustom yang pada dasarnya melakukan hal yang sama - membuka kembali file pribadi saya yang tersimpan dan membunuh awal default jika saya membunuh buffer yang terlihat terakhir.

Saya mengkustomisasi beberapa desktop.elfungsi untuk memuat setelah (kill-buffer "*scratch*") dan(find-file "/Users/HOME/Desktop/.scratch") agar file terakhir terlihat pada saat keluar dari Emacs tidak dikubur oleh goresan standar atau dikubur oleh goresan kustom saya ketika meluncurkan Emacs.

Saya menikmati menggunakan auto-save-buffers-enhanced , yang secara otomatis menyimpan ekstensi file apa pun yang tidak dikecualikan secara khusus:

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

Saya menggunakan sedikit variasi fungsi oleh @paprika ketika saya ingin membuat buffer kunjungan tanpa file:

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

Saya telah menggabungkan solusi yang diposting sejauh ini ke dalam satu fungsi:

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

Untuk menerapkan fungsi ini di .emacs Anda gunakan:

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

Ini akan membuat buffer awal tidak bisa dihancurkan di tempat pertama, dan jika disimpan akan dibuat ulang. Selain itu kami dapat menggunakan fungsi pintasan scratchuntuk membuka buffer dengan cepat:

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

Di masa lalu, terbukti bermanfaat untuk mengetahui direktori startup-awal dari mana Emacs dimulai. Ini adalah nilai desktop-dirnameatau default-directoryvariabel lokal buffer awal:

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

Jadi --startup-direktori akan selalu mengembalikan direktori dasar makefile Anda, TODO-file dll. Jika tidak ada desktop ( --no-desktop commandline-switch atau tidak ada desktop-file) --scratch-directoryvariabel akan menyimpan direktori Emacs dulu mulai di bawah.

temukan jawabannya di 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))

Untuk menambah jawaban yang diterima, jika Anda memiliki mode ILO aktif (dan setelah itu pelengkapan otomatis C-x b, sehingga tidak memungkinkan Anda menulis *scratch*), maka cobalah:

C-xb C-b*scratch* RET

C-x b C-b *scratch* RET

C-xb lalu ketik *scratch* ↩︎

untuk membuat buffer baru yang ada dalam mode interaksi lisp juga.