Emacs'ta bütün bir satırı nasıl çoğaltırım?

Aynı soruyu VIM için gördüm ve Emacs için nasıl yapacağımı bilmek istediğim bir şey oldu. ReSharper'da bu eylem için CTRL-D kullanıyorum. Emacs'ta bunu gerçekleştirmek için en az komut sayısı nedir?

kullanırım

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

hangi yıkılır

• C-a: imleci satırın başına götür
• C-SPACE: bir seçime başla ("ayar işareti")
• C-n: imleci bir sonraki satıra taşıma
• M-w: bölgeyi kopyala
• C-y: yapıştır ("yank")

Adı geçen

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

aynı şeydir (TMTOWTDI)

• C-a: imleci satırın başına götür
• C-k: çizgiyi kes ("öldür")
• C-k: yeni satırı kes
• C-y: yapıştır ("yank") (birinci kareye geri döndük)
• C-y: tekrar yapıştırın (şimdi satırın iki kopyası var)

Bunların ikisi de C-deditörünüzle karşılaştırıldığında utanç verici derecede ayrıntılıdır , ancak Emacs'ta her zaman bir özelleştirme vardır. varsayılan C-dolarak bağlıdır delete-char, peki ya C-c C-d? Sadece aşağıdakileri ekleyin .emacs:

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

(@ Nathan'ın elisp sürümü muhtemelen tercih edilir, çünkü anahtar bağlantılarından herhangi biri değiştirilirse kırılmaz.)

Dikkat: Bazı Emacs modları C-c C-dbaşka bir şey yapmak için geri alabilir .

Önceki yanıtlara ek olarak, bir satırı çoğaltmak için kendi işlevinizi de tanımlayabilirsiniz. Örneğin, .emacs dosyanıza aşağıdakileri koymak Cd'yi geçerli satırı çoğaltır.

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

İmleci hatta yerleştirin, başlangıçta değilse CTRL-A , sonra:

CTRL-K

CTRL-K

CTRL-Y

CTRL-Y

Geri alma ile iyi çalışan ve imleç konumu ile karışık olmayan bir satırı çoğaltma işlevinin sürümü. Kasım 1997'den beri gnu.emacs.sources'da yapılan bir tartışmanın sonucuydu .

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

Daha sonra bu işlevi çağırmak için CTRL-D tanımlayabilirsiniz:

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

Yerine kill-line( C-k) olduğu gibi C-a C-k C-k C-y C-y kullanım kill-whole-linekomutu:

C-S-Backspace
C-y
C-y

Avantajlar C-karasında, noktanın çizginin neresinde olduğu önemli değildir (çizginin C-kbaşlangıcında olması gerekenden farklı olarak) ve ayrıca satırsonu öldürür (yine bir şey C-kyapmaz).

İşte bunu yapmak için başka bir işlev. Sürümüm öldürme halkasına dokunmuyor ve imleç orijinalinde olduğu yeni satıra geliyor. Etkinse (geçici işaret modu) bölgeyi çoğaltır veya satırı aksi takdirde çoğaltır. Ayrıca, bir önek argümanı verilirse birden çok kopya oluşturur ve negatif bir önek argümanı verilirse orijinal satırı yorumlar (bu, eskisini tutarken bir komutun / ifadenin farklı bir sürümünü test etmek için yararlıdır).

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

Ben bağlı C-c d:

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

Bu asla bir mod veya herhangi bir şeyle yeniden atanmamalıdır, çünkü C-ctek bir (değiştirilmemiş) harf kullanıcı bağlamaları için ayrılmıştır.

Nathan'ın .emacs dosyanıza eklenmesi yoludur, ancak değiştirilerek biraz basitleştirilebilir

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

ile

  (newline)

verimli

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

melpa'dan yinelenen şeyi yükle:

MX Paket Yükleme RET Yinelenen Şey

ve bu anahtar bağlamayı init dosyasına ekleyin :

(global-set-key (kbd "Mc") 'yinelenen öğe)

Satır çoğaltmanın başka bir yerde nasıl çalıştığını tam olarak hatırlamıyorum, ancak eski bir SciTE kullanıcısı olarak SciTE-way ile ilgili bir şeyi sevdim: imleç konumuna dokunmuyor! Yani yukarıdaki tüm tarifler benim için yeterince iyi değildi, işte hippi versiyonum:

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

Notlar ve mevcut seçim bozulmadan bırakarak, işlem sırasında hiçbir şey gerçekten öldürülmez.

BTW, neden bu güzel ve temiz öldür-bütünlüklü şey (CS-backspace) varken imleci sarsmaktan hoşlanıyorsunuz?

çünkü bilmiyorum, bu golf turuna bir slowball ile başlayacağım:

ctrl-k, y, y

.emac'larınızda olmasını isteyebileceğiniz bir şey

(setq kill-whole-line t)

Bu, öldürme çizgisini (yani Ck aracılığıyla) her başlattığınızda, tüm çizgiyi ve yeni çizgiyi öldürür. Sonra ekstra kod olmadan, sadece çizgi kopyalamak için Ca Ck Cy Cy yapabilirsiniz. Aşağı iner

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.

Ancak bunu sık sık kullanırsanız, özel bir anahtar bağlama daha iyi bir fikir olabilir, ancak sadece Ca Ck Cy Cy kullanmanın avantajı, satırı geçerli satırın hemen altında değil, başka bir yerde çoğaltabilirsiniz.

Ben var copy-from-above-commandki anahtar ve kullanımına bağlı. XEmacs ile sağlandı, ancak GNU Emacs hakkında bir bilgim yok.

`` copy-from-above-command '' etkileşimli bir derlenmiş Lisp işlevidir
- "/usr/share/xemacs/21.4.15/lisp/misc.elc" den yüklenir (yukarıdaki komuttan kopyala ve isteğe bağlı ARG)

Belgeler: Noktaların hemen üstünde başlayarak önceki boş olmayan satırdaki karakterleri kopyalayın . ARG karakterlerini kopyalayın, ancak bu satırın sonunu geçmeyecek şekilde kopyalayın. Bağımsız değişken verilmemişse, satırın geri kalanının tamamını kopyalayın. Kopyalanan karakterler noktadan önce arabelleğe eklenir.

Avy adında bir paket var Avy-copy-line komutu var. Bu komutu kullandığınızda, pencerenizdeki her satır harf kombinasyonu alır. Sonra sadece kombinasyon yazmanız ve o satırı elde etmeniz gerekir. Bu bölge için de geçerlidir. O zaman sadece iki kombinasyon yazmanız gerekir.

Burada arayüzü görebilirsiniz:

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

Varsayılanlar bunun için korkunç. Ancak, Emacs'ı SlickEdit ve TextMate gibi çalışacak şekilde genişletebilirsiniz, yani metin seçilmediğinde geçerli satırı kopyala / kes:

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

Yukarıdakileri yerleştirin .emacs. Sonra, bir satırı kopyalamak için M-w. Bir satırı silmek için C-w,. Bir satırı çoğaltmak için C-a M-w C-y C-y C-y ...,.

`` Kendi versiyonumu yazdım duplicate-line, çünkü ölüm halkasını berbat etmek istemiyorum.

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

İki şey dışında FraGGod'un versiyonunu beğendim: (1) Tamponun zaten salt okunur olup olmadığını kontrol etmez (interactive "*")ve (2) son satır boşsa tamponun son satırında başarısız olur (siz bu durumda satırı öldüremez), ara belleğinizi salt okunur olarak bırakır.

Bunu çözmek için aşağıdaki değişiklikleri yaptım:

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

Son emac'larla Mw'yi kopyalamak için satırın herhangi bir yerinde kullanabilirsiniz. Böylece olur:

M-w C-a RET C-y

Zaten çok karmaşık çözümler gördüm ...

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

@ [Kevin Conner]: Bildiğim kadarıyla oldukça yakın. Dikkate alınması gereken tek şey kill-whole-line, yeni satırı Ck'ye dahil etmek.

ctrl- k, ctrl- k, (yeni konuma konum) ctrl-y

Satırın başında başlamıyorsanız ctrl- ekleyin a. Ve 2. ctrl- ksatırsonu karakterini kapmak. Sadece metni istiyorsanız kaldırılabilir.

Aktif bölge olmadan etkileşimli olarak çağrıldığında, bunun yerine tek bir satır COPY (Mw):

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

Aktif bölge olmadan etkileşimli olarak çağrıldığında, bunun yerine tek bir satır KILL (Cw).

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

Ayrıca, ilgili bir notta:

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

Tercihim için bir tane yazıyorum.

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

Ancak, geçerli satırda çok baytlık karakterler (örn. CJK karakterleri) olduğunda bunun bir sorun olacağını fark ettim. Bu sorunla karşılaşırsanız, bunun yerine şunu deneyin:

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

Bu işlevsellik, JetBrains uygulamasının hem satıra hem de bölgeye göre çoğaltılması ve daha sonra noktayı ve / veya etkin bölgeyi beklendiği gibi bırakması açısından eşleşmelidir:

Etkileşimli formun etrafına bir sarıcı:

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

Bu da buna

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

Veya bu

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

Ve sonra bu meta + shift + d'ye bağlı

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

Diğer cevaplarda belirtildiği gibi, tuş vuruşlarını lisp koduna bağlamak, onları başka bir tuş vuruşuna bağlamaktan daha iyi bir fikirdir. @ Mw'nin cevabı ile kod satırı çoğaltır ve işareti yeni satırın sonuna taşır. Bu değişiklik, yeni satırdaki aynı sütundaki işaret konumunu korur:

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

Spacemacs kullanıyorsanız duplicate-line-or-region, aşağıdakilere bağlı olarak şunları kullanabilirsiniz :

SPC x l d 

Önek argümanları ve (umarım) sezgisel davranış nedir:

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

İmleç son satırda kalacaktır. Alternatif olarak, sonraki birkaç satırı aynı anda çoğaltmak için bir önek belirtmek isteyebilirsiniz:

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

Kendimi sık sık kullanarak, önek argümanının davranışını değiştirmek için bir sarıcı işlevi kullanarak kendimi bulmak.

Ve bir tuş takımı: (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.

yukarıdaki elisp'i init.el'e ekleyin ve şimdi tüm çizgi işlevini kes / kopyala, daha sonra bir satırı çoğaltmak için F3 F4 yapabilirsiniz.

En basit yol Chris Conway'in yöntemidir.

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

EMACS tarafından zorunlu kılınan varsayılan yol budur. Bence standardı kullanmak daha iyi. EMACS'de kendi anahtar-bağlayıcısını kişiselleştirmeye her zaman dikkat ediyorum. EMACS zaten yeterince güçlü, kendi anahtar bağlarına uyum sağlamak için elimizden gelenin en iyisini yapmalıyız.

Biraz uzun olmasına rağmen, alıştığınız zaman hızlı yapabilirsiniz ve bunun eğlenceli olduğunu göreceksiniz!

Geçerli satırı çoğaltmak için bir işlev. Önek bağımsız değişkenleriyle, satırı birkaç kez çoğaltır. Örneğin, C-3 C-S-ogeçerli satırı üç kez çoğaltacaktır. Öldürme halkasını değiştirmez.

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