Rücktaste, ohne den Ring zu töten

Mit Strg + Rücktaste oder Strg + Entf wird der gelöschte Text zum Kill Ring hinzugefügt.
Wie kann ich das verhindern? Ich muss nicht jedes einzelne Textstück an den Kill Ring senden, wenn es gelöscht wird.

Nebenfrage: Wozu dient diese Standardeinstellung überhaupt? :)

Nach der Dokumentation:

<C-delete>führt den Befehl kill-word (gefunden in global-map) aus, der eine interaktiv kompilierte Lisp-Funktion ist ‘simple.el’.

Es ist gebunden an <C-delete>, M-d.

(Abschusswort ARG)

Töte die Charaktere vorwärts, bis du auf das Ende eines Wortes stößt. Tun Sie dies mit dem Argument ARG so oft.

Lassen Sie uns nun den Quellcode durchsuchen:

(defun kill-word (arg)                                                                                                     
  "Kill characters forward until encountering the end of a word.                                                           
With argument ARG, do this that many times."
  (interactive "p")
  (kill-region (point) (progn (forward-word arg) (point))))

In der Dokumentation der kill-regionFunktion finden wir dann:

Töte ("schneide") Text zwischen Punkt und Markierung.
This deletes the text from the buffer and saves it in the kill ring. Der Befehl [yank] kann es von dort abrufen. (Wenn Sie die Region speichern möchten, ohne sie zu töten, verwenden Sie [kill-ring-save].)

[...]

Lisp-Programme sollten diese Funktion zum Töten von Text verwenden. (Verwenden Sie zum Löschen von Text delete-region.)

Wenn Sie weiter gehen möchten, können Sie diese Funktion zum Löschen verwenden, ohne sie in kill-ring zu kopieren:

(defun my-delete-word (arg)
  "Delete characters forward until encountering the end of a word.
With argument, do this that many times.
This command does not push text to `kill-ring'."
  (interactive "p")
  (delete-region
   (point)
   (progn
     (forward-word arg)
     (point))))

(defun my-backward-delete-word (arg)
  "Delete characters backward until encountering the beginning of a word.
With argument, do this that many times.
This command does not push text to `kill-ring'."
  (interactive "p")
  (my-delete-word (- arg)))

(defun my-delete-line ()
  "Delete text from current position to end of line char.
This command does not push text to `kill-ring'."
  (interactive)
  (delete-region
   (point)
   (progn (end-of-line 1) (point)))
  (delete-char 1))

(defun my-delete-line-backward ()
  "Delete text between the beginning of the line to the cursor position.
This command does not push text to `kill-ring'."
  (interactive)
  (let (p1 p2)
    (setq p1 (point))
    (beginning-of-line 1)
    (setq p2 (point))
    (delete-region p1 p2)))

; bind them to emacs's default shortcut keys:
(global-set-key (kbd "C-S-k") 'my-delete-line-backward) ; Ctrl+Shift+k
(global-set-key (kbd "C-k") 'my-delete-line)
(global-set-key (kbd "M-d") 'my-delete-word)
(global-set-key (kbd "<M-backspace>") 'my-backward-delete-word)

Mit freundlicher Genehmigung von ErgoEmacs

Seit Emacs 24 können Sie ohne Konfiguration jeden Text löschen, ohne ihn dem Kill-Ring hinzuzufügen, indem Sie ihn auswählen und dann Backspaceoder drücken Delete. Wenn die Markierung aktiv ist, löschen diese Tasten die Region, anstatt nur das Zeichen vor / nach dem Cursor zu löschen.

Bewegen Sie sich also an ein Ende des zu löschenden Texts, drücken Sie Ctrl+ Space, bewegen Sie sich an das andere Ende und drücken Sie Backspace(oder Delete), um den markierten Bereich zu löschen. Oder gehen Sie zu einem Ende, halten ShiftSie gedrückt, während Sie mit den Bewegungstasten zum anderen Ende gehen, und drücken Sie Backspace.

Ich hatte das gleiche Problem und löste es leichter auf diese Weise:

(global-set-key (kbd "<backspace>")
          '(lambda () (interactive) (backward-delete-char-untabify 1 nil)))

Durch das Aufrufen (backward-delete-char-untabify 1 nil)wird Emacs angewiesen, ein Zeichen (das ist der 1Parameter) rückwärts zu löschen und das Kopieren in den Ring (das ist der nilParameter) zu unterlassen. Sie benötigen eine Lambda-Funktion (dh eine anonyme Funktion), weil Sie eine Funktion mit Parametern an einen Schlüssel binden.