Rouvrir le tampon * scratch * dans Emacs?


168

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

Réponses:


199

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


8
Notez qu'il y a quelque chose de spécial à propos de scratch , du moins dans GNU Emacs 21 et versions ultérieures: passer à un nouveau tampon de scratch le remettra en mode d'interaction Lisp.
Peter S. Housel

En guise de suivi rapide, si vous .emacsdéfinissez un mode de scratch par défaut différent , celui-ci sera le mode pour le nouveau scratch - pas le mode d'interaction de liste.
ocodo

23

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.


Quand j'essaye ce conseil de "ibuffer", le conseil est ignoré. Mais pour autant que je sache, "ibuffer" utilise "kill-buffer". Pouvez-vous m'aider?
A.Ellett

Eh bien, frapper "fermer le tampon" dans le scratch de l'interface graphique est supprimé. Cela fonctionne pour Cx k uniquement,
Maurizio Loreti

15

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

9

Cx b *scratch*RET y RET avec le mode iswitchb activé.

*scratch*Sinon, juste Cx b RET.


Avec des liaisons par défaut, le « y RET » est pas nécessaire et juste insère un « y » et un saut de ligne dans le nouveau zéro tampon.
Trey Jackson

Oups, c'est peut-être en mode iswitchb. Désolé pour ça. Sur un autre sujet, essayez iswitchb-mode;)
Steven Huwig

Il ne faut pas non plus, il n'y a rien de spécial dans le nom scratch . On peut utiliser Cx b pour créer n'importe quel nombre de tampons "scratch", avec des noms arbitraires.
Chris Conway

1
Il y a quelque chose de spécial à propos du nom * scratch * (comme indiqué dans la réponse acceptée) - si vous créez un tampon appelé * scratch *, le mode majeur sera défini en fonction de la initial-major-modevariable (lisp-interaction-mode par défaut).
phils

4

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

3

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

3

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


En quoi est-ce supérieur au simple passage à un nouveau tampon (Cx b bufnameRET)?
bignose

@bignose: J'utilise ido-modeet ai généralement pas mal de tampons ouverts. Créer un nouveau tampon en utilisant C-x bserait vraiment fastidieux. Je devrais trouver un nom unique qui ne correspond à aucun des tampons actuellement présents.
paprika

3
(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.


3

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.


2

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)

2

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

2

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

1

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.



0

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


-3

C-xb puis tapez *scratch* ↩︎

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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.