Extraire les n derniers caractères d'une chaîne en R

Comment puis-je obtenir les n derniers caractères d'une chaîne en R?
Est-il une fonction SQL DROIT?

InformationsquelleAutor Brani | 2011-11-01

246

Je ne suis pas au courant de quoi que ce soit dans la base de R, mais il est simple de faire une fonction pour faire cela en utilisant substr et nchar:
```
x <- "some text in a string"

substrRight <- function(x, n){
  substr(x, nchar(x)-n+1, nchar(x))
}

substrRight(x, 6)
[1] "string"

substrRight(x, 8)
[1] "a string"
```
C'est vectorisée, comme @mdsumner points. Considérer:
```
x <- c("some text in a string", "I really need to learn how to count")
substrRight(x, 6)
[1] "string" " count"
```
- Et regarder dehors pour les NAs...
- Utilisation stringi paquet. Il fonctionne très bien avec NAs et tous encodage 🙂
- Serait-il plus efficace pour éviter l'appel de nchar(x) deux fois par de l'affecter à une variable locale?
InformationsquelleAutor Andrie
164

Si vous n'avez pas l'esprit à l'aide de la stringr paquet, str_sub est très pratique, car vous pouvez utiliser des négatifs de compte à rebours:
```
x <- "some text in a string"
str_sub(x,-6,-1)
[1] "string"
```
Ou, comme Max de points dans un commentaire à cette réponse,
```
str_sub(x, start= -6)
[1] "string"
```
- aussi, str_sub(x,start=-n) renvoie les n derniers caractères.
- stringr ne fonctionne pas bien avec NA de valeur et tous encodage. Je vous conseille fortement stringi package 🙂
- Je crois stringr avait été refaite à l'aide de stringi comme backend, il doit donc travailler avec NAs, etc. maintenant.
InformationsquelleAutor Xu Wang
41

Utilisation stri_sub fonction de stringi paquet.
Pour obtenir des sous-chaîne à partir de la fin, utiliser des nombres négatifs.
Regardez ci-dessous quelques exemples:
```
stri_sub("abcde",1,3)
[1] "abc"
stri_sub("abcde",1,1)
[1] "a"
stri_sub("abcde",-3,-1)
[1] "cde"
```
Vous pouvez installer ce package de github: https://github.com/Rexamine/stringi

Il est disponible sur le CRAN maintenant, il suffit de taper
```
install.packages("stringi")
```
pour installer ce package.

InformationsquelleAutor bartektartanus

str = 'This is an example'
n = 7
result = substr(str,(nchar(str)+1)-n,nchar(str))
print(result)

> [1] "example"
>

InformationsquelleAutor Andrew

10

Mise à JOUR: comme l'a noté mdsumner, le code d'origine est déjà saisis parce que substr est. Aurait dû être plus prudent.

Et si vous voulez une version vectorisée (basé sur Andrie's code)
```
substrRight <- function(x, n){
  sapply(x, function(xx)
         substr(xx, (nchar(xx)-n+1), nchar(xx))
         )
}

> substrRight(c("12345","ABCDE"),2)
12345 ABCDE
 "45"  "DE"
```
Noter que j'ai changé (nchar(x)-n) à (nchar(x)-n+1) pour obtenir n caractères.
- Je pense que tu veux dire "(nchar(x)-n) à (nchar(x)-n+1)"
- Andrie est déjà vectorisé.
- sapply != vectorisé
InformationsquelleAutor Laurent
8

Un autre, assez simple façon est d'utiliser des expressions régulières et sub:
```
sub('.*(?=.$)', '', string, perl=T)
```
Afin de se débarrasser de tout ce suivi par un caractère". Pour saisir plusieurs caractères à la fin, ajouter cependant de nombreux points dans l'anticipation de l'assertion:
```
sub('.*(?=.{2}$)', '', string, perl=T)
```
où .{2} signifie .., ou "deux personnages", donc, qui signifie "se débarrasser de tout suivi de deux caractères".
```
sub('.*(?=.{3}$)', '', string, perl=T)
```
pour les trois personnages, etc. Vous pouvez définir le nombre de caractères à saisir avec une variable, mais vous aurez à paste la valeur de la variable dans l'expression régulière:
```
n = 3
sub(paste('.+(?=.{', n, '})', sep=''), '', string, perl=T)
```
- Pour éviter tous les look-les recherches en avant, etc, vous pourriez faire regmatches(x, regexpr(".{6}$", x))
InformationsquelleAutor dsb
6

Une alternative à substr est de diviser la chaîne en une liste de caractères simples et les processus qui:
```
N <- 2
sapply(strsplit(x, ""), function(x, n) paste(tail(x, n), collapse = ""), N)
```
- Je sens un système.temps (le) de la bataille de brassage 🙂
InformationsquelleAutor mdsumner
6

Une simple base de R solution à l'aide de la substring() fonction (qui savait que cette fonction existait?):
```
RIGHT = function(x,n){
  substring(x,nchar(x)-n+1)
}
```
Cela prend avantage de fondamentalement substr() en dessous, mais a par défaut la valeur de fin de 1 000 000.

Exemples:
```
> RIGHT('Hello World!',2)
[1] "d!"
> RIGHT('Hello World!',8)
[1] "o World!"
```
InformationsquelleAutor Andrew Haynes
4

- Je utiliser substr trop, mais d'une manière différente. Je veux extraire les 6 derniers caractères de "Donnez-moi votre nourriture." Voici les étapes:

(1) Diviser les personnages
```
splits <- strsplit("Give me your food.", split = "")
```
(2) Extraire les 6 derniers caractères
```
tail(splits[[1]], n=6)
```
De sortie:
```
[1] " " "f" "o" "o" "d" "."
```
Chaque caractère peut être consulté par splits[[1]][x], où x est de 1 à 6.

InformationsquelleAutor Raimi bin Karim

quelqu'un avant utilise une solution similaire à la mienne, mais je la trouve plus facile de penser comme ci-dessous:

> text<-"some text in a string" # we want to have only the last word "string" with 6 letter
> n<-5 #as the last character will be counted with nchar(), here we discount 1
> substr(x=text,start=nchar(text)-n,stop=nchar(text))

Cela apportera les derniers caractères souhaités.

InformationsquelleAutor JP Fonseca

Essayez ceci:

x <- "some text in a string"
n <- 5
substr(x, nchar(x)-n, nchar(x))

Il devraient donner:

[1] "string"

InformationsquelleAutor lukasz

1

J'ai utilisé le code suivant pour obtenir le dernier caractère d'une chaîne.
```
    substr(output, nchar(stringOfInterest), nchar(stringOfInterest))
```
Vous pouvez jouer avec les nchar(stringOfInterest) de comprendre comment obtenir les derniers caractères.

InformationsquelleAutor Anurag Mishra

Un peu de modification sur @Andrie solution permet également le complément:

substrR <- function(x, n) { 
  if(n > 0) substr(x, (nchar(x)-n+1), nchar(x)) else substr(x, 1, (nchar(x)+n))
}
x <- "moSvmC20F.5.rda"
substrR(x,-4)
[1] "moSvmC20F.5"

Que c'était ce que je cherchais. Et il invite à gauche:

substrL <- function(x, n){ 
  if(n > 0) substr(x, 1, n) else substr(x, -n+1, nchar(x))
}
substrL(substrR(x,-4),-2)
[1] "SvmC20F.5"

InformationsquelleAutor xm1

Juste au cas où si une plage de caractères doivent être choisis:

# For example, to get the date part from the string

substrRightRange <- function(x, m, n){substr(x, nchar(x)-m+1, nchar(x)-m+n)}

value <- "REGNDATE:20170526RN" 
substrRightRange(value, 10, 8)

[1] "20170526"

InformationsquelleAutor RanonKahn

Vous devez vous connecter pour publier un commentaire.