R possesses a simple generic function mechanism which can be used for an object-oriented style of programming. Method dispatch takes place based on the class of the first argument to the generic function.
class(x) class(x) <- value unclass(x) inherits(x, what, which = FALSE) oldClass(x) oldClass(x) <- value
- a R object
- what, value
- a character vector naming classes.
valuecan also be
- logical affecting return value: see ‘Details’.
Here, we describe the so called “S3” classes (and methods). For “S4” classes (and methods), see ‘Formal classes’ below.
Many R objects have a
class attribute, a character vector giving the names of the classes from which the object inherits. If the object does not have a class attribute, it has an implicit class,
"array" or the result of
mode(x) (except that integer vectors have implicit class
oldClass<- get and set the attribute, which can also be done directly.)
When a generic function
fun is applied to an object with class attribute
c("first", "second"), the system searches for a function called
fun.first and, if it finds it, applies it to the object. If no such function is found, a function called
fun.second is tried. If no class name produces a suitable function, the function
fun.default is used (if it exists). If there is no class attribute, the implicit class is tried, then the default method.
class prints the vector of names of classes an object inherits from. Correspondingly,
class<- sets the classes an object inherits from. Assigning
NULL removes the class attribute.
unclass returns (a copy of) its argument with its class attribute removed. (It is not allowed for objects which cannot be copied, namely environments and external pointers.)
inherits indicates whether its first argument inherits from any of the classes specified in the
what argument. If
TRUE then an integer vector of the same length as
what is returned. Each element indicates the position in the
class(x) matched by the element of
what; zero indicates no match. If
TRUE is returned by
inherits if any of the names in
what match with any
inherits are primitive functions.
An additional mechanism of formal classes, nicknamed “S4”, is available in package methods which is attached by default. For objects which have a formal class, its name is returned by
class as a character vector of length one and method dispatch can happen on several arguments, instead of only the first. However, S3 method selection attempts to treat objects from an S4 class as if they had the appropriate S3 class attribute, as does
inherits. Therefore, S3 methods can be defined for S4 classes. See the ‘Classes’ and ‘Methods’ help pages for details.
The replacement version of the function sets the class to the value provided. For classes that have a formal definition, directly replacing the class this way is strongly deprecated. The expression
as(object, value) is the way to coerce an object to a particular class.
The analogue of
inherits for formal classes is
is. The two functions behave consistently with one exception: S4 classes can have conditional inheritance, with an explicit test. In this case,
is will test the condition, but
inherits ignores all conditional superclasses.
oldClass<- behave in the same way as functions of those names in S-PLUS 5/6, but in R
UseMethod dispatches on the class as returned by
class (with some interpolated classes: see the link) rather than
oldClass. However, group generics dispatch on the
oldClass for efficiency, and internal generics only dispatch on objects for which
is.object is true.
Documentation reproduced from R 2.15.3. License: GPL-2.