¿Cómo puedo duplicar toda una línea en Emacs?

Question

Vi esta misma pregunta para VIM y ha sido algo que yo quería saber cómo hacer para Emacs.En ReSharper puedo usar CTRL-D para esta acción.¿Cuál es el menor número de comandos para realizar esto en Emacs?

Answer 1

Yo uso

C-a C-SPACE C-n M-w C-y

que se rompe

• C-a:mover el cursor al comienzo de la línea
• C-SPACE:comenzar una selección ("marca")
• C-n:mover el cursor a la siguiente línea
• M-w:copia región
• C-y:pegar ("pegar")

El mencionado

C-a C-k C-k C-y C-y

equivale a la misma cosa (TMTOWTDI)

• C-a:mover el cursor al comienzo de la línea
• C-k:corte ("matar") de la línea
• C-k:cortar el salto de línea
• C-y:pegar ("pegar") (estamos de vuelta en la plaza de uno)
• C-y:pegar de nuevo (ahora tenemos dos copias de la línea)

Ambos son vergonzosamente detallado en comparación con C-d en el editor, pero en Emacs siempre hay una personalización. C-d está obligado a delete-char por defecto, así que ¿cómo C-c C-d?Simplemente añada lo siguiente a su .emacs:

(global-set-key "\C-c\C-d" "\C-a\C- \C-n\M-w\C-y")

(@Nathan elisp versión es probablemente preferible, porque no se rompe si alguna de las teclas que ha cambiado.)

Cuidado:algunos modos de Emacs puede reclamar C-c C-d para hacer algo más.

Answer 2

Además de las respuestas anteriores también puede definir su propia función para duplicar una línea.Por ejemplo, colocando lo siguiente en su .emacs archivo de realizar C-d duplicar la línea actual.

(defun duplicate-line()
  (interactive)
  (move-beginning-of-line 1)
  (kill-line)
  (yank)
  (open-line 1)
  (next-line 1)
  (yank)
)
(global-set-key (kbd "C-d") 'duplicate-line)

Answer 3

Coloque el cursor en la línea, si no al principio hacer un CTRL-Un, y , a continuación:

CTRL-K

CTRL-K

CTRL-Y

CTRL-Y

Answer 4

Mi versión de una función para duplicar una línea que funciona bien con deshacer y no meterse con la posición del cursor.Fue el resultado de un discusión en gnu.emacs.fuentes de noviembre de 1997.

(defun duplicate-line (arg)
  "Duplicate current line, leaving point in lower line."
  (interactive "*p")

  ;; save the point for undo
  (setq buffer-undo-list (cons (point) buffer-undo-list))

  ;; local variables for start and end of line
  (let ((bol (save-excursion (beginning-of-line) (point)))
        eol)
    (save-excursion

      ;; don't use forward-line for this, because you would have
      ;; to check whether you are at the end of the buffer
      (end-of-line)
      (setq eol (point))

      ;; store the line and disable the recording of undo information
      (let ((line (buffer-substring bol eol))
            (buffer-undo-list t)
            (count arg))
        ;; insert the line arg times
        (while (> count 0)
          (newline)         ;; because there is no newline in 'line'
          (insert line)
          (setq count (1- count)))
        )

      ;; create the undo information
      (setq buffer-undo-list (cons (cons eol (point)) buffer-undo-list)))
    ) ; end-of-let

  ;; put the point in the lowest line and return
  (next-line arg))

A continuación, puede definir CTRL-D para llamar a esta función:

(global-set-key (kbd "C-d") 'duplicate-line)

Answer 5

En lugar de kill-line (C-k) como en C-a C-k C-k C-y C-y el uso de la kill-whole-line comando:

C-S-Backspace
C-y
C-y

Las ventajas más C-k incluir que no importa donde se encuentre en la línea (a diferencia de C-k que requiere ser al inicio de la línea) y también mata el salto de línea (de nuevo algo C-k no hacer).

Answer 6

He aquí otra función para hacer esto.Mi versión no toque el kill ring, y el cursor se termina en la nueva línea de donde estaba en el original.Se va a duplicar la región si está activa (transitoria de la marca de modo), o por defecto a la duplicación de la línea de otra manera.Esto también va a hacer múltiples copias, si se le asigna un prefijo arg, y el comentario a la línea original si se le da un prefijo negativo arg (esto es útil para probar una versión diferente de un comando/declaración manteniendo el viejo).

(defun duplicate-line-or-region (&optional n)
  "Duplicate current line, or region if active.
With argument N, make N copies.
With negative N, comment out original line and use the absolute value."
  (interactive "*p")
  (let ((use-region (use-region-p)))
    (save-excursion
      (let ((text (if use-region        ;Get region if active, otherwise line
                      (buffer-substring (region-beginning) (region-end))
                    (prog1 (thing-at-point 'line)
                      (end-of-line)
                      (if (< 0 (forward-line 1)) ;Go to beginning of next line, or make a new one
                          (newline))))))
        (dotimes (i (abs (or n 1)))     ;Insert N times, or once if not specified
          (insert text))))
    (if use-region nil                  ;Only if we're working with a line (not a region)
      (let ((pos (- (point) (line-beginning-position)))) ;Save column
        (if (> 0 n)                             ;Comment out original with negative arg
            (comment-region (line-beginning-position) (line-end-position)))
        (forward-line 1)
        (forward-char pos)))))

Yo lo tengo enlazado a C-c d:

(global-set-key [?\C-c ?d] 'duplicate-line-or-region)

Esto nunca debe ser re-asignados por un modo o nada, porque C-c seguido por un solo (sin modificar) carta está reservado para el usuario los enlaces.

Answer 7

Nathan, además de su .emacs archivo es el camino a seguir, pero podría ser simplificado ligeramente mediante la sustitución de

  (open-line 1)
  (next-line 1)

con

  (newline)

rendimiento

(defun duplicate-line()
  (interactive)
  (move-beginning-of-line 1)
  (kill-line)
  (yank)
  (newline)
  (yank)
)
(global-set-key (kbd "C-d") 'duplicate-line)

Answer 8

Yo no recuerdo bien cómo la línea de la duplicación de obras en cualquier otro lugar, pero como ex SciTE usuario me gustó una cosa acerca de SciTE-forma:no toque la posición del cursor!Así que todas las recetas anteriores no estaban lo suficientemente bueno para mí, aquí está mi hippie de la versión:

(defun duplicate-line ()
    "Clone line at cursor, leaving the latter intact."
    (interactive)
    (save-excursion
        (let ((kill-read-only-ok t) deactivate-mark)
            (toggle-read-only 1)
            (kill-whole-line)
            (toggle-read-only 0)
            (yank))))

Tenga en cuenta que nada se interponga en realidad asesinado en el proceso, dejando marcas y selección actual intacta.

Por CIERTO, ¿por qué ustedes tanto les gusta a los tirones de cursor cuando hay este bonito n''clean matar-toda la línea cosita (C-S-retroceso)?

Answer 9

instalar duplicado-cosa de melpa:

M-x paquete a instalar RET duplicado-cosa

y agrega este keybinding a archivo init :

(global-set-clave (kbd "M-c") 'duplicado-cosa)

Answer 10

porque no sé, voy a empezar esta ronda de golf con un slowball:

ctrl-k, y, y

Answer 11

'Escribí mi propia versión de duplicate-line, porque yo no quiero arruinar el asesinato de anillo.

  (defun jr-duplicate-line ()
    "EASY"
    (interactive)
    (save-excursion
      (let ((line-text (buffer-substring-no-properties
                        (line-beginning-position)
                        (line-end-position))))
        (move-end-of-line 1)
        (newline)
        (insert line-text))))
  (global-set-key "\C-cd" 'jr-duplicate-line)

Answer 12

Tengo copy-from-above-command vinculados a una tecla y el uso que.Con XEmacs, pero yo no sé acerca de GNU Emacs.

`copia-de-arriba-comando' es un interactivo compilado función Lisp
-- cargado de "/usr/share/xemacs/21.4.15/lisp/misc.elc" (copia-de-arriba-command &opcional ARG)

Documentación: Copia los caracteres de anterior no vacías de la línea de, saliendo el punto anterior.Copia ARG personajes, pero no más allá del final de la línea.Si no argumento dado, copia todo el resto de la línea.Los caracteres copiados son insertado en el buffer antes de punto.

Answer 13

C-a C-k C-k C-y C-y

Answer 14

algo que usted puede ser que desee tener en su .emacs es

(setq kill-whole-line t)

Que, básicamente, mata a toda la línea, más la nueva línea cada vez que se invoca a matar línea (es decir,a través de C-k).Luego, sin código adicional, usted puede hacer C-C-k C-y C-y a duplicar la línea.Se descompone a

C-a go to beginning of line
C-k kill-line (i.e. cut the line into clipboard)
C-y yank (i.e. paste); the first time you get the killed line back; 
    second time gives the duplicated line.

Pero si usted utiliza esta frecuencia entonces tal vez una tecla dedicada de unión podría ser una mejor idea, pero la ventaja de usar C-C-k C-y C-y se puede duplicar la línea de otros lugares, en lugar de sólo por debajo de la línea actual.

Answer 15

Los valores predeterminados son horribles para esto.Sin embargo, se puede extender Emacs para trabajar como SlickEdit y TextMate, es decir, copiar/cortar la corriente de línea cuando no hay texto seleccionado:

(transient-mark-mode t)
(defadvice kill-ring-save (before slick-copy activate compile)
  "When called interactively with no active region, copy a single line instead."
  (interactive
   (if mark-active (list (region-beginning) (region-end))
     (message "Copied line")
     (list (line-beginning-position)
           (line-beginning-position 2)))))
(defadvice kill-region (before slick-cut activate compile)
  "When called interactively with no active region, kill a single line instead."
  (interactive
   (if mark-active (list (region-beginning) (region-end))
     (list (line-beginning-position)
           (line-beginning-position 2)))))

Coloque el sobre en .emacs.Entonces, para copiar una línea, M-w.Para eliminar una línea, C-w.Para duplicar una línea, C-a M-w C-y C-y C-y ....

Answer 16

Me gustó FraGGod versión, excepto por dos cosas:(1) no comprueba si el buffer es ya de sólo lectura con (interactive "*"), y (2) se produce un error en la última línea del buffer si la última línea está vacía (como no se puede matar la línea en ese caso), dejando el búfer de sólo lectura.

He hecho los siguientes cambios para resolver que:

(defun duplicate-line ()
  "Clone line at cursor, leaving the latter intact."
  (interactive "*")
  (save-excursion
    ;; The last line of the buffer cannot be killed
    ;; if it is empty. Instead, simply add a new line.
    (if (and (eobp) (bolp))
        (newline)
      ;; Otherwise kill the whole line, and yank it back.
      (let ((kill-read-only-ok t)
            deactivate-mark)
        (toggle-read-only 1)
        (kill-whole-line)
        (toggle-read-only 0)
        (yank)))))

Answer 17

Con los recientes emacs, se puede utilizar M-w en cualquier lugar en la línea de la copia.Por lo que se convierte en:

M-w C-a RET C-y

Answer 18

Vi muy complejas soluciones, de todos modos...

(defun duplicate-line ()
  "Duplicate current line"
  (interactive)
  (kill-whole-line)
  (yank)
  (yank))
(global-set-key (kbd "C-x M-d") 'duplicate-line)

Answer 19

Hay paquete llamado Avy Se ha comando avy-copia de la línea.Cuando se utiliza este comando, cada línea de tu ventana llega combinación de letras.A continuación, sólo tiene que tipo de combinación y se puede conseguir que la línea.Esto también funciona para la región.A continuación, sólo tiene que escribir dos combinaciones.

Aquí se puede ver la interfaz:

http://i68.tinypic.com/24fk5eu.png

Answer 20

@[Kevin Conner]:Muy cerca, a lo que yo sé.La única otra cosa a considerar es el de encender kill-whole-line para incluir la nueva línea en el C-k.

Answer 21

Cuando se llama de forma interactiva con ninguna actividad de la región, COPIA (M-w) de una sola línea en su lugar :

(defadvice kill-ring-save (before slick-copy activate compile)
  "When called interactively with no active region, COPY a single line instead."
  (interactive
   (if mark-active (list (region-beginning) (region-end))
     (message "Copied line")
     (list (line-beginning-position)
           (line-beginning-position 2)))))

Cuando se llama de forma interactiva con ninguna actividad de la región, MATAR (C-w) de una sola línea en su lugar.

(defadvice kill-region (before slick-cut activate compile)
  "When called interactively with no active region, KILL a single line instead."
  (interactive
   (if mark-active (list (region-beginning) (region-end))
     (message "Killed line")
     (list (line-beginning-position)
           (line-beginning-position 2)))))

También, en una nota relacionada:

(defun move-line-up ()
  "Move up the current line."
  (interactive)
  (transpose-lines 1)
  (forward-line -2)
  (indent-according-to-mode))

(defun move-line-down ()
  "Move down the current line."
  (interactive)
  (forward-line 1)
  (transpose-lines 1)
  (forward-line -1)
  (indent-according-to-mode))

(global-set-key [(meta shift up)]  'move-line-up)
(global-set-key [(meta shift down)]  'move-line-down)

Answer 22

ctrl-k, ctrl-k, (posición a la nueva ubicación) ctrl-y

Añadir un ctrl-un si no estás comenzando por el principio de la línea.Y la 2ª ctrl-k es agarrar el carácter de nueva línea.Puede ser eliminado si sólo quieres el texto.

Answer 23

Escribo para mi preferencia.

(defun duplicate-line ()
  "Duplicate current line."
  (interactive)
  (let ((text (buffer-substring-no-properties (point-at-bol) (point-at-eol)))
        (cur-col (current-column)))
    (end-of-line) (insert "\n" text)
    (beginning-of-line) (right-char cur-col)))
(global-set-key (kbd "C-c d l") 'duplicate-line)

Pero he encontrado esto tendría algún problema cuando la línea actual contiene caracteres multi-byte (por ejemplo,Caracteres CJK).Si se produce este problema, intente esto en su lugar:

(defun duplicate-line ()
  "Duplicate current line."
  (interactive)
  (let* ((text (buffer-substring-no-properties (point-at-bol) (point-at-eol)))
         (cur-col (length (buffer-substring-no-properties (point-at-bol) (point)))))
    (end-of-line) (insert "\n" text)
    (beginning-of-line) (right-char cur-col)))
(global-set-key (kbd "C-c d l") 'duplicate-line)

Answer 24

Esta funcionalidad debe coincidir con JetBrains la implementación en términos de duplicar tanto por línea o región y, a continuación, salir del punto y/ o región activa como se esperaba:

Simplemente un contenedor para todo el formulario interactivo:

(defun wrx/duplicate-line-or-region (beg end)
  "Implements functionality of JetBrains' `Command-d' shortcut for `duplicate-line'.
   BEG & END correspond point & mark, smaller first
   `use-region-p' explained: 
   http://emacs.stackexchange.com/questions/12334/elisp-for-applying-command-to-only-the-selected-region#answer-12335"
  (interactive "r")
  (if (use-region-p)
      (wrx/duplicate-region-in-buffer beg end)
    (wrx/duplicate-line-in-buffer)))

El que llama a este,

(defun wrx/duplicate-region-in-buffer (beg end)
  "copy and duplicate context of current active region
   |------------------------+----------------------------|
   |        before          |           after            |
   |------------------------+----------------------------|
   | first <MARK>line here  | first line here            |
   | second item<POINT> now | second item<MARK>line here |
   |                        | second item<POINT> now     |
   |------------------------+----------------------------|
   TODO: Acts funky when point < mark"
  (set-mark-command nil)
  (insert (buffer-substring beg end))
  (setq deactivate-mark nil))

O este

(defun wrx/duplicate-line-in-buffer ()
  "Duplicate current line, maintaining column position.
   |--------------------------+--------------------------|
   |          before          |          after           |
   |--------------------------+--------------------------|
   | lorem ipsum<POINT> dolor | lorem ipsum dolor        |
   |                          | lorem ipsum<POINT> dolor |
   |--------------------------+--------------------------|
   TODO: Save history for `Cmd-Z'
   Context: 
   http://stackoverflow.com/questions/88399/how-do-i-duplicate-a-whole-line-in-emacs#answer-551053"
  (setq columns-over (current-column))
  (save-excursion
    (kill-whole-line)
    (yank)
    (yank))
  (let (v)
    (dotimes (n columns-over v)
      (right-char)
      (setq v (cons n v))))
  (next-line))

Y luego tengo esta obligado a meta+mayús+d

(global-set-key (kbd "M-D") 'wrx/duplicate-line-or-region)

Answer 25

Con el prefijo de argumentos, y lo que es (espero) intuitiva comportamiento:

(defun duplicate-line (&optional arg)
  "Duplicate it. With prefix ARG, duplicate ARG times."
  (interactive "p")
  (next-line 
   (save-excursion 
     (let ((beg (line-beginning-position))
           (end (line-end-position)))
       (copy-region-as-kill beg end)
       (dotimes (num arg arg)
         (end-of-line) (newline)
         (yank))))))

El cursor permanecerá en la última línea.Alternativamente, es posible que desee especificar un prefijo para duplicar el siguiente par de líneas a la vez:

(defun duplicate-line (&optional arg)
  "Duplicate it. With prefix ARG, duplicate ARG times."
  (interactive "p")
  (save-excursion 
    (let ((beg (line-beginning-position))
          (end 
           (progn (forward-line (1- arg)) (line-end-position))))
      (copy-region-as-kill beg end)
      (end-of-line) (newline)
      (yank)))
  (next-line arg))

Me encuentro a mí mismo usando ambos a menudo, el uso de una función de contenedor para cambiar el comportamiento del prefijo argumento.

Y un keybinding:(global-set-key (kbd "C-S-d") 'duplicate-line)

Answer 26

;; http://www.emacswiki.org/emacs/WholeLineOrRegion#toc2
;; cut, copy, yank
(defadvice kill-ring-save (around slick-copy activate)
  "When called interactively with no active region, copy a single line instead."
  (if (or (use-region-p) (not (called-interactively-p)))
      ad-do-it
    (kill-new (buffer-substring (line-beginning-position)
                                (line-beginning-position 2))
              nil '(yank-line))
    (message "Copied line")))
(defadvice kill-region (around slick-copy activate)
  "When called interactively with no active region, kill a single line instead."
  (if (or (use-region-p) (not (called-interactively-p)))
      ad-do-it
    (kill-new (filter-buffer-substring (line-beginning-position)
                                       (line-beginning-position 2) t)
              nil '(yank-line))))
(defun yank-line (string)
  "Insert STRING above the current line."
  (beginning-of-line)
  (unless (= (elt string (1- (length string))) ?\n)
    (save-excursion (insert "\n")))
  (insert string))

(global-set-key (kbd "<f2>") 'kill-region)    ; cut.
(global-set-key (kbd "<f3>") 'kill-ring-save) ; copy.
(global-set-key (kbd "<f4>") 'yank)           ; paste.

agregar el elisp arriba a usted init.el, y usted consigue cortar/copiar toda la línea de la función, entonces usted puede F3 F4 para duplicar una línea.

Answer 27

La forma más sencilla es Chris Conway método.

C-a C-SPACE C-n M-w C-y

Esa es la forma por defecto mandato de EMACS.En mi opinión, es mejor utilizar el estándar.Estoy siempre atenta hacia la personalización de la propia clave de unión en EMACS.EMACS es ya lo suficientemente potente, creo que debemos hacer nuestro mejor esfuerzo para adaptarse a sus propios atajos de teclado.

Aunque es un poco largo, pero cuando ya estás acostumbrado a él, usted puede hacer rápido y encontrará que esto es divertido!

Answer 28

Aquí está una función para la duplicación de la línea actual.Con el prefijo de argumentos, va a duplicar la línea varias veces.E. g., C-3 C-S-o se duplicará la actual línea de tres veces.No cambia matar anillo.

(defun duplicate-lines (arg)
  (interactive "P")
  (let* ((arg (if arg arg 1))
         (beg (save-excursion (beginning-of-line) (point)))
         (end (save-excursion (end-of-line) (point)))
         (line (buffer-substring-no-properties beg end)))
    (save-excursion
      (end-of-line)
      (open-line arg)
      (setq num 0)
      (while (< num arg)
        (setq num (1+ num))
        (forward-line 1)
        (insert-string line))
      )))

(global-set-key (kbd "C-S-o") 'duplicate-lines)

Answer 29

No puedo creer que todas estas complicadas soluciones.Se trata de dos combinaciones de teclas:

<C-S-backspace> ejecuta el comando kill-toda la línea de

C-/ ejecuta el comando deshacer

Así <C-S-backspace> C-/ a "copiar" toda una línea (matar y deshacer).

Usted puede, por supuesto, combinar esto con numérico y negativo args a matar a varias líneas, ya sea hacia adelante o hacia atrás.

Answer 30

Esto se siente más natural, con respecto a la respuesta seleccionada por Chris Conway.

(global-set-clave "\C-c\C-d" "\C-a\C \C-n\M-w\C-y\C-p\C-e")

Esto le permite duplicar una línea de varias veces por la simple repetición de la \C-c\C-d pulsaciones de tecla.