R: + = (mais iguais) e ++ (mais mais) equivalente de c ++ / c # / java, etc.?

R tem um conceito de +=(mais iguais) ou ++(mais mais) como c ++ / c # / outros têm?

Não, não, consulte: Definição da linguagem R: operadores

Seguindo @ GregaKešpret, você pode criar um operador de infix:

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

R não tem um conceito de increment operator(como por exemplo ++ em C). No entanto, não é difícil implementar você mesmo, por exemplo:

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

Nesse caso, você chamaria

x <- 10
inc(x)

No entanto, ele introduz despesas gerais de chamada de função, por isso é mais lento do que digitar x <- x + 1você mesmo. Se não me engano, increment operatorfoi introduzido para facilitar o trabalho do compilador, pois ele poderia converter o código diretamente nessas instruções de linguagem de máquina.

R não possui essas operações porque (a maioria) dos objetos em R são imutáveis. Eles não mudam. Normalmente, quando parece que você está modificando um objeto, na verdade está modificando uma cópia.

Incrementar e diminuir em 10.

require(Hmisc)
inc(x) <- 10 

dec(x) <- 10

Lançamos um pacote, roperators, para ajudar com esse tipo de coisa. Você pode ler mais sobre isso aqui: 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

Nós podemos substituir +. Se unário +for usado e seu argumento for uma +chamada unária , aumente a variável relevante no ambiente de chamada.

`+` <- 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

outras operações não mudam:

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

Não faça isso, pois você diminuirá tudo. Ou faça-o em outro ambiente e verifique se você não possui grandes loops nessas instruções.

Você também pode fazer isso:

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

Existe outra maneira de fazer isso, que eu acho muito fácil, talvez possa ser de alguma ajuda

Eu uso <<-para essa situação Os operadores <<-atribuem o valor ao ambiente pai

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

e você pode chamar assim

x <- 0
inc(x)