आर: आर 6 कक्षा के लिए कई रचनाकारों को परिभाषित करने के लिए कैसे?

Question

मैं वर्तमान में एक परियोजना पर काम कर रहा हूं जहां मुझे आर में R6 class बनाने की आवश्यकता है जिसे एक से अधिक तरीकों से शुरू किया जा सकता है। मैं सोच रहा हूं कि इसके बारे में क्या सबसे अच्छा तरीका है। क्या $new() फ़ंक्शन को अधिभारित करना संभव है? या मुझे एक सहायक समारोह को परिभाषित करने की आवश्यकता है?

एक प्रेरित उदाहरण के रूप में: मैं एक क्षेत्र names है कि या तो प्रयोग करके वेक्टर variable_names या एक पूर्णांक n_variables (जिस स्थिति में यह नामों की एक डिफ़ॉल्ट वेक्टर initializes) का उपयोग कर प्रारंभ किया जा सकता है के साथ एक R6 वर्ग MyClass के लिए दो कंस्ट्रक्टर्स करना चाहते हैं ।

कार्यक्षमता इस तरह काम करना चाहिए:

#define the class (only has a constructor that accepts a vector of names) 
myClass <- R6Class("myClass", 
        public = list(
        names = NA, 
        initialize = function(names) { 
         if (!missing(names)) self$names <- names 
        }) 
) 

#create a test object using a vector of names 
variable_names = c("x","y") 
a = myClass$new(variable_names) 
a$names 
#> [1] "x y" 

#everything after here does not actually work (just to illustrate functionality) 
n_variables = 2; 
b = myClass$new(n_variables) 
b$names 
#> [1] "v1 v2" 

मैं Introductory vignette, के माध्यम से एक बार देख लिया, लेकिन वहाँ यह करने के लिए एक स्पष्ट तरीका हो प्रतीत नहीं होता है।

आदर्श रूप में, मैं ऐसे समाधान की तलाश में हूं जो मुझे तर्कों का नाम देने के लिए मजबूर नहीं करता है (यानी मुझे myClass$new(names=variable_names) जैसे कुछ करने की ज़रूरत नहीं है) और इससे मुझे आसानी से जांच मिलती है कि इनपुट मान्य हैं।

Answer 1

संभावित तरीका कन्स्ट्रक्टर के लिए डॉट-डॉट-डॉट (इलिप्सिस) तर्क का उपयोग करना है जो आपको कार्य में मनमानी संख्याओं के तर्कों को पारित करने की अनुमति देता है। इसके बाद आपको सूची में "..." को परिवर्तित करना होगा और इनपुट तर्कों को पार्स करना होगा।

---

उदाहरण के लिए मान लीजिए कि हम कन्स्ट्रक्टर द्वारा धर्मार्थ को अधिभारित करना चाहते हैं।

myClass <- R6Class("myClass", 
    public = list(
     name = NA, 
     age = NA, 
     favouriteFood = NA, 
     # Constructor overloaded by arity 
     initialize = function(...) { 
     arguments <- list(...) 
     switch(nargs(), 
      # one input argument 
      {self$name <- arguments[[1]]}, 
      # two input arguments 
      {self$name <- arguments[[1]] 
      self$age <- arguments[[2]]}, 
      # three input arguments 
      {self$name <- arguments[[1]] 
      self$age <- arguments[[2]] 
      self$favouriteFood <- arguments[[3]]} 
     ) 
     print(self) 
     }) 
) 

अब निर्माता कॉलिंग हमें देता है

> a = myClass$new("john") 
<myClass> 
    Public: 
    age: NA 
    clone: function (deep = FALSE) 
    favouriteFood: NA 
    initialize: function (...) 
    name: john 
> a = myClass$new("john",35) 
<myClass> 
    Public: 
    age: 35 
    clone: function (deep = FALSE) 
    favouriteFood: NA 
    initialize: function (...) 
    name: john 
> a = myClass$new("john",35,"pasta") 
<myClass> 
    Public: 
    age: 35 
    clone: function (deep = FALSE) 
    favouriteFood: pasta 
    initialize: function (...) 
    name: john