Regex pour faire correspondre la chaîne contenant deux noms dans n'importe quel ordre

J'ai besoin d'un ET logique dans regex.

quelque chose comme

jack et james

d'accord avec les chaînes suivantes

• 'Salut Jack, voici James '

• 'Salut James, voici Jack '

Vous pouvez effectuer des vérifications en utilisant des lookarounds :

^(?=.*\bjack\b)(?=.*\bjames\b).*$

Essaye-le.

Cette approche présente l'avantage de pouvoir spécifier facilement plusieurs conditions.

^(?=.*\bjack\b)(?=.*\bjames\b)(?=.*\bjason\b)(?=.*\bjules\b).*$

Essayer:

james.*jack

Si vous voulez les deux en même temps, alors orles:

james.*jack|jack.*james

Explication de la commande que je vais écrire : -

. signifie n'importe quel caractère, chiffre peut remplacer.

* signifie zéro ou plusieurs occurrences de chose écrite juste avant.

|signifie «ou» .

Alors,

james.*jack

chercherait james , puis n'importe quel nombre de caractères jusqu'à ce que jackvient.

Puisque vous voulez soit jack.*jamesoujames.*jack

D'où la commande :

jack.*james|james.*jack

C'est court et doux

(?=.*jack)(?=.*james)

Tu peux faire:

\bjack\b.*\bjames\b|\bjames\b.*\bjack\b

Vim a un opérateur de succursale \& qui est utile lors de la recherche d'une ligne contenant un ensemble de mots, dans n'importe quel ordre. De plus, étendre l'ensemble des mots requis est trivial.

Par exemple,

/.*jack\&.*james

correspondra à une ligne contenant jacket james, dans n'importe quel ordre.

Consultez cette réponse pour plus d'informations sur l'utilisation. Je ne connais aucune autre saveur regex qui implémente le branchement; l'opérateur n'est même pas documenté sur l' entrée wikipedia Expression régulière .

MÉTHODE 1: Un jacket unjames

Juste au cas où deux jackou deux jamesne seraient pas autorisés, un seul jacket un jamesseraient valides, nous pouvons probablement concevoir une expression similaire à:

^(?!.*\bjack\b.*\bjack\b)(?!.*\bjames\b.*\bjames\b)(?=.*\bjames\b)(?=.*\bjack\b).*$

Ici, nous exclurions ces instances de paires en utilisant ces instructions:

(?!.*\bjack\b.*\bjack\b)

et,

(?!.*\bjames\b.*\bjames\b)

Démo RegEx 1

Nous pouvons également simplifier cela pour,

^(?!.*\bjack\b.*\bjack\b|.*\bjames\b.*\bjames\b)(?=.*\bjames\b|.*\bjack\b).*$

Démo RegEx 2

Si vous souhaitez simplifier / modifier / explorer l'expression, cela a été expliqué dans le panneau supérieur droit de regex101.com . Si vous le souhaitez, vous pouvez également regarder dans ce lien , comment il correspondrait à certains exemples d'entrées.

Circuit RegEx

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

Tester

const regex = /^(?!.*\bjack\b.*\bjack\b|.*\bjames\b.*\bjames\b)(?=.*\bjames\b|.*\bjack\b).*$/gm;
const str = `hi jack here is james
hi james here is jack
hi james jack here is jack james
hi jack james here is james jack
hi jack jack here is jack james
hi james james here is james jack
hi jack jack jack here is james
`;
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}`);
    });
}

MÉTHODE 2: Un jacket un jamesdans un ordre spécifique

Il peut également être conçu pour le premier jamesdernier jack, similaire au suivant:

^(?!.*\bjack\b.*\bjack\b|.*\bjames\b.*\bjames\b)(?=.*\bjames\b.*\bjack\b).*$

Démo RegEx 3

et vice versa:

^(?!.*\bjack\b.*\bjack\b|.*\bjames\b.*\bjames\b)(?=.*\bjack\b.*\bjames\b).*$

Démo RegEx 4

Vous pouvez utiliser la fonction de quantification de regex car elle lookaroundpeut ne pas être prise en charge tout le temps.

(\b(james|jack)\b.*){2,}