Jak zduplikować całą linię w Emacsie?

Widziałem to samo pytanie dla VIM i było to coś, co sam chciałem wiedzieć, jak zrobić dla Emacsa. W ReSharper używam CTRL-D do tej akcji. Jaka jest najmniejsza liczba poleceń do wykonania tego w Emacsie?

używam

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

który rozpada się do

• C-a: przesuń kursor na początek linii
• C-SPACE: rozpocznij zaznaczanie („ustaw znacznik”)
• C-n: przesuń kursor do następnej linii
• M-w: skopiuj region
• C-y: wklej ("szarpnij")

Wcześniej wspomniane

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

sprowadza się do tego samego (TMTOWTDI)

• C-a: przesuń kursor na początek linii
• C-k: wytnij ("zabij") linię
• C-k: wytnij nową linię
• C-y: paste ("yank") (wróciliśmy do punktu wyjścia)
• C-y: wklej ponownie (teraz mamy dwie kopie linii)

Oba są żenująco rozwlekłe w porównaniu do tych C-dw twoim edytorze, ale w Emacsie zawsze istnieje możliwość dostosowania. C-djest delete-chardomyślnie powiązany , więc co powiesz na to C-c C-d? Po prostu dodaj następujące informacje do swojego .emacs:

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

(Wersja elisp @ Nathana jest prawdopodobnie lepsza, ponieważ nie zepsuje się, jeśli którekolwiek z przypisań klawiszy zostanie zmienione.)

Uwaga: niektóre tryby Emacsa mogą odzyskiwać się C-c C-ddo zrobienia czegoś innego.

Oprócz poprzednich odpowiedzi możesz również zdefiniować własną funkcję powielania linii. Na przykład umieszczenie następującego kodu w pliku .emacs spowoduje zduplikowanie bieżącego wiersza przez Cd.

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

Umieść kursor w linii, jeśli nie na początku zrób CTRL- A, a następnie:

CTRL-K

CTRL-K

CTRL-Y

CTRL-Y

Moja wersja funkcji do powielania linii, która działa dobrze z cofaniem i nie psuje pozycji kursora. Był to wynik dyskusji w gnu.emacs.sources z listopada 1997 roku .

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

Następnie możesz zdefiniować CTRL-D, aby wywołać tę funkcję:

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

Zamiast kill-line( C-k) jak w C-a C-k C-k C-y C-y użyciu kill-whole-linepolecenia:

C-S-Backspace
C-y
C-y

Zalety w porównaniu z C-ktym, że nie ma znaczenia, gdzie punkt znajduje się na linii (w przeciwieństwie do tego, C-kco wymaga bycia na początku linii), a także zabija nową linię (znowu coś C-knie działa).

Oto kolejna funkcja, która to robi. Moja wersja nie dotyka pierścienia zabijania, a kursor znajduje się w nowej linii, w której znajdował się w oryginale. Zduplikuje region, jeśli jest aktywny (tryb znacznika przejściowego) lub domyślnie powiela linię w inny sposób. Wykona również wiele kopii, jeśli otrzyma prefiks arg, i zakomentuje oryginalną linię, jeśli otrzyma ujemny prefiks arg (jest to przydatne do testowania innej wersji polecenia / instrukcji z zachowaniem starej).

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

Mam obowiązek C-c d:

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

To nigdy nie powinno być ponownie przypisywane przez tryb lub cokolwiek, ponieważ C-cnastępuje pojedyncza (niezmodyfikowana) litera jest zarezerwowana dla powiązań użytkownika.

Dodanie Nathana do pliku .emacs jest drogą do zrobienia, ale można je nieco uprościć, zastępując

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

z

  (newline)

wydajność

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

zainstaluj duplicate-thing z melpy:

Mx pakiet-install RET zduplikowana rzecz

i dodaj to przypisanie klawiszy do pliku init :

(zduplikowana rzecz global-set-key (kbd "Mc") ')

Nie bardzo pamiętam, jak działa powielanie linii gdziekolwiek indziej, ale jako były użytkownik SciTE podobała mi się jedna rzecz w SciTE-way: nie dotyka pozycji kursora! Więc wszystkie powyższe przepisy nie były dla mnie wystarczająco dobre, oto moja hipisowska wersja:

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

Zauważ, że w rzeczywistości nic nie zostaje zabite, pozostawiając ślady i bieżący wybór nietknięte.

Swoją drogą, dlaczego tak lubicie szarpać kursorem, kiedy jest taka niezła rzecz z zabijaniem całej linii (CS-backspace)?

bo nie wiem, zacznę tę rundę golfa od slowball:

ctrl-k, y, y

coś, co możesz chcieć mieć w swoim .emacs, to

(setq kill-whole-line t)

Co w zasadzie zabija całą linię plus nową linię za każdym razem, gdy wywołujesz kill-line (np. Przez Ck). Następnie bez dodatkowego kodu możesz po prostu wykonać Ca Ck Cy Cy, aby zduplikować linię. Rozpada się do

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.

Ale jeśli używasz tego często, być może dedykowane powiązanie klawiszy może być lepszym pomysłem, ale zaletą samego użycia Ca Ck Cy Cy jest to, że możesz powielić linię w innym miejscu, zamiast tuż pod bieżącą linią.

Mam copy-from-above-commandzwiązany z kluczem i używać. Jest dostarczany z XEmacsem, ale nie wiem o GNU Emacs.

`copy-from-above-command 'to interaktywna skompilowana funkcja Lispa
- ładowana z" /usr/share/xemacs/21.4.15/lisp/misc.elc "(kopiuj z polecenia powyżej i opcjonalny ARG)

Dokumentacja: Kopiuj znaki z poprzedniej niepustej linii , zaczynając tuż nad punktem. Skopiuj znaki ARG, ale nie poza koniec tego wiersza. Jeśli nie podano argumentu, skopiuj całą resztę wiersza. Skopiowane znaki są wstawiane do bufora przed punktem.

Jest pakiet o nazwie Avy Ma komendę avy-copy-line. Kiedy używasz tego polecenia, każda linia w twoim oknie otrzymuje kombinację liter. Następnie wystarczy wpisać kombinację i otrzymasz tę linię. Działa to również w przypadku regionu. Następnie wystarczy wpisać dwie kombinacje.

Tutaj możesz zobaczyć interfejs:

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

Domyślne ustawienia są do tego okropne. Możesz jednak rozszerzyć Emacsa, aby działał jak SlickEdit i TextMate, czyli kopiować / wycinać bieżącą linię, gdy nie jest zaznaczony żaden tekst:

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

Umieść powyższe w .emacs. Następnie, aby skopiować linię M-w. Aby usunąć linię C-w. Aby powielić linię C-a M-w C-y C-y C-y ....

- Napisałem własną wersję duplicate-line, bo nie chcę schrzanić morderczego pierścienia.

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

Podobała mi się wersja FraGGod, z wyjątkiem dwóch rzeczy: (1) Nie sprawdza, czy bufor jest już tylko do odczytu (interactive "*")i (2) kończy się niepowodzeniem w ostatniej linii bufora, jeśli ta ostatnia linia jest pusta (tak jak ty nie można w takim przypadku zabić linii), pozostawiając twój bufor tylko do odczytu.

Wprowadziłem następujące zmiany, aby rozwiązać ten problem:

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

W ostatnim emacsie możesz użyć Mw w dowolnym miejscu linii, aby go skopiować. A więc staje się:

M-w C-a RET C-y

W każdym razie widziałem bardzo złożone rozwiązania ...

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

@ [Kevin Conner]: Dość blisko, o ile wiem. Jedyną inną rzeczą do rozważenia jest włączenie kill-whole-linenowej linii w Ck.

ctrl- k, ctrl- k, (pozycja do nowej lokalizacji) ctrl-y

Dodaj ctrl- ajeśli nie zaczynasz od początku wiersza. A drugi ctrl- kto złapanie znaku nowej linii. Można go usunąć, jeśli chcesz tylko tekst.

W przypadku wywołania interaktywnego bez aktywnego regionu KOPIUJ (Mw) pojedynczą linię:

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

W przypadku wywołania interaktywnego bez aktywnego regionu, zamiast tego KILL (Cw) pojedyncza linia.

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

Ponadto, w powiązanej notatce:

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

Piszę jeden według własnych preferencji.

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

Ale stwierdziłem, że może to mieć problem, gdy bieżąca linia zawiera znaki wielobajtowe (np. Znaki CJK). Jeśli napotkasz ten problem, spróbuj tego:

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

Ta funkcjonalność powinna pasować do implementacji JetBrains pod względem powielania zarówno według linii lub regionu, a następnie opuszczania punktu i / lub aktywnego regionu zgodnie z oczekiwaniami:

Tylko opakowanie wokół interaktywnego formularza:

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

Który to nazywa

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

Albo to

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

A potem mam to powiązane z meta + shift + d

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

Jak wspomniano w innych odpowiedziach, powiązanie naciśnięć klawiszy z kodem lisp jest lepszym pomysłem niż powiązanie ich z innymi naciśnięciami klawiszy. Z odpowiedzią @ mw, kod powiela wiersz i przenosi znacznik na koniec nowego wiersza. Ta modyfikacja utrzymuje pozycję znacznika w tej samej kolumnie w nowym wierszu:

fun duplicate-line ()
  (interactive)
  (let ((col (current-column)))
    (move-beginning-of-line 1)
    (kill-line)
    (yank)
    (newline)
    (yank)
    (move-to-column col)))

Jeśli używasz Spacemacs, możesz po prostu użyć duplicate-line-or-region:

SPC x l d 

Z argumentami przedrostkowymi i (mam nadzieję) intuicyjne zachowanie:

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

Kursor pozostanie w ostatniej linii. Alternatywnie możesz określić przedrostek, aby zduplikować kilka następnych wierszy naraz:

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

Często używam obu, używając funkcji opakowania, aby zmienić zachowanie argumentu prefiksu.

I przypisanie klawisza: (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.

dodaj powyższy elisp do init.el, a otrzymasz teraz funkcję wycinania / kopiowania całej linii, a następnie możesz F3 F4, aby powielić linię.

Najprostszym sposobem jest metoda Chrisa Conwaya.

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

To domyślny sposób zalecany przez EMACS. Moim zdaniem lepiej skorzystać ze standardu. Zawsze staram się dostosowywać własne powiązania klawiszy w EMACS. EMACS jest już wystarczająco potężny, myślę, że powinniśmy zrobić wszystko, co w naszej mocy, aby dostosować się do jego własnych skrótów klawiszowych.

Chociaż jest to trochę długie, ale kiedy już się do tego przyzwyczaisz, możesz działać szybko i przekonasz się, że jest to zabawne!

Oto funkcja do powielania bieżącej linii. Z argumentami prefiksów powiela wiersz wielokrotnie. Np. C-3 C-S-oTrzykrotnie powieli bieżącą linię. Nie zmienia zabójczego pierścienia.

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