Faire correspondre la dernière occurrence en utilisant regex en perl

J'ai un texte comme ceci:

hello world /* select a from table_b
*/some other text with new line cha
racter and there are some blocks of 
/* any string */select this part on
ly 
////RESULT rest string

Le texte est multilined et j'ai besoin d'extraire de la dernière occurrence de "*/" jusqu'à ce que "////RÉSULTAT". Dans ce cas, le résultat devrait être:

 select this part on
ly

Comment atteindre cet objectif en perl?

J'ai tenté \\\*/(.|\n)*////RESULT mais qui va commencer à partir de la première "*/"

source d'informationauteur Peiti Peter Li | 2013-01-02

perl regex

17

Une astuce utile dans les cas de ce genre est le préfixe de l'expression régulière avec les cupides modèle .*qui va tenter de faire correspondre autant de caractères que possible avant que le reste de la répétition des matches. Donc:
```
my ($match) = ($string =~ m!^.*\*/(.*?)////RESULT!s);
```
Nous allons briser ce schéma en ses composantes:
- ^.* commence au début de la chaîne des matchs et autant de caractères que possible. (Le s modificateur permet . de match, et même des retours à la ligne.) Le début de la chaîne de l'ancre ^ n'est pas strictement nécessaire, mais il assure que les regexp moteur ne perdez pas trop de temps de retour en arrière si le match échoue.
- \*/ juste les matchs de la chaîne littérale */.
- (.*?) matchs et capture d'un nombre quelconque de caractères; la ? rend moins gourmand, il préfère match que peu de caractères que possible dans le cas où il n'y a plus d'une position où le reste de la regexp ne peut égaler.
- Enfin, ////RESULT juste matches elle-même.
Depuis le modèle contient beaucoup de barres obliques, et depuis que j'ai voulu éviter se penchant un cure-dent syndrome dej'ai décidé d'utiliser d'autres regexp délimiteurs. Des points d'Exclamation (!) sont un choix populaire, car ils n'entrent pas en collision avec le fonctionnement normal de la syntaxe regexp.

Edit: Par la discussion avec ikegami ci-dessous, je suppose que je devrais noter que, si vous souhaitez utiliser cette regexp comme un sous-modèle dans un plus regexp, et si vous voulez vous assurer que la chaîne correspondant au (.*?) sera jamais contenir ////RESULTalors vous devez envelopper les parties de la regexp dans un indépendant (?>) sous-expressioncomme ceci:
```
my $regexp = qr!\*/(?>(.*?)////RESULT)!s;
...
my $match = ($string =~ /^.*$regexp$some_other_regexp/s);
```
La (?>) provoque le motif à l'intérieur de l'échec plutôt que d'accepter un sous-optimale match (c'est à dire celle qui s'étend au-delà de la première sous-chaîne correspondant ////RESULT), même si cela signifie que le reste de la regexp ne pourront pas égaler.
4
```
(?:(?!STRING).)*
```
correspond à un nombre quelconque de caractères qui ne contiennent pas de STRING. C'est comme [^a]mais pour les chaînes de caractères à la place des caractères.

Vous pouvez prendre des raccourcis si vous savez que certaines entrées ne seront pas rencontrés (comme Kénose et Ilmari Karonen fait), mais c'est ce à quoi correspond ce que vous avez indiqué:
```
my ($segment) = $string =~ m{
    \*/
    ( (?: (?! \*/ ). )* )
    ////RESULT
    (?: (?! \*/ ). )*
    \z
}xs;
```
Si vous n'avez pas de soins si */ apparaît après ////RESULTla suivante est la plus sûre:
```
my ($segment) = $string =~ m{
    \*/
    ( (?: (?! \*/ ). )* )
    ////RESULT
}xs;
```
Vous ne spécifiez pas ce qui se passerait si il y a deux ////RESULT qui suivent le dernier */. Le ci-dessus matches jusqu'à la dernière. Si vous voulais match jusqu'à la première, vous l'auriez
```
my ($segment) = $string =~ m{
    \*/
    ( (?: (?! \*/ | ////RESULT ). )* )
    ////RESULT
}xs;
```

Voici une option:

use strict;
use warnings;

my $string = <<'END';
hello world /* select a from table_b
*/some other text with new line cha
racter and there are some blocks of 
/* any string */select this part on
ly 
////RESULT
END

my ($segment) = $string =~ m!\*/([^/]+)////RESULT$!s;

print $segment;

De sortie:

 select this part on
ly

Vous devez vous connecter pour publier un commentaire.