class {base} | R Documentation |
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
x |
a R object |
what, value |
a character vector naming classes. |
which |
logical affecting return value: see Details. |
Many R objects have a class
attribute, a character vector
giving the names of the classes which the object “inherits”
from. If the object does not have a class attribute, it has an
implicit class, "matrix"
, "array"
or the result of
mode(x)
. (Functions oldClass
and
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.
The function class
prints the vector of names of classes an
object inherits from. Correspondingly, class<-
sets the
classes an object inherits from.
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 which
is 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 which
is FALSE
then TRUE
is
returned by inherits
if any of the names in what
match
with any class
.
An additional mechanism of formal classes is available in
packages 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.
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.
Functions oldClass
and 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.
UseMethod
, NextMethod
,
group generic
.
x <- 10 inherits(x, "a") #FALSE class(x) <- c("a", "b") inherits(x,"a") #TRUE inherits(x, "a", TRUE) # 1 inherits(x, c("a", "b", "c"), TRUE) # 1 2 0