R: Write an Object to a File or Recreate it

dput {base} | R Documentation

## Write an Object to a File or Recreate it

### Description

Writes an ASCII text representation of an R object to a file, the R console, or a connection, or uses one to recreate the object.

### Usage

    dput(x, file = "",
         control = c("keepNA", "keepInteger", "niceNames", "showAttributes"))

    dget(file, keep.source = FALSE)

### Arguments

`x` | an object.
`file` | either a character string naming a file or a connection. `""` indicates output to the console.
`control` | character vector indicating deparsing options. See `.deparseOpts` for their description.
`keep.source` | logical: should the source formatting be retained when parsing functions, if possible?

### Details

`dput` opens `file` and deparses the object `x` into that file. The object name is not written (unlike `dump`). If `x` is a function the associated environment is stripped. Hence scoping information can be lost.

Deparsing an object is difficult, and not always possible. With the default `control`, `dput()` attempts to deparse in a way that is readable, but for more complex or unusual objects (see `dump`), not likely to be parsed as identical to the original. Use `control = "all"` for the most complete deparsing; use `control = NULL` for the simplest deparsing, not even including attributes.

`dput` will warn if fewer characters were written to a file than expected, which may indicate a full or corrupt file system.

To display saved source rather than deparsing the internal representation include `"useSource"` in `control`. R currently saves source only for function definitions. If you do not care about source representation (e.g., for a data object), for speed set `options(keep.source = FALSE`) when calling `source`.

### Value

For `dput`, the first argument invisibly.

For `dget`, the object created.

### Note

This is not a good way to transfer objects between R sessions. `dump` is better, but the functions `save` and `saveRDS` are designed to be used for transporting R data, and will work with R objects that `dput` does not handle correctly as well as being much faster.

To avoid the risk of a source attribute out of sync with the actual function definition, the source attribute of a function will never be written as an attribute.

### References

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language. Wadsworth & Brooks/Cole.

### See Also

`deparse`, `dump`, `write`.

### Examples

    fil <- tempfile()
    ## Write an ASCII version of the 'base' function mean() to our temp file, ..
    dput(base::mean, fil)
    ## ... read it back into 'bar' and confirm it is the same
    bar <- dget(fil)
    stopifnot(all.equal(bar, base::mean))

    ## Create a function with comments
    baz <- function(x) {
      # Subtract from one
      1-x
    }
    ## and display it
    dput(baz)
    ## and now display the saved source
    dput(baz, control = "useSource")

    ## Numeric values:
    xx <- pi^(1:3)
    dput(xx)
    dput(xx, control = "digits17")
    dput(xx, control = "hexNumeric")
    dput(xx, fil); dget(fil) - xx # slight rounding on all platforms
    dput(xx, fil, control = "digits17")
    dget(fil) - xx # slight rounding on some platforms
    dput(xx, fil, control = "hexNumeric"); dget(fil) - xx
    unlink(fil)

    xn <- setNames(xx, paste0("pi^",1:3))
    dput(xn) # nicer, now "niceNames" being part of default 'control'
    dput(xn, control = "S_compat") # no names
    ## explicitly asking for output as in R < 3.5.0:
    dput(xn, control = c("keepNA", "keepInteger", "showAttributes"))

[Package base version 4.0.5 Index]