scan(file = "", what = double(), nmax = -1, n = -1, sep = "", quote = if(identical(sep, "\n")) "" else "'\"", dec = ".", skip = 0, nlines = 0, na.strings = "NA", flush = FALSE, fill = FALSE, strip.white = FALSE, quiet = FALSE, blank.lines.skip = TRUE, multi.line = TRUE, comment.char = "", allowEscapes = FALSE, fileEncoding = "", encoding = "unknown", text, skipNul = FALSE)
""
, then input is taken from the keyboard
(or whatever stdin()
reads if input is redirected or
R is embedded).
(In this case input can be terminated by a blank line or an EOF
signal, Ctrl-D on Unix and Ctrl-Z on Windows.) Otherwise, the file name is interpreted relative to the
current working directory (given by getwd()
),
unless it specifies an absolute path.
Tilde-expansion is performed where supported.
When running R from a script, file = "stdin"
can be used to
refer to the process's stdin
file stream.
This can be a compressed file (see file
).
Alternatively, file
can be a connection
,
which will be opened if necessary, and if so closed at the end of
the function call. Whatever mode the connection is opened in,
any of LF, CRLF or CR will be accepted as the EOL marker for a line
and so will match sep = "\n"
.
file
can also be a complete URL. (For the supported URL
schemes, see the URLs section of the help for
url
.)
To read a data file not in the current encoding (for example a
Latin-1 file in a UTF-8 locale or conversely) use a
file
connection setting its encoding
argument
(or scan
's fileEncoding
argument).
what
gives the type of data to
be read. (Here type is used in the sense of
typeof
.) The supported types are logical
,
integer
, numeric
, complex
, character
,
raw
and list
. If what
is a list, it is
assumed that the lines of the data file are records each containing
length(what)
items (fields) and the list components
should have elements which are one of the first six (atomic)
types listed or NULL
, see section Details below.what
is a list, the maximum number of records to be read. If
omitted or not positive or an invalid value for an integer
(and nlines
is not set to a positive value), scan
will
read to the end of file
.sep
can be used to
specify a character which delimits fields. A field is always
delimited by an end-of-line marker unless it is quoted. If specified this should be the empty character string (the default)
or NULL
or a character string containing just one single-byte
character.
NULL
. In a multibyte locale the quoting characters
must be ASCII (single-byte).NULL
and a
zero-length character vector are also accepted, and taken as the
default.)NA
) values. Blank fields are
also considered to be missing values in logical, integer, numeric
and complex fields. Note that the test happens after
white space is stripped from the input, so na.strings
values
may need their own white space stripped in advance.TRUE
, scan
will flush to the
end of the line after reading the last of the fields requested.
This allows putting comments after the last field, but precludes
putting more that one record on a line.TRUE
, scan
will implicitly add
empty fields to any lines with fewer fields than implied by
what
.what
argument. It is used only when sep
has
been specified, and allows the stripping of leading and trailing
white space from character
fields (numeric
fields
are always stripped). Note: white space inside quoted strings is
not stripped. If strip.white
is of length 1, it applies to all fields;
otherwise, if strip.white[i]
is TRUE
and the
i
-th field is of mode character (because what[i]
is)
then the leading and trailing unquoted white space from field i
is
stripped.
FALSE
(default), scan() will print a
line, saying how many items have been read.TRUE
blank lines in the
input are ignored, except when counting skip
and nlines
.what
is a list. If
FALSE
, all of a record must appear on one line (but more than
one record can appear on a single line). Note that using fill = TRUE
implies that a record will be terminated at the end of a line.""
to
turn off the interpretation of comments altogether (the default).The escapes which are interpreted are the control characters \a, \b, \f, \n, \r, \t, \v and octal and hexadecimal representations like \040 and \0x2A. Any other escaped character is treated as itself, including backslash. Note that Unicode escapes (starting \u or \U: see Quotes) are never processed.
file
, and the R Data
Import/Export Manual.
"latin1"
or "UTF-8"
it is used to mark
character strings as known to be in Latin-1 or UTF-8: it is not used
to re-encode the input (see fileEncoding
).
See also Details.
file
is not supplied and this is,
then data are read from the value of text
via a text connection.
what
can be a list of types, in which case
scan
returns a list of vectors with the types given by the
types of the elements in what
. This provides a way of reading
columnar data. If any of the types is NULL
, the corresponding
field is skipped (but a NULL
component appears in the result). The type of what
or its components can be one of the six
atomic vector types or NULL
(see is.atomic
).
White space is defined for the purposes of this function as one or more contiguous characters from the set space, horizontal tab, carriage return and line feed. It does not include form feed nor vertical tab, but in Latin-1 and Windows 8-bit locales (but not UTF-8) 'space' includes the non-breaking space "\xa0".
Empty numeric fields are always regarded as missing values.
Empty character fields are scanned as empty character vectors, unless
na.strings
contains ""
when they are regarded as missing
values.
The allowed input for a numeric field is optional whitespace followed
either NA
or an optional sign followed by a decimal or
hexadecimal constant (see NumericConstants), or NaN
,
Inf
or infinity
(ignoring case). Out-of-range values
are recorded as Inf
, -Inf
or 0
.
For an integer field the allowed input is optional whitespace,
followed by either NA
or an optional sign and one or more
digits (0-9): all out-of-range values are converted to
NA_integer_
.
If sep
is the default (""
), the character \
in a quoted string escapes the following character, so quotes may be
included in the string by escaping them.
If sep
is non-default, the fields may be quoted in the style of
.csv files where separators inside quotes (''
or
""
) are ignored and quotes may be put inside strings by
doubling them. However, if sep = "\n"
it is assumed
by default that one wants to read entire lines verbatim.
Quoting is only interpreted in character fields and in NULL
fields (which might be skipping character fields).
Note that since sep
is a separator and not a terminator,
reading a file by scan("foo", sep = "\n", blank.lines.skip = FALSE)
will give an empty final line if the file ends in a linefeed and not if
it does not. This might not be what you expected; see also
readLines
.
If comment.char
occurs (except inside a quoted character
field), it signals that the rest of the line should be regarded as a
comment and be discarded. Lines beginning with a comment character
(possibly after white space with the default separator) are treated as
blank lines.
There is a line-length limit of 4095 bytes when reading from the console (which may impose a lower limit: see An Introduction to R).
There is a check for a user interrupt every 1000 lines if what
is a list, otherwise every 10000 items.
If file
is a character string and fileEncoding
is
non-default, or if it is a not-already-open connection with a
non-default encoding
argument, the text is converted to UTF-8
and declared as such (and the encoding
argument to scan
is ignored). See the examples of readLines
.
Embedded nuls in the input stream will terminate the field currently
being read, with a warning once per call to scan
. Setting
skipNul = TRUE
causes them to be ignored.
read.table
for more user-friendly reading of data
matrices;
readLines
to read a file a line at a time.
write
. Quotes
for the details of C-style escape sequences.
readChar
and readBin
to read fixed or
variable length character strings or binary representations of numbers
a few at a time from a connection.
cat("TITLE extra line", "2 3 5 7", "11 13 17", file = "ex.data", sep = "\n")
pp <- scan("ex.data", skip = 1, quiet = TRUE)
scan("ex.data", skip = 1)
scan("ex.data", skip = 1, nlines = 1) # only 1 line after the skipped one
scan("ex.data", what = list("","","")) # flush is F -> read "7"
scan("ex.data", what = list("","",""), flush = TRUE)
unlink("ex.data") # tidy up
## "inline" usage
scan(text = "1 2 3")
Run the code above in your browser using DataLab