Ce qui est un non-capture d'un groupe? Ce n' (?:) faire?

Laissez-moi essayer de vous l'expliquer avec un exemple.

Considérer le texte suivant:

http://stackoverflow.com/
https://stackoverflow.com/questions/tagged/regex

Maintenant, si je demande à l'expression régulière ci-dessous sur elle...

(https?|ftp)://([^/\r\n]+)(/[^\r\n]*)?

... Je voudrais obtenir le résultat suivant:

Match "http://stackoverflow.com/"
     Group 1: "http"
     Group 2: "stackoverflow.com"
     Group 3: "/"

Match "https://stackoverflow.com/questions/tagged/regex"
     Group 1: "https"
     Group 2: "stackoverflow.com"
     Group 3: "/questions/tagged/regex"

Mais je n'ai pas de soins sur le protocole -- je veux juste l'hôte et le chemin d'accès de l'URL. Donc, j'ai modifier la regex pour inclure la non-capture d'un groupe (?:).

(?:https?|ftp)://([^/\r\n]+)(/[^\r\n]*)?

Maintenant, mon résultat ressemble à ceci:

Match "http://stackoverflow.com/"
     Group 1: "stackoverflow.com"
     Group 2: "/"

Match "https://stackoverflow.com/questions/tagged/regex"
     Group 1: "stackoverflow.com"
     Group 2: "/questions/tagged/regex"

Voir? Le premier groupe n'a pas été capturé. L'analyseur utilise pour le texte, mais l'ignore plus tard, dans le résultat final.

---

EDIT:

Comme demandé, laissez-moi vous expliquer groupes de trop.

Bien, groupes servir à de nombreuses fins. Ils peuvent vous aider à extraire des informations exactes à partir d'un gros match (qui peut aussi être nommé), ils vous permettent de revanche d'un précédent groupe apparié, et peut être utilisé pour les substitutions. Essayons quelques exemples, allons-nous?

Ok, imaginez que vous avez une sorte de XML ou HTML (être conscient que regex peut-être pas le meilleur outil pour le travail, mais il est gentil comme un exemple). Vous souhaitez analyser les balises, donc vous pourriez faire quelque chose comme ceci (j'ai ajouté des espaces pour le rendre plus facile à comprendre):

   \<(?<TAG>.+?)\> [^<]*? \</\k<TAG>\>
or
   \<(.+?)\> [^<]*? \</\>

La première regex a un groupe nommé (TAG), tandis que le second utilise un groupe commun. Les deux regexes faire la même chose: ils ont de la valeur du premier groupe (le nom de la balise) pour correspondre à la balise de fermeture. La différence est que le premier utilise le nom pour correspondre à la valeur, et le second utilise l'indice de groupe (qui commence à 1).

Essayons quelques substitutions maintenant. Considérons le texte suivant:

Lorem ipsum dolor sit amet consectetuer feugiat fames malesuada pretium egestas.

Maintenant, nous allons utiliser cette stupide regex sur elle:

\b(\S)(\S)(\S)(\S*)\b

Cette expression correspond à des mots avec au moins 3 caractères, et utilise les groupes de séparer les trois premières lettres. Le résultat est le suivant:

Match "Lorem"
     Group 1: "L"
     Group 2: "o"
     Group 3: "r"
     Group 4: "em"
Match "ipsum"
     Group 1: "i"
     Group 2: "p"
     Group 3: "s"
     Group 4: "um"
...

Match "consectetuer"
     Group 1: "c"
     Group 2: "o"
     Group 3: "n"
     Group 4: "sectetuer"
...

Donc, si nous appliquons la chaîne de substitution:

$1_$3$2_$4

... plus de cela, nous essayons d'utiliser le premier groupe, ajouter un trait de soulignement, utilisez le troisième groupe, puis le deuxième groupe, ajouter un autre trait de soulignement, et puis le quatrième groupe. La chaîne résultante serait comme celui ci-dessous.

L_ro_em i_sp_um d_lo_or s_ti_ a_em_t c_no_sectetuer f_ue_giat f_ma_es m_la_esuada p_er_tium e_eg_stas.

Vous pouvez utiliser des groupes nommés pour les substitutions, en utilisant ${name}.

Jouer avec les regexes, je recommande http://regex101.com/, qui offre une bonne quantité de détails sur la façon dont les regex fonctionne; il offre également quelques regex moteurs à choisir.

?: est utilisé lorsque vous souhaitez une expression, mais vous ne voulez pas enregistrer en tant que appariés/capturé partie de la chaîne.

Un exemple serait quelque chose pour correspondre à une adresse IP:

/(?:\d{1,3}\.){3}\d{1,3}/

Remarque que je n'aime pas à propos de l'enregistrement les 3 premiers octets, mais le (?:...) groupement me permet de raccourcir la regex sans encourir les frais généraux de la capture et du stockage d'un match.

HISTORIQUE de la MOTIVATION: L'existence de non-capture de groupes peut être expliqué par l'utilisation de parenthèses. Considérons les expressions (a|b)c et a|bc, en raison de la priorité de concaténation sur |, ces expressions représentent deux langues différentes ({ac, bc} et {a, bc}, respectivement). Cependant, les parenthèses sont utilisées aussi comme un groupe correspondant (comme expliqué par les autres réponses...).

Quand vous voulez avoir des parenthèses, mais pas de capture de la sous-expression que vous utilisez NON-CAPTURE de GROUPES. Dans l'exemple, (?:a|b)c

Laissez-moi essayer cela avec un exemple :-

Regex Code :- (?:animal)(?:=)(\w+)(,)\1\2

Chaîne De Recherche :-

Ligne 1 - animal=cat,dog,cat,tiger,dog

Ligne 2 - animal=cat,cat,dog,dog,tiger

Ligne 3 - animal=dog,dog,cat,cat,tiger

(?:animal) --> Non saisis Groupe 1

(?:=)--> Non saisis Groupe 2

(\w+)--> Capturé Groupe 1

(,)--> Groupe Capturé 2

\1 --> résultat de la capture de groupe 1 je.e Dans la Ligne 1 est le chat,Dans la Ligne 2 est le chat,Dans la Ligne 3 est chien.

\2 -->résultat de la capture de groupe 2 je.e par des virgules(,)

Donc dans ce code par exemple: \1 et \2, nous le rappelons, ou de répéter le résultat de la capture de groupe 1 et 2 respectivement, plus tard dans le code.

Selon l'ordre de code (?:animal) doit être groupe 1 et (?:=) devrait être le groupe 2 et continue..

mais, en leur donnant l' ?: nous faisons le match-groupe non pris en compte(qui ne compte pas éteint dans le groupe correspondant, de sorte que le groupement de nombre commence à partir du premier groupe capturé et non pas le non capturé), de sorte que la répétition du résultat du match-groupe de (?:animal) ne peut pas être appelé plus tard dans le code.

De l'espoir c'est ce qui explique la non-utilisation de la capture de groupe.

entrez la description de l'image ici

Eh bien, je suis un développeur JavaScript et va tenter d'expliquer son importance concernant JavaScript.

Envisager un scénario où vous voulez faire correspondre cat is animal
lorsque vous souhaitez correspondre à chat et les animaux, et les deux devraient avoir un is entre eux.

 //this will ignore "is" as that's is what we want
"cat is animal".match(/(cat)(?: is )(animal)/) ;
result ["cat is animal", "cat", "animal"]

 //using lookahead pattern it will match only "cat" we can
 //use lookahead but the problem is we can not give anything
 //at the back of lookahead pattern
"cat is animal".match(/cat(?= is animal)/) ;
result ["cat"]

 //so I gave another grouping parenthesis for animal
 //in lookahead pattern to match animal as well
"cat is animal".match(/(cat)(?= is (animal))/) ;
result ["cat", "cat", "animal"]

 //we got extra cat in above example so removing another grouping
"cat is animal".match(/cat(?= is (animal))/) ;
result ["cat", "animal"]

Une chose intéressante que j'ai trouvé est le fait que vous pouvez avoir une capture d'un groupe à l'intérieur d'un non-capture d'un groupe. Regardez ci-dessous regex pour la mise en correspondance des url web:

var parse_url_regex = /^(?:([A-Za-z]+):)(\/{0,3})([0-9.\-A-Za-z]+)(?::(\d+))?(?:\/([^?#]*))?(?:\?([^#]*))?(?:#(.*))?$/;

Url d'entrée de la chaîne:

var url = "http://www.ora.com:80/goodparts?q#fragment";

Le premier groupe dans ma regex (?:([A-Za-z]+):) est un non-capture d'un groupe qui correspond au schéma de protocole et du côlon : caractère c'est à dire http: mais quand j'ai été l'exécution de code ci-dessous, j'ai été voir le 1er indice du tableau retourné était contenant la chaîne de caractères http quand je pensais que http et du côlon : les deux ne seront pas signalés car ils sont à l'intérieur d'un non-capture d'un groupe.

console.debug(parse_url_regex.exec(url));

J'ai pensé que, si le premier groupe (?:([A-Za-z]+):) est un non-capture d'un groupe, alors pourquoi il est de retour http chaîne dans le tableau de sortie.

Donc, si vous remarquez qu'il y a un groupe imbriqué ([A-Za-z]+) à l'intérieur de la non-capture d'un groupe. Que groupe imbriqué ([A-Za-z]+) est une capture d'un groupe (ne pas avoir de ?: au début) dans lui-même à l'intérieur d'un non-capture d'un groupe (?:([A-Za-z]+):). C'est pourquoi le texte http toujours est capturé mais le côlon : personnage qui est à l'intérieur de la non-capture d'un groupe, mais à l'extérieur de la capture d'un groupe à ne pas avoir rapporté dans le tableau de sortie.

Je pense que je voudrais vous donner la réponse,
N'utilisez pas de capture de variables sans vérifier que le match réussi.

La capture de variables $1, etc, ne sont valables que si le match a réussi, et ils ne sont pas effacés, soit.

#!/usr/bin/perl  
use warnings;
use strict;   
$_ = "bronto saurus burger";
if (/(?:bronto)? saurus (steak|burger)/)
{
    print "Fred wants a  $1";
}
else
{
    print "Fred dont wants a $1 $2";
}

Dans l'exemple ci-dessus, À éviter la capture bronto dans $1, (?:) est utilisée.
Si le profil correspond , puis $1 est capturée comme prochaine regroupés modèle.
Donc, la sortie sera comme ci-dessous:

Fred wants a burger

Il est Utile si vous ne voulez pas les matchs pour être sauvé .

Extrêmement simple, Nous pouvons comprendre avec une simple date supposons, par exemple, si la date est mentionné que le 1er janvier 2019 ou 2 Mai 2019 ou à une autre date, et nous voulons simplement convertir jj/mm/aaaa format que nous n'aurions pas besoin de le mois du nom de laquelle est, en janvier ou en février de cette question, de sorte afin de capturer la partie numérique, mais pas le (facultatif) suffixe, vous pouvez utiliser un non-capture d'un groupe.

donc l'expression régulière serait,

([0-9]+)(?:January|February)?

Son aussi simple que cela.