EVOLUTION-MANAGER

Edit File: connections.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><title>R: Functions to Manipulate Connections (Files, URLs, ...)</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<link rel="stylesheet" type="text/css" href="R.css" />
</head><body>

<table width="100%" summary="page for connections {base}"><tr><td>connections {base}</td><td style="text-align: right;">R Documentation</td></tr></table>

<h2>Functions to Manipulate Connections (Files, URLs, ...)</h2>

<h3>Description</h3>

Functions to create, open and close connections, i.e.,
&ldquo;generalized files&rdquo;, such as possibly compressed files, URLs,
pipes, etc.

<h3>Usage</h3>

<pre>
file(description = "", open = "", blocking = TRUE,
 encoding = getOption("encoding"), raw = FALSE,
 method = getOption("url.method", "default"))

url(description, open = "", blocking = TRUE,
    encoding = getOption("encoding"),
    method = getOption("url.method", "default"),
    headers = NULL)

gzfile(description, open = "", encoding = getOption("encoding"),
       compression = 6)

bzfile(description, open = "", encoding = getOption("encoding"),
       compression = 9)

xzfile(description, open = "", encoding = getOption("encoding"),
       compression = 6)

unz(description, filename, open = "", encoding = getOption("encoding"))

pipe(description, open = "", encoding = getOption("encoding"))

fifo(description, open = "", blocking = FALSE,
     encoding = getOption("encoding"))

socketConnection(host = "localhost", port, server = FALSE,
                 blocking = FALSE, open = "a+",
                 encoding = getOption("encoding"),
                 timeout = getOption("timeout"))

open(con, ...)
## S3 method for class 'connection'
open(con, open = "r", blocking = TRUE, ...)

close(con, ...)
## S3 method for class 'connection'
close(con, type = "rw", ...)

flush(con)

isOpen(con, rw = "")
isIncomplete(con)
</pre>

<h3>Arguments</h3>

<table summary="R argblock">
<tr valign="top"><td><code>description</code></td>
<td>
character string. A description of the connection:
see &lsquo;Details&rsquo;.
</td></tr>
<tr valign="top"><td><code>open</code></td>
<td>
character string. A description of how to open the connection
(if it should be opened initially). See section &lsquo;Modes&rsquo; for
possible values.
</td></tr>
<tr valign="top"><td><code>blocking</code></td>
<td>
logical. See the &lsquo;Blocking&rsquo; section.
</td></tr>
<tr valign="top"><td><code>encoding</code></td>
<td>
The name of the encoding to be assumed. See the
&lsquo;Encoding&rsquo; section.
</td></tr>
<tr valign="top"><td><code>raw</code></td>
<td>
logical. If true, a &lsquo;raw&rsquo; interface is used which
will be more suitable for arguments which are not regular files,
e.g. character devices. This suppresses the check for a compressed
file when opening for text-mode reading, and asserts that the
&lsquo;file&rsquo; may not be seekable.
</td></tr>
<tr valign="top"><td><code>method</code></td>
<td>
character string, partially matched to
<code>c("default", "internal", "wininet", "libcurl")</code>:

see &lsquo;Details&rsquo;.
</td></tr>
<tr valign="top"><td><code>headers</code></td>
<td>
named character vector of HTTP headers to use in HTTP
requests. It is ignored for non-HTTP URLs. The <code>User-Agent</code>
header, coming from the <code>HTTPUserAgent</code> option (see
<code><a href="options.html">options</a></code>) is used as the first header, automatically.
</td></tr>
<tr valign="top"><td><code>compression</code></td>
<td>
integer in 0&ndash;9. The amount of compression to be
applied when writing, from none to maximal available. For
<code>xzfile</code> can also be negative: see the &lsquo;Compression&rsquo;
section.
</td></tr>
<tr valign="top"><td><code>timeout</code></td>
<td>
numeric: the timeout (in seconds) to be used for this
connection. Beware that some OSes may treat very large values as
zero: however the POSIX standard requires values up to 31 days to be
supported.
</td></tr>
<tr valign="top"><td><code>filename</code></td>
<td>
a filename within a zip file.
</td></tr>
<tr valign="top"><td><code>host</code></td>
<td>
character string. Host name for the port.
</td></tr>
<tr valign="top"><td><code>port</code></td>
<td>
integer. The TCP port number.
</td></tr>
<tr valign="top"><td><code>server</code></td>
<td>
logical. Should the socket be a client or a server?
</td></tr>
<tr valign="top"><td><code>con</code></td>
<td>
a connection.
</td></tr>
<tr valign="top"><td><code>type</code></td>
<td>
character string. Currently ignored.
</td></tr>
<tr valign="top"><td><code>rw</code></td>
<td>
character string. Empty or <code>"read"</code> or <code>"write"</code>,
partial matches allowed.
</td></tr>
<tr valign="top"><td><code>...</code></td>
<td>
arguments passed to or from other methods.
</td></tr>
</table>

<h3>Details</h3>

The first nine functions create connections. By default the
connection is not opened (except for a <code>socketConnection</code>), but may
be opened by setting a non-empty value of argument <code>open</code>.

For <code>file</code> the description is a path to the file to be opened or
a complete URL (when it is the same as calling <code>url</code>), or
<code>""</code> (the default) or <code>"clipboard"</code> (see the
&lsquo;Clipboard&rsquo; section). Use <code>"stdin"</code> to refer to the
C-level &lsquo;standard input&rsquo; of the process (which need not be
connected to anything in a console or embedded version of R, and is
not in <code>RGui</code> on Windows). See also <code><a href="showConnections.html">stdin</a>()</code> for
the subtly different R-level concept of <code>stdin</code>. See
<code><a href="showConnections.html">nullfile</a>()</code> for a platform-independent way to get
filename of the null device.

For <code>url</code> the description is a complete URL including scheme
(such as http://, https://, ftp:// or
file://). Method <code>"internal"</code> is that available since
connections were introduced, method <code>"wininet"</code> is only available
on Windows (it uses the WinINet functions of that OS) and method
<code>"libcurl"</code> (using the library of that name:
<a href="http://curl.haxx.se/libcurl/">http://curl.haxx.se/libcurl/</a>) is required on a Unix-alike but
optional on Windows. Method <code>"default"</code> uses method
<code>"internal"</code> for file: URLs and <code>"libcurl"</code> for
<code>ftps:</code> URLs. On a Unix-alike it uses <code>"libcurl"</code> for
http:, https: and ftp: URLs; on Windows
<code>"wininet"</code> for http:, ftp: and https: URLs.
Proxies can be specified: see <code><a href="../../utils/html/download.file.html">download.file</a></code>.

For <code>gzfile</code> the description is the path to a file compressed by
<code>gzip</code>: it can also open for reading uncompressed files and
those compressed by <code>bzip2</code>, <code>xz</code> or <code>lzma</code>.

For <code>bzfile</code> the description is the path to a file compressed by
<code>bzip2</code>.

For <code>xzfile</code> the description is the path to a file compressed by
<code>xz</code> (<a href="https://en.wikipedia.org/wiki/Xz">https://en.wikipedia.org/wiki/Xz</a>) or (for reading
only) <code>lzma</code> (<a href="https://en.wikipedia.org/wiki/LZMA">https://en.wikipedia.org/wiki/LZMA</a>).

<code>unz</code> reads (only) single files within zip files, in binary mode.
The description is the full path to the zip file, with &lsquo;.zip&rsquo;
extension if required.

For <code>pipe</code> the description is the command line to be piped to or
from. This is run in a shell, on Windows that specified by the
COMSPEC environment variable.

For <code>fifo</code> the description is the path of the fifo. (Support for
<code>fifo</code> connections is optional but they are available on most
Unix platforms and on Windows.)

The intention is that <code>file</code> and <code>gzfile</code> can be used
generally for text input (from files, http:// and
https:// URLs) and binary input respectively.

<code>open</code>, <code>close</code> and <code>seek</code> are generic functions: the
following applies to the methods relevant to connections.

<code>open</code> opens a connection. In general functions using
connections will open them if they are not open, but then close them
again, so to leave a connection open call <code>open</code> explicitly.

<code>close</code> closes and destroys a connection. This will happen
automatically in due course (with a warning) if there is no longer an
R object referring to the connection.

A maximum of 128 connections can be allocated (not necessarily open)
at any one time. Three of these are pre-allocated (see
<code><a href="showConnections.html">stdout</a></code>). The OS will impose limits on the numbers of
connections of various types, but these are usually larger than 125.

<code>flush</code> flushes the output stream of a connection open for
write/append (where implemented, currently for file and clipboard
connections, <code><a href="showConnections.html">stdout</a></code> and <code><a href="showConnections.html">stderr</a></code>).

If for a <code>file</code> or (on most platforms) a <code>fifo</code> connection
the description is <code>""</code>, the file/fifo is immediately opened (in
<code>"w+"</code> mode unless <code>open = "w+b"</code> is specified) and unlinked
from the file system. This provides a temporary file/fifo to write to
and then read from.

<h3>Value</h3>

<code>file</code>, <code>pipe</code>, <code>fifo</code>, <code>url</code>, <code>gzfile</code>,
<code>bzfile</code>, <code>xzfile</code>, <code>unz</code> and <code>socketConnection</code>
return a connection object which inherits from class
<code>"connection"</code> and has a first more specific class.

<code>open</code> and <code>flush</code> return <code>NULL</code>, invisibly.

<code>close</code> returns either <code>NULL</code> or an integer status,
invisibly. The status is from when the connection was last closed and
is available only for some types of connections (e.g., pipes, files and
fifos): typically zero values indicate success. Negative values will
result in a warning; if writing, these may indicate write failures and should
not be ignored.

<code>isOpen</code> returns a logical value, whether the connection is
currently open.

<code>isIncomplete</code> returns a logical value, whether the last read
attempt was blocked, or for an output text connection whether there is
unflushed output.

<code>url</code> and <code>file</code> support URL schemes file://,
http://, https:// and ftp://.

<code>method = "libcurl"</code> allows more schemes: exactly which schemes
is platform-dependent (see <code><a href="libcurlVersion.html">libcurlVersion</a></code>), but all
Unix-alike platforms will support https:// and most platforms
will support ftps://.

Most methods do not percent-encode special characters such as spaces
in http:// URLs (see <code><a href="../../utils/html/URLencode.html">URLencode</a></code>), but it seems the
<code>"wininet"</code> method does.

A note on file:// URLs. The most general form (from RFC1738) is
file://host/path/to/file, but R only accepts the form with an
empty <code>host</code> field referring to the local machine.

On a Unix-alike, this is then file:///path/to/file, where
path/to/file is relative to &lsquo;/&rsquo;. So although the third
slash is strictly part of the specification not part of the path, this
can be regarded as a way to specify the file &lsquo;/path/to/file&rsquo;. It
is not possible to specify a relative path using a file URL.

In this form the path is relative to the root of the filesystem, not a
Windows concept. The standard form on Windows is
file:///d:/R/repos: for compatibility with earlier versions of
R and Unix versions, any other form is parsed as R as file://
plus <code>path_to_file</code>. Also, backslashes are accepted within the
path even though RFC1738 does not allow them.

No attempt is made to decode a percent-encoded file: URL: call
<code><a href="../../utils/html/URLencode.html">URLdecode</a></code> if necessary.

All the methods attempt to follow redirected HTTP URLs, but the
<code>"internal"</code> method is unable to follow redirections to HTTPS URLs.

Server-side cached data is always accepted.

Function <code><a href="../../utils/html/download.file.html">download.file</a></code> and several contributed packages
provide more comprehensive facilities to download from URLs.

<h3>Modes</h3>

Possible values for the argument <code>open</code> are

<dl>
<dt><code>"r"</code> or <code>"rt"</code></dt><dd>Open for reading in text mode.
</dd>
<dt><code>"w"</code> or <code>"wt"</code></dt><dd>Open for writing in text mode.
</dd>
<dt><code>"a"</code> or <code>"at"</code></dt><dd>Open for appending in text mode.
</dd>
<dt><code>"rb"</code></dt><dd>Open for reading in binary mode.
</dd>
<dt><code>"wb"</code></dt><dd>Open for writing in binary mode.
</dd>
<dt><code>"ab"</code></dt><dd>Open for appending in binary mode.
</dd>
<dt><code>"r+"</code>, <code>"r+b"</code></dt><dd>Open for reading and writing.
</dd>
<dt><code>"w+"</code>, <code>"w+b"</code></dt><dd>Open for reading and writing,
truncating file initially.
</dd>
<dt><code>"a+"</code>, <code>"a+b"</code></dt><dd>Open for reading and appending.
</dd>
</dl>

Not all modes are applicable to all connections: for example URLs can
only be opened for reading. Only file and socket connections can be
opened for both reading and writing. An unsupported mode is usually
silently substituted.

If a file or fifo is created on a Unix-alike, its permissions will be
the maximal allowed by the current setting of <code>umask</code> (see
<code><a href="files2.html">Sys.umask</a></code>).

For many connections there is little or no difference between text and
binary modes. For file-like connections on Windows, translation of
line endings (between LF and CRLF) is done in text mode only (but text
read operations on connections such as <code><a href="readLines.html">readLines</a></code>,
<code><a href="scan.html">scan</a></code> and <code><a href="source.html">source</a></code> work for any form of line
ending). Various R operations are possible in only one of the modes:
for example <code><a href="pushBack.html">pushBack</a></code> is text-oriented and is only
allowed on connections open for reading in text mode, and binary
operations such as <code><a href="readBin.html">readBin</a></code>, <code><a href="load.html">load</a></code> and
<code><a href="save.html">save</a></code> can only be done on binary-mode connections.

The mode of a connection is determined when actually opened, which is
deferred if <code>open = ""</code> is given (the default for all but socket
connections). An explicit call to <code>open</code> can specify the mode,
but otherwise the mode will be <code>"r"</code>. (<code>gzfile</code>,
<code>bzfile</code> and <code>xzfile</code> connections are exceptions, as the
compressed file always has to be opened in binary mode and no
conversion of line-endings is done even on Windows, so the default
mode is interpreted as <code>"rb"</code>.) Most operations that need write
access or text-only or binary-only mode will override the default mode
of a non-yet-open connection.

Append modes need to be considered carefully for compressed-file
connections. They do not produce a single compressed stream
on the file, but rather append a new compressed stream to the file.
Readers may or may not read beyond end of the first stream: currently
R does so for <code>gzfile</code>, <code>bzfile</code> and <code>xzfile</code>
connections.

<h3>Compression</h3>

R supports <code>gzip</code>, <code>bzip2</code> and <code>xz</code>
compression (also read-only support for its precursor, <code>lzma</code>
compression).

For reading, the type of compression (if any) can be determined from
the first few bytes of the file. Thus for <code>file(raw = FALSE)</code>
connections, if <code>open</code> is <code>""</code>, <code>"r"</code> or <code>"rt"</code>
the connection can read any of the compressed file types as well as
uncompressed files. (Using <code>"rb"</code> will allow compressed files to
be read byte-by-byte.) Similarly, <code>gzfile</code> connections can read
any of the forms of compression and uncompressed files in any read
mode.

(The type of compression is determined when the connection is created
if <code>open</code> is unspecified and a file of that name exists. If the
intention is to open the connection to write a file with a
different form of compression under that name, specify
<code>open = "w"</code> when the connection is created or
<code><a href="unlink.html">unlink</a></code> the file before creating the connection.)

For write-mode connections, <code>compress</code> specifies how hard the
compressor works to minimize the file size, and higher values need
more CPU time and more working memory (up to ca 800Mb for
<code>xzfile(compress = 9)</code>). For <code>xzfile</code> negative values of
<code>compress</code> correspond to adding the <code>xz</code> argument
-e: this takes more time (double?) to compress but may
achieve (slightly) better compression. The default (<code>6</code>) has
good compression and modest (100Mb memory) usage: but if you are using
<code>xz</code> compression you are probably looking for high compression.

Choosing the type of compression involves tradeoffs: <code>gzip</code>,
<code>bzip2</code> and <code>xz</code> are successively less widely supported,
need more resources for both compression and decompression, and
achieve more compression (although individual files may buck the
general trend). Typical experience is that <code>bzip2</code> compression
is 15% better on text files than <code>gzip</code> compression, and
<code>xz</code> with maximal compression 30% better. The experience with
R <code><a href="save.html">save</a></code> files is similar, but on some large &lsquo;.rda&rsquo;
files <code>xz</code> compression is much better than the other two. With
current computers decompression times even with <code>compress = 9</code>
are typically modest and reading compressed files is usually faster
than uncompressed ones because of the reduction in disc activity.

<h3>Encoding</h3>

The encoding of the input/output stream of a connection can be
specified by name in the same way as it would be given to
<code><a href="iconv.html">iconv</a></code>: see that help page for how to find out what
encoding names are recognized on your platform. Additionally,
<code>""</code> and <code>"native.enc"</code> both mean the &lsquo;native&rsquo;
encoding, that is the internal encoding of the current locale and
hence no translation is done.

When writing to a text connection, the connections code always assumes its
input is in native encoding, so e.g. <code><a href="writeLines.html">writeLines</a></code> has to
convert text to native encoding. <code><a href="writeLines.html">writeLines</a></code> does not do the
conversion when <code>useBytes=TRUE</code> (for expert use only), but the
connections code still behaves as if the text was in native encoding, so
any attempt to convert encoding (<code>encoding</code> argument other than
<code>""</code> and <code>"native.enc"</code>) in connections will produce incorrect
results.

When reading from a text connection, the connections code, after
re-encoding based on the <code>encoding</code> argument, returns text that is
assumed to be in native encoding; an encoding mark is only added by
functions that read from the connection, so e.g. <code><a href="readLines.html">readLines</a></code>
can be instructed to mark the text as <code>"UTF-8"</code> or <code>"latin1"</code>,
but <code><a href="readLines.html">readLines</a></code> does no further conversion. To allow reading
text in <code>"UTF-8"</code> on a system that cannot represent all such
characters in native encoding (currently only Windows), a connection can
be internally configured to return the read text in UTF-8 even though it
is not the native encoding; currently <code><a href="readLines.html">readLines</a></code> and
<code><a href="scan.html">scan</a></code> use this feature when given a connection that is not
yet open and, when using the feature, they unconditionally mark the text
as <code>"UTF-8"</code>.

Re-encoding only works for connections in text mode: reading from a
connection with re-encoding specified in binary mode will read the
stream of bytes, but mixing text and binary mode reads (e.g., mixing
calls to <code><a href="readLines.html">readLines</a></code> and <code><a href="readChar.html">readChar</a></code>) is likely
to lead to incorrect results.

The encodings <code>"UCS-2LE"</code> and <code>"UTF-16LE"</code> are treated
specially, as they are appropriate values for Windows &lsquo;Unicode&rsquo;
text files. If the first two bytes are the Byte Order Mark
<code>0xFEFF</code> then these are removed as some implementations of
<code><a href="iconv.html">iconv</a></code> do not accept BOMs. Note that whereas most
implementations will handle BOMs using encoding <code>"UCS-2"</code> and
choose the appropriate byte order, some (including earlier versions of
<code>glibc</code>) will not. There is a subtle distinction between
<code>"UTF-16"</code> and <code>"UCS-2"</code> (see
<a href="https://en.wikipedia.org/wiki/UTF-16">https://en.wikipedia.org/wiki/UTF-16</a>): the use of characters in
the &lsquo;Supplementary Planes&rsquo; which need surrogate pairs is very
rare so <code>"UCS-2LE"</code> is an appropriate first choice (as it is more
widely implemented).

As from R 3.0.0 the encoding <code>"UTF-8-BOM"</code> is accepted for
reading and will remove a Byte Order Mark if present (which it often
is for files and webpages generated by Microsoft applications). If a
BOM is required (it is not recommended) when writing it should be
written explicitly, e.g. by <code>writeChar("\ufeff", con, eos
 = NULL)</code> or <code>writeBin(as.raw(c(0xef, 0xbb, 0xbf)), binary_con)</code>

Encoding names <code>"utf8"</code>, <code>"mac"</code> and <code>"macroman"</code> are
not portable, and not supported on all current R platforms.
<code>"UTF-8"</code> is portable and <code>"macintosh"</code> is the official
(and most widely supported) name for &lsquo;Mac Roman&rsquo;. (As from R
3.4.0, R maps <code>"utf8"</code> to <code>"UTF-8"</code> internally.)

Requesting a conversion that is not supported is an error, reported
when the connection is opened. Exactly what happens when the
requested translation cannot be done for invalid input is in general
undocumented. On output the result is likely to be that up to the
error, with a warning. On input, it will most likely be all or some
of the input up to the error.

It may be possible to deduce the current native encoding from
<code><a href="locales.html">Sys.getlocale</a>("LC_CTYPE")</code>, but not all OSes record it.

<h3>Blocking</h3>

Whether or not the connection blocks can be specified for file, url
(default yes), fifo and socket connections (default not).

In blocking mode, functions using the connection do not return to the
R evaluator until the read/write is complete. In non-blocking mode,
operations return as soon as possible, so on input they will return
with whatever input is available (possibly none) and for output they
will return whether or not the write succeeded.

The function <code><a href="readLines.html">readLines</a></code> behaves differently in respect of
incomplete last lines in the two modes: see its help page.

Even when a connection is in blocking mode, attempts are made to
ensure that it does not block the event loop and hence the operation
of GUI parts of R. These do not always succeed, and the whole R
process will be blocked during a DNS lookup on Unix, for example.

Most blocking operations on HTTP/FTP URLs and on sockets are subject to the
timeout set by <code>options("timeout")</code>. Note that this is a timeout
for no response, not for the whole operation. The timeout is set at
the time the connection is opened (more precisely, when the last
connection of that type &ndash; http:, ftp: or socket &ndash; was
opened).

<h3>Fifos</h3>

Fifos default to non-blocking. That follows S version 4 and is
probably most natural, but it does have some implications. In
particular, opening a non-blocking fifo connection for writing (only)
will fail unless some other process is reading on the fifo.

Opening a fifo for both reading and writing (in any mode: one can only
append to fifos) connects both sides of the fifo to the R process,
and provides an similar facility to <code>file()</code>.

<h3>Clipboard</h3>

<code>file</code> can be used with <code>description = "clipboard"</code>
in mode <code>"r"</code> only. This reads the X11 primary selection (see
<a href="http://standards.freedesktop.org/clipboards-spec/clipboards-latest.txt">http://standards.freedesktop.org/clipboards-spec/clipboards-latest.txt</a>),
which can also be specified as <code>"X11_primary"</code> and the secondary
selection as <code>"X11_secondary"</code>. On most systems the clipboard
selection (that used by &lsquo;Copy&rsquo; from an &lsquo;Edit&rsquo; menu) can
be specified as <code>"X11_clipboard"</code>.

When a clipboard is opened for reading, the contents are immediately
copied to internal storage in the connection.

Unix users wishing to write to one of the X11 selections may be
able to do so via <code>xclip</code>
(<a href="http://sourceforge.net/projects/xclip/">http://sourceforge.net/projects/xclip/</a>) or <code>xsel</code>
(<a href="http://www.vergenet.net/~conrad/software/xsel/">http://www.vergenet.net/~conrad/software/xsel/</a>), for example by
<code>pipe("xclip -i", "w")</code> for the primary selection.

macOS users can use <code>pipe("pbpaste")</code> and
<code>pipe("pbcopy", "w")</code> to read from and write to that system's
clipboard.

R's connections are modelled on those in S version 4 (see Chambers,
1998). However R goes well beyond the S model, for example in output
text connections and URL, compressed and socket connections.
The default open mode in R is <code>"r"</code> except for socket connections.
This differs from S, where it is the equivalent of <code>"r+"</code>,
known as <code>"*"</code>.

On (rare) platforms where <code>vsnprintf</code> does not return the needed
length of output there is a 100,000 byte output limit on the length of
a line for text output on <code>fifo</code>, <code>gzfile</code>, <code>bzfile</code> and
<code>xzfile</code> connections: longer lines will be truncated with a
warning.

<h3>References</h3>

Chambers, J. M. (1998)
Programming with Data. A Guide to the S Language. Springer.

Ripley, B. D. (2001) Connections. R News, 1/1, 16&ndash;7.
<a href="https://www.r-project.org/doc/Rnews/Rnews_2001-1.pdf">https://www.r-project.org/doc/Rnews/Rnews_2001-1.pdf</a>

<code><a href="textconnections.html">textConnection</a></code>, <code><a href="seek.html">seek</a></code>,
<code><a href="showConnections.html">showConnections</a></code>, <code><a href="pushBack.html">pushBack</a></code>.

Functions making direct use of connections are (text-mode)
<code><a href="readLines.html">readLines</a></code>, <code><a href="writeLines.html">writeLines</a></code>, <code><a href="cat.html">cat</a></code>,
<code><a href="sink.html">sink</a></code>, <code><a href="scan.html">scan</a></code>, <code><a href="parse.html">parse</a></code>,
<code><a href="dcf.html">read.dcf</a></code>, <code><a href="dput.html">dput</a></code>, <code><a href="dump.html">dump</a></code> and
(binary-mode) <code><a href="readBin.html">readBin</a></code>, <code><a href="readChar.html">readChar</a></code>,
<code><a href="readBin.html">writeBin</a></code>, <code><a href="readChar.html">writeChar</a></code>, <code><a href="load.html">load</a></code>
and <code><a href="save.html">save</a></code>.

<code><a href="capabilities.html">capabilities</a></code> to see if <code>fifo</code> connections are
supported by this build of R.

<code><a href="gzcon.html">gzcon</a></code> to wrap <code>gzip</code> (de)compression around a
connection.

<code><a href="options.html">options</a></code> <code>HTTPUserAgent</code>, <code>internet.info</code> and
<code>timeout</code> are used by some of the methods for URL connections.

<code><a href="memCompress.html">memCompress</a></code> for more ways to (de)compress and references
on data compression.

<code><a href="extSoftVersion.html">extSoftVersion</a></code> for the versions of the <code>zlib</code> (for
<code>gzfile</code>), <code>bzip2</code> and <code>xz</code> libraries in use.

To flush output to the Windows and macOS consoles, see
<code><a href="../../utils/html/flush.console.html">flush.console</a></code>.

<h3>Examples</h3>

<pre>
zzfil &lt;- tempfile(fileext=".data")
zz &lt;- file(zzfil, "w") # open an output file connection
cat("TITLE extra line", "2 3 5 7", "", "11 13 17", file = zz, sep = "\n")
cat("One more line\n", file = zz)
close(zz)
readLines(zzfil)
unlink(zzfil)

zzfil &lt;- tempfile(fileext=".gz")
zz &lt;- gzfile(zzfil, "w")  # compressed file
cat("TITLE extra line", "2 3 5 7", "", "11 13 17", file = zz, sep = "\n")
close(zz)
readLines(zz &lt;- gzfile(zzfil))
close(zz)
unlink(zzfil)
zz # an invalid connection

zzfil &lt;- tempfile(fileext=".bz2")
zz &lt;- bzfile(zzfil, "w")  # bzip2-ed file
cat("TITLE extra line", "2 3 5 7", "", "11 13 17", file = zz, sep = "\n")
close(zz)
zz # print() method: invalid connection
print(readLines(zz &lt;- bzfile(zzfil)))
close(zz)
unlink(zzfil)

## An example of a file open for reading and writing
Tpath &lt;- tempfile("test")
Tfile &lt;- file(Tpath, "w+")
c(isOpen(Tfile, "r"), isOpen(Tfile, "w")) # both TRUE
cat("abc\ndef\n", file = Tfile)
readLines(Tfile)
seek(Tfile, 0, rw = "r") # reset to beginning
readLines(Tfile)
cat("ghi\n", file = Tfile)
readLines(Tfile)
Tfile # -&gt; print() :  "valid" connection
close(Tfile)
Tfile # -&gt; print() :  "invalid" connection
unlink(Tpath)

## We can do the same thing with an anonymous file.
Tfile &lt;- file()
cat("abc\ndef\n", file = Tfile)
readLines(Tfile)
close(Tfile)

## Not run: ## fifo example -- may hang even with OS support for fifos
if(capabilities("fifo")) {
  zzfil &lt;- tempfile(fileext="-fifo")
  zz &lt;- fifo(zzfil, "w+")
  writeLines("abc", zz)
  print(readLines(zz))
  close(zz)
  unlink(zzfil)
}
## End(Not run)

## Unix examples of use of pipes

# read listing of current directory
readLines(pipe("ls -1"))

# remove trailing commas.  Suppose

## Not run: % cat data2_
450, 390, 467, 654,  30, 542, 334, 432, 421,
357, 497, 493, 550, 549, 467, 575, 578, 342,
446, 547, 534, 495, 979, 479
## End(Not run)
# Then read this by
scan(pipe("sed -e s/,$// data2_"), sep = ",")

# convert decimal point to comma in output: see also write.table
# both R strings and (probably) the shell need \ doubled
zzfil &lt;- tempfile("outfile")
zz &lt;- pipe(paste("sed s/\\\\./,/ &gt;", zzfil), "w")
cat(format(round(stats::rnorm(48), 4)), fill = 70, file = zz)
close(zz)
file.show(zzfil, delete.file = TRUE)

## Not run: 
## example for a machine running a finger daemon

con &lt;- socketConnection(port = 79, blocking = TRUE)
writeLines(paste0(system("whoami", intern = TRUE), "\r"), con)
gsub(" *$", "", readLines(con))
close(con)

## End(Not run)

## Not run: 
## Two R processes communicating via non-blocking sockets
# R process 1
con1 &lt;- socketConnection(port = 6011, server = TRUE)
writeLines(LETTERS, con1)
close(con1)

# R process 2
con2 &lt;- socketConnection(Sys.info()["nodename"], port = 6011)
# as non-blocking, may need to loop for input
readLines(con2)
while(isIncomplete(con2)) {
   Sys.sleep(1)
   z &lt;- readLines(con2)
   if(length(z)) print(z)
}
close(con2)

## examples of use of encodings
# write a file in UTF-8
cat(x, file = (con &lt;- file("foo", "w", encoding = "UTF-8"))); close(con)
# read a 'Windows Unicode' file
A &lt;- read.table(con &lt;- file("students", encoding = "UCS-2LE")); close(con)

## End(Not run)</pre>

<hr /><div style="text-align: center;">[Package base version 3.6.0 <a href="00Index.html">Index</a>]</div>
</body></html>