Aquí es una expresión regular que funciona bien en la mayoría de los regex implementaciones:

(?<!filename)\.js$

Este de los partidos .js de una cadena que termina con .js excepto para filename.js

Javascript no tiene regex lookbehind. Es alguien capaz de poner juntos una alternativa regex que lograr el mismo resultado y trabaja en javascript?

Aquí están algunas ideas, pero las necesidades de las funciones auxiliares. Tenía la esperanza de lograr sólo con una expresión regular:
http://blog.stevenlevithan.com/archives/mimic-lookbehind-javascript

  • si usted sólo tiene que comprobar un nombre de archivo o la lista de nombres de archivos, ¿por qué no usar simplemente dos cheques? compruebe si termina en .js y, a continuación, si lo hace, compruebe que no coincida con filename.js o viceversa.
  • Actualización: La última versión de Cromo (v62) incluye (presumiblemente experimental) lookbehinds fuera de la caja 😀 Nota, sin embargo, que lookbehinds todavía están en fase de propuesta 3: github.com/tc39/proposal-regexp-lookbehind . Así, se puede tomar un tiempo hasta que JavaScript en todas partes lo admite. Mejor tener cuidado en el uso en la producción!
  • # Actualización: ES2018 incluye declaraciones de búsqueda hacia atrás Más: – dotAll modo de espera (el indicador s) – declaraciones de búsqueda hacia atrás – Denominada captura de los grupos de Unicode propiedad se escapa
  • Sólo el uso de (?<=thingy)thingy para positivo lookbehind y (?<!thingy)thingy para el negativo lookbehind. Ahora es compatible con ellos.
  • Tan de Febrero de 2018 eso no es cierto todavía!! Y va a necesitar un poco de tiempo porque los navegadores y motores debe implementar la especificación actual (en el proyecto).
  • Sí, tienes razón. El propuesta se encuentra actualmente en la Etapa 4. Tal vez estaba pensando sólo en Chrome, supongo.
  • nodejs kangax.github.io/compat-tabla/es2016plus soporta

InformationsquelleAutor daniel | 2011-09-11

6 Comentarios

  1. 60

    ^(?!filename).+\.js me funciona

    prueba en contra:

    • test.js partido
    • blabla.js partido
    • filename.js ningún partido

    Una explicación adecuada para esta expresión se puede encontrar en la Expresión Regular para que coincida con la cadena no contiene una palabra?

    Mirar hacia adelante está disponible desde la versión 1.5 de javascript y es compatible con todos los principales navegadores

    Actualizado para que coincida con filename2.js y 2filename.js pero no filename.js

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

    • El enlace que pones en tu post no está funcionando.
    • corregido el enlace ¿olvidó añadir la dirección url completa
    • Esa pregunta se ha vinculado a las conversaciones acerca de un problema un poco diferente: la coincidencia de una cadena que no contiene el destino de la palabra lugar. Este es mucho más sencillo: la coincidencia de una cadena que no iniciar con la palabra objetivo.
    • Eso es muy bonito, sólo se echa de menos en casos como: filename2.js o filenameddk.js o similar. Este es un partido, sino que debe ser una coincidencia.
    • actualiza para coincidir con filename2.js y 2filename.js
    • Usted pidió un vistazo detrás, no es un look-ahead, ¿por qué aceptó esta respuesta?
    • Estoy grave-la excavación de aquí, pero la versión actualizada de uno tiene un roto/inútil de captura de grupo y de los partidos «filename.js» en la cadena «nombre de archivo.json». Debe ser ^(?!filename\.js$).+\.js$
    • el dado no coincide en a.js
    • El original regex con lookbehind no coincide con 2filename.js, pero la expresión regular dada aquí. Lo más apropiado sería ^(?!.*filename\.js$).*\.js$. Esto significa, que coincida con cualquier *.js excepto *filename.js.

  2. 142

    EDIT: De ECMAScript 2018 en adelante, declaraciones de búsqueda hacia atrás (aún sin límites) son compatibles de forma nativa.

    En versiones anteriores, puedes hacer esto:

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

    Esto hace de forma explícita lo que el lookbehind expresión está haciendo implícitamente: verificación de cada uno de los caracteres de la cadena si el lookbehind expresión más el regex después no coincide, y sólo entonces permitir que el carácter de partido.

    ^                 # 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 (sobre todo porque esta respuesta ha sido upvoted mucho) que hay un camino más fácil para lograr este objetivo. No hay necesidad de comprobar el lookahead en 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
    • Funciona en muchos de los casos, excepto donde hay precedentes caracteres, por ejemplo: filename.js (obras-nomatch) filename2.js (obras-match) blah.js (obras – match) 2filename.js (no funciona – nomatch) — dicho esto, el lookbehind tiene la misma limitación que no me había dado cuenta hasta ahora…
    • Así, su expresión regular (con lookbehind) también no coincide con 2filename.js. Mi expresión regular coincide exactamente de la misma en casos como el de tu ejemplo regex.
    • Sí, su derecho, lo siento.
    • Perdonad mi ingenuidad pero hay un uso para el que no la captura de grupo aquí? Siempre he sabido que para ser sólo útil cuando se intenta recoger de vuelta de referencia para el reemplazo en una cadena. Hasta donde yo sé, esto también va a trabajar ^(?!filename\.js$).*\.js$
    • No se muy bien, que regex busca «filename.js» sólo en el inicio de la cadena. Pero ^(?!.*filename\.js$).*\.js$ iba a funcionar. Tratando de pensar en situaciones en las que el ncgroup todavía podría ser necesario…
    • Este enfoque se puede resumir así: en lugar de mirar detrás de X, mirar hacia adelante a cada personaje que viene antes de la X?
    • Sí, pero la re-lectura de mi respuesta me di cuenta de que hay una manera mucho menos complicada solución que se me había pasado por alto completamente. Actualizar mi respuesta X-)

  3. 22

    Supongamos que queremos encontrar todos los int no precedido por unsigned:

    Con soporte para negativos mirada-detrás:

    (?<!unsigned )int

    Sin soporte para negativos mirada-detrás:

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

    Básicamente la idea es agarrar n anterior personajes y excluir de coincidir con la negativa de look-ahead, pero también coinciden con los casos en los que no hay precedentes de n caracteres. (donde n es la longitud de la mirada-detrás).

    Por lo que la expresión en cuestión:

    (?<!filename)\.js$

    podría traducirse:

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

    Usted puede ser que necesite para jugar con los grupos de captura para encontrar el lugar exacto de la cadena que te interesa o quieres no para reemplazar la parte específica con algo más.

    • Me acabo de convertir este: (?<!barna)(?<!ene)(?<!en)(?<!erne) (?:sin|vår)e?(?:$| (?!egen|egne)) a (?!barna).(?!erne).(?!ene).(?!en).. (?:sin|vår)e?(?:$| (?!egen|egne)) que hace el truco para mis necesidades. Sólo la prestación de este como otro «mundo real» escenario. Consulte enlace
    • Creo que quiso decir: ((?!unsigned ).{9}|^.{0,8})int
    • Sí. Gracias. Acabo de corregir mi respuesta.
    • Gracias por la respuesta más generalizada que funciona incluso cuando no es necesario para que coincida con profundo en el texto (donde inicial ^ sería poco práctico)!
  4. 5

    Si usted puede mirar hacia adelante, sino hacia atrás, usted podría revertir la cadena de primero y luego realizar una búsqueda hacia delante. Algunos de los más trabajo necesita ser hecho, por supuesto.

    • Esta respuesta podría realmente utilizar algunas mejoras. Se parece más a un comentario para mí.
  5. 0

    Este es un equivalente de la solución a Tim Pietzcker la respuesta (ver también los comentarios de la misma respuesta):

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

    Significa, partido *.js excepto *filename.js.

    Para llegar a esta solución, se puede comprobar que los patrones de la negativa lookbehind excluye, y luego excluir exactamente estos patrones negativos de oteo.

  6. -1

    A continuación es positivo lookbehind JavaScript alternativa que muestra cómo capturar el último nombre de las personas con ‘Michael’ como su primer nombre.

    1) Dado que 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 matriz de los últimos nombres de la gente, llamado Michael.
    El resultado debe 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) Verificación de la solución

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

    Demo aquí: http://codepen.io/PiotrBerebecki/pen/GjwRoo

    También puedes probar ejecutando el siguiente fragmento.

    JS:

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

Dejar respuesta

Please enter your comment!
Please enter your name here