Zabij lub skopiuj bieżącą linię przy minimalnym naciśnięciu klawisza

Robię, C-a C-k C-kżeby zabić cały punkt linii jest włączony.

Jeśli chcę skopiować wiersz zamiast go zabić, mogę uderzyć C-/ C-/ zaraz po wpisaniu powyższej sekwencji.

Alternatywnie mogę to zrobić C-a C-SPC C-n M-w.

Czy istnieje szybszy sposób na zabicie lub skopiowanie całego punktu linii?

Możesz użyć, kill-whole-lineaby zabić cały punkt linii jest włączony. Pozycja punktu nie ma znaczenia. C-S-DELDomyślnie to polecenie jest powiązane .

Możesz także poinstruować kill-line(powiązanego z C-k) zabić całą linię, ustawiając zmienną kill-whole-line na nilwartość inną niż wartość:

(setq kill-whole-line t)

Zauważ, że punkt musi znajdować się na początku linii, aby to zadziałało.

Są jeszcze dwa klejnoty (przez emacs-fu ):

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

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

Po ich wprowadzeniu możesz zabić lub skopiować punkt linii za jednym naciśnięciem klawisza :

• C-w zabija bieżącą linię
• M-w kopiuje bieżącą linię

Zauważ, że jeśli istnieje aktywny region kill-regioni kill-ring-savenadal będziesz robić to, co zwykle: zabij lub skopiuj go.

Przeniesienie slick-cuti slick-copydo nowego systemu porad

Emacs 24.4 wprowadza nowy system porad . Chociaż defadvice nadal działa , istnieje szansa, że ​​może być przestarzały na korzyść nowego systemu w przyszłych wersjach Emacsa. Aby się do tego przygotować, możesz użyć zaktualizowanych wersji slick-cuti slick-copy:

(defun slick-cut (beg end)
  (interactive
   (if mark-active
       (list (region-beginning) (region-end))
     (list (line-beginning-position) (line-beginning-position 2)))))

(advice-add 'kill-region :before #'slick-cut)

(defun slick-copy (beg end)
  (interactive
   (if mark-active
       (list (region-beginning) (region-end))
     (message "Copied line")
     (list (line-beginning-position) (line-beginning-position 2)))))

(advice-add 'kill-ring-save :before #'slick-copy)

Rozwiązaniem, które znalazłem dla siebie, jest użycie argumentów z przedrostkiem.

Dla mnie zabicie połowy linii jest przydatną funkcją, ale chcę też łatwiejszego sposobu zabijania całych linii. Zrobiłem to, aby kill-linepo prostu mordować wszystko w zasięgu wzroku, gdy podano argument prefiksowy.

(defmacro bol-with-prefix (function)
  "Define a new function which calls FUNCTION.
Except it moves to beginning of line before calling FUNCTION when
called with a prefix argument. The FUNCTION still receives the
prefix argument."
  (let ((name (intern (format "endless/%s-BOL" function))))
    `(progn
       (defun ,name (p)
         ,(format 
           "Call `%s', but move to BOL when called with a prefix argument."
           function)
         (interactive "P")
         (when p
           (forward-line 0))
         (call-interactively ',function))
       ',name)))

(global-set-key [remap paredit-kill] (bol-with-prefix paredit-kill))
(global-set-key [remap org-kill-line] (bol-with-prefix org-kill-line))
(global-set-key [remap kill-line] (bol-with-prefix kill-line))
(global-set-key "\C-k" (bol-with-prefix kill-line))

Z tym małym makro C-knadal zabija od punktu, ale C-3 C-kpołyka trzy całe linie. Jako bonus otrzymujemy takie kill-whole-linezachowanie C-1 C-k.

Jest tak zwany pakiet, whole-line-or-regionktóry radzi różnym wbudowanym poleceniom, aby działały na bieżącej linii, jeśli żaden region nie jest aktywny, więc M-wskopiują bieżącą linię i C-wna przykład ją zabiją. Korzystam z pakietu od lat i uważam go za niezbędny.

Dodatkowo ten pakiet sprawia, że ​​przedrostek numeryczny będzie wskazywał liczbę linii, na których ma działać, więc M-2 M-wskopiuje dwie linie. Inne odpowiedzi tutaj nie zapewniają tej przydatnej funkcjonalności.

Przejęłem utrzymanie pakietu na moim koncie github, gdy autor przestał go utrzymywać i przestał odpowiadać.

whole-line-or-region zapewnia także możliwości dodawania tego zachowania do dalszych poleceń, jeśli zajdzie taka potrzeba.

To nie jest odpowiedź na prawosławne emacsy. Jeśli jednak chcesz bluźnić za pomocą evilmodalnej edycji, możesz:

• dd dla linii zabicia
• cc dla linii kopiowania

Oba mogą być poprzedzone liczbą linii do zabicia / skopiowania (np. 4ccSkopiują kolejne 4 linie).

Oprócz odpowiedzi @itsjeyd, czy mogę zasugerować te dwie funkcje?

(defun xah-copy-line-or-region ()
  "Copy current line, or text selection.
When `universal-argument' is called first, copy whole buffer (but respect `narrow-to-region')."
  (interactive)
  (let (p1 p2)
    (if (null current-prefix-arg)
        (progn (if (use-region-p)
                   (progn (setq p1 (region-beginning))
                          (setq p2 (region-end)))
                 (progn (setq p1 (line-beginning-position))
                        (setq p2 (line-end-position)))))
      (progn (setq p1 (point-min))
             (setq p2 (point-max))))
    (kill-ring-save p1 p2)))

(defun xah-cut-line-or-region ()
  "Cut current line, or text selection.
When `universal-argument' is called first, cut whole buffer (but respect `narrow-to-region')."
  (interactive)
  (let (p1 p2)
    (if (null current-prefix-arg)
        (progn (if (use-region-p)
                   (progn (setq p1 (region-beginning))
                          (setq p2 (region-end)))
                 (progn (setq p1 (line-beginning-position))
                        (setq p2 (line-beginning-position 2)))))
      (progn (setq p1 (point-min))
             (setq p2 (point-max))))
    (kill-region p1 p2)))

Następnie kluczowe definicje (prawdopodobnie będziesz chciał je dostosować):

(global-set-key (kbd "<f2>") 'xah-cut-line-or-region) ; cut

(global-set-key (kbd "<f3>") 'xah-copy-line-or-region) ; copy

(global-set-key (kbd "<f4>") 'yank) ; paste

Dzięki uprzejmości ErgoEmacs

Jako rozszerzenie powyższej odpowiedzi @ itsjeyd mam następujące. (Prawdopodobnie logika mogłaby zostać nieco oczyszczona i zrobię to, kiedy przeniesie się do nowego systemu porad, prawdopodobnie również rozszerzę ją, aby rozszerzyć do sexp/ paragraphjeśli powtórzę ponownie).

Inicjał C-w/ M-wpobierze tylko słowo w punkcie, a wywołanie go po raz drugi przejmie całą linię.

;; *** Copy word/line without selecting
(defadvice kill-ring-save (before slick-copy-line activate compile)
  "When called interactively with no region, copy the word or line

Calling it once without a region will copy the current word.
Calling it a second time will copy the current line."
    (interactive
     (if mark-active (list (region-beginning) (region-end))
       (if (eq last-command 'kill-ring-save)
           (progn
             ;; Uncomment to only keep the line in the kill ring
             ;; (kill-new "" t)
             (message "Copied line")
             (list (line-beginning-position)
                   (line-beginning-position 2)))
         (save-excursion
           (forward-char)
           (backward-word)
           (mark-word)
           (message "Copied word")
           (list (mark) (point)))))))

;; *** Kill word/line without selecting
(defadvice kill-region (before slick-cut-line first activate compile)
  "When called interactively kill the current word or line.

Calling it once without a region will kill the current word.
Calling it a second time will kill the current line."
  (interactive
   (if mark-active (list (region-beginning) (region-end))
    (if (eq last-command 'kill-region)
        (progn
          ;; Return the previous kill to rebuild the line
          (yank)
          ;; Add a blank kill, otherwise the word gets appended.
          ;; Change to (kill-new "" t) to remove the word and only
          ;; keep the whole line.
          (kill-new "")
          (message "Killed Line")
          (list (line-beginning-position)
                (line-beginning-position 2)))
      (save-excursion
        (forward-char)
        (backward-word)
        (mark-word)
        (message "Killed Word")
        (list (mark) (point)))))))

Ponieważ chcesz to robić przy minimalnym naciśnięciu klawisza, możesz użyć doskonałego pakietu akordów Davida Anderssona . „Akord klawiszy” to dwa klawisze naciskane jednocześnie lub jeden klawisz naciskany dwukrotnie.

Możesz powiązać dowolne akordy klawiszowe z tymi funkcjami.

(require 'key-chord)
(key-chord-mode 1)
(key-chord-define-global "dd"  'kill-whole-line)
(key-chord-define-global "cc"  'yank-whole-line)

Mniej doraźnym sposobem jest zdefiniowanie mark-whole-line , dla którego Emacs naprawdę powinien mieć domyślną komendę.

(defun mark-whole-line ()               
    "Combinition of C-a, mark, C-e"
    (interactive)
    (move-beginning-of-line nil)
    (set-mark-command nil)
    (move-end-of-line nil)
)
(global-set-key (kbd "C-2") 'mark-whole-line) ; 2 is near w

Następnie C-2 C-w wykona robotę.

Ułatwia to także komentowanie bieżącej całej linii.

To jest modyfikacja odpowiedzi od itsjeyd - obecnie najwyżej głosowanej odpowiedzi, z której korzystałem od lat. Ma jednak problemy: zalecana wersja kill-ring-saveczasami zawiedzie, ponieważ znak nie jest ustawiony (zazwyczaj w nowym buforze), a nawet gdy zadziałał, kursor wykonał dziwny taniec po użyciu funkcji do skopiowania pojedynczego wiersza . Po pewnym kopaniu dotarło do mnie, że dzieje się tak, ponieważ kill-ring-savepołączenia indicate-copied-regionwykonały swoją pracę, ale ponieważ punkt i znak nie pasują do skopiowanego regionu, indicate-copied-regionoznaczono niewłaściwy region.

Wystarczająco powiedziane. Oto rozwiązanie, które temu zaradzi:

(define-advice kill-ring-save
    (:before-while (beg end &optional region) slick)
  (or mark-active
      (not (called-interactively-p 'interactive))
      (prog1 nil
    (copy-region-as-kill
     (line-beginning-position) (line-beginning-position 2))
    (message "Copied current line"))))

Nie ma nic złego w poradach itsjeyd na temat kill-region. Oto jego wariant, bardziej stylistycznie zgodny z powyższym:

(define-advice kill-region
    (:around (kill-region beg end &optional region) slick)
  (if (or mark-active (not region))
      (funcall kill-region beg end region)
    (funcall kill-region
             (line-beginning-position) (line-beginning-position 2))
    (message "Killed current line")))

Pamiętaj, że jeśli transient-mark-modenie jest włączony, te porady nic nie robią.

Używam pakietu o nazwie composable.el . Ciekawą rzeczą w pakiecie jest to, że modyfikuje Mw i Cw (polecenia kopiowania i zabijania), aby były bardziej podobne do Vima, z tym, że akceptuje tradycyjne polecenia emacsa. Więc C-w lzabija całą linię. Ale możesz także robić rzeczy takie jak C-w M->zabijanie końca pliku. Oba polecenia działają normalnie podczas oznaczania regionu.