web-dev-qa-db-fra.com

Expression régulière pour trouver une chaîne comprise entre deux caractères en EXCLUANT les délimiteurs

Je dois extraire d'une chaîne un ensemble de caractères inclus entre deux délimiteurs, sans renvoyer les délimiteurs eux-mêmes.

Un exemple simple devrait être utile:

Target : extrait la sous-chaîne entre crochets, sans renvoyer les crochets eux-mêmes.

Chaîne de base : This is a test string [more or less]

Si j'utilise le reg suivant ex.

[more or less]. Je n'ai besoin que de more or less (sans les crochets). 
Est-il possible de le faire?
regex
232
Diego

Facile à faire:

(?<=\[)(.*?)(?=\])

Techniquement, cela utilise des éléments antérieurs et antérieurs. Voir Lookahead et Lookbehind Zero-Width Assertions . Le motif comprend:

  • est précédé d'un [qui n'est pas capturé (lookbehind);
  • un groupe capturé non-gourmand. C'est non-gourmand de s'arrêter au premier abord; et
  • est suivi par un] qui n'est pas capturé (regarder à l'avance).

Sinon, vous pouvez simplement capturer ce qu'il y a entre les crochets:

\[(.*?)\]

et renvoyer le premier groupe capturé au lieu de la correspondance complète.

355
cletus

Si vous utilisez JavaScript, la première solution fournie par cletus, (?<=\[)(.*?)(?=\]), ne fonctionnera pas, car JavaScript ne prend pas en charge l'opérateur lookbehind.

Cependant, la deuxième solution fonctionne bien, mais vous devez obtenir le deuxième élément correspondant.

Exemple:

var regex = /\[(.*?)\]/;
var strToMatch = "This is a test string [more or less]";
var matched = regex.exec(strToMatch);

Il reviendra:

["[more or less]", "more or less"]

Donc, ce dont vous avez besoin est la deuxième valeur. Utilisation:

var matched = regex.exec(strToMatch)[1];

Revenir:

"more or less"
43
Zanon

Il vous suffit de "capturer" le bit entre les crochets.

\[(.*?)\]

Pour capturer vous le mettez entre parenthèses. Vous ne dites pas quelle langue cela utilise. En Perl par exemple, vous y accéderiez en utilisant la variable $ 1.

my $string ='This is the match [more or less]';
$string =~ /\[(.*?)\]/;
print "match:$1\n";

Les autres langues auront des mécanismes différents. C #, par exemple, utilise la classe Match collection , je crois.

17
Xetius

PHP:

$string ='This is the match [more or less]';
preg_match('#\[(.*)\]#', $string, $match);
var_dump($match[1]);
8
powtac

[^\[] Faites correspondre n'importe quel caractère qui n'est pas [. 

+ Match 1 ou plus de tout ce qui n'est pas [. Crée des groupes de ces correspondances.

(?=\]) lookahead positif ]. Correspond à un groupe se terminant par ] sans l'inclure dans le résultat.

Terminé.

[^\[]+(?=\])

Preuve.

http://regexr.com/3gobr

Similaire à la solution proposée par null. Mais le \] supplémentaire n'est pas requis. De plus, il apparaît que \ n'est pas nécessaire pour échapper au [ après le ^. Pour la lisibilité, je le laisserais po.

Ne fonctionne pas dans la situation dans laquelle les délimiteurs sont identiques. "more or less" par exemple.

5
Stieneee

Celui-ci fonctionne spécifiquement pour l'analyseur d'expression régulière javascript /[^[\]]+(?=])/g

il suffit de lancer ceci dans la console 

var regex = /[^[\]]+(?=])/g;
var str = "This is a test string [more or less]";
var match = regex.exec(str);
match;
3
null

Pour supprimer également le [], utilisez:

\[.+\]
3
Cătălin Rădoi

J'ai eu le même problème en utilisant regex avec des scripts bash . J'ai utilisé une solution en 2 étapes utilisant des pipes avec grep -o 

 '\[(.*?)\]'

d'abord, puis

'\b.*\b'

Évidemment pas aussi efficace que les autres réponses, mais une alternative. 

2
A. Jesús

Je voulais trouver une chaîne entre/et #, mais # est parfois facultatif. Voici la regex que j'utilise:

  (?<=\/)([^#]+)(?=#*)
0
techguy2000

Voici comment je me suis fait sans '[' et ']' en C #:

        var text = "This is a test string [more or less]";
        //Getting only string between '[' and ']'
        Regex regex = new Regex(@"\[(.+?)\]");
        var matchGroups = regex.Matches(text);
        for (int i = 0; i < matchGroups.Count; i++)
        {
            Console.WriteLine(matchGroups[i].Groups[1]);
        }

La sortie est:

more or less
0
Jamaxack