R: += (plus is gelijk aan) en ++ (plus plus) equivalent van c++/c#/java, enz.?

Heeft R een concept van +=(plus is gelijk aan) of ++(plus plus) zoals c++/c#/others doen?


Antwoord 1, autoriteit 100%

Nee, dat is het niet, zie: R Taaldefinitie : Operators


Antwoord 2, autoriteit 54%

Volgend op @GregaKešpret kunt u een infix-operator maken:

`%+=%` = function(e1,e2) eval.parent(substitute(e1 <- e1 + e2))
x = 1
x %+=% 2 ; x

Antwoord 3, autoriteit 30%

R heeft geen concept van increment operator(zoals bijvoorbeeld ++ in C). Het is echter niet moeilijk om er zelf een te implementeren, bijvoorbeeld:

inc <- function(x)
{
 eval.parent(substitute(x <- x + 1))
}

In dat geval zou je bellen

x <- 10
inc(x)

Het introduceert echter overhead voor functieaanroepen, dus het is langzamerdan zelf x <- x + 1te typen. Als ik me niet vergis, is increment operatorgeïntroduceerd om het werk voor de compiler gemakkelijker te maken, omdat het de code rechtstreeks naar die machinetaalinstructies kan converteren.


Antwoord 4, autoriteit 18%

R heeft deze bewerkingen niet omdat (de meeste) objecten in R onveranderlijk zijn. Ze veranderen niet. Meestal, als het lijkt alsof je een object aan het wijzigen bent, ben je eigenlijk een kopie aan het wijzigen.


Antwoord 5, autoriteit 12%

Verhogen en verlagen met 10.

require(Hmisc)
inc(x) <- 10 
dec(x) <- 10

Antwoord 6, autoriteit 5%

We hebben een pakket, roperators, uitgebracht om met dit soort dingen te helpen. Je kunt er hier meer over lezen: https ://happylittlescripts.blogspot.com/2018/09/make-your-r-code-nicer-with-roperators.html

install.packages('roperators')
require(roperators)
x <- 1:3
x %+=% 1; x
x %-=% 3; x
y <- c('a', 'b', 'c')
y %+=% 'text'; y
y %-=% 'text'; y
# etc

Antwoord 7, autoriteit 5%

We kunnen +overschrijven. Als unaire +wordt gebruikt en het argument is zelf een unaire +-aanroep, verhoog dan de relevante variabele in de aanroepende omgeving.

`+` <- function(e1,e2){
    # if unary `+`, keep original behavior
    if(missing(e2)) {
      s_e1 <- substitute(e1)
      # if e1 (the argument of unary +) is itself an unary `+` operation
      if(length(s_e1) == 2 && 
         identical(s_e1[[1]], quote(`+`)) && 
         length(s_e1[[2]]) == 1) {
        # increment value in parent environment
        eval.parent(substitute(e1 <- e1 + 1, list(e1 = s_e1[[2]])))
      # else unary `+` should just return it's input
      } else e1
    # if binary `+`, keep original behavior
    } else .Primitive("+")(e1, e2)
}
x <- 10
++x
x
# [1] 11

andere bewerkingen veranderen niet:

x + 2
# [1] 13
x ++ 2
# [1] 13
+x
# [1] 11
x
# [1] 11

Doe het echter niet, want je vertraagt alles. Of doe het in een andere omgeving en zorg ervoor dat je geen grote lussen hebt in deze instructies.

U kunt dit ook doen:

`++` <- function(x) eval.parent(substitute(x <- x + 1))
a <- 1
`++`(a)
a
# [1] 2

Antwoord 8

We kunnen ook inplace

library(inplace)
x <- 1
x %+<-% 2

Antwoord 9

Als u i++in een array wilt gebruiken om de index te verhogen, kunt u het i <- i + 1proberen, bijvoorbeeld

k = 0
a = 1:4
for (i in 1:4) 
    cat(a[k <- k + 1], " ")
# 1 2 3 4

Maar hier <-kan niet worden vervangen door =, die de index niet bijwerkt,

k = 0
a = 1:4
for (i in 1:4) 
    cat(a[k = k + 1], " ")
# 1 1 1 1

Sinds =en <-zijn niet altijd equivalent, zoals gezegd in ?`<-`

Other episodes