Retour arrière sans ajouter pour tuer l'anneau

L'utilisation de Crtl + Backspace ou Ctrl + Suppr ajoute le texte supprimé au kill ring.
Comment puis-je empêcher que cela se produise? Je n'ai pas besoin d'envoyer chaque élément de texte au kill ring lorsqu'il est supprimé.

Question secondaire: quel est l'objectif de ce paramètre par défaut? :)

Selon la documentation:

<C-delete>exécute la commande kill-word (trouvée dans global-map), qui est une fonction Lisp interactive compilée dans ‘simple.el’.

C'est lié <C-delete>, M-d.

(mot ARG)

Tuez les personnages en avant jusqu'à la fin d'un mot. Avec l'argument ARG, faites cela plusieurs fois.

Maintenant, parcourons le code source:

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

Ensuite, à l'intérieur de la documentation de la kill-regionfonction, nous trouvons:

Tuez ("coupez") le texte entre le point et la marque.
This deletes the text from the buffer and saves it in the kill ring. La commande [yank] peut le récupérer à partir de là. (Si vous souhaitez enregistrer la région sans la tuer, utilisez [kill-ring-save].)

[...]

Les programmes Lisp devraient utiliser cette fonction pour tuer du texte. (Pour supprimer du texte, utilisez delete-region.)

Maintenant, si vous voulez aller plus loin, voici une fonction que vous pouvez utiliser pour supprimer sans copier dans kill-ring:

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

Avec l'aimable autorisation d' ErgoEmacs

Depuis Emacs 24, sans aucune configuration, vous pouvez supprimer n'importe quel texte sans l'ajouter au kill ring en le sélectionnant puis en appuyant sur Backspaceou Delete. Lorsque la marque est active, ces touches suppriment la région au lieu de simplement supprimer le caractère avant / après le curseur.

Autrement dit, déplacez-vous à une extrémité du texte que vous souhaitez supprimer, appuyez sur Ctrl+ Space, passez à l'autre extrémité et appuyez sur Backspace(ou Delete) supprimez la région en surbrillance. Ou déplacez-vous à une extrémité, maintenez la Shifttouche enfoncée tout en utilisant les touches de déplacement pour aller à l'autre extrémité, puis appuyez sur Backspace.

J'ai eu le même problème et je l'ai résolu plus facilement de cette façon:

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

L'appel (backward-delete-char-untabify 1 nil)indique à Emacs de supprimer un caractère en arrière (c'est le 1paramètre) et qu'il s'abstient de copier sur l'anneau (c'est le nilparamètre). Vous avez besoin d'une fonction lambda (c'est-à-dire anonyme) car vous liez une fonction avec des paramètres à une clé.