\Header{strsplit}{Split the Elements of a Character Vector}
\keyword{character}{strsplit}
\begin{Description}\relax
Split the elements of a character vector \code{x} into substrings
according to the presence of substring \code{split} within them.
\end{Description}
\begin{Usage}
\begin{verbatim}
strsplit(x, split, extended = TRUE, fixed = FALSE, perl = FALSE)
\end{verbatim}
\end{Usage}
\begin{Arguments}
\begin{ldescription}
\item[\code{x}] character vector, each element of which is to be split.

\item[\code{split}] character vector containing \link{regular expression}(s)
(unless \code{fixed = TRUE}) to use as \dQuote{split}.  If empty
matches occur, in particular if \code{split} has length 0, \code{x} is
split into single characters.  If \code{split} has length greater than
1, it is re-cycled along \code{x}.

\item[\code{extended}] logical. if \code{TRUE}, extended regular expression matching
is used, and if \code{FALSE} basic regular expressions are used.

\item[\code{fixed}] logical. If \code{TRUE} match string exactly, otherwise
use regular expressions.

\item[\code{perl}] logical. Should perl-compatible regexps be used?
Has priority over \code{extended}.

\end{ldescription}
\end{Arguments}
\begin{Details}\relax
Arguments \code{x} and \code{split} will be coerced to character, so
you will see uses with \code{split = NULL} to mean
\code{split = character(0)}, including in the examples below.

Note that spltting into single characters can be done via
\code{split=character(0)} or \code{split=""}; the two are equivalent
as from \R{} 1.9.0.

A missing value of \code{split} does not split the the corresponding
element(s) of \code{x} at all.
\end{Details}
\begin{Value}
A list of length \code{length(x)} the \code{i}-th element of which
contains the vector of splits of \code{x[i]}.
\end{Value}
\begin{Section}{Warning}
The standard regular expression code has been reported to be very slow
or give errors when applied to extremely long character strings
(tens of thousands of characters or more): the code used when
\code{perl=TRUE} seems faster and more reliable for such usages.
\end{Section}
\begin{SeeAlso}\relax
\code{\Link{paste}} for the reverse,
\code{\Link{grep}} and \code{\Link{sub}} for string search and
manipulation; further \code{\Link{nchar}}, \code{\Link{substr}}.

\link{regular expression} for the details of the pattern specification.
\end{SeeAlso}
\begin{Examples}
\begin{ExampleCode}
noquote(strsplit("A text I want to display with spaces", NULL)[[1]])

x <- c(as = "asfef", qu = "qwerty", "yuiop[", "b", "stuff.blah.yech")
# split x on the letter e
strsplit(x,"e")

unlist(strsplit("a.b.c", "."))
## [1] "" "" "" "" ""
## Note that 'split' is a regexp!
## If you really want to split on '.', use
unlist(strsplit("a.b.c", "\\."))
## [1] "a" "b" "c"
## or
unlist(strsplit("a.b.c", ".", fixed = TRUE))

## a useful function: rev() for strings
strReverse <- function(x)
        sapply(lapply(strsplit(x, NULL), rev), paste, collapse="")
strReverse(c("abc", "Statistics"))

## get the first names of the members of R-core
a <- readLines(file.path(R.home(),"AUTHORS"))[-(1:8)]
a <- a[(0:2)-length(a)]
(a <- sub(" .*","", a))
# and reverse them
strReverse(a)
\end{ExampleCode}
\end{Examples}

