Extrait d'une expression régulière

Je suis en train d'extraire un nombre à partir d'une chaîne.

Et faire quelque chose comme [0-9]+ sur la chaîne "aaa12xxx" et obtenir "12".

Je pensais que ce serait quelque chose comme:

> grep("[0-9]+", "aaa12xxx", value=TRUE)
[1] "aaa12xxx"

Et puis j'ai pensé que...

> sub("[0-9]+", "\", "aaa12xxx")
[1] "aaaxxx"

Mais j'ai eu une certaine forme de réponse à faire:

> sub("[0-9]+", "ARGH!", "aaa12xxx")
[1] "aaaARGH!xxx"

Il y a un petit détail qui me manque.

InformationsquelleAutor tovare | 2010-02-03

r regex

156

Utiliser le nouveau stringr package qui enveloppe tout l'existant, expression régulière opère dans un uniforme de la syntaxe et ajoute quelques-uns qui sont manquant:
```
library(stringr)
str_locate("aaa12xxx", "[0-9]+")
#      start end
# [1,]     4   5
str_extract("aaa12xxx", "[0-9]+")
# [1] "12"
```
- (presque) exactement ce dont j'avais besoin, mais comme j'ai commencé à taper dans ?str_extract j'ai vu str_extract_all et la vie était bien à nouveau.
InformationsquelleAutor hadley
5

Utilisation de la capture des parenthèses dans l'expression régulière et le groupe de références dans le remplacement. Rien entre parenthèses obtient rappeler. Alors, ils sont accessibles par \2, le premier élément. La première des antislashes la barre oblique inverse de l'interprétation dans la R de sorte que celui-ci est transmis à l'expression régulière de l'analyseur.
```
gsub('([[:alpha:]]+)([0-9]+)([[:alpha:]]+)', '\', "aaa12xxx")
```
InformationsquelleAutor Ragy Isaac
4

Un autre moyen serait ceci:
```
test <- regexpr("[0-9]+","aaa12456xxx")
```
Maintenant, avis regexpr vous donne le début et la fin indices de la chaîne:
```
    > test
[1] 4
attr(,"match.length")
[1] 5
```
De sorte que vous pouvez utiliser cette info avec substr fonction
```
substr("aaa12456xxx",test,test+attr(test,"match.length")-1)
```
Je suis sûr qu'il y est une façon plus élégante de le faire, mais c'était le moyen le plus rapide que j'ai pu trouver. Alternativement, vous pouvez utiliser sous/gsub de supprimer ce que vous ne voulez pas laisser ce que vous voulez.

InformationsquelleAutor Robert
2

À l'aide de strapply dans le gsubfn paquet. strapply est comme s'appliquer dans les arguments sont l'objet, modificateur et de la fonction, sauf que l'objet est un vecteur de chaînes de caractères (au lieu d'un tableau) et le modificateur est une expression régulière (plutôt que d'une marge):
```
library(gsubfn)
x <- c("xy13", "ab 12 cd 34 xy")
strapply(x, "\\d+", as.numeric)
# list(13, c(12, 34))
```
Cela dit pour correspondre à un ou plusieurs chiffres (\d+) dans chaque composante de x passant à chaque match, à travers comme.numérique. Elle retourne une liste dont les éléments sont des vecteurs de matches de composantes respectives de x. À la recherche à la production, nous voyons que la première composante de x a un match qui s'13 et la deuxième composante de x a deux matches, qui sont au nombre de 12 et 34. Voir http://gsubfn.googlecode.com pour plus d'info.

InformationsquelleAutor G. Grothendieck

Une autre solution:

temp = regexpr('\\d', "aaa12xxx");
substr("aaa12xxx", temp[1], temp[1]+attr(temp,"match.length")[1])

InformationsquelleAutor pari

0

Une différence importante entre ces approches, le comportement avec les non-correspondances. Par exemple, le regmatches méthode ne peut pas retourner une chaîne de même longueur que l'entrée si il n'y a pas un match dans toutes les positions
```
> txt <- c("aaa12xxx","xyz")

> regmatches(txt,regexpr("[0-9]+",txt)) # could cause problems

[1] "12"

> gsub("[^0-9]", "", txt)

[1] "12" ""  

> str_extract(txt, "[0-9]+")

[1] "12" NA  
```
InformationsquelleAutor andyyy

À l'aide du package décoller nous voudrions effectuer les opérations suivantes:

# install.packages("unglue")
library(unglue)
unglue_vec(c("aaa12xxx", "aaaARGH!xxx"), "{prefix}{number=\\d+}{suffix}", var = "number")
#> [1] "12" NA

^{Créé sur 2019-11-06 par le reprex paquet (v0.3.0)}

Utiliser le convert argument pour convertir automatiquement un numéro :

unglue_vec(
  c("aaa12xxx", "aaaARGH!xxx"), 
  "{prefix}{number=\\d+}{suffix}", 
  var = "number", 
  convert = TRUE)
#> [1] 12 NA

InformationsquelleAutor Moody_Mudskipper

-2

Vous pouvez écrire vos fonctions regex avec le C++, les compiler dans une DLL et de les appeler à partir de R.

    #include <regex>

    extern "C" {
    __declspec(dllexport)
    void regex_match( const char **first, char **regexStr, int *_bool)
    {
        std::cmatch _cmatch;
        const char *last = *first + strlen(*first);
        std::regex rx(*regexStr);
        bool found = false;
        found = std::regex_match(*first,last,_cmatch, rx);
        *_bool = found;
    }

__declspec(dllexport)
void regex_search_results( const char **str, const char **regexStr, int *N, char **out )
{
    std::string s(*str);
    std::regex rgx(*regexStr);
    std::smatch m;

    int i=0;
    while(std::regex_search(s,m,rgx) && i < *N) {
        strcpy(out[i],m[0].str().c_str());
        i++;
        s = m.suffix().str();
    }
}
    };

appel en R comme

dyn.load("C:\\YourPath\\RegTest.dll")
regex_match <- function(str,regstr) {
.C("regex_match",x=as.character(str),y=as.character(regstr),z=as.logical(1))$z }

regex_match("abc","a(b)c")

regex_search_results <- function(x,y,n) {
.C("regex_search_results",x=as.character(x),y=as.character(y),i=as.integer(n),z=character(n))$z }

regex_search_results("aaa12aa34xxx", "[0-9]+", 5)

C'est complètement inutile. Voir les réponses de "thelatemail" ou "Robert" pour une solution simple à l'intérieur de R.

InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.