डॉलर ऑपरेटर के रूप में उम्मीद

Question

काम नहीं कर रहा है निम्न सूची

test_list=list(list(a=1,b=2),list(a=3,b=4)) 

है और मैं के साथ इस सूची तत्व नाम a सभी तत्वों को निकालने के लिए चाहते हैं।

मैं के माध्यम से

sapply(test_list,`[[`,"a") 

जो मुझे सही परिणाम

#[1] 1 3 

देता है जब मैं रुपये डॉलर ऑपरेटर $ के साथ एक ही कोशिश कर सकते हैं, मैं NULL

sapply(test_list,`$`,"a") 
#[[1]] 
#NULL 
# 
#[[2]] 
#NULL 

हालांकि, अगर मैं इसेके एक तत्व पर उपयोग करता हूंयह अपेक्षित

`$`(test_list[[1]],"a") 
#[1] 1 

क्या मुझे यहां कुछ स्पष्ट याद आ रही है?

Answer 1

जो मैं यह निर्धारित करने में सक्षम हूं कि यह दो चीजों का संयोजन है।

पहला, the second element of $ is matched but not evaluated so it cannot be a variable।

दूसरा, जब कार्यों को तर्क पारित किया जाता है तो उन्हें फ़ंक्शन कॉल में संबंधित चर के लिए असाइन किया जाता है। sapply"a" को एक चर के लिए असाइन किया गया है और इसलिए $ के साथ काम नहीं करेगा। हम होने वाली द्वारा यह देख सकते

sapply("a", print) 
[1] "a" 
    a 
"a" 

चलाकर यह इस

sapply(test_list, function(x, a) {`$`(x, a)}) 
[1] 1 3 

कहाँ a के बावजूद किया जा रहा है एक चर (जो भी सौंपा नहीं किया गया है) $ के मैचों ऐसा अजीब परिणाम मिल सकते हैं सूची में तत्वों के नाम।

Answer 2

मूल्यांकन बनाम कोई भी

[[ अपने तर्क का मूल्यांकन करता है, जबकि $ नहीं करता है। L[[a]]L का घटक प्राप्त करता है जिसका नाम चर a पर आयोजित किया गया है। $ सिर्फ तर्क नाम को एक वर्ण स्ट्रिंग के रूप में पास करता है, इसलिए L$aL का घटक पाता है। a को घटक नाम धारण करने वाले चर के रूप में नहीं माना जाता है - केवल एक वर्ण स्ट्रिंग।

L[[b]] नीचे L के घटक "a" नामित रिटर्न क्योंकि चर b मूल्य "a"L$b जबकि रिटर्न L की componet "b" नामित है, क्योंकि है कि वाक्य रचना के साथ b एक चर के रूप में नहीं है, लेकिन एक चरित्र स्ट्रिंग के रूप में माना जाता है खुद को जो पारित कर दिया गया है।

L <- list(a = 1, b = 2) 
b <- "a" 
L[[b]] # same as L[["a"]] since b holds a 
## [1] 1 
L$b # same as L[["b"]] since b is regarded as a character string to be passed 
## [1] 2 

sapply

अब हम मुख्य अंतर यह $ bewteen को समझते हैं और [[देखने के लिए साथ sapply इस उदाहरण पर विचार चल रहा है कि। हम एक "foo" वस्तु में test_list के प्रत्येक तत्व बना दिया है और हमारे अपने $.foo और [[.foo तरीकों परिभाषित जो केवल दिखाने के क्या आर name तर्क के माध्यम से विधि के लिए गुजर रहा है है:

foo_list <- test_list 
class(foo_list[[1]]) <- class(foo_list[[2]]) <- "foo" 

"$.foo" <- "[[.foo" <- function(x, name) print(name) 

result <- sapply(foo_list, "$", "a") 
## "..." 
## "..." 

result2 <- sapply(foo_list, "[[", "a")  
## [1] "a" 
## [1] "a" 

क्या पहले मामले में हो रहा है वह यह है कि sapplywhatever$... और ... पर कॉल किया जा रहा है, इसलिए इसका मूल्यांकन नहीं किया गया है, इसलिए यह एक सूची घटक की तलाश करेगा जिसे शाब्दिक रूप से "..." नाम दिया गया है और, ज़ाहिर है, ऐसा कोई घटक नहीं है इसलिए whatever$... न्यूल है इसलिए सवाल में आउटपुट में दिखाए गए एनयूएलएल हैं। दूसरे मामले में whatever[[[...]]whatever[["a"]] का मूल्यांकन किया गया है इसलिए मनाया गया परिणाम।