Make a backup file: Difference between revisions

Some examples on this page assume that the original file already exists. They might fail if some user is trying to create a new file.

 

=={{header|AutoHotkey}}==

if FileExist(targetfile)

FileMove, %targetfile%, %targetfile%.bak

}

file.Write("This is a test string.`r`n")

 

=={{header|AWK}}==

# syntax: GAWK -f MAKE_A_BACKUP_FILE.AWK filename(s)

# see: http://www.gnu.org/software/gawk/manual/gawk.html#Extension-Sample-Inplace

exit(0)

}

 

=={{header|Batch File}}==

@echo off

setlocal enabledelayedexpansion

echo !line[1]!>"%filePath%"

for /l %%i in (2,1,%i%) do echo !line[%%i]!>>"%filePath%"

 

=={{header|Common Lisp}}==

Appends a version number and increments it on each backup

(ignore-errors (apply #'parse-integer args)))

 

(rename-file file (get-next-version file))

(with-open-file (out file :direction :output)

 

=={{header|Elixir}}==

def backup_file(filename) do

backup = filename <> ".backup"

end

 

 

=={{header|Go}}==

===Rename===

This is the technique of the task description.

 

import (

fmt.Println(err)

}

===Copy===

Alternative technique copies an existing file to make the backup copy, then updates the origial file. In an attempt to keep operations atomic, the original file is opened as the first operation and is not closed until all operations are complete. In an attempt to avoid data loss, the original file is not modified until the backup file is closed.

 

import (

// backup complete (as long as err == nil)

return

 

=={{header|Java}}==

{{works with|Java|7+}}

import java.io.IOException;

import java.io.PrintWriter;

}

}

 

Contents of 'original.txt' ''before'' the program is run and of 'original.txt.backup' ''after'' it is run:

 

{{works with|Java|1.5+}}

import java.io.IOException;

import java.io.PrintWriter;

}

}

 

{{out}}

{{works with|Julia|0.6}}

 

mv(realpath(targetfile), realpath(targetfile) * ".bak")

# "a+" for permissions of reading, writing, creating

open(targetfile, "w+") do io

println(io, "this task was solved during a talk about rosettacode at the PyCon China in 2011")

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.io.File

fun main(args: Array<String>) {

saveWithBackup("original.txt", "fourth", "fifth", "sixth")

 

Contents of 'original.txt' ''before'' the program is run and of 'original.txt.backup' ''after'' it is run:

 

=={{header|Lasso}}==

 

// create file

// create new file with new contents

local(nf = file(#file2use))

 

=={{header|Locomotive Basic}}==

 

AMSDOS has automatic one-level backups which also work from Locomotive BASIC: If e.g. the file <tt>test.bas</tt> is saved, the data gets written to <tt>test.$$$</tt>. When the file is closed a preexisting <tt>test.bas</tt> gets renamed to <tt>test.bak</tt> and finally <tt>test.$$$</tt> is renamed to <tt>test.bas</tt>. (These backups affect all file types, not just BASIC source code.)

 

=={{header|Perl}}==

use warnings;

 

 

# back up this program

 

=={{header|Phix}}==

{{trans|Go}}

if not rename_file(targetfile, targetfile&".bak", overwrite:=true) then

puts(1,"warning: could not rename file\n")

puts(fn,"this task was translated from the Python entry\n")

close(fn)

Before basing anything on the above code, though, I would recommend you take a look at <br>

function saveFile in demo\edix\edix.exw, which does this sort of thing for real: <br>

=={{header|PicoLisp}}==

PicoLisp makes use of external commands as much as possible (at least for not time-critical operations), to avoid duplicated functionality.

(call 'mv Path (pack Path ".backup"))

(out Path

 

=={{header|Pike}}==

targetfile = System.resolvepath(targetfile);

mv(targetfile, targetfile+"~");

 

=={{header|Python}}==

Using [https://docs.python.org/library/os.html os library]

import os

targetfile = "pycon-china"

f.write("this task was solved during a talk about rosettacode at the PyCon China in 2011")

f.close()

Or using a newer [https://docs.python.org/library/pathlib.html pathlib library] (Python >= 3.4):

from pathlib import Path

 

with filepath.open('w') as file:

file.write("New content")

 

=={{header|Racket}}==

This version keeps unlimited backups, with <tt>*.bak</tt> being the freshest one, <tt>*.bak1</tt> is an older backup, etc. So each backup moves all existing names up.

 

#lang racket

 

 

(revise "fff")

 

=={{header|Raku}}==

{{works with|Rakudo|2017.10}}

 

# where n is in the range 1 - $limit (default 3).

# Prints 'File not found' to STDERR if the file does not exist.

# Optionally, specify limit, back-up extension pattern and whether to follow symlinks.

# Optional parameters can be in any order, in any combination.

 

=={{header|REXX}}==

This REXX version executes under DOS or DOS under Windows.

parse arg oFID . /*get a required argument from the C.L.*/

if oFID=='' then do /*No argument? Then issue an err msg.*/

'RENAME' oFID tFID /*rename the original file to backup. */

call lineout oFID, '═══This is line 1.' /*write one line to the original file. */

The contents of the original file (before execution): &nbsp; '''A.FILE''':

<pre>

=={{header|Ruby}}==

This version does not overwrite the backup file if it exists.

filename = File.realpath(filename)

bkup = filename + ".backup"

end

 

 

Example:

=={{header|Scala}}==

===Java Interoperability===

import java.nio.file.{Files, Paths, StandardCopyOption}

 

saveWithBackup("original.txt", "fourth", "fifth", "sixth")

 

 

=={{header|Tcl}}==

 

proc backupopen {filename mode} {

}

return [open $filename $mode]

 

=={{header|VBA}}==

If Len(Dir(filename)) > 0 Then

On Error Resume Next

Public Sub main()

backup "D:\test.txt"

 

=={{header|Wren}}==

{{libheader|Wren-ioutil}}

 

var saveWithBackup = Fn.new { |filePath, lines|

System.print(File.read("original.txt"))

System.print("Contents of original.txt.backup:")

 

{{out}}