web-dev-qa-db-fra.com

Obtenir et supprimer le premier caractère d'une chaîne

Je voudrais faire des promenades en deux dimensions en utilisant des chaînes de caractères en attribuant des valeurs différentes à chaque caractère. Je prévoyais de faire apparaître le premier caractère d'une chaîne, de l'utiliser et de le répéter pour le reste de la chaîne.

Comment puis-je réaliser quelque chose comme ça?

x <- 'hello stackoverflow'

J'aimerais pouvoir faire quelque chose comme ça:

a <- x.pop[1]

print(a)

'h'
print(x)

'Ello stackoverflow'
stringr
91
pedrosaurio

Voir ?substring .

_x <- 'hello stackoverflow'
substring(x, 1, 1)
## [1] "h"
substring(x, 2)
## [1] "Ello stackoverflow"
_

L'idée d'avoir une méthode pop qui renvoie une valeur et a pour effet secondaire de mettre à jour les données stockées dans x est un concept de la programmation orientée objet. Ainsi, plutôt que de définir une fonction pop pour opérer sur des vecteurs de caractères, nous pouvons créer une classe de référence avec une méthode pop.

_PopStringFactory <- setRefClass(
  "PopString",
  fields = list(
    x = "character"  
  ),
  methods = list(
    initialize = function(x)
    {
      x <<- x
    },
    pop = function(n = 1)
    {
      if(nchar(x) == 0)
      {
        warning("Nothing to pop.")
        return("")
      }
      first <- substring(x, 1, n)
      x <<- substring(x, n + 1)
      first
    }
  )
)

x <- PopStringFactory$new("hello stackoverflow")
x
## Reference class object of class "PopString"
## Field "x":
## [1] "hello stackoverflow"
replicate(nchar(x$x), x$pop())
## [1] "h" "e" "l" "l" "o" " " "s" "t" "a" "c" "k" "o" "v" "e" "r" "f" "l" "o" "w"
_
146
Richie Cotton

Il y a aussi str_sub du paquet stringr

x <- 'hello stackoverflow'
str_sub(x, 2) # or
str_sub(x, 2, str_length(x))
[1] "Ello stackoverflow"
9
Tony Ladson

Utilisez cette fonction du paquet stringi

> x <- 'hello stackoverflow'
> stri_sub(x,2)
[1] "Ello stackoverflow"
9
bartektartanus

substring est certainement la meilleure solution, mais voici une strsplit alternative, car je n'en ai pas encore vu.

> x <- 'hello stackoverflow'
> strsplit(x, '')[[1]][1]
## [1] "h"

ou équivalent

> unlist(strsplit(x, ''))[1]
## [1] "h"

Et vous pouvez paste reconstituer le reste de la chaîne.

> paste0(strsplit(x, '')[[1]][-1], collapse = '')
## [1] "Ello stackoverflow"
6
Rich Scriven

enlever les premiers caractères:

x <- 'hello stackoverflow'
substring(x, 2, nchar(x))

L'idée est de sélectionner tous les caractères allant de 2 au nombre de caractères dans x. Ceci est important lorsque vous avez un nombre inégal de caractères dans Word ou dans une phrase.

La sélection de la première lettre est triviale comme réponses précédentes:

substring(x,1,1)
4
jon

Une autre alternative consiste à utiliser des sous-expressions de capture avec les fonctions d'expressions régulières regmatches et regexec.

# the original example
x <- 'hello stackoverflow'

# grab the substrings
myStrings <- regmatches(x, regexec('(^.)(.*)', x))

Cela renvoie la chaîne entière, le premier caractère et le résultat "sauté" dans une liste de longueur 1.

myStrings
[[1]]
[1] "hello stackoverflow" "h"                   "Ello stackoverflow"

ce qui équivaut à list(c(x, substr(x, 1, 1), substr(x, 2, nchar(x)))). C'est-à-dire qu'il contient le super ensemble des éléments souhaités ainsi que la chaîne complète.

Ajouter sapply permettra à cette méthode de fonctionner pour un vecteur de caractère de longueur> 1.

# a slightly more interesting example
xx <- c('hello stackoverflow', 'right back', 'at yah')

# grab the substrings
myStrings <- regmatches(x, regexec('(^.)(.*)', xx))

Cela renvoie une liste avec la chaîne complète correspondante comme premier élément et les sous-expressions correspondantes capturées par () comme les éléments suivants. Ainsi, dans l'expression régulière '(^.)(.*)', (^.) correspond au premier caractère et (.*) correspond aux caractères restants.

myStrings
[[1]]
[1] "hello stackoverflow" "h"                   "Ello stackoverflow" 

[[2]]
[1] "right back" "r"          "ight back" 

[[3]]
[1] "at yah" "a"      "t yah"

Nous pouvons maintenant utiliser la méthode fiable sapply + [ pour extraire les sous-chaînes souhaitées.

myFirstStrings <- sapply(myStrings, "[", 2)
myFirstStrings
[1] "h" "r" "a"
mySecondStrings <- sapply(myStrings, "[", 3)
mySecondStrings
[1] "Ello stackoverflow" "ight back"          "t yah"
1
lmo