R: + = (plus gleich) und ++ (plus plus) äquivalent von c ++ / c # / java usw.?

Hat R ein Konzept von +=(plus gleich) oder ++(plus plus) wie c ++ / c # / andere?

Nein, siehe nicht: R Sprachdefinition: Operatoren

Nach @ GregaKešpret können Sie einen Infix-Operator erstellen:

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

R hat kein Konzept von increment operator(wie zum Beispiel ++ in C). Es ist jedoch nicht schwierig, eine selbst zu implementieren, zum Beispiel:

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

In diesem Fall würden Sie anrufen

x <- 10
inc(x)

Es führt jedoch zu einem Funktionsaufruf-Overhead, sodass es langsamer ist als das Eingeben x <- x + 1. Wenn ich mich nicht irre, increment operatorwurde eingeführt, um die Arbeit für den Compiler zu vereinfachen, da er den Code direkt in diese Maschinensprachenanweisungen konvertieren könnte.

R hat diese Operationen nicht, da (die meisten) Objekte in R unveränderlich sind. Sie ändern sich nicht. Wenn es so aussieht, als würden Sie ein Objekt ändern, ändern Sie normalerweise eine Kopie.

Inkrementieren und Dekrementieren um 10.

require(Hmisc)
inc(x) <- 10 

dec(x) <- 10

Wir haben ein Paket veröffentlicht, Roperators, um bei solchen Dingen zu helfen. Weitere Informationen finden Sie hier: 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

Wir können überschreiben +. Wenn unary +verwendet wird und sein Argument selbst ein unary- +Aufruf ist, erhöhen Sie die relevante Variable in der aufrufenden Umgebung.

`+` <- 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 Operationen ändern sich nicht:

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

Tun Sie es aber nicht, da Sie alles verlangsamen werden. Oder machen Sie es in einer anderen Umgebung und stellen Sie sicher, dass diese Anweisungen keine großen Schleifen enthalten.

Sie können dies auch einfach tun:

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

Es gibt noch einen anderen Weg, den ich sehr einfach finde, vielleicht ohne Hilfe

Ich benutze <<-für diese Situation Die Operatoren <<-weisen den Wert der übergeordneten Umgebung zu

inc <- function(x)
{
   x <<- x + 1
}

und man kann es so nennen

x <- 0
inc(x)