एक स्ट्रिंग

Question

के रूप में फ़ंक्शन नाम प्राप्त करना कहें कि मेरे पास MyFunction.1 आदि जैसे कुछ कार्य हैं। मैं इन कार्यों को किसी अन्य फ़ंक्शन में पास करना चाहता हूं, जो एक छोटी रिपोर्ट को प्रिंट करता है। आदर्श रूप में मैं एक रिपोर्ट के अनुभागों को लेबल करने में सक्षम होना चाहता हूं जिसके परिणामस्वरूप परिणाम उत्पन्न करने के लिए फ़ंक्शन का उपयोग किया जा रहा है।

तो क्या एक पूर्वनिर्धारित फ़ंक्शन का नाम स्ट्रिंग के रूप में प्राप्त करने का कोई अच्छा तरीका है?

Answer 1

कि parse(eval(...)) को जन्म दे सकती है, जिस पर आप इस आलोचना के लिए खुले हैं बिंदु:

R> library(fortunes) 
R> fortune("parse") 

If the answer is parse() you should usually rethink the question. 
    -- Thomas Lumley 
     R-help (February 2005) 

R> 

तो अपने कार्यों के नाम से जाना गए हैं MyFunction.1 आदि पीपी?

Answer 2

जब किसी ऑब्जेक्ट के रूप में फ़ंक्शन पारित किया जाता है, तो यह उसका नाम खो देता है। देखें, उदाहरण के लिए, निम्नलिखित लाइनों के परिणाम:

str(lm) 
lm 

आप तर्क और समारोह के शरीर प्राप्त कर सकते हैं, लेकिन नहीं नाम।

मेरे सुझाव काम करता है, जहां नाम मुद्रित किया जा सकता है की एक नामित सूची के निर्माण के लिए किया जाएगा:

> somefns <- list(lm=lm, aggregate=aggregate) 
> str(somefns) 
List of 2 
$ lm  :function (formula, data, subset, weights, na.action, method = "qr", 
    model = TRUE, x = FALSE, y = FALSE, qr = TRUE, singular.ok = TRUE, 
    contrasts = NULL, offset, ...) 
$ aggregate:function (x, ...) 

> somefns[[1]](dist ~ speed, data=cars) 

Call: 
somefns[[1]](formula = dist ~ speed, data = cars) 

Coefficients: 
(Intercept)  speed 
    -17.58   3.93 

> names(somefns)[[1]] 
[1] "lm" 

Answer 3

एक और दृष्टिकोण अपनी रिपोर्ट समारोह में कार्यों के नाम से पारित है, और फिर प्राप्त करने के लिए किया जाएगा खुद को get() कमांड के साथ कार्य करता है। उदाहरण के लिए:

function.names <- c("which","all") 
fun1 <- get(function.names[1]) 
fun2 <- get(function.names[2]) 

तो फिर आप अपने मूल चरित्र वेक्टर में नाम है, और कार्यों नए नाम है के रूप में आप उन्हें परिभाषित किया। इस मामले में, all समारोह अब fun2 के रूप में कहा जाता है की जा रही:

> fun2(c(TRUE, FALSE)) 
[1] FALSE 

या, यदि आप वास्तव में मूल कार्य के नाम रखना चाहते हैं, बस असाइन समारोह के साथ स्थानीय स्तर पर उन्हें आवंटित:

assign(function.names[2], get(function.names[2])) 

यदि आप अभी इस आदेश को चलाते हैं, तो आप अपने ".GlobalEnv" में all फ़ंक्शन के साथ समाप्त हो जाएंगे। आप इसे ls() के साथ देख सकते हैं।

Answer 4

आप match.call के माध्यम से किसी फ़ंक्शन के अनचाहे तर्क प्राप्त कर सकते हैं।

> x <- function(y) print(match.call()[2]) 
> x(lm) 
lm() 

Answer 5

क्या इस बारे में: उदाहरण के लिए:

deparse(quote(foo.bar)) 

Answer 6

मैं एक ही बात चाहते किया गया था, और library(foo) उद्धरण जरूरत नहीं थी याद, इस यह क्या करता है:

package <- as.character(substitute(package)) 

Answer 7

बस इस मुद्दे में लाभ और सीमा दिखाने के लिए एक उदाहरण प्रदान करना चाहते हैं:

I अपने नाम के साथ एक समारोह "सेव" करने के लिए एक विकल्प है कि एक और समारोह में इस्तेमाल किया जाएगा के रूप में चाहते हैं:

R> foreach(..., .combine=test_fun) {...} 

test_fun समारोह का नाम है, और निश्चित रूप से

R> mode(test_fun) 
[1] "function" 

जब मैं इसे foreach में उपयोग करें, मुझे केवल फ़ंक्शन नाम की आवश्यकता है, जबकि test_fun एक मौजूदा फ़ंक्शन हो सकता है (उदाहरण के लिए cbind)। तो, test_fun

R> test_fun <- get('cbind') 

या

R> test_fun <- assign('cbind', get('cbind')) 

द्वारा असाइन किया गया है तो, आप समारोह यहां

R> test_fun 
function (..., deparse.level = 1) 
.Internal(cbind(deparse.level, ...)) 

वास्तव में मिला है, मूल नाम, नहीं रखा जा सकता है ताकि आप कोई है test_fun को स्ट्रिंग "cbind" पर कनवर्ट करने का तरीका।

R> deparse(substitute(test_fun)) 
[1] "test_fun" 

दुर्भाग्यवश मुझे फ़ोरैच कोड को छोड़ने की आवश्यकता है ताकि स्ट्रिंग में मूल नाम दिखाना पड़े। इसका मतलब है कि एकमात्र तरीका 'cbind' को एक स्ट्रिंग के रूप में सहेजना और ऐसी फ़ंक्शन ऑब्जेक्ट बनाना इस मामले में कोई लाभ नहीं लाता है।