Como obter os dígitos antes de alguma palavra específica usando regex em c #?

Usaremos abaixo do regex para obter os dígitos antes das palavras.

Exemplo:

838123 someWord 8 someWord 12 someWord

(\d+)\s*someWord

Mas, às vezes, qualquer coisa fica entre Número e palavra. Consulte a linha de exemplo abaixo.

Ex:

43434 de alguma coisa 12 alguma coisa alguma 2323 nova alguma coisa

Como obter o dígito exato antes dessa palavra usando regex?

Por favor me dê suas sugestões.

Faça isso:

(\d+)[^\d]+some[wW]ord

Você precisa aceitar algo diferente de dígitos. Também considerei os dois we Wjá que seus exemplos continham ambos.

Demo

Presumindo que "qualquer coisa" não inclua dígitos, você pode usar este regex:

(\d+)[^\d]+someWord

Demonstração sobre regex101

Um possível "caso esquecido" da resposta do CinCout é se a correspondência someWorddeve ser exata, por exemplo, se notsomeWorde someWordNotThisnão deve ser correspondida.

A seguinte extensão para essa expressão regular fornece uma maneira de resolver isso:

(\d+)[^\d]*[^\w]some[wW]ord[^\w]

Explicação: O [^\w]antes ou o depois do correspondente parasomeWord pesquisador procurar um "caractere que não seja palavra" antes e depois dele - um final da linha também conta aqui. Obviamente, isso pode se tornar mais complexo / específico, dependendo dos requisitos exatos.

Demo

Você pode tentar algo como isto:

(\d+)\s?([^\d]*)

(\d+)    - get the digits
\s?      - discard a possible space
([^\d]*) - get all chars that are not digits

Você pode ver o teste aqui

primeiro separou o some[wW]ord, numbere spacecom um padrão, depois execute o segundo padrão nele

 var pattern = @"\b(some[wW]ord|[\d]|\s)*\b";
 var rgx = new Regex(pattern);
 var sentence = "43434 of someword 12 anything someword 2323 new someword";
 var result = string.Empty;
 foreach (Match match in rgx.Matches(sentence)){
     result += match.Value;
}
//output => result: 43434 someword 12 someword 2323 someword

 var patternOnCorrectSentence = @"\b(\d+)\s*some[wW]ord*\b";
 var rgxOnCorrectSentence = new Regex(patternOnCorrectSentence);

 var resultOnCorrectSentence = new List<string>();
 foreach (Match match in rgxOnCorrectSentence.Matches(result)){
     resultOnCorrectSentence.Add(match.Value);
 }
 resultOnCorrectSentence.ForEach(Console.WriteLine);

 Console.ReadKey();

Quando o primeiro padrão é executado, a sentença será a desejada

43434 de alguma coisa 12 alguma coisa alguma 2323 nova alguma coisa

mudança:

43434 alguma coisa 12 alguma coisa 2323 alguma coisa

Mas, às vezes, qualquer coisa fica entre Número e palavra. Consulte a linha de exemplo abaixo.

Ex:

43434 de alguma coisa 12 alguma coisa alguma 2323 nova alguma coisa

tente isso

(\ d +) (. *?) alguma coisa

Explicado

\ d + - números

. *? - qualquer coisa depois dos números, exceto a ocorrência mínima.

someord - correspondência exata de um pouco

Demo

Usando \s* corresponderá apenas a 0 ou mais caracteres de espaço em branco.

Você poderia usar \D+ mas também corresponderá às novas linhas, pois corresponde a qualquer caractere, exceto um dígito.

Se você deseja corresponder os dígitos na mesma linha, pode adicionar uma linha não correspondente a uma classe de caracteres negada [^\d\r\n]

No seu exemplo, você usa \d, mas se você deseja apenas combinar 1 ou mais dígitos de 0 a 9, pode usar uma classe de caractere[0-9]+

Para impedir que os dígitos e a palavra façam parte de uma palavra maior, você pode usar limites de palavras \b

Se você deseja corresponder a palavra de uma maneira que não diferencia maiúsculas de minúsculas, você pode usar RegexOptions.IgnoreCaseou um modificador embutido(?i)

(?i)\b([0-9]+)\b[^\d\r\n]*\bsomeword\b

Veja uma demonstração do regex .NET

Use capturas de correspondência nomeadas (para obter dados, use mtch.Groups["Value"].Value... etc) para extrair as informações conforme necessário.

(?<Value>\d+)     -- Get the digits
(?<Other>.+?)     -- Capture all text, but minimal (greedy) capture
(?<Key>someword)  -- til the keyword here.

Quando o acima é executado ( com a IgnorePatternWhiteSpaceremoção dos comentários, junte-se ao padrão para executá-lo, como (?<Value>\d+)(?<Other>.+?)(?<Key>someword)sem opções de regex ), ele obtém os dados para cada par de Dados / Chave e organiza cada um em uma única correspondência.

Resultado

Aqui está o resultado (para o seu segundo exemplo), que está contido em correspondências individuais e seus grupos e capturas fornecem em cada correspondência:

Match #0
              [0]:  43434˽of˽someword
  ["Value"] → [1]:  43434
      →1 Captures:  43434
  ["Other"] → [2]:  ˽of˽
      →2 Captures:  ˽of˽
    ["Key"] → [3]:  someword
      →3 Captures:  someword
Match #1
              [0]:  12˽anything˽someword
  ["Value"] → [1]:  12
      →1 Captures:  12
  ["Other"] → [2]:  ˽anything˽
      →2 Captures:  ˽anything˽
    ["Key"] → [3]:  someword
      →3 Captures:  someword
Match #2
              [0]:  2323˽new˽someword
  ["Value"] → [1]:  2323
      →1 Captures:  2323
  ["Other"] → [2]:  ˽new˽
      →2 Captures:  ˽new˽
    ["Key"] → [3]:  someword
  →3 Captures:  someword

Visualmente, aqui está o que corresponde: