| files {base} | R Documentation |
These functions provide a low-level interface to the computer's file system.
file.create(..., showWarnings = TRUE)
file.exists(...)
file.remove(...)
file.rename(from, to)
file.append(file1, file2)
file.copy(from, to, overwrite = recursive, recursive = FALSE,
copy.mode = TRUE)
file.symlink(from, to)
file.link(from, to)
Sys.junction(from, to)
..., file1, file2 |
character vectors, containing file names or paths. |
from, to |
character vectors, containing file names or paths.
For |
overwrite |
logical; should existing destination files be overwritten? |
showWarnings |
logical; should the warnings on failure be shown? |
recursive |
logical. If |
copy.mode |
logical: should file permission bits be copied where possible? This applies to both files and directories. |
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 read/write permissions allowed by the
‘umask’ setting (where relevant). By default a warning
is given (with the reason) if the operation fails.
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.) What constitutes a
‘file’ is system-dependent, but should include directories.
(However, directory names must not include a trailing backslash or
slash on Windows.) Note that if the file is a symbolic link on a
Unix-alike, the result indicates if the link points to an actual file,
not just if the link exists.
file.remove attempts to remove the files named in its argument.
On most Unix platforms ‘file’ includes empty
directories, symbolic links, fifos and sockets. On Windows,
‘file’ means a regular file and not, say, an empty directory.
file.rename attempts to rename files (and from and
to must be of the same length). Where file permissions allow
this will overwrite an existing element of to. This is subject
to the limitations of the OS's corresponding system call (see
something like man 2 rename on a Unix-alike): in particular
in the interpretation of ‘file’: most platforms will not rename
files across file systems. (On Windows, file.rename nowadays
works across volumes for files but not directories.)
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. If
copy.mode = TRUE (added in R 2.13.0) file read/write/execute
permissions are copied where possible, restricted by
‘umask’. Other security attributes such as ACLs are not
copied. On a POSIX filesystem the targets of symbolic links will be
copied rather than the links themselves.
file.symlink and file.link make symbolic and hard links
on those file systems which support them. For file.symlink the
to argument can specify a single existing directory. (Unix and
Mac OS X native filesystems support both. Windows has hard links to
files on NTFS file systems and concepts related to symbolic links on
recent versions: see the section below on the Windows version of this
help page. What happens on a FAT or SMB-mounted file system is OS-specific.)
These functions return a logical vector indicating which operation succeeded for each of the files attempted. Using a missing value for a file or path name will always be regarded as a failure.
If showWarnings = TRUE, file.create will give a warning
for an unexpected failure.
Case-insensitive file systems are the norm on Windows and Mac OS X, but can be found on all OSes (for example a FAT-formatted USB drive is probably case-insensitive).
These functions will most likely match existing files regardless of case on such file systems: however this is an OS function and it is possible that file names might be mapped to upper or lower case.
Symbolic links in the sense of POSIX file systems do not exist on Windows: however, NTFS file systems support two similar concepts.
Windows 2000 and later have ‘junctions’ (or
‘junction points’), unfortunately without a public API. They
are a Windows version of the Unix concept of mounting one directory on
another. One way to create, list and delete junctions is via
‘junction.exe’ from
http://download.sysinternals.com/Files/Junction.zip (see
http://technet.microsoft.com/en-us/sysinternals/bb896768). On
recent enough versions of Windows mklink /J can also be
used. Function Sys.junction (added in R 2.15.0) creates one
or more junctions: to should either specify a single existing
directory or a set of non-existent file paths of the same length as
from.
A version of symbolic linking to files/directories was implemented
starting with Vista, and file.symlink makes use of that interface since
R 2.15.0. However, it has restrictions (apart from the OS
restriction) that are crippling. First, the user needs permission to
make symbolic links, and that permission is not normally granted
except to Administrator accounts (note: not users with Administrator
rights): further many users report that whereas the Policy Editor
appears to be able to grant such rights, the API still reports
insufficient permissions. Second, the interface needs to know if
from is a file or a directory (and it need not yet exist): we
have implemented this to allow linking from a directory only if it
currently exists.
Care is needed with removing a junction (and most likely also a
symbolic link): many tools will remove the target and its contents
(including Windows Explorer in XP, and unlink in R prior to
2.15.0).
There is no guarantee that these functions will handle Windows relative paths of the form ‘d:path’: try ‘d:./path’ instead. In particular, ‘d:’ is not recognized as a directory. Nor are \\?\ prefixes (and similar) supported.
Most of these functions accept UTF-8 filepaths not valid in the current locale.
User error in supplying invalid file names (and note that ‘foo/’ and ‘foo\’ are invalid on Windows) has undefined consequences.
Ross Ihaka, Brian Ripley
file.info, file.access, file.path,
file.show, list.files,
unlink, basename,
path.expand.
Sys.glob to expand wildcards in file specifications.
http://en.wikipedia.org/wiki/Hard_link and http://en.wikipedia.org/wiki/Symbolic_link for the concepts of links and their limitations.
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")
unlink("tmp", recursive=TRUE)
file.remove("A", "B", "C")