मूल बातें में

मूल बातें के बारे में

वेरिएबल और असाइनमेंट

R एक डायनामिक टाइपिंग वाली भाषा है, इसलिए सामान्य तौर पर किसी वेरिएबल का टाइप बताना ज़रूरी नहीं होता। डिफॉल्ट टाइप numeric होता है, जिसे आम तौर पर डबल-प्रिसिजन दशमलव संख्या के रूप में लागू किया जाता है। 32-बिट पूर्णांक इस्तेमाल करने के लिए L प्रत्यय लगाइए (Long का संक्षिप्त रूप)।

किसी ऑब्जेक्ट का "टाइप" पता करना (ऐतिहासिक कारणों से) उलझन भरा हो सकता है। फंक्शन typeof() और class() एक जैसे हैं, लेकिन थोड़े अलग नतीजे लौटा सकते हैं:

typeof(50)
#> [1] "double"  # more specific: an implementation detail
typeof(50L)
##> [1] "integer"

class(50)
#> [1] "numeric"  # less specific: ignores implementation details
class(50L)
#> [1] "integer"

असाइन करने के लिए पसंदीदा ऑपरेटर <- है। यदि आप RStudio में काम कर रहे हैं, तो इसे कीबोर्ड शॉर्टकट Alt-minus से लिखा जा सकता है।

x <- 42
avogadro <- 6.02e23
mystr <- "Hello, World!"

<- के बजाय = इस्तेमाल करना अक्सर काम कर जाता है, लेकिन हमेशा नहीं, और इसे खराब स्टाइल माना जाता है।

ऑपरेटर ज़्यादातर दूसरी भाषाओं जैसे ही होते हैं, हालाँकि %% और %/% कुछ अलग तरह के हैं। यह % सिंटैक्स मैक्रो के रूप में लागू किए गए इन्फिक्स ऑपरेटरों को कॉल करने का एक तरीका है।

2 + 3   # 5
2 - 3   # -1
2 * 3   # 6
2 / 3   # 0.6666667
8 %/% 3 # 2 (integer division)
8 %% 3  # 2 (remainder)
2 ^ 3   # 8 (exponential)

R में # से एक-लाइन कमेंट शुरू होता है। मल्टीलाइन कमेंट के लिए अलग सिंटैक्स नहीं है।

फंक्शन

फंक्शन बनाने के लिए:

squareit <- function(x) {
    x * x
}

फंक्शन में शून्य या अधिक आर्गुमेंट हो सकते हैं, जो कॉमा से अलग किए जाते हैं। function() के साथ ब्रैकेट () लगाना ज़रूरी है, चाहे कोई पैरामीटर न हो।

फंक्शन आर्गुमेंट के लिए डिफॉल्ट वैल्यू भी तय की जा सकती है, लेकिन ये उन सभी आर्गुमेंट के बाद आनी चाहिए जिनकी कोई डिफॉल्ट वैल्यू नहीं है, और डिफॉल्ट वैल्यू असाइन करने के लिए <- नहीं, = इस्तेमाल कीजिए। थोड़ा बेमतलब सा उदाहरण देखिए:

squareit <- function(x = 42) {
    x * x
}

squareit()
#> [1] 1764

एक-लाइन वाले फंक्शन के अंदर के कोड के लिए ब्रेस { } ज़रूरी नहीं हैं, लेकिन इन्हें लिखना अच्छा स्टाइल माना जाता है।

R फंक्शन की अंतिम वैल्यू अपने आप लौटा देता है, जैसा कि ऊपर के उदाहरणों में दिख रहा है।

फंक्शन के अंदर कहीं भी return() इस्तेमाल करके रिटर्न वैल्यू को स्पष्ट रूप से बताया जा सकता है। यह दी गई वैल्यू तुरंत लौटा देता है और फंक्शन के अंदर बचे हुए एक्सप्रेशन चलाए बिना फंक्शन को वहीं समाप्त कर देता है।

return() को स्पष्ट रूप से कॉल करना आम तौर पर तभी ज़रूरी होता है जब आप किसी कारण से फंक्शन से जल्दी बाहर निकलना चाहते हैं और कोई खास वैल्यू लौटाना चाहते हैं। इसका एक उदाहरण if-else शर्त के अंदर देखने को मिल सकता है।

हालाँकि कुछ डेवलपर कोड स्टाइल के तौर पर स्पष्ट रूप से लौटाना पसंद करते हैं।

फंक्शन कॉल करना कई दूसरी भाषाओं जैसा ही है:

squareit(3)
#> [1] 9

आगे के कॉन्सेप्ट में हम देखेंगे कि नतीजा 9 वास्तव में एक स्केलर संख्या नहीं, बल्कि लंबाई 1 वाला वेक्टर है। इसीलिए यह बताने के लिए [1] लिखा जाता है कि यह वेक्टर की शुरुआत है।

is.vector(9)
#> [1] TRUE

R में ज़्यादातर चीज़ें किसी न किसी तरह का वेक्टर होती हैं!

> squareit(3)
[1] 9