savewrites an external representation of R objects to the specified file. The objects can be read back from the file at a later date by using the function
datain some cases).
save.image() is just a short-cut for save my current
save(list = ls(all.names = TRUE), file =
".RData", envir = .GlobalEnv).
It is also what happens with
save(..., list = character(), file = stop("'file' must be specified"), ascii = FALSE, version = NULL, envir = parent.frame(), compress = isTRUE(!ascii), compression_level, eval.promises = TRUE, precheck = TRUE)save.image(file = ".RData", version = NULL, ascii = FALSE, compress = !ascii, safe = TRUE)
version = 1.
TRUE, an ASCII representation of the data is written. The default value of
FALSEwhich leads to a binary file being written. If
version >= 2, a different ASCII representation is used which writes double/complex numbers as binary fractions.
NULLspecifies the current default format. The version used from R 0.99.0 to R 1.3.1 was version 1. The default format as from R 1.4.0 is version 2.
gzipcompression, and character strings
"xz"specify the type of compression. Ignored when
fileis a connection and for workspace format version 1.
gzipcompression and to
TRUE, a temporary file is used for creating the saved workspace. The temporary file is renamed to
fileif the save succeeds. This preserves an existing workspace
fileif the save fails, but at the cost of using extra disk space during the save.
gzipcompression in 8 secs, 19MB with
bzip2compression in 13 secs and 9.4MB with
xzcompression in 40 secs. The load times were 1.3, 2.8, 5.5 and 5.7 seconds respectively. These results are indicative, but the relative performances do depend on the actual file:
xzcompressed unusually well here. It is possible to compress later (with
xz) a file saved with
compress = FALSE: the effect is the same as saving with compression. Also, a saved file can be uncompressed and re-compressed under a different compression scheme (and see
resaveRdaFilesfor a way to do so from within R).
filecan be a connection can be exploited to make use of an external parallel compression utility such as
pbzip2(http://compression.ca/pbzip2/) via a
pipeconnection. For example, using 8 threads,
con <- pipe("pigz -p8 > fname.gz", "wb") save(myObj, file = con); close(con) con <- pipe("pbzip2 -p8 -9 > fname.bz2", "wb") save(myObj, file = con); close(con) con <- pipe("xz -T8 -6 -e > fname.xz", "wb") save(myObj, file = con); close(con)where the last requires
xz5.1.1 or later built with support for multiple threads (and parallel compression is only effective for large objects: at level 6 it will compress in serialized chunks of 12MB).
...arguments only give the names of the objects to be saved: they are searched for in the environment given by the
envirargument, and the actual objects given as arguments need not be those found. Saved R objects are binary files, even those saved with
ascii = TRUE, so ensure that they are transferred without conversion of end-of-line markers and of 8-bit characters. The lines are delimited by LF on all platforms. Although the default version has not changed since R 1.4.0, this does not mean that saved files are necessarily backwards compatible. You will be able to load a saved image into an earlier version of R unless use is made of later additions (for example, raw vectors, external pointers and some S4 objects). One such later addition was long vectors, introduced in R 3.0.0 and loadable only on 64-bit platforms. Loading files saved with
ASCII = NArequires a C99-compliant C function
sscanf: this is a problem on Windows, first worked around in R 3.1.2: they should be readable in earlier versions of R on all other platforms.
...or as a character vector in
listare used to look up the objects from environment
envir. By default promises are evaluated, but if
eval.promises = FALSEpromises are saved (together with their evaluation environments). (Promises embedded in objects are always saved unevaluated.)
All R platforms use the XDR (bigendian) representation of C ints and doubles in binary save-d files, and these are portable across all R platforms.
ASCII saves used to be useful for moving data between platforms but are now mainly of historical interest. They can be more compact than binary saves where compression is not used, but are almost always slower to both read and write: binary saves compress much better than ASCII ones. Further, decimal ASCII saves may not restore double/complex values exactly, and what value is restored may depend on the R platform.
Default values for the
version arguments can be modified with the
"save.defaults" option (used both by
save.image), see also the Examples section. If a
"save.image.defaults" option is set it is used in preference to
"save.defaults" for function
save.image (which allows
this to have different defaults). In addition,
compression_level can be part of the
A connection that is not already open will be opened in mode
"wb". Supplying a connection which is open and not in binary
mode gives an error.
For other interfaces to the underlying serialization format, see
x <- stats::runif(20) y <- list(a = 1, b = TRUE, c = "oops") save(x, y, file = "xy.RData") save.image() unlink("xy.RData") unlink(".RData") # set save defaults using option: options(save.defaults = list(ascii = TRUE, safe = FALSE)) save.image() unlink(".RData")
Run the code above in your browser using DataCamp Workspace