is.object et le système de classe S3

Question

En utilisant la fonction class nous permet de déterminer la classe d'un objet:

> x = 5
> class(x)
[1] "numeric"

Je comprends aussi que nous pouvons utiliser la commande is.object pour déterminer si un objet a une classe. Cependant, certains types d'objets sont implicites, qui est

> is.object(x)
[1] FALSE

Serait-il exact de dire que toutes les variables R sont des objets et is.object est un test pour les classes non seulement implicites?

En outre, comment faire les types entrent dans cette. Naïvement, je pensais que la pièce de code suivante produirait une erreur:

> x = 5
> class(x) = "fake"
> x = X + 1
> x + 1
[1] 6
attr(,"class")
[1] "fake"

Mais x a encore de type "double", encore tout fonctionne encore. Les types peuvent être considérés comme une superclasse que tous les autres objets héritent?

Answer 1

typeof renvoie le type de représentation interne de C, et il ne sert pas pour l'expédition de la méthode. Donc, strictement parlant, vous ne pouvez pas penser types comme « superclasse ».

Il y a lieu des classes de base (numérique, caractère, liste, fonction, etc.) qui correspondent à peu près aux noms retourné par typeof, mais pas toujours (par exemple du type à double est numérique de classe, la fermeture et la classe sont de fonction et data.frame de classe est la liste de type!).

Avec S3 et S4 systèmes, vous pouvez construire des classes non triviales à l'aide des classes de base. (Mais pas nécessaire extension de ceux !! exemple: setClass("foo", list(a="numeric",b="character") n'accorde aucune des classes de base )

Pour les objets de ces classes de base is.object rendements FALSE. Comme sa documentation indique, cette fonction fournit un très rapide moyen de vérifier si l'objet est de construire utilisateur classe S3 ou S4 (c.-à-pas l'une des classes de base).

Après la coulée x comme « faux » votre objet est pas formellement de la classe « numérique »:

is(x, "numeric")
#FALSE

mais il est interprétable comme objet « numérique » de base:

is.numeric(x)
#TRUE

Et voilà pourquoi + travaille ici. Ainsi, en interne, comme @Richie déjà dit que les interprète méthode par défaut x au classe de base numérique.

Ce désordre conceptuel est à cause de S3 traitement informel des classes. Utilisez S4 à la place.

---

correspondance entre typeof et la classe de base (.) (.):

                              typeof(.)  class(.)
NULL                          "NULL"     "NULL"
1                             "double"   "numeric"
1:1                           "integer"  "integer"
1i                            "complex"  "complex"
list(1)                       "list"     "list"
data.frame(x=1)               "list"     "data.frame"
pairlist(pi)                  "pairlist" "pairlist"
c                             "special"  "function"
lm                            "closure"  "function"
formals(lm)[[1]]              "symbol"   "name"
formals(lm)[[2]]              "symbol"   "name"
y~x                           "language" "formula"
expression((1))[[1]]          "language" "("
(y~x)[[1]]                    "symbol"   "name"
expression(x <- pi)[[1]][[1]] "symbol"   "name"

Answer 2

Une réponse partielle à la première question se trouve dans le chapitre 2 de la defninition langage R

  

R ne fournit pas un accès direct à   la mémoire de l'ordinateur, mais plutôt   fournit un certain nombre de données spécialisées   les structures que nous appellerons   objets. Ces objets sont appelés   par des symboles ou des variables. En R,   cependant, les symboles sont eux-mêmes   objets et peut être manipulé dans le   même manière que tout autre objet.

Alors, oui, toutes les variables sont des objets.

is.object semble être plus ou moins équivalent à function(x) !is.null(attr(x, "class")) mais je suis prêt à être démentie sur ce point.

En ce qui concerne la deuxième question, je pense que c'est ce qui se passe: Depuis x a la classe « faux », regards R pour une +.fake de méthode dans l'addition mais quand il ne trouve pas, il recourt à la méthode par défaut. Cette méthode par défaut est basée sur le code sous-jacent C, qui utilise typeof(x) (ou un équivalent C) afin de déterminer ce qu'il faut faire. Dans ce cas, le type de x est « entier ».