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 or connection, or uses one to recreate the object.

### Usage

    dput(x, file = "",
         control = c("keepNA", "keepInteger", "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 function `save` is 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

    ## Write an ASCII version of function mean to the file "foo"
    dput(mean, "foo")
    ## And read it back into 'bar'
    bar <- dget("foo")
    ## 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, "foo"); dget("foo") - xx # slight rounding on all platforms
    dput(xx, "foo", control = "digits17")
    dget("foo") - xx # slight rounding on some platforms
    dput(xx, "foo", control = "hexNumeric"); dget("foo") - xx
    unlink("foo")

[Package base version 3.4.3 Index]