Извлечь совпадение регулярного выражения

Question

Я пытаюсь извлечь число из строки.

И сделать что-то вроде [0-9]+ в строке "aaa12xxx" и получить "12".

Я думал, что это будет что-то вроде:

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

А потом я понял ...

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

Но я получил какую-то форму ответа:

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

Я пропускаю небольшую деталь.

Answer 1

Использование нового пакета stringr, который упаковывает все существующие регулярные выражения, работает в согласованном синтаксисе и добавляет несколько отсутствующих:

library(stringr)
str_locate("aaa12xxx", "[0-9]+")
#      start end
# [1,]     4   5
str_extract("aaa12xxx", "[0-9]+")
# [1] "12"

Answer 2

Вероятно, немного поспешно сказать ' игнорировать стандартные функции ' - файл справки для ?gsub даже специально ссылается на 'Смотрите также':

'regmatches' для извлечения совпавших подстрок на основе результатов "Regexpr", "gregexpr" и "regexec".

Так что это будет работать, и довольно просто:

txt <- "aaa12xxx"
regmatches(txt,regexpr("[0-9]+",txt))
#[1] "12"

Answer 3

Может

gsub("[^0-9]", "", "aaa12xxxx")
# [1] "12"

Answer 4

Вы можете использовать ленивое сопоставление регулярных выражений PERL:

> sub(".*?([0-9]+).*", "\\1", "aaa12xx99",perl=TRUE)
[1] "12"

Попытка замены нецифровых символов приведет к ошибке в этом случае.

Answer 5

Используйте захватные скобки в регулярном выражении и групповые ссылки в замене. Все в скобках запоминается. Затем к ним обращается \ 2, первый элемент. Первая обратная косая черта экранируется от интерпретации обратной косой черты в R, поэтому она передается анализатору регулярных выражений.

gsub('([[:alpha:]]+)([0-9]+)([[:alpha:]]+)', '\\2', "aaa12xxx")

Answer 6

Один из способов будет следующим:

test <- regexpr("[0-9]+","aaa12456xxx")

Теперь обратите внимание, что regexpr дает вам начальный и конечный индексы строки:

    > test
[1] 4
attr(,"match.length")
[1] 5

Таким образом, вы можете использовать эту информацию с substrfunction

substr("aaa12456xxx",test,test+attr(test,"match.length")-1)

Я уверен, что есть более элегантный способ сделать это, но это был самый быстрый способ, который я мог найти.В качестве альтернативы, вы можете использовать sub / gsub, чтобы удалить то, что вы не хотите оставлять, что вы хотите.

Answer 7

Использование strapply в пакете gsubfn.strapply похож на apply в том, что аргументы являются объектом, модификатором и функцией, за исключением того, что объект является вектором строк (а не массивом), а модификатор является регулярным выражением (а не полем):

library(gsubfn)
x <- c("xy13", "ab 12 cd 34 xy")
strapply(x, "\\d+", as.numeric)
# list(13, c(12, 34))

Это означает совпадение одной или нескольких цифр (\ d +) в каждом компоненте x, пропуская каждое совпадение через as.numeric.Возвращает список, компоненты которого являются векторами совпадений соответствующих компонентов x.Посмотрев на результат, мы видим, что первый компонент x имеет одно совпадение, равное 13, а второй компонент x имеет два совпадения, равное 12 и 34. Для получения дополнительной информации см. http://gsubfn.googlecode.com.

Answer 8

Другое решение:

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

Answer 9

Вы можете написать свои функции регулярного выражения с C ++, скомпилировать их в DLL и вызвать их из 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();
    }
}
    };

вызов в R как

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)

Answer 10

Одно важное различие между этими подходами заключается в поведении с любыми несоответствиями.Например, метод regmatches может не возвращать строку той же длины, что и входные данные, если совпадение не во всех позициях

> 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