R'nin c ++ / c # / diğerlerinin yaptığı gibi +=
(artı eşittir) veya ++
(artı artı) kavramı var mı ?
Yanıtlar:
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
x = %+=% y/2
iadeleri x = (x + y)/2
. Parantez eklemek, yani x = %+=% (y/2)
sorunu çözer.
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.
INC
talimat, öncelikle sayaçları uygulamak için işlemcilerde tanıtıldı (cf. Intel Yazılım Geliştirici Kılavuzu). Cevabı güncelleyeceğim.
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.
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
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)
<<- assigns the value to parent environment
. Saygıyla olumsuz oy verin, kaldırmayı düşünün.
x += 1
ya dax++
-x = x + 1
çalışır.