How can I make Emacs backup every time I save?

From time to time I delete files that I shouldn't and worst is files that I've been writing myself. Therefore I have many times been saved by the backup feature of Emacs.

But my problem is that Emacs only makes a backup the very first time you save a buffer. Is there a way to make Emacs do it every time I press C-x C-s?

This is what my .emacs look like currently (only the part that deals with backups):

* snip *

;; ===== Backups =====

;; Enable backup files.

(setq make-backup-files t)

;; Save all backup file in this directory.

(setq backup-directory-alist (quote ((".*" . "~/.emacs_backups/")))开发者_运维百科)

;; Always backup by copying (safest, but slowest)

(setq backup-by-copying t)

;; Append .~1~ (and increasing numbers) to end of file when saving backup

(setq version-control t)

;; Defining how many old versions of a file to keep (starting from the

;; most recent and counting backward

(setq kept-new-versions 100)

* snip *

After reading this: EmacsWiki: Force Backups

I added these lines to my .emacs:

(defun force-backup-of-buffer ()
  (setq buffer-backed-up nil))

(add-hook 'before-save-hook  'force-backup-of-buffer)

It utilizes the standard back up/version control but resets the flag that indicates wether or not the buffer has been backed up this session before a save.

First two rows define a function that resets the flag that indicates wether the buffer was backed up during this session.

Last row adds an event hook that executes the function before a save.

This does exactly what I wanted.

If you want to do it on your own, here's a start:

(defun backup-and-save ()
  (interactive)
  (setq filename (buffer-file-name))
  (write-file (concat filename (format-time-string "_" "%Y%m%d%H%M%S")))
  (write-file filename)
  )

It saves a copy as originalfilename_timestamp in connection with a timestamp.

You might of course adjust it to store it in a separate backup folder or add other "tweaks".

Here is what I use. It puts backups in a subdirectory of the directory the file is in. It also saves a backup each time the file is saved.

(setq make-backup-files t               ; backup of a file the first time it is saved.
      backup-by-copying t               ; don't clobber symlinks
      version-control t                 ; version numbers for backup files
      delete-old-versions t             ; delete excess backup files silently
      delete-by-moving-to-trash t
      kept-old-versions 6               ; oldest versions to keep when a new numbered
                                        ; backup is made (default: 2)
      kept-new-versions 9               ; newest versions to keep when a new numbered
                                        ; backup is made (default: 2)
      auto-save-default t               ; auto-save every buffer that visits a file
      auto-save-timeout 20              ; number of seconds idle time before auto-save
                                        ; (default: 30)
      auto-save-interval 200            ; number of keystrokes between auto-saves
                                        ; (default: 300)
      )
;; make backup to a designated dir, mirroring the full path

;; backup to dir hung on source dir...

(add-hook 'write-file-hooks 'setBackUp)
(defun setBackUp ()
  "Called by before-save-hook to set up backup location"
  (defvar backupdirname "BackUps~")     ; you can chose the sub dir name here
  (if (not (file-exists-p  backupdirname))
      (make-directory  backupdirname t))
  (setq backup-directory-alist `(("." . ,backupdirname)))
  (setq buffer-backed-up nil)            ; force backup every save
  nil
  )