अगर R में ऑब्जेक्ट (वेरिएबल) को परिभाषित किया गया है, तो कैसे जांचें?

Question

अगर कोई चर R में परिभाषित किया गया है, तो बिना त्रुटि प्राप्त किए, मैं जांचना चाहता हूं। मैं यह कैसे कर सकता हूँ?

मेरे प्रयास (सफल नहीं):

> is.na(ooxx)
Error: object 'ooxx' not found
> is.finite(ooxx)
Error: object 'ooxx' not found

धन्यवाद!

Answer 1

आप चाहते हैं exists():

R> exists("somethingUnknown")
[1] FALSE
R> somethingUnknown <- 42
R> exists("somethingUnknown")
[1] TRUE
R> 

Comments

@ गेविन एंड डिर्क, आप एक-दूसरे के लिए बहुत अच्छे हैं :) केवल समाधान यह है कि आप सिक्के को टॉस करें (बर्नौली पी = 0.5 :-)) जिसे स्वीकार किया जाएगा! :-)

— TMS

@ अगर आप किसी फंक्शन के अंदर हैं, तो मिसिंग () वही है जो आप चाहते हैं।

— चचेरे भाई की उम्र

सूची तत्वों की जाँच करने पर थोड़ा पेचीदा हो सकता है: stackoverflow.com/q/7719741

— TMS

के बारे में क्या op चाहता था - चर नाम का उपयोग करते हुए, उद्धरणों में नहीं?

— टिम

Answer 2

देखें ?exists, "... परिभाषित है" की कुछ परिभाषा के लिए। उदाहरण के लिए

> exists("foo")
[1] FALSE
> foo <- 1:10
> exists("foo")
[1] TRUE

Comments

आप 52 सेकंड से जीतते हैं :)

— डिर्क एडल्डबुलेटेल

@DirkEddelbuettel ठीक है, यदि आप हास्यास्पद रूप से लंबे ऑब्जेक्ट नाम का उपयोग करेंगे; ;-)

— गाविन सिम्पसन

हे। मुझे हर समय होता है जब मैं पोस्टिंग से पहले उदाहरणों का परीक्षण कर रहा हूं, गेविन या जोश ने पहले ही इसका जवाब दिया है।

— मयासुर

Answer 3

यदि आप किसी फ़ंक्शन के अंदर हैं, तो गायब है () वही है जो आप चाहते हैं।

exchequer = function(x) {
    if(missing(x)){
        message("x is missing… :-(")
    }
}

exchequer()
x is missing… :-(

Comments

missingहालांकि, केवल फ़ंक्शन तर्कों के लिए काम करता है। आप कर सकते हैं foo <- function(x) {missing(x); missing(y)}या आप नहीं मिलेगा foo(1) > Error in missing(y) : 'missing' can only be used for arguments।

— दनिद

Answer 4

जैसा कि दूसरों ने बताया है, आप ढूंढ रहे हैं exists। ध्यान रखें कि existsR के आधार पैकेजों द्वारा उपयोग किए जाने वाले नामों के साथ प्रयोग करना सही होगा, भले ही आपने चर को परिभाषित किया हो:

> exists("data")
[1] TRUE

इसके आसपास जाने के लिए (जैसा कि बज़ द्वारा बताया गया है; देखें ?exists), inheritsतर्क का उपयोग करें :

> exists("data", inherits = FALSE)
[1] FALSE

foo <- TRUE
> exists("foo", inherits = FALSE)
[1] TRUE

बेशक, यदि आप संलग्न पैकेजों के नाम स्थान की खोज करना चाहते हैं, तो यह भी कम होगा:

> exists("data.table")
[1] FALSE
require(data.table)
> exists("data.table", inherits = FALSE)
[1] FALSE
> exists("data.table")
[1] TRUE

केवल एक चीज जो मैं इसके आसपास पाने के लिए सोच सकता हूं - संलग्न पैकेजों में खोज करने के लिए लेकिन आधार पैकेजों में नहीं - निम्नलिखित है:

any(sapply(1:(which(search() == "tools:rstudio") - 1L),
           function(pp) exists(_object_name_, where = pp, inherits = FALSE)))

( ) बनाम ( ) के _object_name_साथ की तुलना करें"data.table"TRUE"var"FALSE

(बेशक, अगर आप RStudio पर नहीं हैं, तो मुझे लगता है कि पहला स्वचालित रूप से संलग्न वातावरण है "package:stats")

Comments

चारों ओर खेलना, तर्क का उपयोग inherits = FALSEकरना वैश्विक वातावरण में चीजों को अलग करना प्रतीत होता है। क्या यह सही है?

— CJB

@ उज्ज्वल आप सही हैं; मैंने इसे उत्तर में संपादित किया है।

— माइकलक्रिको

यह टिप्पणी उच्चतर होनी चाहिए, क्योंकि मैं चर नाम "डेटा" का उपयोग करता हूं, बस मौजूद का उपयोग करने से मुझे शुरू में कुछ परेशानी हुई।

— mzm

Answer 5

यदि आप उद्धरण का उपयोग नहीं करना चाहते हैं, तो आप उस deparse(substitute())ट्रिक का उपयोग कर सकते हैं जो मैंने उदाहरण अनुभाग में पाया था ?substitute:

is.defined <- function(sym) {
  sym <- deparse(substitute(sym))
  env <- parent.frame()
  exists(sym, env)
}

is.defined(a)
# FALSE
a <- 10
is.defined(a)
# TRUE

Comments

आप forceइसे इस तरह से कार्य कर सकते हैं या इसका मूल्यांकन कर सकते हैं :is.defined <- function(sym) class(try(sym, TRUE))!='try-error'

— chinsoon12

Answer 6

ऐसी परिस्थितियां हो सकती हैं जिनमें आप उस चर का नाम नहीं जानते, जिसे आप खोज रहे हैं, जैसे जब एक कतार प्रणाली द्वारा परिणामों का एक सरणी बनाया गया हो। इन्हें संभवतः "एलएस" और इसके तर्क "पैटर्न" के साथ संबोधित किया जा सकता है जो एक नियमित अभिव्यक्ति की अपेक्षा करता है।

"मौजूद" फ़ंक्शन को इस तरह से फिर से लागू किया जा सकता है

exists <-function(variablename) {
   #print(ls(env=globalenv()))
   return(1==length(ls(pattern=paste("^",variablename,"$",sep=""),env=globalenv())))
}

इस उत्तर को तैयार करते समय, मैं एक फ़ंक्शन के भीतर से ls () को लागू करते समय पर्यावरण के विनिर्देश की आवश्यकता के बारे में थोड़ा आश्चर्यचकित था । तो, इसके लिए धन्यवाद, स्टैकओवरफ़्लो! एक "all.names" विशेषता भी है जिसे मुझे सही पर सेट करना चाहिए लेकिन छोड़ दिया गया है।