VOTRE REGEX est logiquement et syntialatiquement pour les expressions ordinaires compatibles Perl-compatibles (PCRE). Le problème que je crois que vous êtes confronté est le fait que JavaScript a des problèmes avec des groupes de capture répétés. C'est pourquoi la regex fonctionne bien une fois que vous avez pris le {2,} code>. En ajoutant le quantificateur, JavaScript sera sûr de revenir uniquement fort> le dernier match.

Ce que je recommanderais, c'est supprimer le quantificateur {2,} code> et ensuite vérifiant par programme. allumettes. Je sais que ce n'est pas idéal pour ceux qui sont de grands fans de regex, mais c'est la vie em>. P>

S'il vous plaît voir l'extrait ci-dessous: p>

p>

var regex = /(?:01(\d{14})|10([^\x1D]{6,20})|11(\d{6})|17(\d{6}))/g;
var str = "011234567890123417501200";

// Check to see if we have at least 2 matches.
var m = str.match(regex);
console.log("Matches list: " + JSON.stringify(m));
if (m.length < 2) {
    console.log("We only received " + m.length + " matches.");
} else {
    console.log("We received " + m.length + " matches.");
    console.log("We have achieved the minimum!");
}

// If we exec the regex, what would we get?
console.log("** Method 1 **");
var n;
while (n = regex.exec(str)) {
    console.log(JSON.stringify(n));
}

// That's not going to work.  Let's try using a second regex.
console.log("** Method 2 **");
var regex2 = /^(\d{2})(\d{6,})$/;
var arr = [];
var obj = {};
for (var i = 0, len = m.length; i < len; i++) {
    arr = m[i].match(regex2);
    obj[arr[1]] = arr[2];
}

console.log(JSON.stringify(obj));

// EOF

La raison en est que les groupes de capture ne donnent que le dernier match par ce groupe particulier. Imaginez que vous auriez deux codes à barres dans votre séquence qui ont à la fois le même identifiant 01 code> ... maintenant, il devient évident que 1 $ code> ne peut pas se référer aux deux en même temps. Le groupe de capture conserve uniquement la deuxième occurrence.

Un moyen simple, mais pas si élégant, est de supprimer le {2,} code> et répétez plutôt le motif d'expression régulier pour correspondre au second code à barres. séquence. Je pense que vous devez également utiliser le ^ code> (début de l'ancrage de chaîne) pour vous assurer que la correspondance est au début de la chaîne, sinon vous pourriez récupérer un identifiant à mi-chemin d'une séquence non valide. Après le motif d'expression régulier répété, vous devez également ajouter . * Code> si vous souhaitez ignorer tout ce qui suit après la deuxième séquence, et ne vous y retournerez pas lorsque vous utilisez remplacer code> . P>

Enfin, comme vous ne savez pas quel identifiant sera trouvé pour la première et deuxième match, vous devez reproduire 1 $ $ 3 $ 3 $ 4 code> dans votre Remplacer , sachant que l'une de ces quatre sera une chaîne non vide. Idem pour le deuxième match: 5 $ 6 $ 7 $ 8 $ 8 $ code>. P>

Voici le code amélioré appliqué à votre exemple de chaîne: p>

P>

var str = "011234567890123417501200";
var regex = /(?:01(\d{14})|10([^\x1D]{6,20})|11(\d{6})|17(\d{6})|(.))/g;
//              1: ^^^^^^  2: ^^^^^^^^^^^^^  3: ^^^^^  4: ^^^^^ 5:^ (=failure)
var result = [], grp;
while ((grp = regex.exec(str)) && !grp[5]) result.push(grp.slice(1).join(''));

// Consider it a failure when not at least 2 matched.
if (result.length < 2) result = [];
console.log(result);