RegEx pour passer la ponctuation

Je suppose qu'ici nous souhaitons concevoir une expression et faire correspondre nos entrées, partie par partie, comme:

const regex = /(.+?)\s+CO\s+(['"].+?['"])([(\[{]).+?([)\]}])/mg;
const str = `3M CO 'A'(MINNESOTA MINING AND MANUFACTURING COMPANY)
3M CO 'A'[MINNESOTA MINING AND MANUFACTURING COMPANY]
3M CO 'A'{MINNESOTA MINING AND MANUFACTURING COMPANY}
3M CO "A"{MINNESOTA MINING AND MANUFACTURING COMPANY}`;
let m;

while ((m = regex.exec(str)) !== null) {
    // This is necessary to avoid infinite loops with zero-width matches
    if (m.index === regex.lastIndex) {
        regex.lastIndex++;
    }
    
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

Nous avons ajouté des limites supplémentaires, qui peuvent être réduites si pas souhaité.

Nous avons trois groupes de capture principaux:

(.+?) # anything before Co;
(['"].+?['"]) # the quotation part; and
([(\[{]).+?([)\]}]) # inside various brackets included those, which we can escape, if required.

Circuit RegEx

jex.im visualise les expressions régulières:

DEMO a>

Démo

Cet extrait montre simplement le fonctionnement des groupes de capture:

(.+?)\s+CO\s+(['"].+?['"])([(\[{]).+?([)\]}])

RegEx

Si cette expression n'était pas souhaitée, elle peut être modifiée / changée dans regex101.com .

Votre expression régulière doit être exprimée en

let regex = /(.*)\sCO\s?(\(.+\)|".+".*|'.+'.*|{.+}.*|\[.+\].*)/;

[pattern, match1, match2] = "3M CO 'A'(MINNESOTA MINING AND MANUFACTURING COMPANY)".match(regex);
console.log(match1 + " CO " + match2);
//3M CO 'A'(MINNESOTA MINING AND MANUFACTURING COMPANY)

[pattern, match1, match2] = '3M CO (A)(MINNESOTA MINING AND MANUFACTURING COMPANY)'.match(regex);
console.log(match1 + " CO " + match2);
//3M CO (A)(MINNESOTA MINING AND MANUFACTURING COMPANY)

[pattern, match1, match2] = '3M CO "A"(MINNESOTA MINING AND MANUFACTURING COMPANY)'.match(regex);
console.log(match1 + " CO " + match2);
//3M CO "A"(MINNESOTA MINING AND MANUFACTURING COMPANY)

[pattern, match1, match2] = "3M CO [A](MINNESOTA MINING AND MANUFACTURING COMPANY)".match(regex);
console.log(match1 + " CO " + match2);
//3M CO [A](MINNESOTA MINING AND MANUFACTURING COMPANY)

[pattern, match1, match2] = "3M CO {A}(MINNESOTA MINING AND MANUFACTURING COMPANY)".match(regex);
console.log(match1 + " CO " + match2);
//3M CO {A}(MINNESOTA MINING AND MANUFACTURING COMPANY)

(. *) Le premier groupe de capture capturera le groupe de départ ("3M" dans votre exemple)

\ sCO \ s Recherche ensuite un espace suivi de CO suivi d'un espace

(". +". * etc.) Deuxième groupe de capture qui recherche les guillemets ou crochets de départ suivis d'au moins un caractère de tout suivi d'un guillemet fermant, suivi d'un nombre quelconque caractère

Pourquoi la regex originale n'a pas fonctionné

Dans l'expression régulière originale, [\ (. * \) | \ [. * \] | \ {. * \} | ''. * '' | ". *"] peut être simplifié en [''. * ''] (pour la chaîne que vous avez fournie) . Je me rends compte que pour les autres chaînes, vous voudrez peut-être rechercher (. *) ou [. *] ou {. *} ou ". *" , mais pour la chaîne "3M", seul le [''. * ''] est pertinent donc nous allons juste regarder ceci. p >

Donc [''. * ''] signifie simplement: correspond à n'importe quel caractère de la liste à l'intérieur de [] , dans n'importe quel ordre. Dans ce cas, il y a trois caractères uniques dans la liste: ', . et * (même si vous l'avez fait répéter ' 3 fois). Il correspondait donc au premier '. Mais comme cette correspondance est en dehors de votre groupe de capture () , ce premier ' n'est pas inclus dans la réponse de votre groupe de capture.

Donc, la prochaine correspondance avec (. *) correspond à tout ce qui vient après le premier ' et les inclut dans le deuxième groupe correspondant, c'est-à-dire A '(MINNESOTA MINING AND MANUFACTURING COMPANY) sans le ' devant.

Est-ce que cela a du sens?

Démo

Si vous vouliez vous assurer que le format inclut 'A' ou [A] ou "A" code> ou {A} ou (A) , voici ce que vous voulez:

/(.*)\sCO\s?(\(.+\).*|".+".*|'.+'.*|{.+}.*|\[.+\].*)/

Le ' ne correspond pas car dans le deuxième groupe de capture car vous utilisez une classe de caractères qui peut être écrite sous la forme CO \ s? [(. *) | [\] {} '"] et ensuite il correspondra à CO'

Donc, votre modèle ressemble en fait à:

(.*?)CO\s?((?:(['"]).*?\3|\(.*?\)|\[.*?\]|\{.*?\}).*)

Ce que vous pourriez faire pour obtenir ceux qui correspondent dans 2 groupes, il faut utiliser:

(.*) CO\s?[.*()|[\]{}'"](.*)
^         ^             ^
group 1   Char class    group 2

Explication

• (. *?) Groupe de capture 1, correspond à n'importe quel caractère sauf saut de ligne non gourmand
• CO \ s? Faire correspondre CO et caractère d'espacement facultatif
• ( Groupe de capture 2
  • (?: Groupe non capturant, correspond à l'une des options
    • (['"]). *? \ 3 Faire correspondre' ou" et utiliser une référence arrière à ce qui est capturé
    • | Ou
    • \ (. *? \) Correspondance (....)
    • | Ou
    • \ [. *? \] Match [....
    • | Ou
    • \ {. *? \} Correspondance {....}
  • ) Fermer le groupe non capturant
  • . * Correspond à n'importe quel caractère jusqu'à la fin de la chaîne
• ) Fermer le groupe 2

Démo Regex

Notez que la . *? n'est pas gourmand pour éviter les retours en arrière inutiles et les correspondances excessives.