¿Vuelve a abrir el búfer * scratch * en Emacs?

Question

Si cerré accidentalmente el cero buffer en Emacs, ¿cómo creo un nuevo scratch buffer?

Answer 1

GNU Emacs enlaces predeterminados:

C-xb*scratch*RET

o, más informa extensamente

M-xswitch-to-buffer *scratch*RET

El tampón *scratch* es el tampón seleccionado en el inicio, y tiene el modo mayor Lisp Interaction. Nota: el modo para el buffer *scratch* está controlado por la variable initial-major-mode.

En general, puede crear tantos buffers "scratch" como desee, y asígneles el nombre que desee.

C-xbNAMERET

cambia a un tampón NAME, creándolo si no existe. Un nuevo buffer no está asociado con un archivo en el disco hasta que utilice C-xC-w (o M-xwrite-fileRET) para seleccionar un archivo en el que se debe guardar.

M-xtext-modeRET

cambia modo mayor del búfer en el modo de texto.Para encontrar todos los modos disponibles (es decir, sin necesidad de nuevos paquetes), se puede obtener una lista escribiendo:

Mxapropos-command -mode$RET

Answer 2

C-x b *scratch* RET y RET con iswitchb-mode habilitado.

Just C-x b *scratch* RET en caso contrario.

Answer 3

C-xb y escriba *scratch*↩︎

para crear una nueva memoria intermedia que está en el modo de interacción Lisp también.

Answer 4

encontré esto hace años cuando Primero comencé a usar emacs; No tengo idea de dónde está ahora, pero siempre ha tenido un hogar en mis archivos .el personales. Aparece en las búsquedas de 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) 
;;;---------------------------------------------------------------------- 

Answer 5

agrego siguiente en mi .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 yo no quiero ver rascar búfer presiono Cx Ck, pero no la mata, sólo tiene que colocar en al final de la lista de almacenamiento intermedio, entonces la necesito la próxima vez que no tenga que crear una nueva.

Answer 6

Esto es lo que uso - Tengo esto obligado a una cómoda pulsación de tecla. Se le envía a la memoria intermedia *scratch*, independientemente de si es o no ya existe, y lo establece para estar en 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))) 

Answer 7

Solía ​​usar la solución de dwj, y yo estaba muy feliz por eso, hasta el día que se dio cuenta de que falló cuando en realidad renombre el búfer de rayado (por ejemplo, guardándolo).

Entonces adoptó este, que funciona bien para mí:

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

Answer 8

Al igual que la cadena de documentación dice, esta función:

Cambiar a la memoria intermedia de cero. Si no existe el buffer de crear y escribir el mensaje inicial en ella."

Esto traerá un nuevo buffer de cero hasta que se parece a la memoria intermedia cero inicial.

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

Answer 9

Hay una . toda montón de consejos sobre this EmacsWiki page

Ésta es la primera de ellas:

una función muy simple para recrear el cero búfer:

(defun create-scratch-buffer nil 
    "create a scratch buffer" 
    (interactive) 
    (switch-to-buffer (get-buffer-create "*scratch*")) 
    (lisp-interaction-mode))    

Answer 10

he combinado con las soluciones publicadas hasta ahora en una sola función:

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

Para aplicar esta función en sus .emacs uso:

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

Esto hará que el buffer de scratch sea indestructible en el primer colocar, y si se guarda, se volverá a crear.Además podemos usar una función de acceso directo scratch para que aparezca la memoria intermedia rápida:

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

En el pasado ha demostrado ser útil para conocer la puesta en marcha-directorio original a partir del cual se inició Emacs. Este es el valor de desktop-dirname o la variable local default-directory del cero-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)) 

Así --startup-directorio siempre devolverá el directorio base de su makefile, TODO-archivo, etc. En caso no hay una computadora de escritorio (--no desktop commandline-switch o ningún archivo de escritorio) la variable --scratch-directory contendrá el directorio en el que se inició Emacs una vez.

Answer 11

tengo scratch como un comando interactivo para la apertura de una nueva memoria intermedia cero (me gusta tener varios):

(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ó a partir de: http://everything2.com/index.pl?node_id=1038451

Answer 12

Yo prefiero tener mi memoria intermedia cero sea una real archivo que se guarda automáticamente, y volver a abrirlo es tan simple como abrir un archivo. Al inicio, elimino el valor predeterminado y encuentro el mío así.

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

que tienen una función de caché de eliminación a medida que lo hace esencialmente la misma cosa - vuelve a abrir archivo guardado mi arañazos personal y mata al cero defecto si Maté a la última memoria intermedia visible.

I personalizar algunas de las funciones para cargar desktop.eldespués(kill-buffer "*scratch*") y (find-file "/Users/HOME/Desktop/.scratch") para que el archivo última visibles al salir de Emacs no quede enterrado por el cero por defecto o enterrado por mi costumbre de cero cuando se inicia Emacs.

me gusta usar auto-save-buffers-enhanced, que guarda automáticamente cualquier extensión de archivo que no está excluido específicamente:

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

utilizo una ligera variación de la función de @paprika cuando quiero crear una búfer sin visitar archivo:

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

Answer 13

hallazgo respuesta en 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)) 

Answer 14

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

esto no va a cambiar sólo a gran velocidad a *scratch* memoria intermedia (como hago esto con frecuencia), pero volver a crear un búfer y permitir *scratch*lisp-interaction-mode automáticamente si matas accidentalmente. Cambie el enlace como lo desee.

Answer 15

Solo para observar el paquete unkillable-scratch de emacs en MELPA hará esto. También hay scratch-persist que guardará y restaurará automáticamente el búfer entre las sesiones.