javascript regex: ¿mirar detrás de la alternativa?

Aquí hay una expresión regular que funciona bien en la mayoría de las implementaciones de expresiones regulares:

(?<!filename)\.js$

Esto coincide con .js para una cadena que termina con .js excepto para filename.js

Javascript no tiene regex retrospectiva. ¿Alguien puede armar una expresión regular alternativa que logre el mismo resultado y funcione en javascript?

Aquí hay algunos pensamientos, pero necesita funciones de ayuda. Esperaba lograrlo solo con una expresión regular: http://blog.stevenlevithan.com/archives/mimic-lookbehind-javascript

^(?!filename).+\.js funciona para mi

probado contra:

• prueba.js partido
• partido de blabla.js
• filename.js no coincide

¿Se puede encontrar una explicación adecuada para esta expresión regular en Expresión regular para que coincida con la cadena que no contiene una palabra?

Look ahead está disponible desde la versión 1.5 de javascript y es compatible con todos los principales navegadores

Actualizado para coincidir con filename2.js y 2filename.js pero no filename.js

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

EDITAR: desde ECMAScript 2018 en adelante, las aserciones retrospectivas (incluso ilimitadas) son compatibles de forma nativa .

En versiones anteriores, puedes hacer esto:

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

Esto hace explícitamente lo que la expresión de retrospectiva está haciendo implícitamente: verifique cada carácter de la cadena si la expresión de retrospectiva más la expresión regular después de que no coincida, y solo entonces permita que ese carácter coincida.

^                 # 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

Otra edición:

Me duele decir (especialmente porque esta respuesta se ha votado tanto) que hay una manera mucho más fácil de lograr este objetivo. No hay necesidad de verificar la anticipación de cada personaje:

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

funciona igual de 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

Supongamos que desea encontrar todo lo que intno esté precedido por unsigned:

Con soporte para mirar hacia atrás negativo:

(?<!unsigned )int

Sin soporte para la retrospectiva negativa:

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

Básicamente, la idea es tomar n caracteres anteriores y excluir la coincidencia con anticipación negativa, pero también coincide con los casos en los que no hay n caracteres anteriores. (donde n es la longitud de mirar hacia atrás).

Entonces la expresión regular en cuestión:

(?<!filename)\.js$

se traduciría a:

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

Es posible que deba jugar con grupos de captura para encontrar el lugar exacto de la cadena que le interesa o no desea reemplazar una parte específica con otra cosa.

Si puede mirar hacia adelante pero hacia atrás, puede invertir la cadena primero y luego mirar hacia adelante. Se necesitará más trabajo, por supuesto.

Esta es una solución equivalente a la respuesta de Tim Pietzcker (ver también comentarios de la misma respuesta):

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

Significa, partido *.jsexcepto *filename.js.

Para llegar a esta solución, puede verificar qué patrones excluye la mirada negativa hacia atrás y luego excluir exactamente estos patrones con una mirada negativa hacia adelante.

A continuación se muestra una alternativa positiva de JavaScript detrás que muestra cómo capturar el apellido de las personas con 'Michael' como primer nombre.

1) Dado este texto:

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?";

obtener una variedad de apellidos de personas llamadas Michael. El resultado debería ser:["Jordan","Johnson","Green","Wood"]

2) Solución:

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) Verificar solución

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

Demostración aquí: http://codepen.io/PiotrBerebecki/pen/GjwRoo

También puedes probarlo ejecutando el fragmento a continuación.

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)    ));