R: + = (artı eşittir) ve ++ (artı artı) eşdeğeri c ++ / c # / java, vb.?

R'nin c ++ / c # / diğerlerinin yaptığı gibi +=(artı eşittir) veya ++(artı artı) kavramı var mı ?

Hayır, görmez: R Dil Tanım: Operatörler

@ GregaKešpret'i takip ederek bir infix operatörü oluşturabilirsiniz:

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

R'nin bir kavramı yoktur increment operator(örneğin C'deki ++). Ancak, birini kendiniz uygulamak zor değildir, örneğin:

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

Bu durumda arayacaksın

x <- 10
inc(x)

Ancak, işlev çağrısı ek yükünü sunar, bu nedenle kendiniz yazmaktan daha yavaştırx <- x + 1 . Eğer yanılmıyorsam increment operator, derleyicinin işini kolaylaştırmak için tanıtıldı, çünkü kodu doğrudan bu makine dili talimatlarına dönüştürebilirdi.

R'nin bu işlemleri yoktur çünkü R'deki (çoğu) nesne değişmezdir. Değişmezler. Tipik olarak, bir nesneyi değiştiriyormuşsunuz gibi göründüğünde, aslında bir kopyayı değiştiriyorsunuzdur.

10 artırın ve azaltın.

require(Hmisc)
inc(x) <- 10 

dec(x) <- 10

Bu tür şeylere yardımcı olmak için bir paket, halatlayıcılar yayınladık. Bununla ilgili daha fazla bilgiyi buradan okuyabilirsiniz: 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

Geçersiz kılabiliriz +. Tekli +kullanılırsa ve argümanının kendisi tekli bir +çağrı ise, o zaman çağıran ortamda ilgili değişkeni artırın.

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

diğer işlemler değişmez:

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

Her şeyi yavaşlatacağın için yapma. Veya başka bir ortamda yapın ve bu talimatlarda büyük döngüler olmadığından emin olun.

Ayrıca şunu da yapabilirsiniz:

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

Ayrıca kullanabiliriz inplace

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

Bunu yapmanın başka bir yolu var ki çok kolay buluyorum, belki biraz yardımım olabilir

<<-Bu durumlar için kullanıyorum Operatörler <<-değeri ana ortama atar

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

ve ona şöyle diyebilirsin

x <- 0
inc(x)