मैं Emacs में एक पूरी लाइन की नकल कैसे करूँ?

Question

मैंने वीआईएम के लिए यही सवाल देखा और यह कुछ ऐसा था जिसे मैं खुद जानना चाहता था कि एमॅक्स के लिए क्या करना है। ReSharper में मैं इस क्रिया के लिए CTRL-D का उपयोग करता हूं। Emacs में यह प्रदर्शन करने के लिए कम से कम संख्या क्या है?

Comments

बेशक, यह बहुत TMTOWTDI emacs है - वहाँ 22 है! (और गिनती) c2.com/cgi/wiki?ThereIsMoreThanOneWayToDoIt

— टॉम

Answer 1

मैं उपयोग करता हूं

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

जो टूट जाता है

• C-a: लाइन की शुरुआत के लिए कर्सर ले जाएँ
• C-SPACE: एक चयन शुरू करें ("सेट मार्क")
• C-n: कर्सर को अगली पंक्ति में ले जाएँ
• M-w: प्रतिलिपि क्षेत्र
• C-y: पेस्ट ("यंक")

पूर्वकथित

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

एक ही चीज़ के लिए राशि (TMTOWTDI)

• C-a: लाइन की शुरुआत के लिए कर्सर ले जाएँ
• C-k: कट ("मार") लाइन
• C-k: न्यूलाइन में कटौती
• C-y: पेस्ट ("यंक") (हम वापस स्क्वायर में हैं)
• C-y: फिर से पेस्ट करें (अब हमें पंक्ति की दो प्रतियां मिल गई हैं)

ये दोनों C-dआपके संपादक की तुलना में शर्मनाक क्रिया हैं , लेकिन Emacs में हमेशा एक अनुकूलन होता है। डिफ़ॉल्ट रूप C-dसे बाध्य है delete-char, तो कैसे के बारे में C-c C-d? बस अपने निम्नलिखित जोड़ें .emacs:

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

(@ नाथन का संभावित संस्करण शायद बेहतर है, क्योंकि यदि कोई महत्वपूर्ण बाइंडिंग हैं, तो यह टूटेगा नहीं।)

खबरदार: कुछ Emacs मोड C-c C-dकुछ और करने के लिए पुनः प्राप्त कर सकते हैं।

Comments

नमस्ते! ध्यान रखें कि यदि आपके पास '(सेट-किल-पूरी-लाइन टी)' है, तो आपको केवल एक 'सीके' (समाधान 2) की आवश्यकता होगी क्योंकि यह पहले से ही लाइन की सामग्री के साथ मिलकर नई लाइन को मारता है। 'सी-के' का मेरा पसंदीदा इस्तेमाल। चीयर्स, डैनियल

— danielpoe

यह वास्तव में शर्मनाक है।

— टॉफूटिम

किस बारे में C-S-backspace C-y C-y?

— इरिक्ज़मा

Mw क्या है? किस कुंजी का उपयोग करना है?

— बाला

@ बाला "M" "मेटा" है (आमतौर पर Esc या Alt, यह आपके कीबोर्ड लेआउट पर निर्भर करता है)। "Mw" "मेटा" और "w" एक साथ (मेरे कीबोर्ड पर, "Alt-w") है।

— क्रिस कॉनवे

Answer 2

पिछले उत्तरों के अलावा आप एक पंक्ति को डुप्लिकेट करने के लिए अपने स्वयं के फ़ंक्शन को भी परिभाषित कर सकते हैं। उदाहरण के लिए, अपने .emacs फ़ाइल में निम्नलिखित डालने से 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)

Comments

मुझे इसके साथ निम्नलिखित त्रुटि हो रही है:Symbol's function definition is void: move-beginning-of-line

— Rohaq

इसके साथ समस्या यह है कि "डेल" कुंजी भी लाइन को डुप्लिकेट करने के लिए बाध्य है ...

— डेविड गोम्स

तो, Delइस फ़ंक्शन से अन-बाइंड कैसे करें के किसी भी विचार ?

— अलेक्जेंडर शेकब्लिकिन

ठीक है, Delनए को रखते हुए सामान्य रूप से वापस लौटने का समाधान मिला C-d: परिभाषा के (global-set-key (kbd "<delete>") 'delete-char)बाद इसे जोड़ने की आवश्यकता है C-d।

— अलेक्जेंडर शेकब्लिकिन

कोशिश करते हैं कि खाली लाइन पर केवल एक के बजाय दो लाइनें डालने का परिणाम है। मुझे पता नहीं क्यों। क्या वहां कोई आसान उपाय है?

— जेल्फ़िर कलस्टहल

Answer 3

लाइन पर प्लेस कर्सर, नहीं तो शुरुआत में एक ऐसा CTRL- Aहै, तो:

CTRL-K

CTRL-K

CTRL-Y

CTRL-Y

Comments

मुझे नहीं लगता कि दूसरे CY की जरूरत है।

— बास्टियन लेओनार्ड

यह बिना डुप्लिकेट नहीं होगा

— epatel

Ck के बजाय CS-Backspace (किल-पूरी-लाइन) का उपयोग करें। आपको कर्सर की स्थिति के साथ पेंच या न्यूलाइन को मारने की ज़रूरत नहीं है।

— नीत्शे-जो

यह अच्छी तरह से काम करता है, लेकिन ऐसा करने का एक छोटा तरीका नहीं है?

— स्ट्राइकर

Answer 4

एक फ़ंक्शन का मेरा संस्करण एक ऐसी पंक्ति को डुप्लिकेट करने के लिए है जो पूर्ववत के साथ अच्छा काम करता है और कर्सर की स्थिति के साथ गड़बड़ नहीं करता है। यह नवंबर 1997 से gnu.emacs.sources में चर्चा का परिणाम था ।

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

तब आप इस फ़ंक्शन को कॉल करने के लिए CTRL-D को परिभाषित कर सकते हैं:

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

Comments

अति उत्कृष्ट! पूर्ववत और कर्सर स्थिति सुविधा इसे सबसे अच्छा बनाती है। धन्यवाद!

— ptrn

इसके अलावा, लिंक पर क्षेत्रों के लिए कुछ कोड भी है!

— pcarvalho

बहुत अच्छा उपाय है। Thx

— प्लांकालुकल

बहुत अच्छा काम करता है। समाधान के लिए धन्यवाद।

— स्ट्रीकर

@spche crux-duplicate-current-line-or-regionमेरे लिए बेहतर काम करता है, क्योंकि आपके कार्य के साथ यह लाइन डुप्लिकेट और पिछले ऑपरेशन को भी पूर्ववत करता है।

— rofrol

Answer 5

इसके बजाय kill-line( C-k) कमांड के C-a C-k C-k C-y C-y उपयोग के रूप में kill-whole-line:

C-S-Backspace
C-y
C-y

इन लाभों C-kमें यह शामिल है कि यह कोई फर्क नहीं पड़ता कि बिंदु कहाँ है (इसके विपरीत C-kजिसे रेखा के शुरू होने की आवश्यकता है) और यह नई लाइन को भी मारता है (फिर कुछ C-kनहीं करता है)।

Comments

कुडोस @RayVega! मैंने इस समाधान की कोशिश की और यह एक विजेता की तरह काम करता है (मेरे GNU Emacs में 23.3.1, वैसे भी)। क्या यह समाधान कुछ लोगों के लिए काम नहीं कर रहा है? यह आपके (अपने) सवाल का सबसे अच्छा जवाब है।

— जेएस।

आपको इस उत्तर को सही मान लेना चाहिए। यह वही करता है जो आपने मांगा था, और "कम से कम संख्या में"।

— क्यूबेरिक

Answer 6

यहाँ ऐसा करने के लिए एक और समारोह है। मेरा संस्करण किल रिंग को नहीं छूता है, और कर्सर नई लाइन पर समाप्त होता है जहां यह मूल पर था। यदि यह सक्रिय (क्षणिक चिह्न मोड) है, तो यह क्षेत्र को डुप्लिकेट करेगा या लाइन को डुप्लिकेट करने के लिए डिफ़ॉल्ट रूप से अन्यथा। यदि उपसर्ग arg दिया गया है, तो यह कई प्रतियाँ भी बनायेगा, और यदि ऋणात्मक उपसर्ग arg दिया जाता है, तो मूल पंक्ति पर टिप्पणी करें (यह पुराने को रखते हुए कमांड / स्टेटमेंट के भिन्न संस्करण के परीक्षण के लिए उपयोगी है)।

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

मेरे पास इसके लिए बाध्य है C-c d:

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

इसे कभी भी मोड या किसी भी चीज़ से दोबारा नहीं सौंपा जाना चाहिए क्योंकि C-cइसके बाद सिंगल (अनमॉडिफाइड) लेटर यूजर बाइंडिंग के लिए आरक्षित होता है।

Comments

अब तक का सबसे अच्छा समाधान

— लियो उफिम्त्सेव

मैंने इसे अपनी .emacs फ़ाइल में डाल दिया है, लेकिन जब मैं उपयोग करने की कोशिश करता हूं तो मुझे C-c dत्रुटि मिलती है command-execute: Wrong type argument: commandp, duplicate-line-or-region। किसी भी विचार क्या है? मैं Emacs 25.1.1 उपयोग कर रहा हूँ Windows पर

— जुनिउस

वास्तव में अच्छा समाधान, मैं क्षेत्र की विशेषता और टिप्पणी-के साथ नकारात्मक-तर्क सुविधा की सराहना करता हूं। सुझाए गए कुंजी बंधन की तरह भी।

— एलेक्स ट्रूमैन

Answer 7

आपके .emacs फ़ाइल के लिए नाथन के अलावा जाने का तरीका है, लेकिन इसे बदलकर इसे थोड़ा सरल बनाया जा सकता है

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

साथ में

  (newline)

उपज

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

Comments

यह अच्छा है। धन्यवाद!

— तेजसबुबेन

Answer 8

डंप से डुप्लिकेट-चीज़ स्थापित करें:

Mx पैकेज-स्थापित RET डुप्लिकेट-चीज़

और इस कीबाइंडिंग को init फाइल में जोड़ें :

(वैश्विक-सेट-कुंजी (kbd "Mc") 'डुप्लिकेट-चीज़'

Comments

लगता है इस तारीख तक वहाँ नहीं।

— मार्कसेफ

Answer 9

मुझे यह बिल्कुल याद नहीं है कि रेखा का दोहराव कहीं और कैसे काम करता है, लेकिन एक पूर्व SciTE उपयोगकर्ता के रूप में मुझे SciTE-way के बारे में एक बात पसंद आई: यह कर्सर की स्थिति को नहीं छूता है! तो ऊपर दिए गए सभी प्राप्तकर्ता मेरे लिए पर्याप्त नहीं थे, यहाँ मेरा हिप्पी-संस्करण है:

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

ध्यान दें कि प्रक्रिया में वास्तव में कुछ भी नहीं मारा जाता है, निशान और वर्तमान चयन को छोड़कर।

BTW, क्यों तुम लोग जब यह अच्छा'''''clean हत्या पूरे लाइन thingy (CS-backspace) के आसपास कर्सर मरोड़ते के शौकीन हैं?

Answer 10

क्योंकि मुझे नहीं पता, मैं गोल्फ के इस दौर को एक धीमी गति के साथ शुरू करूँगा:

ctrl-k, y, y

Answer 11

आप अपने .emacs में जो कुछ करना चाहते हैं, वह है

(setq kill-whole-line t)

जब भी आप जब भी किल-लाइन (Ck के माध्यम से) आह्वान करते हैं, तो मूल रूप से पूरी लाइन के साथ-साथ नई रेखा को भी मारता है। फिर अतिरिक्त कोड के बिना, आप बस लाइन को कॉपी करने के लिए Ca Ck Cy Cy कर सकते हैं। यह टूट जाता है

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.

लेकिन अगर आप अक्सर इसका इस्तेमाल करते हैं तो हो सकता है कि डेडिकेटेड की-बाइंडिंग एक बेहतर आइडिया हो, लेकिन Ca Ck Cy का इस्तेमाल करने का फायदा यह है कि आप लाइन को कहीं और डुप्लिकेट कर सकते हैं, बजाय मौजूदा लाइन के।

Answer 12

मैं copy-from-above-commandएक कुंजी के लिए बाध्य है और इसका उपयोग करता हूं । यह XEmacs के साथ उपलब्ध कराया गया है, लेकिन मुझे GNU Emacs के बारे में जानकारी नहीं है।

`प्रतिलिपि-से-ऊपर-कमान 'एक संकलित संकलित लिस्प फ़ंक्शन है
- जिसे " /usr/share/xemacs/21.4.15/lisp/misc.elc "(कॉपी-से-ऊपर-कमांड और वैकल्पिक ARG) से लोड किया गया है

दस्तावेज़ीकरण: पिछले गैर-रिक्त रेखा से वर्णों की प्रतिलिपि बनाएँ , बिंदु से ठीक ऊपर। ARG वर्णों की प्रतिलिपि बनाएँ, लेकिन उस पंक्ति के अंत में नहीं। यदि कोई तर्क नहीं दिया गया है, तो बाकी की पूरी पंक्ति की प्रतिलिपि बनाएँ। कॉपी किए गए पात्रों को बिंदु से पहले बफर में डाला जाता है।

Comments

संस्करण 23 के लिए, यह मानक GNU Emacs वितरण का भी हिस्सा है।

— viam0Zah

यह मेरे संस्करण में नहीं लगता है। क्या कुछ लोड करना पड़ता है? मेरे संस्करण है GNU Emacs 23.2.1 (amd64-portbld-freebsd8.1) of 2010-11-14 on [host clipped]।

— qmega

@qmega आपको करने की आवश्यकता है ('मिसकैश की आवश्यकता है)।

— दिमित्री

Answer 13

एवी नामक पैकेज है इसमें कमांड एवी-कॉपी-लाइन है। जब आप उस कमांड का उपयोग करते हैं, तो आपकी विंडो की प्रत्येक पंक्ति में अक्षर संयोजन हो जाता है। फिर आपको बस संयोजन टाइप करना होगा और आपको वह लाइन मिल जाएगी। यह क्षेत्र के लिए भी काम करता है। फिर आपको बस दो संयोजन टाइप करना है।

यहाँ आप इंटरफ़ेस देख सकते हैं:

Answer 14

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

Answer 15

चूक इसके लिए भयानक हैं। हालाँकि, आप Emacs को SlickEdit और TextMate की तरह काम करने के लिए बढ़ा सकते हैं, अर्थात्, जब कोई पाठ नहीं चुना जाता है, तो वर्तमान लाइन को कॉपी / कट करें:

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

ऊपर में रखें .emacs। फिर, एक लाइन कॉपी करने के लिए M-w। एक लाइन को हटाने के लिए C-w। एक लाइन नकल करने के लिए, C-a M-w C-y C-y C-y ...।

Answer 16

'मैंने अपना खुद का संस्करण लिखा है duplicate-line, क्योंकि मैं हत्या की अंगूठी को खराब नहीं करना चाहता।

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

मुझे FraGGod का संस्करण पसंद आया, दो चीजों को छोड़कर: (1) यह जाँच नहीं करता है कि क्या बफर पहले से ही पढ़ा हुआ है (interactive "*"), और (2) यह बफर की अंतिम पंक्ति में विफल रहता है अगर वह अंतिम पंक्ति खाली है (जैसे कि आप उस मामले में लाइन को नहीं मार सकता है), अपने बफर को केवल पढ़ने के लिए छोड़कर।

मैंने निम्नलिखित परिवर्तन किए हैं कि हल करने के लिए:

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

हाल के एमएसीएस के साथ, आप इसे कॉपी करने के लिए कहीं भी एमडब्ल्यू का उपयोग लाइन में कर सकते हैं। तो यह हो जाता है:

M-w C-a RET C-y

Comments

वास्तव में? कौन सा "हालिया" Emacs होगा? 24.4 के साथ ऐसा नहीं है: आपको "निशान अब सेट नहीं है, इसलिए कोई क्षेत्र नहीं है।"

— डावर क्यूब्रिक

वर्तमान Emacs 24.5 है, और इसके M-wलिए बाध्य है easy-kill। जाँच करें कि आप क्या करते हैं जब आप करते हैंC-h c M-w

— लुई कोट्टमन

Emacs 24.5.1 में काम नहीं किया। पूर्ववर्ती रिक्त पंक्ति सम्मिलित करने के बाद उसी पंक्ति के आरंभ में बिंदु के प्रारंभ से बिंदु तक ही प्रतिलिपि बनाई गई।

— डेरेक महार

Answer 19

मैं वैसे भी बहुत जटिल समाधान देखा ...

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

Comments

ध्यान दें कि यह मारने की अंगूठी के साथ गड़बड़ करेगा।

— डोडेगी

यह अंतिम पंक्ति होने पर फ़ाइल को अपने आप जोड़ देता है और फ़ाइल एक नई पंक्ति में समाप्त नहीं होती है

— Mark

Answer 20

@ [केविन कोनर]: बहुत करीब है, जहाँ तक मुझे पता है। केवल दूसरी बात पर विचार kill-whole-lineकरने के लिए Ck में newline को शामिल करना चालू है ।

Comments

@ सभी: निकालें [और ]में@[Kevin Conner]

— जवानों 1:18

Answer 21

ctrl- k, ctrl- k, (नए स्थान पर स्थिति) ctrl-y

यदि आप लाइन की शुरुआत में शुरू नहीं कर रहे हैं तो एक ctrl- जोड़ें a। और दूसरा ctrl- kन्यूलाइन वर्ण को हथियाना है। यदि आप केवल पाठ चाहते हैं तो इसे हटाया जा सकता है।

Comments

यह यहाँ सबसे सीधा तरीका है। धन्यवाद!

— bartlomiej.n

Answer 22

जब कोई सक्रिय क्षेत्र के साथ अंतःक्रियात्मक रूप से कहा जाता है, तो 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)))))

जब कोई सक्रिय क्षेत्र के साथ अंतःक्रियात्मक रूप से कहा जाता है, तो 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)))))

इसके अलावा, संबंधित नोट पर:

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

मैं अपनी पसंद के लिए एक लिखता हूं।

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

लेकिन मैंने पाया कि यह तब कुछ समस्या होगी जब वर्तमान लाइन में मल्टी-बाइट वर्ण (जैसे CJK वर्ण) होते हैं। यदि आप इस समस्या का सामना करते हैं, तो इसके बजाय यह प्रयास करें:

(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

यह कार्यक्षमता लाइन या क्षेत्र द्वारा दोनों को डुप्लिकेट करने के संदर्भ में JetBrains के कार्यान्वयन के साथ मेल खाना चाहिए, और फिर बिंदु और / या सक्रिय क्षेत्र को छोड़ देना चाहिए:

इंटरेक्टिव फॉर्म के चारों ओर बस एक आवरण:

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

जो यह कहता है,

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

या यह

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

और फिर मैं मेटा + शिफ्ट + डी के लिए बाध्य है

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

Answer 25

जैसा कि अन्य उत्तरों में उल्लेख किया गया है, लिस्प कोड में कुंजी स्ट्रोक को बांधना एक अन्य कुंजी स्ट्रोक के लिए बाध्य करने से बेहतर विचार है। @ Mw के जवाब के साथ, कोड लाइन को डुप्लिकेट करता है और मार्क को नई लाइन के अंत तक ले जाता है। यह संशोधन नई पंक्ति में समान स्तंभ पर चिह्न स्थिति रखता है:

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

Answer 26

यदि आप Spacemacs का उपयोग कर रहे हैं, तो आप बस इसका उपयोग कर सकते हैं duplicate-line-or-region:

SPC x l d 

Answer 27

उपसर्ग तर्कों के साथ, और क्या है (मुझे उम्मीद है) सहज व्यवहार:

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

कर्सर अंतिम पंक्ति पर रहेगा। वैकल्पिक रूप से, आप एक बार में अगली कुछ पंक्तियों को डुप्लिकेट करने के लिए एक उपसर्ग निर्दिष्ट करना चाह सकते हैं:

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

मैं खुद को अक्सर दोनों का उपयोग करता हूं, उपसर्ग तर्क के व्यवहार को बदलने के लिए एक आवरण फ़ंक्शन का उपयोग करता हूं।

और एक कीबाइंडिंग: (global-set-key (kbd "C-S-d") 'duplicate-line)

Answer 28

;; 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.

आप init.el में ऊपर दिए गए क्विक को जोड़ें, और अब आपको कट / कॉपी पूरी लाइन फ़ंक्शन मिलती है, तो आप एक लाइन को डुप्लिकेट करने के लिए F3 F4 कर सकते हैं।

Answer 29

सबसे सरल तरीका क्रिस कॉनवे की विधि है।

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

यह EMACS द्वारा अनिवार्य तरीका है। मेरी राय में, मानक का उपयोग करना बेहतर है। मैं हमेशा ईएमएसीएस में स्वयं की कुंजी-बंधन के अनुकूलन के प्रति सावधान हूं। EMACS पहले से ही काफी शक्तिशाली है, मुझे लगता है कि हमें अपनी खुद की की-बाइंडिंग के अनुकूल होने की पूरी कोशिश करनी चाहिए।

हालांकि यह थोड़ा लंबा है, लेकिन जब आप इसके लिए अभ्यस्त हैं, तो आप तेजी से कर सकते हैं और पाएंगे कि यह मजेदार है!

Comments

सभी चीजों पर विचार किया, Emacs जनादेश बहुत कम - विशाल जीत यह देता है कि आप में आसानी है को अनुकूलित कर अपनी जरूरतों के लिए यह। बेशक व्यवहार में बहुत सारे मानक तरीके हैं जो उन चीजों को करने के लिए फायदेमंद हैं जिनसे आप चिपकना फायदेमंद है, लेकिन यदि आप "डिफ़ॉल्ट" Emacs का उपयोग कर रहे हैं और कुछ कर रहे हैं तो जरूरत से ज्यादा कठिन तरीका है क्योंकि आपको लगता है कि "मानक का उपयोग करना बेहतर है" , आप बहुत गलत कर रहे हैं।

— फिल्स

Answer 30

यहां वर्तमान लाइन को डुप्लिकेट करने के लिए एक फ़ंक्शन है। उपसर्ग तर्कों के साथ, यह कई बार लाइन को डुप्लिकेट करेगा। उदाहरण के लिए, C-3 C-S-oवर्तमान लाइन को तीन बार डुप्लिकेट करेगा। मार अंगूठी नहीं बदलता है।

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