Jak powielić całą linię w Emacsie?

Oprócz poprzednich odpowiedzi Możesz również zdefiniować własną funkcję, która powieli linię. Na przykład, umieszczenie następujących w swoim .plik emacs spowoduje, że C-d powieli bieżącą linię.

(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 wykonaj CTRL-A , wtedy:

CTRL-K

CTRL-K

CTRL-Y

CTRL-Y

Moja wersja funkcji do powielania linii, która działa ładnie z undo i nie bałagan z pozycji kursora. Było to wynikiem dyskusji w gnu.emacs.źródła z listopada 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))

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żyj kill-whole-line polecenie:

C-S-Backspace
C-y
C-y

Zalety nad C-k obejmują to, że nie ma znaczenia, gdzie punkt znajduje się na linii (w przeciwieństwie do C-k, która wymaga bycia na początku linii), a także zabija nową linię (znowu coś C-k nie robi).

Oto kolejna funkcja do tego. Moja wersja nie dotyka pierścienia zabijania, a kursor kończy się na nowej linii, gdzie był na oryginale. Powieli region, jeśli jest aktywny (tryb znaczników przejściowych), lub domyślnie powieli linię w przeciwnym razie. Będzie również tworzyć wiele kopii, jeśli podano przedrostek arg, i komentować oryginalną linię, jeśli podano ujemny przedrostek arg (jest to przydatne do testowania innej wersji polecenia / instrukcji przy zachowaniu starej jeden).

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

I have it bound to C-c d:

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

To nie powinno być ponownie przypisane przez tryb lub cokolwiek, ponieważ C-c po którym następuje pojedyncza (niezmodyfikowana) litera jest zarezerwowana dla wiązań użytkowników.

Dodatek Nathana do twojego .plik emacs jest dobrym rozwiązaniem, ale można go nieco uprościć, zastępując

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

Z

  (newline)

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

Nie do końca pamiętam, jak powielanie linii działa 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 przepisy powyżej 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 nic nie ginie w trakcie procesu, pozostawiając ślady i bieżące zaznaczenie nienaruszone.

BTW, po co wy tak lubicie szarpać kursorem, kiedy jest taki miły ' n ' Clean kill-whole-line thingy (C-S-backspace)?

Install duplicate-thing from melpa

I dodaj ten keybinding:

(global-set-key (kbd "M-c") 'duplicate-thing)

Ponieważ Nie wiem, zacznę tę rundę golfa od slowballa:

Ctrl-k, y, y

Mam copy-from-above-command przypisany do klucza i używam go. Jest dostarczany z Xemacsem, ale nie znam się na GNU Emacsie.

'copy-from-above-command' is an interactive compiled Lisp function
-- loaded from " / usr/share/xemacs/21.4.15/lisp / misc.elc" (polecenie Kopiuj z góry & opcjonalne ARG)

Dokumentacja: kopiowanie znaków z poprzednia linia nonblank , zaczynająca się tylko wyżej. Kopiuj znaki ARG, ale nie na końcu tej linii. Jeśli nie argument podane, Skopiuj całą resztę linii. Skopiowane znaki to wstawiony do bufora przed punktem.

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

Coś, co chciałbyś mieć w swoim .emacs jest

(setq kill-whole-line t)

Który w zasadzie zabija całą linię plus nową linię za każdym razem, gdy wywołujesz kill-line (np. przez C-k). Następnie bez dodatkowego kodu, możesz po prostu zrobić C - A C-k C-y C - Y, aby zduplikować linię. Rozkłada się na

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, może dedykowane Wiązanie kluczy może być lepszym pomysłem, ale zaletą używania C - A C-k C-y C-y jest to, że możesz powielać linię gdzie indziej, zamiast tuż pod aktualna linia.

Wartości domyślne są do tego okropne. Można jednak rozszerzyć Emacsa tak, aby działał jak SlickEdit i TextMate, czyli kopiować / wycinać bieżącą linię, gdy nie zaznaczono żadnego tekstu:

(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ć wiersz, M-w. Aby usunąć wiersz, C-w. Aby powielić linię, C-a M-w C-y C-y C-y ....

' napisałem własną wersję duplicate-line, ponieważ nie chcę spieprzyć pierścienia śmierci.

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

Z najnowszym emacsem, możesz użyć M-W w dowolnym miejscu linii, aby go skopiować. Więc staje się:

M-w C-a RET C-y

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

Istnieje pakiet o nazwie Avy posiada polecenie avy-copy-line. Gdy używasz tego polecenia, każda linia w oknie otrzymuje kombinację liter. Potem wystarczy wpisać kombinację i dostaniesz tę linię. Dotyczy to również regionu. Potem wystarczy wpisać dwa kombinacje.

Tutaj możesz zobaczyć interfejs:

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

@[Kevin Conner]: całkiem blisko, z tego co wiem. Jedyną inną rzeczą do rozważenia jest włączenie kill-whole-line, aby włączyć nową linię w C-K.

Podobała mi się Wersja Fraggoda, z wyjątkiem dwóch rzeczy: (1) nie sprawdza, czy bufor jest już tylko do odczytu z (interactive "*"), i (2) nie sprawdza się w ostatniej linii bufora, jeśli ta ostatnia linia jest pusta (ponieważ nie można zabić linii w tym przypadku), pozostawiając bufor tylko do odczytu.

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

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

Gdy wywołane interaktywnie bez aktywnego regionu, skopiuj (M-w) pojedynczą linię zamiast:

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

Gdy wywołane interaktywnie bez aktywnego regionu, Zabij (C-w) pojedynczą linię zamiast tego.

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

Również, w związku z tym:

(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 , (pozycja do nowej lokalizacji) ctrl-y

Dodaj ctrl-a jeśli nie zaczynasz na początku linii. I 2. ctrl-k jest chwytaniem znaku nowej linii. Można go usunąć, jeśli chcesz tylko tekst.

Piszę jeden dla moich 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 będzie to miało jakiś problem, gdy bieżąca linia zawiera znaki wielobajtowe (np. znaki CJK). Jeśli napotkasz ten problem, spróbuj zamiast 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)

Z argumentami przedrostkowymi, a co to jest (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 ostatnim wierszu. Alternatywnie, możesz podać prefiks, aby powielić 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 wrapper do zmiany zachowania argumentu przedrostka.

I keybinding: (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ższe elisp do INIT.el, a teraz dostajesz funkcję cięcia / kopiowania całej linii, a następnie możesz F3 F4, aby zduplikować linię.

Najprostszym sposobem jest metoda Chrisa Conwaya.

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

Jest to domyślna droga wymagana przez Emacsa. Moim zdaniem lepiej zastosować standard. Zawsze dbam o personalizację własnego klucza w Emacsie. EMACS jest już wystarczająco potężny, myślę, że powinniśmy spróbować jak najlepiej dostosować się do własnych wiązań kluczy.

Choć jest to trochę długie, ale kiedy jesteś przyzwyczajony do niego, można zrobić szybko i przekonasz się, że to jest zabawne!

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

Wystarczy owijka wokół interaktywnej formy:

(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 nazywa to,

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

Lub 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 związane z meta + shift + d

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

Oto funkcja do powielania bieżącej linii. Z argumentami przedrostkowymi, powieli wiersz wiele razy. Np. C-3 C-S-o powieli bieżącą linię trzy razy. Nie zmienia pierścienia śmierci.

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

Nie mogę uwierzyć w te wszystkie skomplikowane rozwiązania. To są dwa naciśnięcia klawiszy:

<C-S-backspace> uruchamia polecenie kill-whole-line

C-/ uruchamia polecenie undo

Więc <C-S-backspace> C-/ aby "skopiować" całą linię (zabić i cofnąć).

Można oczywiście połączyć to z liczbowymi i ujemnymi argami, aby zabić wiele linii do przodu lub do tyłu.

Cóż zwykle używam:

Ctl-Space (set the mark)
move to end of line
Ctl-K kill line
Ctl-Y * 2 (yank the line back)

Może jednak być o wiele lepszy sposób: P