R语言面向对象编程：S3和R6

一、基于S3的面向对象编程

基于S3的面向对象编程是一种基于泛型函数(generic function)的实现方式。

1.S3函数的创建

S3对象组成：generic(generic FUN)+method(generic.class FUN）

泛型函数（generic）创建示例：

get_n_elements <- function(x,...)
{
UseMethod("get_n_elements")
}

通常用UseMethod()函数定义一个泛型函数的名称，通过传入参数的class属性，来确定对应的方法调用。

method(generic.class）函数，创建示例：

# Create a data.frame method for get_n_elements
get_n_elements.data.frame <- function(x, ...)
{
nrow(x) * ncol(x)
}

# Create a default method for get_n_elements。在使用UseMethod调用时，先在methods中寻找对应class，如果都没有找到，则会调用default方法。
get_n_elements.default <- function(x,...)
{
length(unlist(x))
}

methods() 用于查找S3泛型函数中所有可用的methods。

调用pryr包中的is_s3_method() 可以验证函数是否S3方法。

2、S3对象的传入参数有多个class属性的处理方法

当变量x具有多个class属性，应按具体到通用的顺序来排列变量对应的class。

使用NextMethod()来调用methods

an_s3_method.some_class <- function(x, ...)
{
# Act on some_class, then
NextMethod("an_s3_method")
}

具体示例如下：

# Assign classes
class(kitty) <- c("cat","mammal","character")

what_am_i <- function(x,...)
{
   UseMethod("what_am_i")
}

# cat method
what_am_i.cat <- function(x)
{
  message("I‘m a cat")
  NextMethod("what_am_i")
}

# mammal method
what_am_i.mammal <- function(x, ...)
{
  message("I‘m a mammal")
  NextMethod("what_am_i")
}

# character method
what_am_i.character <- function(x, ...)
{
  message("I‘m a character vector")
}

　

　

二、基于R6的面向对象编程

1、R6对象的创建

首先使用 R6Class() 创建一个class generator(也可叫factory）。

第一个参数是创建的对象的类的名字。
参数private为一个list，为对象保存数据域（data field），包含每个元素的名字。
参数pubilc为一个list，为对象保存面向用户的函数或功能。

library(R6)thing_factory <- R6Class(
  "Thing",
  private = list(
    a_field = "a value",
    another_field = 123
  ),
  public = list(
    do_something = function(x, y, z) {
      # Do something here
    }
  )
)

创建factory后，再调用new()来生成一个R6对象。new()无需定义，所有的factory都默认具有该方法。

a_thing <- thing_factory$new()

initialize()是一种特殊的公有方法(public method), 在R6对象创建时自动调用，用来设置私域（private field）值。

new()中的参数被传给initialize()。

# Add an initialize method
microwave_oven_factory <- R6Class(
"MicrowaveOven",
private = list(
power_rating_watts = 800,
door_is_open = FALSE
),
public = list(
cook = function(time_seconds) {
Sys.sleep(time_seconds)
print("Your food is cooked!")
},
open_door = function() {
private$door_is_open = TRUE
},
close_door = function() {
private$door_is_open = FALSE
},
# Add initialize() method here
initialize = function(power_rating_watts,door_is_open){
if(!missing(power_rating_watts)){
private$power_rating_watts<-power_rating_watts
}
if(!missing(door_is_open)){
private$door_is_open<-door_is_open
}
}
)
)

# Make a microwave
a_microwave_oven <- microwave_oven_factory$new(
power_rating_watts = 650,
door_is_open = TRUE
)

　　

2.访问和设置私有域

private组件中的数据对用户隐藏，这是封装的原理。使用private$前缀可以访问私域（private field）。

存在active组件中的active binding（行为像变量的函数），可以获取和设置私有数据域。

Active bindings是R6中一种特殊的函数调用方式，把对函数的访问表现为对属性的访问，属于公有组件。

thing_factory <- R6Class(
  "Thing",
  private = list(
    ..a_field = "a value"
  ),
  active = list(
    a_field = function(value) {
      if(missing(value)) {
        private$..a_field
      } else {
        assert_is_a_string(value) # or another assertion
        private$..a_field <- value
      }
    }
  )
)

将active binding作为数据变量而不是函数进行调用。

a_thing <- thing_factory$new()

a_thing$a_field # not a_thing$a_field()

3、R6的继承 

（1）子类的创建

继承将一个类（class）的功能复制到另一个。可在R6Class()中用inherit参数来创建子类。

child_class_factory <- R6Class(
"ChildClass",
inherit = parent_class_factory
)

子类可以添加公有方法来扩展父类的功能，并在公有方法中使用前缀self$调用其他公有方法。

子类也可定义与父类相同的方法名称来重写该方法，用于扩展父类的功能，子类使用前缀super$访问父类的公有方法。

（2）跨级访问

R6类默认只能使用直接父类的功能。为了跨级访问，中间类(intermediate classes)首先需要定义一个active binding来显示父类，形式如下:

active = list(super_ = function() super)

然后可以跨级使用方法parent_method <- super$method()grand_parent_method <- super$super_$method(great_grand_parent_method <- super$super_$super_$method()

（3）共享域

大部分类型的R变量是通过值复制，意思是当复制一个变量时 ，新的变量具有自己的复制值，改变其中一个变量不会影响另外一个。环境变量(Environments)比较特殊，通过地址传送来复制（by reference)，因此所有的复制品都是等同的，改变其中一个就会改变其他变量。R6类可利用环境的地址传送（by reference）复制行为在对象之间共享区域，定义一个名为shared的私域，方式如下：创建一个新的环境，指定该环境的任意共享域，可通过active bindings访问。工作方式与其他active bindings相同，但需使用private$shared$前缀来找回(retrieve)这些区域
R6Class(
"Thing",
private = list(
shared = {
e <- new.env()
e$a_shared_field <- 123
e
}
),
active = list(
a_shared_field = function(value) {
if(missing(value)) {
private$shared$a_shared_field
} else {
private$shared$a_shared_field <- value
}
}
)
)

　

（4）R6对象的复制　

R6对象使用与环境变量相同的地址传送复制方式，如果使用<- 符号复制R6对象，原对象的变化会影响复制品。
a_reference_copy <- an_r6_object
R6 对象有一个自动生成的clone() 方法，用于值复制，使用clone()复制的对象的变化不影响其他对象。
a_value <- an_r6_object$clone()

当R6对象的一个或多个域包含另一个R6对象时，默认clone() 通过地址传送复制该R6域。

如果值复制这些R6域，clone() 方法必须使用参数：deep = TRUE。
a_deep_copy <- an_r6_object$clone(deep = TRUE)

（5）R6对象的消除

当消除对象时，定义公有finalize()方法运行自定义代码。该方法一般用于关闭与数据库或文件的连接，或者消除例如改变全局选项（option）或者图形参数的副作用。

thing_factory <- R6Class(
"Thing",
public = list(
initialize = function(x, y, z) {
# do something
},
finalize = function() {
# undo something# Print a message"Disconnecting from the cooking times database."# Disconnect from the databasedbDisconnect(private$conn)
}
)
)　

当R的自动垃圾回收器（automated garbage collector）从存储中清除对象时调用finalize() 方法，可使用gc()强制垃圾回收。

时间： 2024-08-24 05:30:53

R语言面向对象编程：S3和R6的相关文章

R语言基础编程技巧汇编 - 26

1.      监视R语言包更新状态的网站 R语言包的数量已经有近万个,及时关注新发布的包,以及已发布的包的更新状态,非常重要,下列网站提供了这个功能,读者可以经常访问: http://lib.stat.cmu.edu/R/CRAN/web/packages/available_packages_by_date.html 2.      使用命令行参数的R程序示例 以Windows系统为例,按照以下步骤: 1.    把Rscript.exe的路径加入到Path环境变量中,在我的机器上设置如下:

R语言基础编程技巧汇编 - 前言

前 言 R语言是近年来迅速崛起的用于数据分析和数据挖据的编程语言,它由一批统计学家开发,进而广泛应用于各种需要进行统计分析的行业.在大数据时代,其优雅的编码风格.包罗万象的开发包.强大的数据处理能力,吸引了来自各个领域从事数据分析相关工作的人员. R语言是强大自由的,但是其学习曲线也是陡峭的.本人具有C/C++,C#,Python等多种语言的开发经验,就本人的体会,从R语言初级开发水平进阶到中级开发水平,要比其他编程语言更加困难,往往很多初学者就在这个阶段放弃了,相当可惜.另外,对于大量没有很多

c语言面向对象编程

#include <stdio.h> #include <stdlib.h> /*  *  *   1.  简单实现模拟虚函数表实现c语言面向对象的设计  *   2.  为实现:  函数注册调用  *   3.            通过文件实现函数注册调用  */ //封装 typedef struct _Shape Shape; //模拟虚函数表 struct ShapeClass {     void (*construct)(Shape* self); //构造函数   

R语言基础编程技巧汇编 - 17

1.       timestamp函数输出当前时间 timestamp() ##------ Sun Apr 05 20:54:06 2015 ------## 该函数可以输入当前的系统时间,可用于耗时很长的程序定时输出当前时间,用于判断程序是否正常运行:也可用于调试,判断哪一段代码效率较低. 2.       多个比较的boxplot图 a=c(1,2,3,4,5,2,1,2,4,2,5,6) b=c("A","A","B","B&

R语言基础编程技巧汇编 - 27

1.      向量循环移位 library("magic") x <- 1:10 magic::shift(x,1) # [1] 10 1  2  3 4  5  6 7  8  9 magic::shift(x,1) # [1] 10 1  2  3 4  5  6 7  8  9 magic::shift(x,2) # [1] 9 10  1  2 3  4  5 6  7  8 magic::shift(x,3) # [1] 8  9 10  1 2  3  4 5  6

R语言基础编程技巧汇编 - 25

1.      使用rClr包访问.NET库 下载地址:http://r2clr.codeplex.com/ library(rClr) clrLoadAssembly('c:/path/to/myassembly.dll') myObj <-clrNew('MyNamespace.MyClass,MyAssemblyName') clrCall(myObj, 'SayHelloWorld') 2.      向C语言代码传递数据框参数示例 data.frame是一个list对象 #includ

R语言基础编程技巧汇编 - 20

1.      RCurl设置代理 假设代理地址是10.10.10.10:端口是:8080. 设置代理地址如下: curl<-getCurlHandle(proxy="10.10.10.10:8080"); getURL("http://baidu.com",curl=curl) 2.      抓取网页中的表格 library(XML) library(RCurl) u ="http://en.wikipedia.org/wiki/List_of_

R语言基础编程技巧汇编 - 16

1.      利用magrittr包进行管道操作 很多情况下,管道操作符可以很大程度的简化代码,并且使其更加直观.易读.易懂,下面就简单说明了useR2014上颇受R用户喜爱的magrittr包. the pipe operatoris one (if not THE) most important innovation introduced, this year, to the Recosystem Intro 类似于linux中的|,可以把前一个表达式(函数)的输出(而不用定义中间变量来表

R语言高性能编程（三）

一.使用并行计算加倍提升性能1.数据并行 VS 任务并行实现数据并行的算法scoket 并行性注意并行计算时间并不与执行任务的计算资源数目成正比(计算机核心),amdahl定律:并行代码的速度受限于串行执行的部分,包括并行性带来的开销在非windows系统中,parallel支持分叉集群(交叉法),新的work进程会从父R进程分叉出来,并拷贝数据.好处是不需要显示的创建和销毁集群实现任务并行的算法 2.计算机集群并行执行多个任务只有基于socket的集群可以做到这一点,因为进程不可能被分叉到另外