Exemple d'analyse de l'utilisation du regroupement sans capture des expressions régulières JS

L'exemple de cet article décrit l'utilisation d'un regroupement sans capture d'expressions régulières JS. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

Lorsque je regardais JsonSQL récemment, j'ai appris ce qu'est le regroupement sans capture et ses scénarios d'utilisation grâce à une expression régulière dans le code source. Dans js, le format de regroupement de capture normal est (XX) et le format de regroupement sans capture est (?:XX). Commençons par le quantificateur d'expression régulière. Si nous exigeons que le caractère b apparaisse au moins une fois, nous pouvons utiliser le caractère régulier /b / ; si nous exigeons que ab apparaisse au moins une fois, alors nous devons utiliser /(ab) /, et non /ab/. En d’autres termes, si vous souhaitez utiliser des quantificateurs pour plusieurs caractères, vous devez utiliser des parenthèses.

var str = "a1***ab1cd2***c2";
var reg1 = /((ab)+\d+)((cd)+\d+)/i;
var reg2 = /((?:ab)+\d+)((?:cd)+\d+)/i;
alert(str.match(reg1));//ab1cd2,ab1,ab,cd2,cd
alert(str.match(reg2));//ab1cd2,ab1,cd2

Vous pouvez voir la différence entre les groupes capturants et les groupes non capturants : les groupes non capturants ne sont utilisés que pour la correspondance et n'extraireont pas le groupe contenu. . Autrement dit, si l'on veut utiliser uniquement des parenthèses pour modifier certains caractères avec des quantificateurs, on n'a pas besoin du contenu de ce groupe, qui est un groupe non capturant.

Le code suivant est utilisé pour extraire divers sous-fragments dans l'instruction SQL. Il utilise un grand nombre de groupes non capturants, vous pouvez donc y regarder de plus près.

var returnfields = sql.match(/^\s*SELECT\s+((?:[0-9A-Za-z_]+\s*,\s*)+[0-9A-Za-z_]+ |\*|[0-9A-Za-z_]+)\s+FROM\s+([a-z0-9A-Z_]+)(?: where\s+(.+))?(?:\s+order\s+by\s+([a-z0-9_A-Z]+)(?:\s+(asc|desc|ascnum|descnum)?))?(?:\s+limit\s+(\d+,\d+))?/i);
var ops = {
  fields: returnfields[1].replace('\s','').split(','),
  from: returnfields[2].replace('\s',''),
  where: (returnfields[3] == undefined)? "true":returnfields[3],
  orderby: (returnfields[4] == undefined)? []:returnfields[4].replace('\s','').split(','),
  order: (returnfields[5] == undefined)? "asc":returnfields[5],
  limit: (returnfields[6] == undefined)? []:returnfields[6].replace('\s','').split(',')
};

Il y a plusieurs explications à cette règle régulière :

1. Les noms de champs et les indications ne peuvent être composés que de majuscules et de minuscules. lettres, composées de chiffres et de traits de soulignement.

2. La condition après où doit être placée entre (), sinon elle ne peut pas correspondre. C'est différent du vrai SQL.

3. Les champs suivant la sélection ont 3 formats : champ unique, champs multiples (séparés par des virgules) et tous les champs (indiqués par *).

4. La sous-instruction Where, la sous-instruction Order by et la sous-instruction Limit sont toutes facultatives.

Le texte suivant peut correspondre à l'expression régulière ci-dessus :

select age from data where (name=='aty')

J'espère que cet article sera utile à tout le monde dans la programmation JavaScript.

Pour plus d'articles connexes sur des exemples d'utilisation de regroupement sans capture d'expressions régulières JS, veuillez faire attention au site Web PHP chinois !