Wie duplizieren ich eine ganze Zeile in Emacs?
https://stackoverflow.com/questions/88399
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
ich sah diese gleiche Frage für VIM und es wurde etwas, was ich wollte mich wissen, wie für Emacs zu tun. In ReSharper verwende ich CTRL-D für diese Aktion. Was ist die geringste Anzahl von Befehlen dies in Emacs ausführen?
Lösung
ich
C-a C-SPACE C-n M-w C-y
, die bricht auf
-
C-a: Cursor bewegt von Zeile beginnen -
C-SPACE: beginnen, eine Auswahl ( "set mark") -
C-n: Cursor auf nächste Zeile -
M-w: copy Region -
C-y: Paste ( "yank")
Die zuvor genannte
C-a C-k C-k C-y C-y
auf dasselbe (TMTOWTDI)
-
C-a: Cursor bewegt von Zeile beginnen -
C-k: Schnitt ( "kill") die Zeile -
C-k: schneiden Sie das Newline -
C-y: Einfügen ( "yank") (wir sind wieder auf Platz eins) -
C-y: wieder einfügen (jetzt wir haben zwei Kopien der Zeile)
Dies sind beide peinliche ausführliche Vergleich zu C-d in Ihrem Editor, aber in Emacs gibt es immer eine Anpassung. C-d gebunden ist standardmäßig delete-char, so wie etwa C-c C-d? Fügen Sie einfach die folgende auf Ihre .emacs:
(global-set-key "\C-c\C-d" "\C-a\C- \C-n\M-w\C-y")
(@ Nathans elisp Version ist wahrscheinlich vorzuziehen, weil es nicht brechen, wenn eine der Tastenbelegung geändert werden.)
Achtung:. Einig Emacs-Modi zurückfordern kann C-c C-d etwas anderes zu tun
Andere Tipps
Zusätzlich zu den bisherigen Antworten können Sie auch Ihre eigene Funktion definieren eine Linie zu duplizieren. Zum Beispiel setzen die folgenden in Ihrer .emacs-Datei machen C-d die aktuelle Zeile duplizieren.
(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)
Setzen Sie den Cursor auf der Linie, wenn nicht am Anfang tun a STRG - A , dann:
STRG - K
STRG - K
STRG - Y
STRG - Y
Meine Version einer Funktion eine Linie zu duplizieren, die schön mit Undo arbeitet und nicht mit Zohan an der Cursorposition. Es war das Ergebnis einer Diskussion in gnu.emacs.sources von November 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))
Dann können Sie CTRL-D definieren diese Funktion aufzurufen:
(global-set-key (kbd "C-d") 'duplicate-line)
Statt kill-line (C-k), wie in C-a C-k C-k C-y C-y verwenden Sie die kill-whole-line Befehl:
C-S-Backspace
C-y
C-y
Die Vorteile gegenüber C-k sind, dass es keine Rolle spielt, wo Punkt auf der Linie ist (im Gegensatz zu C-k, das ist am Anfang der Zeile erfordert), und es tötet auch das Newline (wieder etwas C-k nicht tut).
Hier ist noch eine weitere Funktion, dies zu tun. Meine Version berührt nicht den Kill-Ring, und die Cursor enden auf die neue Linie, wo es auf dem Original war. Es wird die Region duplizieren, wenn er aktiv ist (transient Markierungsmodus) oder standardmäßig die Zeile anders zu duplizieren. Es wird auch mehrere Kopien machen, wenn ein Präfix arg gegeben, und kommentieren Sie die ursprüngliche Linie, wenn ein negatives Vorzeichen arg gegeben (dies zum Testen eine andere Version eines Befehl / Erklärung nützlich ist, während die alten zu halten).
(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)))))
Ich habe es gebunden C-c d:
(global-set-key [?\C-c ?d] 'duplicate-line-or-region)
Dies sollte niemals von einem einzigen (nicht modifiziert) Brief von einem Modus oder irgendetwas, weil C-c gefolgt neu zugeordnet werden, für Benutzer Bindungen reserviert ist.
Nathans zusätzlich zu Ihrer .emacs-Datei ist der Weg zu gehen, aber es leicht durch den Austausch vereinfacht werden könnte
(open-line 1)
(next-line 1)
mit
(newline)
Nachgeben
(defun duplicate-line()
(interactive)
(move-beginning-of-line 1)
(kill-line)
(yank)
(newline)
(yank)
)
(global-set-key (kbd "C-d") 'duplicate-line)
Ich weiß nicht mehr genau erinnern, wie Linie Vervielfältigung anderswo funktioniert, aber als ehemaliger SciTE Benützer mag ich eine Sache über SciTE-Weg: es ist nicht die Cursorposition nicht berührt! So sind alle oben recipies waren nicht gut genug für mich, hier ist meine 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))))
Beachten Sie, dass nichts tatsächlich in Prozess getötet wird, Marken und aktuelle Auswahl intakt lassen.
BTW, warum euch so gern Cursor von Rucken, wenn gibt es diese nice'n'clean Kill-ganze-line Dingens (C-S-Backspace)?
installiert Duplikat-Sache von Melpa:
M-x-Paket installiert RET Duplikat-thing
und fügen Sie diese Tastenkombination auf init Datei :
(global-set-Taste (kbd "M-c") ‚Duplikat-Sache)
, weil ich weiß nicht, ich werde diese Runde Golf mit einem slowball starten:
ctrl-k, y, y
‘Ich meine eigene Version von duplicate-line geschrieben, denn ich will nicht die Tötung Ring vermasseln.
(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)
Ich habe copy-from-above-command auf einen Schlüssel gebunden und verwendet diesen. Es ist mit XEmacs zur Verfügung gestellt, aber ich weiß nicht, über GNU Emacs.
`Kopieren-von-oben-Befehl‘ ein interaktive zusammengestellt Lisp Funktion
- geladen von „/usr/share/xemacs/21.4.15/lisp/misc.elc“ (Copy-von-oben-Befehl & optional ARG)Dokumentation: Kopieren Zeichen aus vorherige nicht leere Zeile , gerade erst oben Punkt. Kopieren ARG Zeichen, aber nicht über das Ende der Zeile. wenn nein Argument gegeben, kopieren Sie den gesamten Rest die Linie. Die Zeichen kopiert werden in dem Puffer vor dem Punkt eingefügt.
C-a C-k C-k C-y C-y
etwas, das Sie vielleicht in Ihrem .emacs haben wollen, ist
(setq kill-whole-line t)
, die im Grunde tötet die gesamte Linie plus dem Newline, wenn Sie Kill-Zeile aufrufen (das heißt über C-k). Dann ohne zusätzlichen Code, Sie tun können, nur C-C-k C-y C-y, die Linie zu duplizieren. Es bricht auf
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.
Aber wenn man dies oft verwendet dann vielleicht eine spezielle Taste Bindung könnte eine bessere Idee sein, aber der Vorteil von nur Ca Ck Cy Cy verwendet, wird die Zeile an anderer Stelle kopieren können, anstatt nur unter der aktuellen Zeile.
Die Standardeinstellungen sind schrecklich für diese. Sie können jedoch Emacs erweitern wie SlickEdit und Textmate zu arbeiten, das heißt, zu kopieren / schneiden Sie die aktuelle Zeile, wenn kein Text ausgewählt ist:
(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)))))
Legen Sie die oben in .emacs. Dann eine Linie, M-w zu kopieren. Um eine Linie, C-w zu löschen. So duplizieren Sie eine Linie, C-a M-w C-y C-y C-y ....
Ich mochte FraGGod-Version, mit Ausnahme von zwei Dingen: (1) Es prüft nicht, ob der Puffer bereits schreibgeschützt ist mit (interactive "*"), und (2) es nicht in der letzten Zeile des Puffers, wenn die letzte Zeile ist leer (wie Sie nicht die Linie in diesem Fall töten können), Ihre Puffer schreibgeschützt zu verlassen.
ich folgende Änderungen vorgenommen, das zu beheben:
(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)))))
Mit dem jüngsten Emacs, können Sie M-w überall auf der Linie, um sie zu kopieren verwenden. So wird es:
M-w C-a RET C-y
Ich sah sehr komplexe Lösungen, sowieso ...
(defun duplicate-line ()
"Duplicate current line"
(interactive)
(kill-whole-line)
(yank)
(yank))
(global-set-key (kbd "C-x M-d") 'duplicate-line)
Es gibt Paket namens Avy Es hat Befehl avy-copy-line. Wenn Sie diesen Befehl verwenden, wird jede Zeile in dem Fenster Buchstabenkombination ein. Dann müssen Sie nur noch Kombination eingeben und Sie erhalten diese Zeile. Dies funktioniert auch für Region. Dann müssen Sie nur noch zwei Kombination eingeben.
Hier können Sie sehen, Schnittstelle:
@ [Kevin Conner]: Ziemlich nah, so weit ich weiß. Die einzige andere Sache zu prüfen, ist auf kill-whole-line Drehen des Newline in der C-k enthalten.
Wenn interaktiv ohne aktiven Bereich, COPY (M-w) eine einzige Zeile statt genannt:
(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)))))
Wenn interaktiv ohne aktiven Bereich bezeichnet, kill (C-w) eine einzige Zeile statt.
(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)))))
Auch auf einem entsprechenden Hinweis:
(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 , (Position zu neuem Standort) ctrl - y
In a ctrl - a , wenn Sie nicht am Anfang der Zeile beginnen. Und die zweite ctrl - k ist das Newline-Zeichen zu greifen. Es kann entfernt werden, wenn Sie nur den Text.
Ich schreibe für meine Präferenz.
(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)
Aber ich fand dies ein Problem haben würde, wenn aktuelle Zeile Multi-Byte-Zeichen enthält (z CJK-Zeichen). Wenn dieses Problem auftritt, versuchen Sie stattdessen:
(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)
Diese Funktionalität sollte mit JetBrains' Implementierung in Bezug auf die Duplizierung sowohl durch die Linie oder Region, und dann verlassen Sie den Punkt und / oder aktiven Bereich wie erwartet zusammenpassen:
Nur ein Wrapper um die interaktive Form:
(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)))
Welche nennt dies,
(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))
oder das
(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))
Und dann habe ich diese gebunden zu meta + shift + d
(global-set-key (kbd "M-D") 'wrx/duplicate-line-or-region)
Mit Präfix Argumenten, und was ist (hoffe ich) intuitives Verhalten:
(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))))))
Der Cursor wird in der letzten Zeile bleiben. Alternativ könnten Sie einen Präfix angeben mögen die nächsten paar Zeilen auf einmal kopieren:
(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))
Ich finde mich mit beiden oft mit einem Wrapper-Funktion das Verhalten des Präfix Argument zu wechseln.
Und ein 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.
fügen Sie die elisp oben Ihnen init.el, und Sie erhalten schneiden / kopieren jetzt ganze Zeile Funktion, dann können Sie F3 F4, um eine Linie zu duplizieren.
Der einfachste Weg ist Chris Conway Methode.
C-a C-SPACE C-n M-w C-y
Das ist die Standardmethode von EMACS beauftragt. Meiner Meinung nach ist es besser, den Standard zu verwenden. Ich bin immer vorsichtig auf die Anpassung eines eigenen Schlüssel-Bindung in EMACS. EMACS ist schon stark genug, ich denke, wir sollten unser Bestes versuchen, um seinen eigenen Schlüssel-Bindungen anzupassen.
Obwohl es ein bisschen lang, aber wenn Sie es gewohnt sind, können Sie schnell tun und finden diesen Spaß!
Hier ist eine Funktion zur aktuellen Zeile duplizieren. Mit Präfix Argumente, wird es die Linie mehrfach duplizieren. Z. B. C-3 C-S-o wird die aktuelle Zeile dreimal duplizieren. Nicht Kill-Ring ändern.
(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)
Ich kann all diese komplizierten Lösungen nicht glauben. Dies ist zwei Eingaben:
<C-S-backspace> führt den Befehl kill-ganze-line
C-/ führt den Befehl rückgängig machen
So <C-S-backspace> C-/ zu "kopieren" eine ganze Zeile (töten und rückgängig gemacht werden).
Sie können natürlich, kombinieren diese mit numerischem und negativen args mehr Zeilen entweder vorwärts oder rückwärts zu töten.
Das fühlt sich natürlicher, in Bezug auf die gewählte Antwort von Chris Conway.
(global-set-key "\ C-C \ C-d" "\ C-a \ C \ C-n \ M-w \ C-y \ C-p \ C-E")
Auf diese Weise können Sie durch einfaches Wiederholen der \ C-c \ C-d Tastenanschläge einer Linie mehrfach kopieren.
