मैं किसी फ़ंक्शन के लिए स्रोत कोड कैसे देख सकता हूं?


550

मैं एक फ़ंक्शन के लिए स्रोत कोड को देखना चाहता हूं कि यह कैसे काम करता है। मुझे पता है कि मैं प्रॉम्प्ट पर अपना नाम लिखकर एक फ़ंक्शन प्रिंट कर सकता हूं:

> t
function (x) 
UseMethod("t")
<bytecode: 0x2332948>
<environment: namespace:base>

इस मामले में, क्या UseMethod("t")मतलब है? मैं उदाहरण के लिए, वास्तव में किस स्रोत कोड का उपयोग कर रहा हूं t(1:10):?

वहाँ जब मैं देख रहा हूँ के बीच एक अंतर है UseMethodऔर जब मैं देख रहा हूँ standardGenericऔर showMethods, साथ के रूप में with?

> with
standardGeneric for "with" defined from package "base"

function (data, expr, ...) 
standardGeneric("with")
<bytecode: 0x102fb3fc0>
<environment: 0x102fab988>
Methods may be defined for arguments: data
Use  showMethods("with")  for currently available ones.

अन्य मामलों में, मैं देख सकता हूं कि आर फ़ंक्शन कहा जा रहा है, लेकिन मैं उन कार्यों के लिए स्रोत कोड नहीं ढूंढ सकता।

> ts.union
function (..., dframe = FALSE) 
.cbind.ts(list(...), .makeNamesTs(...), dframe = dframe, union = TRUE)
<bytecode: 0x36fbf88>
<environment: namespace:stats>
> .cbindts
Error: object '.cbindts' not found
> .makeNamesTs
Error: object '.makeNamesTs' not found

मुझे किस तरह के कार्य मिलते हैं .cbindtsऔर .makeNamesTs?

अभी भी अन्य मामलों में, आर कोड का एक सा है, लेकिन ज्यादातर काम कहीं और किया जा रहा है।

> matrix
function (data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL) 
{
    if (is.object(data) || !is.atomic(data)) 
        data <- as.vector(data)
    .Internal(matrix(data, nrow, ncol, byrow, dimnames, missing(nrow), 
        missing(ncol)))
}
<bytecode: 0x134bd10>
<environment: namespace:base>
> .Internal
function (call)  .Primitive(".Internal")
> .Primitive
function (name)  .Primitive(".Primitive")

मुझे कैसे पता चलेगा कि .Primitiveफ़ंक्शन क्या करता है? इसी तरह, कुछ कार्यों फोन .C, .Call, .Fortran, .External, या .Internal। मैं उन लोगों के लिए स्रोत कोड कैसे खोज सकता हूं?




जवाबों:


518

UseMethod("t")आपको बता रहा है कि t()एक ( S3 ) जेनेरिक फ़ंक्शन है जिसमें विभिन्न ऑब्जेक्ट कक्षाओं के लिए तरीके हैं।

S3 विधि प्रेषण प्रणाली

S3 वर्गों के लिए, आप methodsकिसी विशेष जेनेरिक फ़ंक्शन या वर्ग के लिए विधियों को सूचीबद्ध करने के लिए फ़ंक्शन का उपयोग कर सकते हैं ।

> methods(t)
[1] t.data.frame t.default    t.ts*       

   Non-visible functions are asterisked
> methods(class="ts")
 [1] aggregate.ts     as.data.frame.ts cbind.ts*        cycle.ts*       
 [5] diffinv.ts*      diff.ts          kernapply.ts*    lines.ts        
 [9] monthplot.ts*    na.omit.ts*      Ops.ts*          plot.ts         
[13] print.ts         time.ts*         [<-.ts*          [.ts*           
[17] t.ts*            window<-.ts*     window.ts*      

   Non-visible functions are asterisked

"गैर-दृश्य फ़ंक्शंस तारांकित हैं" इसका मतलब है कि फ़ंक्शन को उसके पैकेज के नाम स्थान से निर्यात नहीं किया गया है। आप इसके स्रोत कोड को अभी भी देख सकते हैं::: फ़ंक्शन (यानी stats:::t.ts), या उपयोग करकेgetAnywhere()getAnywhere()उपयोगी है क्योंकि आपको यह पता नहीं है कि समारोह किस पैकेज से आया है।

> getAnywhere(t.ts)
A single object matching ‘t.ts’ was found
It was found in the following places
  registered S3 method for t from namespace stats
  namespace:stats
with value

function (x) 
{
    cl <- oldClass(x)
    other <- !(cl %in% c("ts", "mts"))
    class(x) <- if (any(other)) 
        cl[other]
    attr(x, "tsp") <- NULL
    t(x)
}
<bytecode: 0x294e410>
<environment: namespace:stats>

S4 विधि प्रेषण प्रणाली

S4 प्रणाली एक नई विधि प्रेषण प्रणाली है और S3 प्रणाली का एक विकल्प है। यहाँ एक S4 फ़ंक्शन का एक उदाहरण दिया गया है:

> library(Matrix)
Loading required package: lattice
> chol2inv
standardGeneric for "chol2inv" defined from package "base"

function (x, ...) 
standardGeneric("chol2inv")
<bytecode: 0x000000000eafd790>
<environment: 0x000000000eb06f10>
Methods may be defined for arguments: x
Use  showMethods("chol2inv")  for currently available ones.

आउटपुट पहले से ही बहुत सारी जानकारी प्रदान करता है। standardGenericS4 फ़ंक्शन का एक संकेतक है। परिभाषित एस 4 विधियों को देखने की विधि मदद से पेश की जाती है:

> showMethods(chol2inv)
Function: chol2inv (package base)
x="ANY"
x="CHMfactor"
x="denseMatrix"
x="diagonalMatrix"
x="dtrMatrix"
x="sparseMatrix"

getMethod तरीकों में से एक के स्रोत कोड को देखने के लिए इस्तेमाल किया जा सकता है:

> getMethod("chol2inv", "diagonalMatrix")
Method Definition:

function (x, ...) 
{
    chk.s(...)
    tcrossprod(solve(x))
}
<bytecode: 0x000000000ea2cc70>
<environment: namespace:Matrix>

Signatures:
        x               
target  "diagonalMatrix"
defined "diagonalMatrix"

उदाहरण के लिए, प्रत्येक विधि के लिए अधिक जटिल हस्ताक्षर वाले तरीके भी हैं

require(raster)
showMethods(extract)
Function: extract (package raster)
x="Raster", y="data.frame"
x="Raster", y="Extent"
x="Raster", y="matrix"
x="Raster", y="SpatialLines"
x="Raster", y="SpatialPoints"
x="Raster", y="SpatialPolygons"
x="Raster", y="vector"

इन विधियों में से किसी एक के लिए स्रोत कोड देखने के लिए पूरे हस्ताक्षर की आपूर्ति की जानी चाहिए, जैसे

getMethod("extract" , signature = c( x = "Raster" , y = "SpatialPolygons") )

यह आंशिक हस्ताक्षर की आपूर्ति करने के लिए पर्याप्त नहीं होगा

getMethod("extract",signature="SpatialPolygons")
#Error in getMethod("extract", signature = "SpatialPolygons") : 
#  No method found for function "extract" and signature SpatialPolygons

फ़ंक्शंस जो अस्पष्टीकृत कार्यों को कहते हैं

के मामले में ts.union, .cbindtsऔर नाम स्थान .makeNamesTsसे अस्पष्टीकृत कार्य हैं stats। आप :::ऑपरेटर का उपयोग करके गैर-पंजीकृत कार्यों के स्रोत कोड देख सकते हैं getAnywhere

> stats:::.makeNamesTs
function (...) 
{
    l <- as.list(substitute(list(...)))[-1L]
    nm <- names(l)
    fixup <- if (is.null(nm)) 
        seq_along(l)
    else nm == ""
    dep <- sapply(l[fixup], function(x) deparse(x)[1L])
    if (is.null(nm)) 
        return(dep)
    if (any(fixup)) 
        nm[fixup] <- dep
    nm
}
<bytecode: 0x38140d0>
<environment: namespace:stats>

संकलित कोड को कॉल करने वाले फ़ंक्शंस

ध्यान दें कि "संकलित" बाइट-संकलित आर कोड को संदर्भित नहीं करता है जैसा कि संकलक पैकेज द्वारा बनाया गया है । <bytecode: 0x294e410>ऊपर उत्पादन में रेखा यह संकेत समारोह बाइट-संकलित है, और आप अभी भी आर कमांड लाइन से स्रोत देख सकते हैं।

कार्य है कि कॉल .C, .Call, .Fortran, .External, .Internal, या .Primitiveसंकलित कोड में प्रवेश बिंदुओं बुला रहे हैं, तो आप संकलित कोड के स्रोतों को देखने के लिए करता है, तो आप पूरी तरह से समारोह को समझना चाहते हैं होगा। R स्रोत कोड का यह GitHub दर्पण शुरू करने के लिए एक सभ्य स्थान है। फ़ंक्शन pryr::show_c_sourceएक उपयोगी उपकरण हो सकता है क्योंकि यह आपको कॉल .Internalऔर .Primitiveकॉल के लिए सीधे GitHub पृष्ठ पर ले जाएगा । संकुल का उपयोग कर सकते .C, .Call, .Fortran, और .External; लेकिन नहीं.Internal या.Primitive , क्योंकि ये आर दुभाषिया में निर्मित कार्यों को कॉल करने के लिए उपयोग किया जाता है।

उपरोक्त कार्यों में से कुछ को संकलित फ़ंक्शन को संदर्भित करने के लिए वर्ण स्ट्रिंग के बजाय ऑब्जेक्ट का उपयोग किया जा सकता है। उन मामलों में, वस्तु वर्ग की है "NativeSymbolInfo", "RegisteredNativeSymbol"या "NativeSymbol"; और ऑब्जेक्ट को प्रिंट करने से उपयोगी जानकारी मिलती है। उदाहरण के लिए, optimकॉल .External2(C_optimhess, res$par, fn1, gr1, con)(ध्यान दें कि C_optimhess, नहीं "C_optimhess")। optimआँकड़े पैकेज में है, इसलिए आप stats:::C_optimhessसंकलित फ़ंक्शन के बारे में जानकारी देखने के लिए कह सकते हैं।

एक पैकेज में संकलित कोड

यदि आप एक पैकेज में संकलित कोड देखना चाहते हैं, तो आपको पैकेज स्रोत को डाउनलोड / अनपैक करना होगा। स्थापित बायनेरिज़ पर्याप्त नहीं हैं। पैकेज का स्रोत कोड उसी CRAN (या CRAN संगत) रिपॉजिटरी से उपलब्ध है जिसे पैकेज मूल रूप से स्थापित किया गया था। download.packages()समारोह आप के लिए पैकेज स्रोत मिल सकता है।

download.packages(pkgs = "Matrix", 
                  destdir = ".",
                  type = "source")

यह मैट्रिक्स पैकेज के स्रोत संस्करण को डाउनलोड करेगा और .tar.gzवर्तमान निर्देशिका में संबंधित फ़ाइल को बचाएगा । संकलित कार्यों के लिए स्रोत कोड srcको असम्पीडित और अनरेटेड फ़ाइल की निर्देशिका में पाया जा सकता है । फ़ंक्शन के उपयोग Rसे या उसके भीतर से अनकम्प्रेस्ड और अनटेयरिंग स्टेप किया जा सकता है । डाउनलोड और एक्सपेंशन स्टेप को एक कॉल में संयोजित करना संभव है (ध्यान दें कि एक बार में केवल एक पैकेज को डाउनलोड किया जा सकता है और इस तरह से अनपैक किया जा सकता है):Runtar()

untar(download.packages(pkgs = "Matrix",
                        destdir = ".",
                        type = "source")[,2])

वैकल्पिक रूप से, यदि पैकेज के विकास को सार्वजनिक रूप से होस्ट किया जाता है (जैसे GitHub , R-Forge , या RForge.net के माध्यम से ), तो आप शायद ऑनलाइन स्रोत कोड ब्राउज़ कर सकते हैं।

आधार पैकेज में संकलित कोड

कुछ पैकेजों को "आधार" पैकेज माना जाता है। इन पैकेजों आर के साथ जहाज और उनके संस्करण आर उदाहरण के संस्करण के लिए लॉक किया गया है शामिल हैं base, compiler, stats, और utils। जैसे, वे ऊपर वर्णित के रूप में CRAN पर अलग डाउनलोड करने योग्य पैकेज के रूप में उपलब्ध नहीं हैं। बल्कि, वे व्यक्तिगत पैकेज निर्देशिकाओं में R स्रोत वृक्ष का हिस्सा हैं /src/library/। R स्रोत तक पहुंचने का तरीका अगले भाग में वर्णित है।

संकलित कोड आर दुभाषिया में बनाया गया

यदि आप आर इंटरप्रेटर में निर्मित कोड देखना चाहते हैं, तो आपको आर स्रोतों को डाउनलोड / अनपैक करना होगा; या आप आर सबवर्सन रिपॉजिटरी या विंस्टन चांग के जीथब मिरर के माध्यम से स्रोतों को ऑनलाइन देख सकते हैं ।

Uwe Ligges का R न्यूज़ आर्टिकल (PDF) (पृष्ठ 43) एक अच्छा सामान्य संदर्भ है कि कैसे .Internalऔर .Primitiveफ़ंक्शंस के सोर्स कोड को देखा जाए । मूल चरणों को पहले फ़ंक्शन नाम में देखना है src/main/names.cऔर फिर फ़ाइलों में "सी-एंट्री" नाम खोजना है src/main/*


71
यदि आप उपयोग करते हैं RStudio, तो यह उस फ़ंक्शन के लिए स्रोत को खींचने का प्रयास करेगा जब आप F2कुंजी दबाते हैं तो आपका टेक्स्ट कर्सर खत्म हो जाता है ।
अरी बी। फ्रीडमैन

1
@ अरी बी। फ्रीडमैन इस लेट प्रश्न के लिए क्षमा करें। क्या RStudio फ़ंक्शन के लिए C स्रोत कोड या R में लिखे गए कार्यों के लिए भी खींचेगा? साभार
सनी

3
@ आमिर का मानना ​​है कि यह सिर्फ आर स्रोत है।
अरी बी। फ्रीडमैन

@ AriB.Friedman - धन्यवाद एर, यह काम है। मेरे मामले में मुझे अभी भी उत्तर में दिखाए गए ज्ञान की आवश्यकता है ( scale, जो एस 3 है - मुझे मिला UseMethod("scale")और फिर उपयोग किया गया getAnywhere(scale.default))। लेकिन सादे कार्य ठीक काम करते हैं।
टॉमस गैंडर

2
नकल चापलूसी का सबसे ईमानदार रूप है, मुझे लगता है कि यह उत्तर / विकी पहले आया :) :) इससे पहले rfaqs.com/source-code-of-r-method
JimLohse

94

इस सवाल और इसके डुप्लिकेट पर अन्य उत्तरों के अलावा, यहां पैकेज फ़ंक्शन के लिए स्रोत कोड प्राप्त करने का एक अच्छा तरीका है, यह जानने की आवश्यकता के बिना कि यह किस पैकेज में है। उदाहरण के लिए, यदि हम इसके लिए स्रोत चाहते हैं randomForest::rfcv():

पॉप-अप विंडो में इसे देखने / संपादित करने के लिए :

edit(getAnywhere('rfcv'), file='source_rfcv.r')

करने के लिए एक अलग फाइल को अनुप्रेषित :

capture.output(getAnywhere('rfcv'), file='source_rfcv.r')

निश्चित रूप से , getAnywhere किसी चीज़ के लिए नाम का एक और निराला आर विकल्प है, जिसे findOnSearchPath या समान कहा जाना चाहिए ।
मुस्कान

1
मैं इस उत्तर को बढ़ाऊंगा क्योंकि यह मुझे वही मिला जो मैं चाहता था। मैं वास्तव में RStudio में चाहता था, था View(foo); जहां fooपहले से लोड पैकेज से एक फ़ंक्शन था।
सिगफ्रीड

1
@Sigfried: edit()एक टेक्स्ट एडिटर (उपयोगकर्ता की पसंद के) को View()खोलता है , जबकि डेटा के लिए एक एक्सेल-टाइप स्प्रेडशीट दर्शक खोलता है , बाद वाला ब्राउजिंग (मल्टी-कॉलम) डेटा के लिए अच्छा है, लेकिन आमतौर पर खिलौना लंबाई के अलावा अन्य किसी भी चीज़ के कोड के लिए भयानक है। उदाहरण के लिए, जैसा कि मैं संकेत करता हूं, आम तौर पर एक फ़ंक्शन ब्राउज़ करते समय पहली चीज जो मैं करना चाहता हूं वह है कि सभी आर्ग-पार्सिंग और डिफ़ॉल्ट-एक्शन लॉजिक को छोड़ दें, यह देखने के लिए कि फ़ंक्शन वास्तव में क्या करता है
शाम

25

यह तब प्रकट होता है जब आप डीबग () फ़ंक्शन का उपयोग करते हुए डीबग करते हैं। मान लीजिए कि आप अंतर्निहित कोड को t () ट्रांज़ोज़ फ़ंक्शन में देखना चाहते हैं। बस 't' टाइप करने से ज्यादा पता नहीं चलता है।

>t 
function (x) 
UseMethod("t")
<bytecode: 0x000000003085c010>
<environment: namespace:base>

लेकिन, 'डीबग (फ़ंक्शननाम)' का उपयोग करते हुए, यह अंतर्निहित कोड को प्रकट करता है, इंटर्नल को संसूचित करता है।

> debug(t)
> t(co2)
debugging in: t(co2)
debug: UseMethod("t")
Browse[2]> 
debugging in: t.ts(co2)
debug: {
    cl <- oldClass(x)
    other <- !(cl %in% c("ts", "mts"))
    class(x) <- if (any(other)) 
        cl[other]
    attr(x, "tsp") <- NULL
    t(x)
}
Browse[3]> 
debug: cl <- oldClass(x)
Browse[3]> 
debug: other <- !(cl %in% c("ts", "mts"))
Browse[3]> 
debug: class(x) <- if (any(other)) cl[other]
Browse[3]>  
debug: attr(x, "tsp") <- NULL
Browse[3]> 
debug: t(x)

EDIT: डिबगोन () अंडरबग का उपयोग किए बिना ही पूरा करता है ()


स्वीकार किए गए उत्तर में दिए गए की तुलना में इस पद्धति के डाउनसाइड्स यह हैं कि आपको एक कार्य फ़ंक्शन कॉल (सभी आवश्यक पैरामीटर निर्दिष्ट, स्वीकार किए जाते हैं) की आवश्यकता है; और, कोड के प्रारंभिक ब्लॉक के अलावा, आपको प्रत्येक ब्लॉक को उस समय चलाया जाता है जब वह चलाया जाता है। यह डिबगिंग के लिए बहुत अच्छा है, लेकिन सिर्फ स्रोत प्राप्त करने के लिए इष्टतम नहीं है।
ब्रायन डिग

हां, इसका इष्टतम नहीं है। लेकिन अगर आप चतुर हैं, तो आप इन-बिल्ट कार्यों के लिए स्रोत को त्वरित और गंदा कर सकते हैं, जासूसी कर सकते हैं।
सेल्वा

2
मैं भी इस उदाहरण के debugonceबजाय उपयोग करने की सलाह debugदूंगा।
जोशुआ उलरिच

20

गैर-आदिम कार्यों के लिए, आर बेस में एक फ़ंक्शन शामिल होता है, जिसे फ़ंक्शन body()का शरीर लौटाता है। उदाहरण के लिए print.Date()फ़ंक्शन का स्रोत देखा जा सकता है:

body(print.Date)

इसका उत्पादन करेंगे:

{
    if (is.null(max)) 
        max <- getOption("max.print", 9999L)
    if (max < length(x)) {
        print(format(x[seq_len(max)]), max = max, ...)
        cat(" [ reached getOption(\"max.print\") -- omitted", 
            length(x) - max, "entries ]\n")
    }
    else print(format(x), max = max, ...)
    invisible(x)
}

यदि आप एक स्क्रिप्ट में काम कर रहे हैं और एक चरित्र वेक्टर के रूप में फ़ंक्शन कोड चाहते हैं, तो आप इसे प्राप्त कर सकते हैं।

capture.output(print(body(print.Date)))

आपको मिलेगा:

[1] "{"                                                                   
[2] "    if (is.null(max)) "                                              
[3] "        max <- getOption(\"max.print\", 9999L)"                      
[4] "    if (max < length(x)) {"                                          
[5] "        print(format(x[seq_len(max)]), max = max, ...)"              
[6] "        cat(\" [ reached getOption(\\\"max.print\\\") -- omitted\", "
[7] "            length(x) - max, \"entries ]\\n\")"                      
[8] "    }"                                                               
[9] "    else print(format(x), max = max, ...)"                           
[10] "    invisible(x)"                                                    
[11] "}"     

मैं ऐसा काम क्यों करना चाहूंगा? मैं एक सूची के आधार पर एक कस्टम S3 ऑब्जेक्ट ( x, जहां class(x) = "foo") बना रहा था । सूची सदस्यों में से एक ("मज़ेदार नाम") एक समारोह था और मैं print.foo()इंडेंटेड फंक्शन सोर्स कोड प्रदर्शित करना चाहता था । तो मैं निम्नलिखित स्निपेट के साथ समाप्त हुआ print.foo():

sourceVector = capture.output(print(body(x[["fun"]])))
cat(paste0("      ", sourceVector, "\n"))

जो संबंधित कोड को इंडेंट और प्रदर्शित करता है x[["fun"]]


18

यह नहीं देखा कि यह मुख्य उत्तर के प्रवाह में कैसे फिट होता है, लेकिन इसने मुझे थोड़ी देर के लिए रोक दिया, इसलिए मैं इसे यहां जोड़ रहा हूं:

Infix ऑपरेटर्स

कुछ आधार इन्फ़िक्स ऑपरेटरों (जैसे, के स्रोत कोड को देखने के लिए %%, %*%, %in%), उपयोग getAnywhere, जैसे:

getAnywhere("%%")
# A single object matching ‘%%’ was found
# It was found in the following places
#   package:base
#   namespace:base
#  with value
#
# function (e1, e2)  .Primitive("%%")

मुख्य उत्तर कवर करता है कि फिर गहरी खुदाई करने के लिए दर्पण का उपयोग कैसे करें।


6
smci के जवाब की सिफारिश की getAnywhere। या यदि आप पहले से ही ऑपरेटर का नाम जानते हैं तो आप केवल बैकटिक्स का उपयोग कर सकते हैं `%in%`:।
जोशुआ उलरिच

3
@JoshuaUlrich को नहीं पता था कि आप backticks का उपयोग कर सकते हैं! धन्यवाद। getAnywhereआपके उत्तर में भी उल्लेख किया गया है, लेकिन मुझे लगता है कि infix का एक विशिष्ट संदर्भ इस उत्तर के भविष्य के संदर्भ के लिए उपयोगी है - मैंने इस पृष्ठ को कई बार पढ़ा है और अभी भी कुछ के लिए इस तरह के कार्यों के लिए कोड खोजने की कोशिश कर रहा था जबकि - और मुझे नहीं लगा कि यह या तो अन्य उत्तर के प्रवाह में फिट बैठता है (जो दोनों getAnywhereकिसी अन्य उद्देश्य के लिए उपयोग कर रहे हैं )।
माइकलचिरिको

10

आर में एक बहुत ही आसान कार्य है edit

new_optim <- edit(optim)

यह optimआर के में निर्दिष्ट संपादक का उपयोग करने के स्रोत कोड को खोल देगा options, और फिर आप इसे संपादित कर सकते हैं और संशोधित फ़ंक्शन को असाइन कर सकते हैं new_optim। मुझे यह फ़ंक्शन कोड को देखने या कोड को डीबग करने के लिए बहुत पसंद है, उदाहरण के लिए, कुछ संदेश या चर प्रिंट करें या उन्हें आगे की जांच के लिए एक वैश्विक चर पर असाइन करें (बेशक आप उपयोग कर सकते हैं debug)।

यदि आप केवल स्रोत कोड देखना चाहते हैं और अपने कंसोल पर मुद्रित लंबा स्रोत कोड नहीं चाहते हैं, तो आप उपयोग कर सकते हैं

invisible(edit(optim))

स्पष्ट रूप से, इसका उपयोग C / C ++ या फोरट्रान स्रोत कोड देखने के लिए नहीं किया जा सकता है।

BTW, editसूची, मैट्रिक्स, आदि जैसी अन्य वस्तुओं को खोल सकता है, जो तब विशेषताओं के साथ डेटा संरचना को भी दिखाता है। deमैट्रिक्स या डेटा फ़्रेम को संशोधित करने और नए को वापस करने के लिए संपादक (जैसे GUI इसका समर्थन करता है) की तरह एक एक्सेल खोलने के लिए फ़ंक्शन का उपयोग किया जा सकता है। यह कभी-कभी आसान होता है, लेकिन सामान्य मामले में बचा जाना चाहिए, खासकर जब आप मैट्रिक्स बड़े होते हैं।


3
यह दृष्टिकोण केवल वही फ़ंक्शन स्रोत लाता है जो फ़ंक्शन को प्रिंट करता है (जो कि प्रश्न में समान है)। इससे आगे / गहरा हो रहा है कि यह सवाल क्या है।
ब्रायन डिग्स

2
@BrianDiggs हाँ, आप सही हैं। मुझे इस सवाल का जवाब देने का मतलब यह नहीं था, क्योंकि यहोशू ने काफी हद तक जवाब दिया है। मैं केवल विषय से संबंधित कुछ जोड़ने की कोशिश करता हूं, दिलचस्प और इसके बारे में जानने के लिए उपयोगी हो सकता है।
एरिक

8

जब तक फ़ंक्शन शुद्ध आर नॉट सी / सी ++ / फोरट्रान में लिखा जाता है, तब तक कोई भी निम्नलिखित का उपयोग कर सकता है। अन्यथा सबसे अच्छा तरीका डिबगिंग और " जंप इन " का उपयोग करना है :

> functionBody(functionName)

2
यह भी ऐसा ही है bodyidentical(functionBody, body)है TRUE
जोशुआ उलरिच

1
base::bodyऔर methods::functionBody, हालांकि वे अलग-थलग रहने के लिए हैं। bodyओवरराइड भी किया जा सकता है: rdocumentation.org/search?q=body
Moody_Mudskipper

7

RStudio में, कम से कम 3 तरीके हैं:

  1. किसी भी फ़ंक्शन पर कर्सर होने पर F2 कुंजी दबाएं।
  2. Ctrl या Command रखते हुए फ़ंक्शन नाम पर क्लिक करें
  3. View(function_name) (जैसा ऊपर कहा गया है)

स्रोत कोड के साथ एक नया फलक खुल जाएगा। यदि आप पहुंच जाते हैं।। गंभीर या .सी आपको एक और विधि की आवश्यकता होगी, क्षमा करें।


5

View([function_name])- जैसे। View(mean)अपरकेस [V] का उपयोग करना सुनिश्चित करें। संपादक में केवल-पढ़ने के लिए कोड खुलेगा।


5

आप print.function()कंसोल में फ़ंक्शन लिखने के लिए , जो कि S3 जेनेरिक है, का उपयोग करने का प्रयास कर सकते हैं ।


3
print.function()एक S3 विधि है । जेनेरिक है print()। और यह आम तौर पर सीधे तरीकों को कॉल करने के लिए एक अच्छा विचार नहीं है। यह सामान्य कार्यों और विधि प्रेषण के पूरे उद्देश्य को हरा देता है।
जोशुआ उलरिच
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.