Rouvrir le tampon * scratch * dans Emacs?

Si je accidentellement fermé le zéro tampon dans Emacs, comment puis-je créer une nouvelle zéro tampon?

Liaisons par défaut de GNU Emacs:

C-xb *scratch* RET

ou, plus verbeusement

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

Le *scratch*tampon est le tampon sélectionné au démarrage et possède le mode majeur Lisp Interaction . Remarque: le mode du *scratch*tampon est contrôlé par la variable initial-major-mode.

En général, vous pouvez créer autant de tampons «scratch» que vous le souhaitez et les nommer comme vous le souhaitez.

C-xb NAME RET

bascule vers un tampon NAME, le créant s'il n'existe pas. Un nouveau tampon n'est pas associé à un fichier sur le disque jusqu'à ce que vous utilisiez C-xC-w(ou M-x write-file RET) pour choisir un fichier dans lequel il doit être enregistré.

M-x text-mode RET

change le mode principal du tampon actuel en mode Texte. Pour trouver tous les modes disponibles (c'est-à-dire sans nécessiter de nouveaux packages), vous pouvez obtenir une liste en tapant:

M-x apropos-command -mode$ RET

J'ajoute ce qui suit dans mes .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)))

Si je ne veux pas voir de zéro tampon je presse Ck Cx, mais il ne tue pas, lieu juste à la fin de la liste des tampons, donc je besoin prochaine fois que je ne dois pas en créer un nouveau.

Il y a tout un tas d'astuces sur cette page EmacsWiki .

Voici le premier:

Une fonction très simple pour recréer le tampon de travail:

(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 avec le mode iswitchb activé.

*scratch*Sinon, juste Cx b RET.

J'ai découvert cela il y a des années lorsque j'ai commencé à utiliser emacs; Je ne sais pas où maintenant mais il a toujours eu une place dans mes fichiers personnels .el. Il apparaît dans les recherches 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)
;;;----------------------------------------------------------------------

J'avais l'habitude d'utiliser la solution de dwj, et j'en étais plutôt content, jusqu'au jour où j'ai réalisé qu'elle échouait lorsque vous renommez réellement le tampon de travail (par exemple en le sauvegardant).

Ensuite, j'ai adopté ceci, qui fonctionne bien pour moi:

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

J'ai scratchcomme commande interactive pour ouvrir un nouveau tampon de scratch (j'aime en avoir plusieurs):

(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

adopté de: http://everything2.com/index.pl?node_id=1038451

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

Cela ne passera pas seulement rapidement en *scratch*tampon (puisque je le fais fréquemment), mais recréera un *scratch*tampon et s'activera lisp-interaction-modeautomatiquement si vous le tuez accidentellement. Modifiez la reliure à votre guise.

Juste pour noter que le package emacs unkillable-scratchdans MELPA fera cela. Il y a aussi scratch-persistqui sauvegardera et restaurera automatiquement le tampon entre les sessions.

Comme le dit la docstring, cette fonction va:

Basculez vers le tampon de travail. Si le tampon n'existe pas, créez-le et écrivez-y le message initial. "

Cela apportera un nouveau tampon de scratch qui ressemble au tampon de scratch initial.

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

C'est ce que j'utilise - je l'ai lié à une frappe pratique. Il vous envoie au*scratch* tampon, qu'il existe déjà ou non, et le définit pour être danslisp-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)))

Je préfère que mon tampon de travail soit un fichier réel qui est automatiquement enregistré, et sa réouverture est aussi simple que d'ouvrir un fichier. Au démarrage, je tue la valeur par défaut et trouve la mienne comme ça.

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

J'ai une fonction de kill-buffer personnalisée qui fait essentiellement la même chose - rouvre mon fichier personnel enregistré de scratch et tue le scratch par défaut si j'ai tué le dernier tampon visible.

J'ai personnalisé quelques-unes des desktop.elfonctions à charger après (kill-buffer "*scratch*") et(find-file "/Users/HOME/Desktop/.scratch") pour que le fichier visible pour la dernière fois à la sortie d'Emacs ne soit pas enterré par le scratch par défaut ou enterré par mon scratch personnalisé lors du lancement d'Emacs.

J'aime utiliser auto-save-buffers-enhanced, qui enregistre automatiquement toute extension de fichier qui n'est pas spécifiquement exclue:

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

J'utilise une légère variation de la fonction par @paprika lorsque je veux créer un tampon de visite sans fichier:

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

J'ai combiné les solutions publiées jusqu'à présent en une seule fonction:

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

Pour appliquer cette fonction dans votre .emacs, utilisez:

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

Cela rendra le tampon de scratch indestructible en premier lieu, et s'il est enregistré, il sera recréé. De plus, nous pouvons utiliser une fonction de raccourci scratchpour faire apparaître le tampon rapidement:

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

Dans le passé, il s'est avéré utile de connaître le répertoire de démarrage d'origine à partir duquel Emacs a été lancé. C'est la valeur desktop-dirnameou la default-directoryvariable locale du scratch-buffer:

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

Donc --startup-directory retournera toujours le répertoire de base de votre makefile, TODO-file etc. Dans le cas où il n'y a pas de bureau ( --no-desktop commandline-switch ou pas de desktop-file) la --scratch-directoryvariable contiendra le répertoire qu'Emacs était une fois commencé sous.

trouver la réponse dans 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))

Pour ajouter à la réponse acceptée, si vous avez activé le mode ILO (et qu'il se complète automatiquement après C-x b, vous ne permettant donc pas d'écrire *scratch*), essayez:

C-xb C-b*scratch* RET

C-x b C-b *scratch* RET

C-xb puis tapez *scratch* ↩︎

pour créer un nouveau tampon qui est également en mode d'interaction lisp.