Réponses:
Non, ce n'est pas le cas, voir: Définition du langage R: opérateurs
Après @ GregaKešpret, vous pouvez créer un opérateur d'infixe:
`%+=%` = function(e1,e2) eval.parent(substitute(e1 <- e1 + e2))
x = 1
x %+=% 2 ; x
x = %+=% y/2
revient x = (x + y)/2
. L'ajout de parenthèses, c'est-à-dire x = %+=% (y/2)
résout le problème.
R n'a pas de concept de increment operator
(comme par exemple ++ en C). Cependant, il n'est pas difficile d'en implémenter un vous-même, par exemple:
inc <- function(x)
{
eval.parent(substitute(x <- x + 1))
}
Dans ce cas, vous appelleriez
x <- 10
inc(x)
Cependant, cela introduit une surcharge d'appel de fonction, donc c'est plus lent que de taper x <- x + 1
vous-même. Si je ne me trompe pas, il a increment operator
été introduit pour faciliter le travail du compilateur, car il pourrait convertir directement le code en ces instructions en langage machine.
INC
L'instruction a été introduite dans les processeurs principalement pour l'implémentation des compteurs (cf. Manuel du développeur de logiciels Intel). Je mettrai à jour la réponse.
R n'a pas ces opérations car (la plupart) des objets dans R sont immuables. Ils ne changent pas. En règle générale, lorsqu'il semble que vous modifiez un objet, vous modifiez en fait une copie.
Nous avons publié un paquet, roperators, pour aider avec ce genre de chose. Vous pouvez en savoir plus ici: 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
Nous pouvons passer outre +
. Si unaire +
est utilisé et que son argument est lui-même un +
appel unaire , incrémentez la variable appropriée dans l'environnement appelant.
`+` <- 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
les autres opérations ne changent pas:
x + 2
# [1] 13
x ++ 2
# [1] 13
+x
# [1] 11
x
# [1] 11
Ne le faites pas car vous ralentirez tout. Ou faites-le dans un autre environnement et assurez-vous de ne pas avoir de grandes boucles sur ces instructions.
Vous pouvez également simplement faire ceci:
`++` <- function(x) eval.parent(substitute(x <-x +1))
a <- 1
`++`(a)
a
# [1] 2
Il y a une autre façon de faire cela, que je trouve très facile, peut-être que cela pourrait vous aider
J'utilise <<-
pour ces situations Les opérateurs <<-
attribuent la valeur à l'environnement parent
inc <- function(x)
{
x <<- x + 1
}
et vous pouvez l'appeler comme
x <- 0
inc(x)
x += 1
oux++
-x = x + 1
fonctionne.