Como faço para duplicar uma linha inteira no Emacs?
https://stackoverflow.com/questions/88399
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
essa mesma pergunta para VIM e tem sido algo que eu mesmo queria saber como fazer para Emacs. Em ReSharper Eu uso CTRL-D para esta ação. Qual é o menor número de comandos para executar esta no Emacs?
Solução
Eu uso
C-a C-SPACE C-n M-w C-y
que decompõe a
-
C-a: move cursor para o início da linha -
C-SPACE: começar uma seleção ( "conjunto de marca") -
C-n: move cursor para a próxima linha -
M-w: região cópia -
C-y: colar ( "puxão")
A descrição acima
C-a C-k C-k C-y C-y
equivale à mesma coisa (TMTOWTDI)
-
C-a: move cursor para o início da linha -
C-k: corte ( "matar") a linha -
C-k: cortar a nova linha -
C-y: colar ( "puxão") (Estamos de volta em uma praça) -
C-y: colar novamente (agora temos duas cópias da linha)
Estes são os dois embaraçosamente detalhado em comparação com C-d no seu editor, mas em Emacs há sempre uma personalização. C-d é obrigado a delete-char por padrão, assim como sobre C-c C-d? Basta adicionar o seguinte ao seu .emacs:
(global-set-key "\C-c\C-d" "\C-a\C- \C-n\M-w\C-y")
(@ versão elisp de Nathan é provavelmente preferível, porque ele não vai quebrar se qualquer uma das teclas são alteradas.)
Cuidado:. Alguns modos Emacs pode recuperar C-c C-d para fazer outra coisa
Outras dicas
Além das respostas anteriores você também pode definir a sua própria função para duplicar uma linha. Por exemplo, colocar o seguinte no seu arquivo .emacs fará C-d duplicar a linha atual.
(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)
Coloque o cursor na linha, se não no início fazer um Ctrl - A , então:
Ctrl - K
Ctrl - K
Ctrl - Y
Ctrl - Y
Minha versão de uma função para duplicar uma linha que funciona agradável com desfazer e não mexer com a posição do cursor. Foi o resultado de um discussão em gnu.emacs.sources de novembro 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))
Em seguida, você pode definir CTRL-D para chamar esta função:
(global-set-key (kbd "C-d") 'duplicate-line)
Em vez de kill-line (C-k) como em C-a C-k C-k C-y C-y usar o kill-whole-line comando:
C-S-Backspace
C-y
C-y
As vantagens sobre C-k incluem que não importa onde o ponto está na linha (ao contrário C-k que requer estar no início da linha) e também mata a nova linha (novamente algo C-k não fazer).
Aqui está ainda outra função para fazer isso. Minha versão não toca o anel de matar, e o cursor acaba na nova linha onde estava no original. Ele vai duplicar a região se é ativo (modo de marca transitória), ou padrão para duplicar a linha de outra forma. Ele também irá fazer várias cópias se for dado um prefixo arg, e comente a linha original se dado uma negativa prefixo arg (isto é útil para testar uma versão diferente de um comando / declaração, mantendo o antigo).
(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)))))
eu tê-lo obrigado a C-c d:
(global-set-key [?\C-c ?d] 'duplicate-line-or-region)
Isso nunca deve ser re-atribuído por um modo ou nada, porque C-c seguido por uma única letra (não modificada) é reservada para ligações de usuários.
Além de Nathan ao seu arquivo .emacs é o caminho a percorrer, mas poderia ser simplificado um pouco, substituindo
(open-line 1)
(next-line 1)
com
(newline)
rendendo
(defun duplicate-line()
(interactive)
(move-beginning-of-line 1)
(kill-line)
(yank)
(newline)
(yank)
)
(global-set-key (kbd "C-d") 'duplicate-line)
Eu não me lembro muito bem como a duplicação de linha funciona em qualquer outro lugar, mas como um ex-usuário SciTE eu gostei uma coisa sobre SciTE-way: não toque na posição do cursor! Assim, todos os recipies acima não eram bons o suficiente para mim, aqui está o meu hippie-version:
(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))))
Note-se que nada é realmente morto no processo, deixando marcas e seleção atual intacto.
BTW, por que vocês gostam tanto de empurrando cursor em torno de quando há essa kill-toda-line nice'n'clean coisinha (C-S-backspace)?
instalar duplicado-coisa de Melpa:
M-x pacote instalar RET duplicado-coisa
e adicione atalho de teclado para inicialização arquivo :
(global-set-key (kbd "M-c") 'duplicar-coisa)
porque eu não sei, eu vou começar esta rodada de golfe com um slowball:
ctrl-k, y, y
' Eu escrevi minha própria versão de duplicate-line, porque eu não quero estragar o anel de matar.
(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)
Eu tenho copy-from-above-command vinculado a uma chave e uso isso. É fornecido com XEmacs, mas eu não sei sobre GNU Emacs.
`copy-from-acima-comando' é um interativa compilado Lisp função
- carregado a partir de "/usr/share/xemacs/21.4.15/lisp/misc.elc" (Cópia-de-acima-comando e opcional ARG)Documentação: caracteres Copie linha não vazia anterior , começando logo ponto acima. caracteres cópia ARG, mas não para além da extremidade dessa linha. Se não argumento dado, copie o resto inteiro da linha. Os caracteres copiados são inserido no tampão antes de ponto.
C-a C-k C-k C-y C-y
algo que você pode querer ter em suas .emacs é
(setq kill-whole-line t)
O que basicamente mata toda a linha mais a nova linha sempre que você invocar matá-line (ou seja, via C-k). Então, sem código extra, você pode apenas fazer C-a C-y C-k C-y para duplicar a linha. Ele quebra 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.
Mas se você usar isso muitas vezes, então talvez uma ligação dedicada chave pode ser uma idéia melhor, mas a vantagem de usar apenas Ca Ck Cy Cy é que você pode duplicar a linha em outro lugar, em vez de apenas abaixo da linha atual.
Os padrões são horríveis para isso. No entanto, você pode estender o Emacs para o trabalho como SlickEdit e TextMate, ou seja, copiar / cortar a linha atual quando nenhum texto for selecionado:
(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 o acima em .emacs. Então, para copiar uma linha, M-w. Para excluir uma linha, C-w. Para duplicar uma linha, C-a M-w C-y C-y C-y ....
Eu gostava versão de FraGGod, exceto por duas coisas: (1) Ele não verifica se o buffer já é só de leitura com (interactive "*"), e (2) ele falhar na última linha do buffer se a última linha é esvaziar (como você não pode matar a linha nesse caso), deixando seu buffer de somente leitura.
Eu fiz as seguintes alterações para resolver isso:
(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)))))
Com emacs recentes, você pode usar em qualquer lugar M-w na linha para copiá-lo. Assim torna-se:
M-w C-a RET C-y
Eu vi soluções muito complexas, de qualquer maneira ...
(defun duplicate-line ()
"Duplicate current line"
(interactive)
(kill-whole-line)
(yank)
(yank))
(global-set-key (kbd "C-x M-d") 'duplicate-line)
Há pacote chamado Avy Tem comando avy-copy-line. Quando você usa esse comando, cada linha na sua janela recebe combinação de letras. Então você só tem que digitar a combinação e você terá essa linha. Isso também funciona para a região. Então você só tem que digitar dois combinação.
Aqui você pode ver de interface:
@ [Kevin Conner]: Muito perto, tão longe quanto eu sei. A única outra coisa a considerar é ligar kill-whole-line para incluir a nova linha na C-k.
Quando chamado interactivamente com nenhuma região activa, CÓPIA (H-W), em vez de uma única linha:
(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)))))
Quando chamado interactivamente com nenhuma região activa, mate (C-w) em vez de uma única linha.
(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)))))
Além disso, em uma 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)
Ctrl - k , Ctrl - k , (posição para a nova localização) Ctrl - y
Adicionar um Ctrl - a , se você não está começando no início da linha. Eo 2º Ctrl - k é agarrar o caractere de nova linha. Ele pode ser removido se você quiser apenas o texto.
Eu escrevo um para minha preferência.
(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)
Mas eu achei que isso teria algum problema quando a linha atual contém caracteres multi-byte (por exemplo caracteres CJK). Se você encontrar esse problema, tente isso em vez disso:
(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)
Esta funcionalidade deve corresponder-se com a implementação JetBrains em termos de duplicação tanto por linha ou região e, em seguida, deixando o ponto e / ou região ativa como esperado:
Apenas um invólucro em torno de forma interativa:
(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)))
O que chama 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))
Ou 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))
E então eu tenho esta obrigado a meta + shift + d
(global-set-key (kbd "M-D") 'wrx/duplicate-line-or-region)
Com argumentos de prefixo, eo que é (espero) o comportamento intuitivo:
(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))))))
O cursor permanecerá na última linha. Alternativamente, você pode querer especificar um prefixo para duplicar as próximas linhas de uma só 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))
Eu me encontrar com ambos, muitas vezes, usando uma função de invólucro para mudar o comportamento do argumento prefixo.
E uma combinação de teclas:
(global-set-key (kbd "C-S-d") 'duplicate-line)
;; 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.
adicionar o elisp acima para você init.el, e você terá de cortar / copiar função linha inteira agora, então você pode F3 F4 para duplicar uma linha.
A maneira mais simples é o método de Chris Conway.
C-a C-SPACE C-n M-w C-y
Essa é a maneira padrão mandatado pelo Emacs. Na minha opinião, é melhor usar o padrão. Estou sempre cuidado no sentido de personalização de um própria chave de ligação no Emacs. EMACS já é suficiente poderoso, eu acho que devemos tentar o nosso melhor para se adaptar às suas próprias combinações de teclas.
Apesar de ser um pouco demorado, mas quando você está acostumado a isso, você pode fazer rápido e vai encontrar isso é divertido!
Aqui está uma função para a duplicação da linha atual. Com argumentos de prefixo, ele irá duplicar a linha várias vezes. Por exemplo, C-3 C-S-o vai duplicar a linha atual três vezes. não muda anel de matar.
(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)
Eu não posso acreditar que todas estas soluções complicadas. Esta é duas teclas:
<C-S-backspace> corre o kill-todo de linha de comando
C-/ executa o comando undo
Assim <C-S-backspace> C-/ para "copiar" uma linha inteira (matar e desfazer).
Você pode, é claro, combinar isso com argumentos numéricos e negativos para matar várias linhas frente ou para trás.
Este parece mais natural, com relação à resposta selecionada por Chris Conway.
(global-conjunto-chave "\ C-C \ C-d" "\ C-A \ C \ C-N \ H-w \ C-y \ C-p \ C-E")
Este permite duplicar uma linha várias vezes simplesmente repetindo os traços \ C-d-chave \-c C.
