Modifier l'objet sans utiliser return dans la fonction R

Cela peut être fait facilement avec stringi

library(stringi)
a <- "StackOverFlow"
stri_reverse(a)
#[1] "wolFrevOkcatS"

Il est toujours préférable de tirer parti de la vectorisation en R (au lieu des boucles for ou while). Donc, en base-R, sans aucun paquet, ce serait quelque chose comme:

ReverseString <- function(x) {
  #splitstring splits every character, and rev reverses the order
  out <- rev(strsplit(x, split = '')[[1]])
  #paste to paste them together
  paste(out, collapse = '')
}

a <- "StackOverFlow"
ReverseString(a)
#[1] "wolFrevOkcatS"

Selon votre commentaire, vous souhaitez inverser la chaîne sans appeler aucune fonction qui effectue l'inversion, c'est-à-dire pas de rev et co. Les deux solutions ci-dessous font cela.

Je pense que vous essayez également de modifier un a global à partir de la fonction, c'est pourquoi vous avez essayé . Je ne sais pas pourquoi cela n'a pas fonctionné pour vous, mais vous l'avez peut-être mal utilisé.

Vous devez savoir qu'utiliser seul ne signifie pas que vous utilisez moins d'espace. Pour vraiment économiser de l'espace, vous devrez appeler ou modifier le a global à chaque étape de votre fonction où vous appelez ou modifiez TestString . Cela impliquerait une combinaison de assign , do.call , eval et parse - sans parler de tous les coller que vous auriez à faire pour accéder aux éléments de a par position entière. Votre fonction finirait par être encombrante, presque illisible et très probablement moins efficace en raison des nombreux appels de fonction, bien qu'elle ait économisé une quantité négligeable d'espace en ne stockant pas une copie de a . Si vous êtes résolu à créer une telle abomination, jetez un œil aux fonctions que je viens d'énumérer et découvrez comment les utiliser.

Votre énergie serait mieux dépensée en améliorant votre inversion de chaîne fonctionner d’autres manières. Par exemple, vous pouvez le raccourcir un peu en utilisant une séquence numérique telle que 13: 1 dans sapply:

reverse_string2 <- function(string){
    vec <- str_split(string, "")[[1]]
    i_vec <- c(1, length(vec))

    while(i_vec[1] < i_vec[2]) {
        vec[i_vec] <- vec[c(i_vec[2], i_vec[1])]
        i_vec <- i_vec + c(1, -1)
    }

    paste(vec, collapse = "")
}

reverse_string2("StackOverFlow")

#### OUTPUT ####

[1] "wolFrevOkcatS"

Si vos enquêteurs ont également un problème avec les séquences inversées, voici une autre option plus proche de votre code d'origine, juste un peu plus propre. J'ai également fait de mon mieux pour éliminer d'autres zones où un "espace supplémentaire" était utilisé (index stockés dans un seul vecteur, plus de Temp):

reverse_string <- function(string) {
    vec <- str_split(string, "")[[1]]
    paste(sapply(length(vec):1, function(i) vec[i]), collapse = "")
}

reverse_string("StackOverFlow")

#### OUTPUT ####

[1] "wolFrevOkcatS"

p>

Je ne suis pas sûr d'avoir compris exactement le problème, mais je pense que vous cherchez un moyen d'inverser l'objet string et de l'attribuer automatiquement à l'objet d'origine sans avoir à faire un (en supposant que c'est la raison pour laquelle vous avez essayé d'utiliser ). Ma solution consiste à utiliser deparse (substitute ()) pour lire le nom de la variable d'origine dans la fonction et assign (en utilisant envir = .GlobalEnv ) pour affecter votre résultat sur la variable d'origine.

ReverseString <- function(TestString){

  nm <- deparse(substitute(TestString))

  TestString <- unlist(strsplit(TestString, ""))
  Left <- 1
  Right <- length(TestString)
  while (Left < Right){
    Temp <- TestString[Left]
    TestString[Left] <- TestString[Right]
    TestString[Right] <- Temp
    Left <- Left + 1
    Right <- Right - 1
  }

  assign(nm, paste(TestString, collapse = ""), envir = .GlobalEnv)

}

## Input
a = "StackOverFlow"

ReverseString(a)

a
#[1] "wolFrevOkcatS"