javascript regex - regarder derrière une alternative?

Voici une regex qui fonctionne bien dans la plupart des implémentations de regex:

(?<!filename)\.js$

Cela correspond à .js pour une chaîne qui se termine par .js sauf pour filename.js

Javascript n'a pas de regex lookbehind. Quelqu'un est-il capable de créer une expression régulière alternative qui atteint le même résultat et fonctionne en javascript?

Voici quelques réflexions, mais a besoin de fonctions d'assistance. J'espérais y parvenir simplement avec une regex: http://blog.stevenlevithan.com/archives/mimic-lookbehind-javascript

^(?!filename).+\.js travaille pour moi

testé contre:

• correspondance test.js
• match blabla.js
• filename.js pas de correspondance

Une explication correcte de cette expression régulière peut être trouvée dans Expression régulière pour correspondre à une chaîne ne contenant pas de mot?

Look ahead est disponible depuis la version 1.5 de javascript et est pris en charge par tous les principaux navigateurs

Mis à jour pour correspondre à filename2.js et 2filename.js mais pas à filename.js

(^(?!filename\.js$).).+\.js

EDIT: À partir d'ECMAScript 2018, les assertions de recherche (même illimitées) sont prises en charge de manière native .

Dans les versions précédentes, vous pouvez faire ceci:

^(?:(?!filename\.js$).)*\.js$

Cela fait explicitement ce que fait implicitement l'expression lookbehind: vérifiez chaque caractère de la chaîne si l'expression lookbehind plus le regex après elle ne correspondent pas, et seulement alors autorisez ce caractère à correspondre.

^                 # Start of string
(?:               # Try to match the following:
 (?!              # First assert that we can't match the following:
  filename\.js    # filename.js 
  $               # and end-of-string
 )                # End of negative lookahead
 .                # Match any character
)*                # Repeat as needed
\.js              # Match .js
$                 # End of string

Une autre modification:

Cela me fait mal de dire (d'autant plus que cette réponse a été tellement votée) qu'il existe un moyen beaucoup plus simple d'atteindre cet objectif. Il n'est pas nécessaire de vérifier l'anticipation de chaque caractère:

^(?!.*filename\.js$).*\.js$

fonctionne aussi bien:

^                 # Start of string
(?!               # Assert that we can't match the following:
 .*               # any string, 
  filename\.js    # followed by filename.js
  $               # and end-of-string
)                 # End of negative lookahead
.*                # Match any string
\.js              # Match .js
$                 # End of string

Supposons que vous vouliez tout trouver intnon précédé de unsigned:

Avec prise en charge du look-behind négatif:

(?<!unsigned )int

Sans prise en charge de la rétroaction négative:

((?!unsigned ).{9}|^.{0,8})int

Fondamentalement, l'idée est de saisir n caractères précédents et d'exclure la correspondance avec une anticipation négative, mais également de faire correspondre les cas où il n'y a pas de n caractères précédents. (où n est la longueur du regard derrière).

Donc le regex en question:

(?<!filename)\.js$

se traduirait par:

((?!filename).{8}|^.{0,7})\.js$

Vous devrez peut-être jouer avec la capture de groupes pour trouver l'endroit exact de la chaîne qui vous intéresse ou vous ne voulez pas remplacer une partie spécifique par autre chose.

Si vous pouvez regarder en avant mais en arrière, vous pouvez d'abord inverser la chaîne, puis faire une anticipation. Il faudra bien sûr faire un peu plus de travail.

C'est une solution équivalente à la réponse de Tim Pietzcker (voir aussi les commentaires de la même réponse):

^(?!.*filename\.js$).*\.js$

Cela signifie, match *.jssauf *filename.js.

Pour arriver à cette solution, vous pouvez vérifier quels modèles le lookbehind négatif exclut, puis exclure exactement ces modèles avec une anticipation négative.

Vous trouverez ci-dessous un aperçu positif de l'alternative JavaScript montrant comment capturer le nom de famille des personnes avec `` Michael '' comme prénom.

1) Compte tenu de ce texte:

const exampleText = "Michael, how are you? - Cool, how is John Williamns and Michael Jordan? I don't know but Michael Johnson is fine. Michael do you still score points with LeBron James, Michael Green Miller and Michael Wood?";

obtenir un tableau de noms de famille de personnes nommées Michael. Le résultat devrait être:["Jordan","Johnson","Green","Wood"]

2) Solution:

function getMichaelLastName2(text) {
  return text
    .match(/(?:Michael )([A-Z][a-z]+)/g)
    .map(person => person.slice(person.indexOf(' ')+1));
}

// or even
    .map(person => person.slice(8)); // since we know the length of "Michael "

3) Vérifier la solution

console.log(JSON.stringify(    getMichaelLastName(exampleText)    ));
// ["Jordan","Johnson","Green","Wood"]

Démo ici: http://codepen.io/PiotrBerebecki/pen/GjwRoo

Vous pouvez également l'essayer en exécutant l'extrait ci-dessous.

const inputText = "Michael, how are you? - Cool, how is John Williamns and Michael Jordan? I don't know but Michael Johnson is fine. Michael do you still score points with LeBron James, Michael Green Miller and Michael Wood?";



function getMichaelLastName(text) {
  return text
    .match(/(?:Michael )([A-Z][a-z]+)/g)
    .map(person => person.slice(8));
}

console.log(JSON.stringify(    getMichaelLastName(inputText)    ));