blocks|key|465733|text|您需要使用get来获取对象的值，而不是使用ls返回的字符名称|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|465734|x+<-+1L
typeof(ls())
[1]+"character"
typeof(get(ls()))
[1]+"integer"|code-block|syntax|javascript|465735|或者，对于出现的问题，您可能希望使用eapply|465736|eapply(.GlobalEnv,typeof)
$x
[1]+"integer"

$a
[1]+"double"

$b
[1]+"character"

$c
[1]+"list"|465737|entityMap^0|5|3|L|2|0|0|I|6|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

<p>You need to use <code>get</code> to obtain the value rather than the character name of the object as returned by <code>ls</code>:</p>

<pre><code>x &lt;- 1L
typeof(ls())
[1] "character"
typeof(get(ls()))
[1] "integer"
</code></pre>

<p>Alternatively, for the problem as presented you might want to use <code>eapply</code>:</p>

<pre><code>eapply(.GlobalEnv,typeof)
$x
[1] "integer"

$a
[1] "double"

$b
[1] "character"

$c
[1] "list"
</code></pre>


blocks|key|249271|text|这是我的工具包玩具之一，它的设计本质上与你想要的相反：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|249272|+lstype<-function(type='closure'){
inlist<-ls(.GlobalEnv)
if+(type=='function')+type+<-'closure'
typelist<-sapply(sapply(inlist,get),typeof)
return(names(typelist[typelist==type]))
}|code-block|syntax|javascript|249273|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Designed to do essentially the inverse of what you wanted, here's one of my toolkit toys: </p>

<pre><code> lstype&lt;-function(type='closure'){
inlist&lt;-ls(.GlobalEnv)
if (type=='function') type &lt;-'closure'
typelist&lt;-sapply(sapply(inlist,get),typeof)
return(names(typelist[typelist==type]))
}
</code></pre>


blocks|key|249295|text|您可以使用class(x)来检查变量类型。如果要求检查数据帧的所有变量类型，则可以使用sapply(x，class)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|249296|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

<p>You can use class(x) to check the variable type. If requirement is to check all variables type of a data frame then sapply(x, class) can be used.</p>


blocks|key|465860|text|R/r脚本没有具体的数据类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|465861|R解释器有一个鸭子类型的内存分配系统。没有内置的方法来告诉你你的内存指针的数据类型。鸭子类型是为了提高速度而做的，但事实证明这不是一个好主意，因为now语句如：print(is.integer(5))返回FALSE，is.integer(as.integer(5))返回TRUE。去想一想。|offset|length|style|CODE|465862|基本类型R手册：https://cran.r-project.org/doc/manuals/R-lang.html#Basic-types|465863|最好是编写自己的函数来探测指向内存的指针，然后使用消除过程来决定它是否适合您的需要。|465864|如果您的变量是全局变量或对象变量：|465865|你需要先用get(...)穿透你的object()，然后才能看到里面。示例：|465866|a+<-+10
myGlobals+<-+objects()
for(i+in+myGlobals){
++typeof(i)+++++++++#prints+character
++typeof(get(i))++++#prints+integer
}|code-block|syntax|javascript|465867|typeof(...)探测指向内存的变量指针：|465868|例如，R+function+typeof偏向于给出最大深度的文字。|465869|library(tibble)

#expression++++++++++++++notes++++++++++++++++++++++++++++++++++type
#-----------------------+--------------------------------------+----------
typeof(TRUE)+++++++++++++#a+single+boolean:+++++++++++++++++++++logical
typeof(1L)+++++++++++++++#a+single+numeric+with+L+postfixed:++++integer
typeof("foobar")+++++++++#A+single+string+in+double+quotes:+++++character
typeof(1)++++++++++++++++#a+single+numeric:+++++++++++++++++++++double
typeof(list(5,6,7))++++++#a+list+of+numeric:++++++++++++++++++++list
typeof(2i)+++++++++++++++#an+imaginary+number+++++++++++++++++++complex

typeof(5+%2B+5L)+++++++++++#double+%2B+integer+is+coerced:++++++++++double
typeof(c())++++++++++++++#an+empty+vector+has+no+type:++++++++++NULL
typeof(!5)+++++++++++++++#a+bang+before+a+double:+++++++++++++++logical
typeof(Inf)++++++++++++++#infinity+has+a+type:++++++++++++++++++double
typeof(c(5,6,7))+++++++++#a+vector+containing+only+doubles:+++++double
typeof(c(c(TRUE)))+++++++#a+vector+of+vector+of+logicals:+++++++logical
typeof(matrix(1:10))+++++#a+matrix+of+doubles+has+a+type:+++++++list

typeof(substr("abc",2,2))#a+string+at+index+2+which+is+'b'+is:++character
typeof(c(5L,6L,7L))++++++#a+vector+containing+only+integers:++++integer
typeof(c(NA,NA,NA))++++++#a+vector+containing+only+NA:++++++++++logical
typeof(data.frame())+++++#a+data.frame+with+nothing+in+it:++++++list
typeof(data.frame(c(3)))+#a+data.frame+with+a+double+in+it:+++++list
typeof(c("foobar"))++++++#a+vector+containing+only+strings:+++++character
typeof(pi)+++++++++++++++#builtin+expression+for+pi:++++++++++++double

typeof(1.66)+++++++++++++#a+single+numeric+with+mantissa:+++++++double
typeof(1.66L)++++++++++++#a+double+with+L+postfixed+++++++++++++double
typeof(c("foobar"))++++++#a+vector+containing+only+strings:+++++character
typeof(c(5L,+6L))++++++++#a+vector+containing+only+integers:++++integer
typeof(c(1.5,+2.5))++++++#a+vector+containing+only+doubles:+++++double
typeof(c(1.5,+2.5))++++++#a+vector+containing+only+doubles:+++++double
typeof(c(TRUE,+FALSE))+++#a+vector+containing+only+logicals:++++logical

typeof(factor())+++++++++#an+empty+factor+has+default+type:+++++integer
typeof(factor(3.14))+++++#a+factor+containing+doubles:++++++++++integer
typeof(factor(T,+F))+++++#a+factor+containing+logicals:+++++++++integer
typeof(Sys.Date())+++++++#builtin+R+dates:++++++++++++++++++++++double
typeof(hms::hms(3600))+++#hour+minute+second+timestamp++++++++++double
typeof(c(T,+F))++++++++++#T+and+F+are+builtins:+++++++++++++++++logical
typeof(1:10)+++++++++++++#a+builtin+sequence+of+numerics:+++++++integer
typeof(NA)+++++++++++++++#The+builtin+value+not+available:++++++logical

typeof(c(list(T)))+++++++#a+vector+of+lists+of+logical:+++++++++list
typeof(list(c(T)))+++++++#a+list+of+vectors+of+logical:+++++++++list
typeof(c(T,+3.14))+++++++#a+vector+of+logicals+and+doubles:+++++double
typeof(c(3.14,+"foo"))+++#a+vector+of+doubles+and+characters:+++character
typeof(c("foo",list(T)))+#a+vector+of+strings+and+lists:++++++++list
typeof(list("foo",c(T)))+#a+list+of+strings+and+vectors:++++++++list
typeof(TRUE+%2B+5L)++++++++#a+logical+plus+an+integer:++++++++++++integer
typeof(c(TRUE,+5L)[1])+++#The+true+is+coerced+to+1++++++++++++++integer
typeof(c(c(2i),+TRUE)[1])#logical+coerced+to+complex:+++++++++++complex
typeof(c(NaN,+'batman'))+#NaN's+in+a+vector+don't+dominate:+++++character
typeof(5+&&+4)+++++++++++#doubles+are+coerced+by+order+of+&&++++logical
typeof(8+<+'foobar')+++++#string+and+double+is+coerced++++++++++logical
typeof(list(4,+T)[[1]])++#a+list+retains+type+at+every+index:+++double
typeof(list(4,+T)[[2]])++#a+list+retains+type+at+every+index:+++logical
typeof(2+**+5)+++++++++++#result+of+exponentiation++++++++++++++double
typeof(0E0)++++++++++++++#exponential+lol+notation++++++++++++++double
typeof(0x3fade)++++++++++#hexidecimal+++++++++++++++++++++++++++double
typeof(paste(3,+'3'))++++#paste+promotes+types+to+string++++++++character
typeof(3+%2B+四)+++++++++++#R+pukes+on+unicode++++++++++++++++++++error
typeof(iconv("a",+"latin1",+"UTF-8"))+#UTF-8+characters+++++++++character
typeof(5+==+5)+++++++++++#result+of+a+comparison:+++++++++++++++logical|465870|类(...)探测指向内存的变量指针：|465871|例如，R+function+class偏向于给出封装类型的容器或结构的类型。|465872|library(tibble)

#expression++++++++++++notes++++++++++++++++++++++++++++++++++++class
#---------------------+----------------------------------------+---------
class(matrix(1:10))+++++#a+matrix+of+doubles+has+a+class:+++++++matrix
class(factor("hi"))+++++#factor+of+items+is:++++++++++++++++++++factor
class(TRUE)+++++++++++++#a+single+boolean:++++++++++++++++++++++logical
class(1L)+++++++++++++++#a+single+numeric+with+L+postfixed:+++++integer
class("foobar")+++++++++#A+single+string+in+double+quotes:++++++character
class(1)++++++++++++++++#a+single+numeric:++++++++++++++++++++++numeric
class(list(5,6,7))++++++#a+list+of+numeric:+++++++++++++++++++++list
class(2i)+++++++++++++++#an+imaginary+++++++++++++++++++++++++++complex
class(data.frame())+++++#a+data.frame+with+nothing+in+it:+++++++data.frame
class(Sys.Date())+++++++#builtin+R+dates:+++++++++++++++++++++++Date
class(sapply)+++++++++++#a+function+is++++++++++++++++++++++++++function
class(charToRaw("hi"))++#convert+string+to+raw:+++++++++++++++++raw
class(array("hi"))++++++#array+of+items+is:+++++++++++++++++++++array

class(5+%2B+5L)+++++++++++#double+%2B+integer+is+coerced:++++++++++numeric
class(c())++++++++++++++#an+empty+vector+has+no+class:+++++++++NULL
class(!5)+++++++++++++++#a+bang+before+a+double:+++++++++++++++logical
class(Inf)++++++++++++++#infinity+has+a+class:+++++++++++++++++numeric
class(c(5,6,7))+++++++++#a+vector+containing+only+doubles:+++++numeric
class(c(c(TRUE)))+++++++#a+vector+of+vector+of+logicals:+++++++logical

class(substr("abc",2,2))#a+string+at+index+2+which+is+'b'+is:++character
class(c(5L,6L,7L))++++++#a+vector+containing+only+integers:++++integer
class(c(NA,NA,NA))++++++#a+vector+containing+only+NA:++++++++++logical
class(data.frame(c(3)))+#a+data.frame+with+a+double+in+it:+++++data.frame
class(c("foobar"))++++++#a+vector+containing+only+strings:+++++character
class(pi)+++++++++++++++#builtin+expression+for+pi:++++++++++++numeric

class(1.66)+++++++++++++#a+single+numeric+with+mantissa:+++++++numeric
class(1.66L)++++++++++++#a+double+with+L+postfixed+++++++++++++numeric
class(c("foobar"))++++++#a+vector+containing+only+strings:+++++character
class(c(5L,+6L))++++++++#a+vector+containing+only+integers:++++integer
class(c(1.5,+2.5))++++++#a+vector+containing+only+doubles:+++++numeric
class(c(TRUE,+FALSE))+++#a+vector+containing+only+logicals:++++logical

class(factor())+++++++#an+empty+factor+has+default+class:++++++factor
class(factor(3.14))+++#a+factor+containing+doubles:++++++++++++factor
class(factor(T,+F))+++#a+factor+containing+logicals:+++++++++++factor
class(hms::hms(3600))+#hour+minute+second+timestamp++++++++++++hms+difftime
class(c(T,+F))++++++++#T+and+F+are+builtins:+++++++++++++++++++logical
class(1:10)+++++++++++#a+builtin+sequence+of+numerics:+++++++++integer
class(NA)+++++++++++++#The+builtin+value+not+available:++++++++logical

class(c(list(T)))+++++++#a+vector+of+lists+of+logical:+++++++++list
class(list(c(T)))+++++++#a+list+of+vectors+of+logical:+++++++++list
class(c(T,+3.14))+++++++#a+vector+of+logicals+and+doubles:+++++numeric
class(c(3.14,+"foo"))+++#a+vector+of+doubles+and+characters:+++character
class(c("foo",list(T)))+#a+vector+of+strings+and+lists:++++++++list
class(list("foo",c(T)))+#a+list+of+strings+and+vectors:++++++++list
class(TRUE+%2B+5L)++++++++#a+logical+plus+an+integer:++++++++++++integer
class(c(TRUE,+5L)[1])+++#The+true+is+coerced+to+1++++++++++++++integer
class(c(c(2i),+TRUE)[1])#logical+coerced+to+complex:+++++++++++complex
class(c(NaN,+'batman'))+#NaN's+in+a+vector+don't+dominate:+++++character
class(5+&&+4)+++++++++++#doubles+are+coerced+by+order+of+&&++++logical
class(8+<+'foobar')+++++#string+and+double+is+coerced++++++++++logical
class(list(4,+T)[[1]])++#a+list+retains+class+at+every+index:++numeric
class(list(4,+T)[[2]])++#a+list+retains+class+at+every+index:++logical
class(2+**+5)+++++++++++#result+of+exponentiation++++++++++++++numeric
class(0E0)++++++++++++++#exponential+lol+notation++++++++++++++numeric
class(0x3fade)++++++++++#hexidecimal+++++++++++++++++++++++++++numeric
class(paste(3,+'3'))+++++#paste+promotes+class+to+string+++++++character
class(3+%2B+四)+++++++++++#R+pukes+on+unicode+++++++++++++++++++error
class(iconv("a",+"latin1",+"UTF-8"))+#UTF-8+characters+++++++++character
class(5+==+5)+++++++++++#result+of+a+comparison:+++++++++++++++logical|465873|获取变量的数据storage.mode：|465874|当R变量被写入磁盘时，数据布局再次改变，并被称为data's+storage.mode。函数storage.mode(...)揭示了以下低级信息:请参阅Mode,+Class,+and+Type+of+R+objects。您不应该担心R的storage.mode，除非您正在尝试理解在向磁盘分配数据和从磁盘读取数据时发生的往返强制转换/强制导致的延迟。|465875|演示:R/R脚本gettype(your_variable)|465876|运行这段R代码，然后根据您的目的调整它，它会很好地猜测它是什么类型。|465877|get_type+<-+function(variable){+
++sz+<-+as.integer(length(variable))+#length+of+your+variable+
++tof+<-+typeof(variable)++++++++++++#typeof+your+variable+
++cls+<-+class(variable)+++++++++++++#class+of+your+variable+
++isc+<-+is.character(variable)++++++#what+is.character()+has+to+say+about+it.++
++d+<-+dim(variable)+++++++++++++++++#dimensions+of+your+variable+
++isv+<-+is.vector(variable)+
++if+(is.matrix(variable)){++
++++d+<-+dim(t(variable))+++++++++++++#dimensions+of+your+matrix
++}++++
++#observations+---->+datatype+
++if+(sz>=1+&&+tof+==+"logical"+&&+cls+==+"logical"+&&+isv+==+TRUE){+return("vector+of+logical")+}+
++if+(sz>=1+&&+tof+==+"integer"+&&+cls+==+"integer"+){+return("vector+of+integer")+}+
++if+(sz==1+&&+tof+==+"double"++&&+cls+==+"Date"+){+return("Date")+}+
++if+(sz>=1+&&+tof+==+"raw"+++++&&+cls+==+"raw"+){+return("vector+of+raw")+}+
++if+(sz>=1+&&+tof+==+"double"++&&+cls+==+"numeric"+){+return("vector+of+double")+}+
++if+(sz>=1+&&+tof+==+"double"++&&+cls+==+"array"+){+return("vector+of+array+of+double")+}+
++if+(sz>=1+&&+tof+==+"character"++&&+cls+==+"array"+){+return("vector+of+array+of+character")+}+
++if+(sz>=0+&&+tof+==+"list"+++++++&&+cls+==+"data.frame"+){+return("data.frame")+}+
++if+(sz>=1+&&+isc+==+TRUE+++++++++&&+isv+==+TRUE){+return("vector+of+character")+}+
++if+(sz>=1+&&+tof+==+"complex"++++&&+cls+==+"complex"+){+return("vector+of+complex")+}+
++if+(sz==0+&&+tof+==+"NULL"+++++++&&+cls+==+"NULL"+){+return("NULL")+}+
++if+(sz>=0+&&+tof+==+"integer"++++&&+cls+==+"factor"+){+return("factor")+}+
++if+(sz>=1+&&+tof+==+"double"+++++&&+cls+==+"numeric"+&&+isv+==+TRUE){+return("vector+of+double")+}+
++if+(sz>=1+&&+tof+==+"double"+++++&&+cls+==+"matrix"){+return("matrix+of+double")+}+
++if+(sz>=1+&&+tof+==+"character"++&&+cls+==+"matrix"){+return("matrix+of+character")+}+
++if+(sz>=1+&&+tof+==+"list"+++++++&&+cls+==+"list"+&&+isv+==+TRUE){+return("vector+of+list")+}+
++if+(sz>=1+&&+tof+==+"closure"++++&&+cls+==+"function"+&&+isv+==+FALSE){+return("closure/function")+}+
++return("it's+pointer+to+memory,+bruh")+
}+
assert+<-+function(a,+b){+
++if+(a+==+b){+
++++cat("P")+
++}+
++else{+
++++cat("\nFAIL!!!++Sniff+test:\n")+
++++sz+<-+as.integer(length(variable))+++#length+of+your+variable+
++++tof+<-+typeof(variable)++++++++++++++#typeof+your+variable+
++++cls+<-+class(variable)+++++++++++++++#class+of+your+variable+
++++isc+<-+is.character(variable)++++++++#what+is.character()+has+to+say+about+it.+
++++d+<-+dim(variable)+++++++++++++++++++#dimensions+of+your+variable+
++++isv+<-+is.vector(variable)+
++++if+(is.matrix(variable)){++
++++++d+<-+dim(t(variable))+++++++++++++++++++#dimensions+of+your+variable+
++++}+
++++if+(!is.function(variable)){+
++++++print(paste("value:+'",+variable,+"'"))+
++++}+
++++print(paste("get_type+said:+'",+a,+"'"))+
++++print(paste("supposed+to+be:+'",+b,+"'"))+
+
++++cat("\nYour+pointer+to+memory+has+properties:\n")++
++++print(paste("sz:+'",+sz,+"'"))+
++++print(paste("tof:+'",+tof,+"'"))+
++++print(paste("cls:+'",+cls,+"'"))+
++++print(paste("d:+'",+d,+"'"))+
++++print(paste("isc:+'",+isc,+"'"))+
++++print(paste("isv:+'",+isv,+"'"))+
++++quit()+
++}+
}
#these+asserts+give+a+sample+for+exercising+the+code.+
assert(get_type(TRUE),++++++"vector+of+logical")++#everything+is+a+vector+in+R+by+default.+
assert(get_type(c(TRUE)),+++"vector+of+logical")++#c()+just+casts+to+vector+
assert(get_type(c(c(TRUE))),"vector+of+logical")++#casting+vector+multiple+times+does+nothing+
assert(get_type(!5),++++++++"vector+of+logical")++#bang+inflicts+'not+truth-like'+
assert(get_type(1L),++++++++++++++"vector+of+integer")+++#naked+integers+are+still+vectors+of+1+
assert(get_type(c(1L,+2L)),+++++++"vector+of+integer")+++#Longs+are+not+doubles+
assert(get_type(c(1L,+c(2L,+3L))),"vector+of+integer")+++#nested+vectors+of+integers+
assert(get_type(c(1L,+c(TRUE))),++"vector+of+integer")+++#logicals+coerced+to+integer+
assert(get_type(c(FALSE,+c(1L))),+"vector+of+integer")+++#logicals+coerced+to+integer+
assert(get_type("foobar"),++++++++"vector+of+character")++++#character+here+means+'string'+
assert(get_type(c(1L,+"foobar")),+"vector+of+character")++++#integers+are+coerced+to+string+
assert(get_type(5),+++++++++++"vector+of+double")+
assert(get_type(5+%2B+5L),++++++"vector+of+double")+
assert(get_type(Inf),+++++++++"vector+of+double")+
assert(get_type(c(5,6,7)),++++"vector+of+double")+
assert(get_type(NaN),+++++++++++"vector+of+double")+
assert(get_type(list(5)),+++++++"vector+of+list")++++#your+list+is+in+a+vector.+
assert(get_type(list(5,6,7)),+++"vector+of+list")+
assert(get_type(c(list(5,6,7))),"vector+of+list")+
assert(get_type(list(c(5,6),T)),"vector+of+list")++++#vector+of+list+of+vector+and+logical+
assert(get_type(list(5,6,7)),+++"vector+of+list")+
assert(get_type(2i),++++++++++++"vector+of+complex")+
assert(get_type(c(2i,+3i,+4i)),+"vector+of+complex")+
assert(get_type(c()),++++++++++++"NULL")+
assert(get_type(data.frame()),+++"data.frame")+
assert(get_type(data.frame(4,5)),"data.frame")+
assert(get_type(Sys.Date()),+++++"Date")+
assert(get_type(sapply),+++++++++"closure/function")+
assert(get_type(charToRaw("hi")),"vector+of+raw")+
assert(get_type(c(charToRaw("a"),+charToRaw("b"))),+"vector+of+raw")+
assert(get_type(array(4)),+++++++"vector+of+array+of+double")+
assert(get_type(array(4,5)),+++++"vector+of+array+of+double")+
assert(get_type(array("hi")),++++"vector+of+array+of+character")+
assert(get_type(factor()),+++++++"factor")+
assert(get_type(factor(3.14)),+++"factor")+
assert(get_type(factor(TRUE)),+++"factor")+
assert(get_type(matrix(3,4,5)),++"matrix+of+double")+
assert(get_type(as.matrix(5)),+++"matrix+of+double")+
assert(get_type(matrix("yatta")),"matrix+of+character")+|465878|我在这里加入了C%2B%2B/Java/Python的思想，它给了我一个独家新闻，让我知道内存是什么样的。R三合一打字系统就像试图把意大利面钉在墙上一样，<-和<<-会在你最不怀疑的时候把你的矩阵打包到一个列表中。正如老鸭打字所说:如果它像鸭子一样摇摇晃晃，如果它像鸭子一样叫，如果它有羽毛，那么它就是一只鸭子。|465879|entityMap|0|LINK|mutability|MUTABLE|url|https://cran.r-project.org/doc/manuals/R-lang.html#Basic-types|1|https://cran.r-project.org/doc/manuals/R-lang.html#index-typeof|2|https://stat.ethz.ch/R-manual/R-devel/library/base/html/class.html|3|https://stat.ethz.ch/R-manual/R-devel/library/base/html/mode.html|4|https://stats.stackexchange.com/questions/3212/mode-class-and-type-of-r-objects^0|0|28|K|30|P|0|8|1Q|0|0|0|0|5|8|H|8|0|0|0|E|6|5|F|1|0|0|0|E|5|5|E|2|0|0|7|C|0|V|C|1A|H|O|J|3|24|Y|4|0|8|M|0|0|0|21|2|24|3|0^^$0|@$1|2|3|4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Z|8|@$D|20|E|21|F|G]|$D|22|E|23|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|24|8|@]|9|@$D|25|E|26|1|27]]|A|$]]|$1|J|3|K|5|6|7|28|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|29|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|2A|8|@$D|2B|E|2C|F|G]|$D|2D|E|2E|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|R|7|2F|8|@]|9|@]|A|$S|T]]|$1|U|3|V|5|6|7|2G|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2H|8|@$D|2I|E|2J|F|G]]|9|@$D|2K|E|2L|1|2M]]|A|$]]|$1|Y|3|Z|5|R|7|2N|8|@]|9|@]|A|$S|T]]|$1|10|3|11|5|6|7|2O|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2P|8|@$D|2Q|E|2R|F|G]]|9|@$D|2S|E|2T|1|2U]]|A|$]]|$1|14|3|15|5|R|7|2V|8|@]|9|@]|A|$S|T]]|$1|16|3|17|5|6|7|2W|8|@$D|2X|E|2Y|F|G]]|9|@]|A|$]]|$1|18|3|19|5|6|7|2Z|8|@$D|30|E|31|F|G]|$D|32|E|33|F|G]]|9|@$D|34|E|35|1|36]|$D|37|E|38|1|39]]|A|$]]|$1|1A|3|1B|5|6|7|3A|8|@$D|3B|E|3C|F|G]]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|3D|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|R|7|3E|8|@]|9|@]|A|$S|T]]|$1|1G|3|1H|5|6|7|3F|8|@$D|3G|E|3H|F|G]|$D|3I|E|3J|F|G]]|9|@]|A|$]]|$1|1I|3|-4|5|6|7|3K|8|@]|9|@]|A|$]]]|1J|$1K|$5|1L|1M|1N|A|$1O|1P]]|1Q|$5|1L|1M|1N|A|$1O|1R]]|1S|$5|1L|1M|1N|A|$1O|1T]]|1U|$5|1L|1M|1N|A|$1O|1V]]|1W|$5|1L|1M|1N|A|$1O|1X]]]]

<h2>R/Rscript doesn't have concrete datatypes.</h2>
<p>R interpreter has a duck-typing memory allocation system.  There is no builtin method to tell you the datatype of your pointer to memory.  Duck typing is done for speed, but turned out to be a bad idea because now statements such as: <code>print(is.integer(5))</code> returns FALSE and <code>is.integer(as.integer(5))</code> returns TRUE.  Go figure.</p>
<p>The R-manual on basic types: <a href="https://cran.r-project.org/doc/manuals/R-lang.html#Basic-types" rel="nofollow noreferrer">https://cran.r-project.org/doc/manuals/R-lang.html#Basic-types</a></p>
<p>The best you can hope for is to write your own function to probe your pointer to memory, then use process of elimination to decide if it is suitable for your needs.</p>
<h2>If your variable is a global or an object:</h2>
<p>Your <code>object()</code> needs to be penetrated with <code>get(...)</code> before you can see inside.  Example:</p>
<pre><code>a &lt;- 10
myGlobals &lt;- objects()
for(i in myGlobals){
  typeof(i)         #prints character
  typeof(get(i))    #prints integer
}
</code></pre>
<h2>typeof(...) probes your variable pointer to memory:</h2>
<p>The R <a href="https://cran.r-project.org/doc/manuals/R-lang.html#index-typeof" rel="nofollow noreferrer">function <code>typeof</code></a> has a bias to give you the type at maximum depth, for example.</p>
<pre><code>library(tibble)

#expression              notes                                  type
#----------------------- -------------------------------------- ----------
typeof(TRUE)             #a single boolean:                     logical
typeof(1L)               #a single numeric with L postfixed:    integer
typeof(&quot;foobar&quot;)         #A single string in double quotes:     character
typeof(1)                #a single numeric:                     double
typeof(list(5,6,7))      #a list of numeric:                    list
typeof(2i)               #an imaginary number                   complex

typeof(5 + 5L)           #double + integer is coerced:          double
typeof(c())              #an empty vector has no type:          NULL
typeof(!5)               #a bang before a double:               logical
typeof(Inf)              #infinity has a type:                  double
typeof(c(5,6,7))         #a vector containing only doubles:     double
typeof(c(c(TRUE)))       #a vector of vector of logicals:       logical
typeof(matrix(1:10))     #a matrix of doubles has a type:       list

typeof(substr(&quot;abc&quot;,2,2))#a string at index 2 which is 'b' is:  character
typeof(c(5L,6L,7L))      #a vector containing only integers:    integer
typeof(c(NA,NA,NA))      #a vector containing only NA:          logical
typeof(data.frame())     #a data.frame with nothing in it:      list
typeof(data.frame(c(3))) #a data.frame with a double in it:     list
typeof(c(&quot;foobar&quot;))      #a vector containing only strings:     character
typeof(pi)               #builtin expression for pi:            double

typeof(1.66)             #a single numeric with mantissa:       double
typeof(1.66L)            #a double with L postfixed             double
typeof(c(&quot;foobar&quot;))      #a vector containing only strings:     character
typeof(c(5L, 6L))        #a vector containing only integers:    integer
typeof(c(1.5, 2.5))      #a vector containing only doubles:     double
typeof(c(1.5, 2.5))      #a vector containing only doubles:     double
typeof(c(TRUE, FALSE))   #a vector containing only logicals:    logical

typeof(factor())         #an empty factor has default type:     integer
typeof(factor(3.14))     #a factor containing doubles:          integer
typeof(factor(T, F))     #a factor containing logicals:         integer
typeof(Sys.Date())       #builtin R dates:                      double
typeof(hms::hms(3600))   #hour minute second timestamp          double
typeof(c(T, F))          #T and F are builtins:                 logical
typeof(1:10)             #a builtin sequence of numerics:       integer
typeof(NA)               #The builtin value not available:      logical

typeof(c(list(T)))       #a vector of lists of logical:         list
typeof(list(c(T)))       #a list of vectors of logical:         list
typeof(c(T, 3.14))       #a vector of logicals and doubles:     double
typeof(c(3.14, &quot;foo&quot;))   #a vector of doubles and characters:   character
typeof(c(&quot;foo&quot;,list(T))) #a vector of strings and lists:        list
typeof(list(&quot;foo&quot;,c(T))) #a list of strings and vectors:        list
typeof(TRUE + 5L)        #a logical plus an integer:            integer
typeof(c(TRUE, 5L)[1])   #The true is coerced to 1              integer
typeof(c(c(2i), TRUE)[1])#logical coerced to complex:           complex
typeof(c(NaN, 'batman')) #NaN's in a vector don't dominate:     character
typeof(5 &amp;&amp; 4)           #doubles are coerced by order of &amp;&amp;    logical
typeof(8 &lt; 'foobar')     #string and double is coerced          logical
typeof(list(4, T)[[1]])  #a list retains type at every index:   double
typeof(list(4, T)[[2]])  #a list retains type at every index:   logical
typeof(2 ** 5)           #result of exponentiation              double
typeof(0E0)              #exponential lol notation              double
typeof(0x3fade)          #hexidecimal                           double
typeof(paste(3, '3'))    #paste promotes types to string        character
typeof(3 + 四)           #R pukes on unicode                    error
typeof(iconv(&quot;a&quot;, &quot;latin1&quot;, &quot;UTF-8&quot;)) #UTF-8 characters         character
typeof(5 == 5)           #result of a comparison:               logical
</code></pre>
<h2>class(...) probes your variable pointer to memory:</h2>
<p>The R <a href="https://stat.ethz.ch/R-manual/R-devel/library/base/html/class.html" rel="nofollow noreferrer">function <code>class</code></a> has a bias to give you the type of container or structure encapsulating your types, for example.</p>
<pre><code>library(tibble)

#expression            notes                                    class
#--------------------- ---------------------------------------- ---------
class(matrix(1:10))     #a matrix of doubles has a class:       matrix
class(factor(&quot;hi&quot;))     #factor of items is:                    factor
class(TRUE)             #a single boolean:                      logical
class(1L)               #a single numeric with L postfixed:     integer
class(&quot;foobar&quot;)         #A single string in double quotes:      character
class(1)                #a single numeric:                      numeric
class(list(5,6,7))      #a list of numeric:                     list
class(2i)               #an imaginary                           complex
class(data.frame())     #a data.frame with nothing in it:       data.frame
class(Sys.Date())       #builtin R dates:                       Date
class(sapply)           #a function is                          function
class(charToRaw(&quot;hi&quot;))  #convert string to raw:                 raw
class(array(&quot;hi&quot;))      #array of items is:                     array

class(5 + 5L)           #double + integer is coerced:          numeric
class(c())              #an empty vector has no class:         NULL
class(!5)               #a bang before a double:               logical
class(Inf)              #infinity has a class:                 numeric
class(c(5,6,7))         #a vector containing only doubles:     numeric
class(c(c(TRUE)))       #a vector of vector of logicals:       logical

class(substr(&quot;abc&quot;,2,2))#a string at index 2 which is 'b' is:  character
class(c(5L,6L,7L))      #a vector containing only integers:    integer
class(c(NA,NA,NA))      #a vector containing only NA:          logical
class(data.frame(c(3))) #a data.frame with a double in it:     data.frame
class(c(&quot;foobar&quot;))      #a vector containing only strings:     character
class(pi)               #builtin expression for pi:            numeric

class(1.66)             #a single numeric with mantissa:       numeric
class(1.66L)            #a double with L postfixed             numeric
class(c(&quot;foobar&quot;))      #a vector containing only strings:     character
class(c(5L, 6L))        #a vector containing only integers:    integer
class(c(1.5, 2.5))      #a vector containing only doubles:     numeric
class(c(TRUE, FALSE))   #a vector containing only logicals:    logical

class(factor())       #an empty factor has default class:      factor
class(factor(3.14))   #a factor containing doubles:            factor
class(factor(T, F))   #a factor containing logicals:           factor
class(hms::hms(3600)) #hour minute second timestamp            hms difftime
class(c(T, F))        #T and F are builtins:                   logical
class(1:10)           #a builtin sequence of numerics:         integer
class(NA)             #The builtin value not available:        logical

class(c(list(T)))       #a vector of lists of logical:         list
class(list(c(T)))       #a list of vectors of logical:         list
class(c(T, 3.14))       #a vector of logicals and doubles:     numeric
class(c(3.14, &quot;foo&quot;))   #a vector of doubles and characters:   character
class(c(&quot;foo&quot;,list(T))) #a vector of strings and lists:        list
class(list(&quot;foo&quot;,c(T))) #a list of strings and vectors:        list
class(TRUE + 5L)        #a logical plus an integer:            integer
class(c(TRUE, 5L)[1])   #The true is coerced to 1              integer
class(c(c(2i), TRUE)[1])#logical coerced to complex:           complex
class(c(NaN, 'batman')) #NaN's in a vector don't dominate:     character
class(5 &amp;&amp; 4)           #doubles are coerced by order of &amp;&amp;    logical
class(8 &lt; 'foobar')     #string and double is coerced          logical
class(list(4, T)[[1]])  #a list retains class at every index:  numeric
class(list(4, T)[[2]])  #a list retains class at every index:  logical
class(2 ** 5)           #result of exponentiation              numeric
class(0E0)              #exponential lol notation              numeric
class(0x3fade)          #hexidecimal                           numeric
class(paste(3, '3'))     #paste promotes class to string       character
class(3 + 四)           #R pukes on unicode                   error
class(iconv(&quot;a&quot;, &quot;latin1&quot;, &quot;UTF-8&quot;)) #UTF-8 characters         character
class(5 == 5)           #result of a comparison:               logical
</code></pre>
<h2>Get the data <code>storage.mode</code> of your variable:</h2>
<p>When an R variable is written to disk, the data layout changes again, and is called the <a href="https://stat.ethz.ch/R-manual/R-devel/library/base/html/mode.html" rel="nofollow noreferrer">data's <code>storage.mode</code></a>.  The function <code>storage.mode(...)</code> reveals this low level information: see <a href="https://stats.stackexchange.com/questions/3212/mode-class-and-type-of-r-objects">Mode, Class, and Type of R objects</a>. You shouldn't need to worry about R's storage.mode unless you are trying to understand delays caused by round trip casts/coercions that occur when assigning and reading data to and from disk.</p>
<h2>Demo: R/Rscript <code>gettype(your_variable)</code>:</h2>
<p>Run this R code then adapt it for your purposes, it'll make a pretty good guess as to what type it is.</p>
<pre><code>get_type &lt;- function(variable){ 
  sz &lt;- as.integer(length(variable)) #length of your variable 
  tof &lt;- typeof(variable)            #typeof your variable 
  cls &lt;- class(variable)             #class of your variable 
  isc &lt;- is.character(variable)      #what is.character() has to say about it.  
  d &lt;- dim(variable)                 #dimensions of your variable 
  isv &lt;- is.vector(variable) 
  if (is.matrix(variable)){  
    d &lt;- dim(t(variable))             #dimensions of your matrix
  }    
  #observations ----&gt; datatype 
  if (sz&gt;=1 &amp;&amp; tof == &quot;logical&quot; &amp;&amp; cls == &quot;logical&quot; &amp;&amp; isv == TRUE){ return(&quot;vector of logical&quot;) } 
  if (sz&gt;=1 &amp;&amp; tof == &quot;integer&quot; &amp;&amp; cls == &quot;integer&quot; ){ return(&quot;vector of integer&quot;) } 
  if (sz==1 &amp;&amp; tof == &quot;double&quot;  &amp;&amp; cls == &quot;Date&quot; ){ return(&quot;Date&quot;) } 
  if (sz&gt;=1 &amp;&amp; tof == &quot;raw&quot;     &amp;&amp; cls == &quot;raw&quot; ){ return(&quot;vector of raw&quot;) } 
  if (sz&gt;=1 &amp;&amp; tof == &quot;double&quot;  &amp;&amp; cls == &quot;numeric&quot; ){ return(&quot;vector of double&quot;) } 
  if (sz&gt;=1 &amp;&amp; tof == &quot;double&quot;  &amp;&amp; cls == &quot;array&quot; ){ return(&quot;vector of array of double&quot;) } 
  if (sz&gt;=1 &amp;&amp; tof == &quot;character&quot;  &amp;&amp; cls == &quot;array&quot; ){ return(&quot;vector of array of character&quot;) } 
  if (sz&gt;=0 &amp;&amp; tof == &quot;list&quot;       &amp;&amp; cls == &quot;data.frame&quot; ){ return(&quot;data.frame&quot;) } 
  if (sz&gt;=1 &amp;&amp; isc == TRUE         &amp;&amp; isv == TRUE){ return(&quot;vector of character&quot;) } 
  if (sz&gt;=1 &amp;&amp; tof == &quot;complex&quot;    &amp;&amp; cls == &quot;complex&quot; ){ return(&quot;vector of complex&quot;) } 
  if (sz==0 &amp;&amp; tof == &quot;NULL&quot;       &amp;&amp; cls == &quot;NULL&quot; ){ return(&quot;NULL&quot;) } 
  if (sz&gt;=0 &amp;&amp; tof == &quot;integer&quot;    &amp;&amp; cls == &quot;factor&quot; ){ return(&quot;factor&quot;) } 
  if (sz&gt;=1 &amp;&amp; tof == &quot;double&quot;     &amp;&amp; cls == &quot;numeric&quot; &amp;&amp; isv == TRUE){ return(&quot;vector of double&quot;) } 
  if (sz&gt;=1 &amp;&amp; tof == &quot;double&quot;     &amp;&amp; cls == &quot;matrix&quot;){ return(&quot;matrix of double&quot;) } 
  if (sz&gt;=1 &amp;&amp; tof == &quot;character&quot;  &amp;&amp; cls == &quot;matrix&quot;){ return(&quot;matrix of character&quot;) } 
  if (sz&gt;=1 &amp;&amp; tof == &quot;list&quot;       &amp;&amp; cls == &quot;list&quot; &amp;&amp; isv == TRUE){ return(&quot;vector of list&quot;) } 
  if (sz&gt;=1 &amp;&amp; tof == &quot;closure&quot;    &amp;&amp; cls == &quot;function&quot; &amp;&amp; isv == FALSE){ return(&quot;closure/function&quot;) } 
  return(&quot;it's pointer to memory, bruh&quot;) 
} 
assert &lt;- function(a, b){ 
  if (a == b){ 
    cat(&quot;P&quot;) 
  } 
  else{ 
    cat(&quot;\nFAIL!!!  Sniff test:\n&quot;) 
    sz &lt;- as.integer(length(variable))   #length of your variable 
    tof &lt;- typeof(variable)              #typeof your variable 
    cls &lt;- class(variable)               #class of your variable 
    isc &lt;- is.character(variable)        #what is.character() has to say about it. 
    d &lt;- dim(variable)                   #dimensions of your variable 
    isv &lt;- is.vector(variable) 
    if (is.matrix(variable)){  
      d &lt;- dim(t(variable))                   #dimensions of your variable 
    } 
    if (!is.function(variable)){ 
      print(paste(&quot;value: '&quot;, variable, &quot;'&quot;)) 
    } 
    print(paste(&quot;get_type said: '&quot;, a, &quot;'&quot;)) 
    print(paste(&quot;supposed to be: '&quot;, b, &quot;'&quot;)) 
 
    cat(&quot;\nYour pointer to memory has properties:\n&quot;)  
    print(paste(&quot;sz: '&quot;, sz, &quot;'&quot;)) 
    print(paste(&quot;tof: '&quot;, tof, &quot;'&quot;)) 
    print(paste(&quot;cls: '&quot;, cls, &quot;'&quot;)) 
    print(paste(&quot;d: '&quot;, d, &quot;'&quot;)) 
    print(paste(&quot;isc: '&quot;, isc, &quot;'&quot;)) 
    print(paste(&quot;isv: '&quot;, isv, &quot;'&quot;)) 
    quit() 
  } 
}
#these asserts give a sample for exercising the code. 
assert(get_type(TRUE),      &quot;vector of logical&quot;)  #everything is a vector in R by default. 
assert(get_type(c(TRUE)),   &quot;vector of logical&quot;)  #c() just casts to vector 
assert(get_type(c(c(TRUE))),&quot;vector of logical&quot;)  #casting vector multiple times does nothing 
assert(get_type(!5),        &quot;vector of logical&quot;)  #bang inflicts 'not truth-like' 
assert(get_type(1L),              &quot;vector of integer&quot;)   #naked integers are still vectors of 1 
assert(get_type(c(1L, 2L)),       &quot;vector of integer&quot;)   #Longs are not doubles 
assert(get_type(c(1L, c(2L, 3L))),&quot;vector of integer&quot;)   #nested vectors of integers 
assert(get_type(c(1L, c(TRUE))),  &quot;vector of integer&quot;)   #logicals coerced to integer 
assert(get_type(c(FALSE, c(1L))), &quot;vector of integer&quot;)   #logicals coerced to integer 
assert(get_type(&quot;foobar&quot;),        &quot;vector of character&quot;)    #character here means 'string' 
assert(get_type(c(1L, &quot;foobar&quot;)), &quot;vector of character&quot;)    #integers are coerced to string 
assert(get_type(5),           &quot;vector of double&quot;) 
assert(get_type(5 + 5L),      &quot;vector of double&quot;) 
assert(get_type(Inf),         &quot;vector of double&quot;) 
assert(get_type(c(5,6,7)),    &quot;vector of double&quot;) 
assert(get_type(NaN),           &quot;vector of double&quot;) 
assert(get_type(list(5)),       &quot;vector of list&quot;)    #your list is in a vector. 
assert(get_type(list(5,6,7)),   &quot;vector of list&quot;) 
assert(get_type(c(list(5,6,7))),&quot;vector of list&quot;) 
assert(get_type(list(c(5,6),T)),&quot;vector of list&quot;)    #vector of list of vector and logical 
assert(get_type(list(5,6,7)),   &quot;vector of list&quot;) 
assert(get_type(2i),            &quot;vector of complex&quot;) 
assert(get_type(c(2i, 3i, 4i)), &quot;vector of complex&quot;) 
assert(get_type(c()),            &quot;NULL&quot;) 
assert(get_type(data.frame()),   &quot;data.frame&quot;) 
assert(get_type(data.frame(4,5)),&quot;data.frame&quot;) 
assert(get_type(Sys.Date()),     &quot;Date&quot;) 
assert(get_type(sapply),         &quot;closure/function&quot;) 
assert(get_type(charToRaw(&quot;hi&quot;)),&quot;vector of raw&quot;) 
assert(get_type(c(charToRaw(&quot;a&quot;), charToRaw(&quot;b&quot;))), &quot;vector of raw&quot;) 
assert(get_type(array(4)),       &quot;vector of array of double&quot;) 
assert(get_type(array(4,5)),     &quot;vector of array of double&quot;) 
assert(get_type(array(&quot;hi&quot;)),    &quot;vector of array of character&quot;) 
assert(get_type(factor()),       &quot;factor&quot;) 
assert(get_type(factor(3.14)),   &quot;factor&quot;) 
assert(get_type(factor(TRUE)),   &quot;factor&quot;) 
assert(get_type(matrix(3,4,5)),  &quot;matrix of double&quot;) 
assert(get_type(as.matrix(5)),   &quot;matrix of double&quot;) 
assert(get_type(matrix(&quot;yatta&quot;)),&quot;matrix of character&quot;) 
</code></pre>
<p>I put in a C++/Java/Python ideology here that gives me the scoop of what the memory most looks like.  R triad typing system is like trying to nail spaghetti to the wall, <code>&lt;-</code> and <code>&lt;&lt;-</code> will package your matrix to a list when you least suspect.   As the old duck-typing saying goes: If it waddles like a duck and if it quacks like a duck and if it has feathers, then it's a duck.</p>


blocks|key|249372|text|>+mtcars+%25>%25+
%2B+++++summarise_all(typeof)+%25>%25+
%2B+++++gather
++++key++value
1+++mpg+double
2+++cyl+double
3++disp+double
4++++hp+double
5++drat+double
6++++wt+double
7++qsec+double
8++++vs+double
9++++am+double
10+gear+double
11+carb+double|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|249373|我尝试了class和typeof函数，但都失败了。|unstyled|offset|length|style|CODE|249374|entityMap^0|0|4|5|A|6|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|S|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>&gt; mtcars %&gt;% 
+     summarise_all(typeof) %&gt;% 
+     gather
    key  value
1   mpg double
2   cyl double
3  disp double
4    hp double
5  drat double
6    wt double
7  qsec double
8    vs double
9    am double
10 gear double
11 carb double
</code></pre>

<p>I try <code>class</code> and <code>typeof</code> functions, but all fails.</p>


blocks|key|249401|text|lapply(your_dataframe，类)为您提供了类似以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|249402|$tikr+1“系数”|249403|$Date+1“日期”|249404|$Open+1“数字”|249405|$High+1“数字”|249406|..。等。|249407|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

<p>lapply(your_dataframe, class) gives you something like:</p>

<p>$tikr
[1] "factor"</p>

<p>$Date
[1] "Date"</p>

<p>$Open
[1] "numeric"</p>

<p>$High
[1] "numeric"</p>

<p>... etc.</p>


<p>In R, I'd like to retrieve a list of global variables at the end of my script and iterate over them. Here is my code</p>

<pre><code>#declare a few sample variables
a&lt;-10
b&lt;-"Hello world"
c&lt;-data.frame()

#get all global variables in script and iterate over them
myGlobals&lt;-objects()
for(i in myGlobals){
  print(typeof(i))     #prints 'character'
}
</code></pre>

<p>My problem is that <code>typeof(i)</code> always returns <code>character</code> even though variable <code>a</code> and <code>c</code> are not character variables. How can I get the original type of variable inside the for loop?</p>


Get type of all variables

解释器

容器

Python

Java

在R中，我希望检索脚本末尾的全局变量列表，并对它们进行迭代。以下是我的代码#declare a few sample variablesa<-10b<-"Hello world"c<-data.frame()#get all global variables in script and iterate over the...

问获取所有变量的类型
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问获取所有变量的类型EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问获取所有变量的类型
EN