files {base} | R Documentation

## File and Directory Manipulation

### Description

These functions provide a low-level interface to the computer's file system.

### Usage

    file.create(..., showWarnings = TRUE)
    file.exists(...)
    file.remove(...)
    file.rename(from, to)
    file.append(file1, file2)
    file.copy(from, to, overwrite = FALSE)
    file.symlink(from, to)
    dir.create(path, showWarnings = TRUE, recursive = FALSE,
               mode = "0777")
    Sys.chmod(paths, mode = "0777")
    Sys.umask(mode = "0000")

### Arguments

`..., file1, file2, from, to, paths` | character vectors, containing file names or paths.
`path` | a character vector containing a single path name.
`overwrite` | logical; should the destination files be overwritten?
`showWarnings` | logical; should the warnings on failure be shown?
`recursive` | logical: should elements of the path other than the last be created? If true, like Unix's `mkdir -p`.
`mode` | the file mode to be used on Unix-alikes: it will be coerced by `as.octmode`.

### Details

The `...` arguments are concatenated to form one character string: you can specify the files separately or as one vector. All of these functions expand path names: see `path.expand`.

`file.create` creates files with the given names if they do not already exist and truncates them if they do. They are created with the maximal permissions allowed by the `umask` setting.

`file.exists` returns a logical vector indicating whether the files named by its argument exist. (Here ‘exists’ is in the sense of the system's `stat` call: a file will be reported as existing only if you have the permissions needed by `stat`. Existence can also be checked by `file.access`, which might use different permissions and so obtain a different result. Note that the existence of a file does not imply that it is readable: for that use `file.access`.)

`file.remove` attempts to remove the files named in its argument. On most platforms ‘file’ includes empty directories, symbolic links, fifos and sockets.

`file.rename` attempts to rename a single file.

`file.append` attempts to append the files named by its second argument to those named by its first. The R subscript recycling rule is used to align names given in vectors of different lengths.

`file.copy` works in a similar way to `file.append` but with the arguments in the natural order for copying. Copying to existing destination files is skipped unless `overwrite = TRUE`. The `to` argument can specify a single existing directory.

`file.symlink` makes symbolic links on those Unix-like platforms which support them. The `to` argument can specify a single existing directory.

`dir.create` creates the last element of the path, unless `recursive = TRUE`. Trailing path separators are removed. The mode will be modified by the `umask` setting in the same way as for the system function `mkdir`. What modes can be set is OS-dependent, and it is unsafe to assume that more than three octal digits will be used. For more details see your OS's documentation on the system call `mkdir` (and not that on the command-line utility of that name).

`Sys.chmod` sets the file permissions of one or more files. It may not be supported (when a warning is issued). See the comments for `dir.create` for how modes are interpreted. Changing mode on a symbolic link is unlikely to work (nor be necessary). For more details see your OS's documentation on the system call `chmod` (and not that on the command-line utility of that name).

`Sys.umask` sets the `umask`. It may not be supported (when a warning is issued and `"0000"` returned). For more details see your OS's documentation on the system call `umask`.

### Value

`dir.create` and `file.rename` return a logical, true for success.
`Sys.umask` returns the previous value of the `umask`, invisibly, as a length-one object of class `"octmode"`.
The remaining functions return a logical vector indicating which operation succeeded for each of the files attempted.
`dir.create` will return failure if the directory already exists.
If `showWarnings = TRUE`, `file.create` and `dir.create` will give a warning for an unexpected failure (e.g. not for a missing value nor for an already existing component for `dir.create(recursive = TRUE)`).
Using a missing value for a file or path name will always be regarded as a failure.

### Author(s)

Ross Ihaka, Brian Ripley

### See Also

`file.info`, `file.access`, `file.path`, `file.show`, `list.files`, `unlink`, `basename`, `path.expand`.

`file_test`.

### Examples

    cat("file A\n", file="A")
    cat("file B\n", file="B")
    file.append("A", "B")
    file.create("A")
    file.append("A", rep("B", 10))
    if(interactive()) file.show("A")
    file.copy("A", "C")
    dir.create("tmp")
    file.copy(c("A", "B"), "tmp")
    list.files("tmp")
    setwd("tmp")
    file.remove("B")
    file.symlink(file.path("..", c("A", "B")), ".")
    setwd("..")
    unlink("tmp", recursive=TRUE)
    file.remove("A", "B", "C")

[Package base version 2.7.1 Index]