\name{write.table}
\alias{write.table}
\alias{write.csv}
\alias{write.csv2}
\title{Data Output}
\description{
  \code{write.table} prints its required argument \code{x} (after
  converting it to a data frame if it is not one nor a matrix) to
  a file or connection.
}
\usage{
write.table(x, file = "", append = FALSE, quote = TRUE, sep = " ",
            eol = "\n", na = "NA", dec = ".", row.names = TRUE,
	    col.names = TRUE, qmethod = c("escape", "double"))

write.csv(\dots)
write.csv2(\dots)
}
\arguments{
  \item{x}{the object to be written, preferably a matrix or data frame.
    If not, it is attempted to coerce \code{x} to a data frame.}
  \item{file}{either a character string naming a file or a connection.
    \code{""} indicates output to the console.}
  \item{append}{logical.  If \code{TRUE}, the output is appended to the
    file.  If \code{FALSE}, any existing file of the name is destroyed.}
  \item{quote}{a logical value (\code{TRUE} or \code{FALSE}) or a
    numeric vector.  If \code{TRUE}, any character or factor columns
    will be surrounded by double quotes.  If a numeric vector, its
    elements are taken as the indices of columns to quote.  In both
    cases, row and column names are quoted if they are written.  If
    \code{FALSE}, nothing is quoted.}
  \item{sep}{the field separator string.  Values within each row of
    \code{x} are separated by this string.}
  \item{eol}{the character(s) to print at the end of each line (row).}
  \item{na}{the string to use for missing values in the data.}
  \item{dec}{the string to use for decimal points in numeric or complex
    columns: must be a single character.}
  \item{row.names}{either a logical value indicating whether the row
    names of \code{x} are to be written along with \code{x}, or a
    character vector of row names to be written.}
  \item{col.names}{either a logical value indicating whether the column
    names of \code{x} are to be written along with \code{x}, or a
    character vector of column names to be written.  See the section on
    \sQuote{CSV files} for the meaning of \code{col.names = NA}.}
  \item{qmethod}{a character string specifying how to deal with embedded
    double quote characters when quoting strings.  Must be one of
    \code{"escape"} (default), in which case the quote character is
    escaped in C style by a backslash, or \code{"double"}, in which case
    it is doubled.  You can specify just the initial letter.}

  \item{\dots}{arguments to \code{write.table}: \code{col.names},
    \code{sep}, \code{dec} and \code{qmethod} cannot be altered.
  }
}
\details{
  If the table has no columns the rownames will be written only if
  \code{row.names=TRUE}, and \emph{vice versa}.

  Real and complex numbers are written to the maximal possible precision.

  If a data frame has matrix-like columns these will be converted to
  multiple columns in the result (\emph{via} \code{\link{as.matrix}})
  and so a character \code{col.names} or a numeric \code{quote} should
  refer to the columns in the result, not the input.  Such matrix-like
  columns are unquoted by default.

  Any columns in a data frame which are lists or have a class
  (e.g. dates) will be converted by the appropriate \code{as.character}
  method: such columns are unquoted by default.  On the other hand,
  any class information for a matrix is discarded and non-atomic
  (e.g. list) matrices are coerced to character.

  Only columns which have been converted to character will be quoted if
  specified by \code{quote}.

  The \code{dec} argument only applies to columns that are not subject
  to conversion to character because they have a class or are part of a
  matrix-like column (or matrix), in particular to columns protected by
  \code{\link{I}()}.  Use \code{\link{options}("OutDec")} to control
  such conversions.

  In almost all cases the conversion of numeric quantities is governed
  by the options in force, in particular by \code{"digits"} and
  \code{"scipen"} (see \code{\link{options}}).  For finer control, use
  \code{\link{format}} to make a character matrix/data frame, and call
  \code{write.table} on that.

  These functions check for a user interrupt every 1000 lines of output.
}
\section{CSV files}{
  By default there is no column name for a column of row names.  If
  \code{col.names = NA} and \code{row.names = TRUE} a blank column name
  is added, which is the convention used for CSV files to be read by
  spreadsheets.

  \code{write.csv} and \code{write.csv2} provide convenience wrappers
  for writing CSV files.  They set \code{sep}, \code{dec} and
  \code{qmethod}, and \code{col.names} to \code{NA} if \code{row.names =
    TRUE} and \code{TRUE} otherwise.

  \code{write.csv} uses \code{"."} for the decimal point and a comma for
  the separator.

  \code{write.csv2} uses a comma for the decimal point and a semicolon for
  the separator, the Excel convention for CSV files in some Western
  European locales.

  These wrappers are deliberately inflexible: they are designed to
  ensure that the correct conventions are used to write a valid file.
  Attempts to change \code{col.names}, \code{sep}, \code{dec} or
  \code{qmethod} are ignored, with a warning.
}
\note{
  \code{write.table} can be slow for data frames with large numbers
  (hundreds or more) of columns: this is inevitable as each column could
  be of a different class and so must be handled separately.  If they
  are all of the same class, consider using a matrix instead.
}

\seealso{
  The \sQuote{R Data Import/Export} manual.

  \code{\link{read.table}}, \code{\link{write}}.

  \code{\link[MASS]{write.matrix}} in package \pkg{MASS}.
}

\examples{
\dontrun{
## To write a CSV file for input to Excel one might use
x <- data.frame(a = I("a \" quote"), b = pi)
write.table(x, file = "foo.csv", sep = ",", col.names = NA,
            qmethod = "double")
## and to read this file back into R one needs
read.table("foo.csv", header = TRUE, sep = ",", row.names = 1)
## NB: you do need to specify a separator if qmethod = "double".

### Alternatively
write.csv(x, file = "foo.csv")
read.csv("foo.csv", row.names = 1)
## or without row names
write.csv(x, file = "foo.csv", row.names = FALSE)
read.csv("foo.csv")
}}
\keyword{print}
\keyword{file}