Hoe krijg je in R de naam van een object nadat het naar een functie is verzonden?

Ik zoek het omgekeerde van get().

Gegeven een objectnaam, wil ik dat de tekenreeks die dat object vertegenwoordigt, rechtstreeks uit het object wordt geëxtraheerd.

Beduidend voorbeeld waarbij foode tijdelijke aanduiding is voor de functie die ik zoek.

z <- data.frame(x=1:10, y=1:10)
test <- function(a){
  mean.x <- mean(a$x)
  print(foo(a))
  return(mean.x)}
test(z)

Zou afdrukken:

 "z"

Mijn oplossing, die moeilijker te implementeren is in mijn huidige probleem, is:

test <- function(a="z"){
  mean.x <- mean(get(a)$x)
  print(a)
  return(mean.x)}
test("z")

Antwoord 1, autoriteit 100%

De oude deparse-substitute-truc:

a<-data.frame(x=1:10,y=1:10)
test<-function(z){
   mean.x<-mean(z$x)
   nm <-deparse(substitute(z))
   print(nm)
   return(mean.x)}
 test(a)
#[1] "a"   ... this is the side-effect of the print() call
#          ... you could have done something useful with that character value
#[1] 5.5   ... this is the result of the function call

Bewerken: uitgevoerd met het nieuwe testobject

Opmerking: dit zal niet lukken binnen een lokale functie wanneer een set lijstitems wordt doorgegeven van het eerste argument aan lapply(en het mislukt ook wanneer een object wordt doorgegeven uit een lijst die aan een for-loop.) U zou het “.Names”-attribuut en de volgorde van verwerking uit het structuurresultaat kunnen extraheren als het een benoemde vector was die werd verwerkt.

> lapply( list(a=4,b=5), function(x) {nm <- deparse(substitute(x)); strsplit(nm, '\\[')} )
$a      # This "a" and the next one in the print output are put in after processing
$a[[1]]
[1] "X"    ""     "1L]]"  # Notice that there was no "a"
$b
$b[[1]]
[1] "X"    ""     "2L]]"
> lapply( c(a=4,b=5), function(x) {nm <- deparse(substitute(x)); strsplit(nm, '\\[')} )
$a
$a[[1]]   # but it's theoretically possible to extract when its an atomic vector
[1] "structure(c(4, 5), .Names = c(\"a\", \"b\"))" ""                                            
[3] "1L]]"                                        
$b
$b[[1]]
[1] "structure(c(4, 5), .Names = c(\"a\", \"b\"))" ""                                            
[3] "2L]]"  

Antwoord 2, autoriteit 10%

deparse(quote(var))

Mijn intuïtieve begrip
Waarin het citaat de var of uitdrukking van evaluatie bevriest
en de deparse-functie, die het omgekeerde is van de parse-functie, maakt dat bevroren symbool terug naar String

Antwoord 3, autoriteit 4%

Houd er rekening mee dat het gedrag voor afdrukmethoden anders kan zijn.

print.foo=function(x){ print(deparse(substitute(x))) }
test = list(a=1, b=2)
class(test)="foo"
#this shows "test" as expected
print(test)
#this (just typing 'test' on the R command line)
test
#shows
#"structure(list(a = 1, b = 2), .Names = c(\"a\", \"b\"), class = \"foo\")"

Andere opmerkingen die ik op forums heb gezien, suggereren dat het laatste gedrag onvermijdelijk is. Dit is jammer als u afdrukmethoden voor pakketten schrijft.

Antwoord 4

Om het antwoord van Eli Holmes uit te werken:

1. myfuncwerkt prachtig
2. Ik kwam in de verleiding om het binnen een andere functie te noemen (zoals besproken in zijn opmerking van 15 augustus ’20)
3. Mislukt
4. Binneneen functie, direct gecodeerd (in plaats van aangeroepen vanuit een externe functie), werkt de truc deparse(substitute()goed.
5. Dit is allemaal impliciet in zijn antwoord, maar voor het voordeel van piepers met mijn mate van onwetendheid, wilde ik het spellen.

an_object <- mtcars
myfunc <- function(x) deparse(substitute(x))
myfunc(an_object)
#> [1] "an_object"
# called within another function 
wrapper <- function(x){
  myfunc(x)
}
wrapper(an_object)
#> [1] "x"