Expresión regular para obtener una cadena entre dos cadenas en Javascript

He encontrado publicaciones muy similares, pero no puedo obtener mi expresión regular aquí.

Estoy tratando de escribir una expresión regular que devuelve una cadena que se encuentra entre otras dos cadenas. Por ejemplo: quiero obtener la cadena que reside entre las cadenas "vaca" y "leche".

Mi vaca siempre da leche

volvería

"siempre da"

Aquí está la expresión que he juntado hasta ahora:

(?=cow).*(?=milk)

Sin embargo, esto devuelve la cadena "vaca siempre da".

Una búsqueda anticipada (esa (?=parte) no consume ninguna entrada. Es una afirmación de ancho cero (al igual que las comprobaciones de límites y las miradas posteriores).

Desea una coincidencia regular aquí, para consumir la cowporción. Para capturar la parte intermedia, utiliza un grupo de captura (solo coloca la parte del patrón que deseas capturar entre paréntesis):

cow(.*)milk

No se necesitan lookaheads en absoluto.

Expresión regular para obtener una cadena entre dos cadenas en JavaScript

La solución más completa que funcionará en la gran mayoría de los casos es usar un grupo de captura con un patrón de coincidencia de puntos diferidos . Sin embargo, un punto .en JavaScript expresión regular no coincide con caracteres de salto de línea, por lo que, lo que va a funcionar en 100% de los casos es un [^]o [\s\S]/ [\d\D]/ [\w\W]construcciones.

ECMAScript 2018 y una solución compatible más nueva

En entornos JavaScript que admiten ECMAScript 2018 , el smodificador permite .hacer coincidir cualquier carácter, incluidos los caracteres de salto de línea, y el motor regex admite retrospectivas de longitud variable. Entonces, puedes usar una expresión regular como

var result = s.match(/(?<=cow\s+).*?(?=\s+milk)/gs); // Returns multiple matches if any
// Or
var result = s.match(/(?<=cow\s*).*?(?=\s*milk)/gs); // Same but whitespaces are optional

En ambos casos, la posición actual se verifica cowcon cualquier 1/0 o más espacios en blanco después cow, luego se iguala y consume cualquier carácter de 0+ lo menos posible (= agregado al valor de coincidencia), y luego milkse verifica (con cualquier 1/0 o más espacios en blanco antes de esta subcadena).

Escenario 1: entrada de línea única

Este y todos los demás escenarios a continuación son compatibles con todos los entornos JavaScript. Ver ejemplos de uso al final de la respuesta.

cow (.*?) milk

cowse encuentra en primer lugar, a continuación, un espacio, entonces cualquier 0+ caracteres distintos de caracteres de salto de línea, tan pocos como sea posible como *?es un cuantificador perezoso, son capturados en el Grupo 1 y luego un espacio con milkdebe seguir (y aquellos se emparejan y consume , también )

Escenario 2: entrada multilínea

cow ([\s\S]*?) milk

Aquí, cowy se hace coincidir un espacio primero, luego se combinan los caracteres 0+ lo menos posible y se capturan en el Grupo 1, y luego milkse hace coincidir un espacio con .

Escenario 3: coincidencias superpuestas

Si tiene una cadena como >>>15 text>>>67 text2>>>y necesita obtener 2 coincidencias entre >>>+ number+ whitespacey >>>, no puede usar, />>>\d+\s(.*?)>>>/gya que esto solo encontrará 1 coincidencia debido a que el >>>anterior 67ya se consume al encontrar la primera coincidencia. Puede utilizar una búsqueda anticipada positiva para verificar la presencia del texto sin realmente "engullirlo" (es decir, agregarlo a la coincidencia):

/>>>\d+\s(.*?)(?=>>>)/g

Vea el rendimiento de la demostración de expresiones regulares en líneatext1 y los text2contenidos del Grupo 1 encontrados.

Consulte también Cómo obtener todas las coincidencias superpuestas posibles para una cadena .

Consideraciones de rendimiento

El patrón de coincidencia de puntos diferidos ( .*?) dentro de los patrones de expresiones regulares puede ralentizar la ejecución del script si se proporciona una entrada muy larga. En muchos casos, la técnica de desenrollar el bucle ayuda en mayor medida. Intentando tomar todo entre cowy milkdesde "Their\ncow\ngives\nmore\nmilk", vemos que solo necesitamos unir todas las líneas que no comienzan milk, por lo tanto, en lugar de cow\n([\s\S]*?)\nmilkpoder usar:

/cow\n(.*(?:\n(?!milk$).*)*)\nmilk/gm

Vea la demostración de expresiones regulares (si puede haberla \r\n, úsela /cow\r?\n(.*(?:\r?\n(?!milk$).*)*)\r?\nmilk/gm). Con esta pequeña cadena de prueba, la ganancia de rendimiento es insignificante, pero con un texto muy grande, sentirá la diferencia (especialmente si las líneas son largas y los saltos de línea no son muy numerosos).

Ejemplo de uso de expresiones regulares en JavaScript:

//Single/First match expected: use no global modifier and access match[1]
console.log("My cow always gives milk".match(/cow (.*?) milk/)[1]);
// Multiple matches: get multiple matches with a global modifier and
// trim the results if length of leading/trailing delimiters is known
var s = "My cow always gives milk, thier cow also gives milk";
console.log(s.match(/cow (.*?) milk/g).map(function(x) {return x.substr(4,x.length-9);}));
//or use RegExp#exec inside a loop to collect all the Group 1 contents
var result = [], m, rx = /cow (.*?) milk/g;
while ((m=rx.exec(s)) !== null) {
  result.push(m[1]);
}
console.log(result);

Ejecutar fragmento de códigoOcultar resultados

Expandir fragmento

Usando el String#matchAllmétodo moderno

const s = "My cow always gives milk, thier cow also gives milk";
const matches = s.matchAll(/cow (.*?) milk/g);
console.log(Array.from(matches, x => x[1]));

Ejecutar fragmento de códigoOcultar resultados

Expandir fragmento

Aquí hay una expresión regular que captará lo que hay entre la vaca y la leche (sin espacio inicial / final):

srctext = "My cow always gives milk.";
var re = /(.*cow\s+)(.*)(\s+milk.*)/;
var newtext = srctext.replace(re, "$2");

Un ejemplo: http://jsfiddle.net/entropo/tkP74/

• Necesitas capturar el .*
• Puedes (pero no tienes que hacerlo) hacer la no .*codicia

• Realmente no hay necesidad de mirar hacia adelante.

  > /cow(.*?)milk/i.exec('My cow always gives milk');
  ["cow always gives milk", " always gives "]

La respuesta elegida no funcionó para mí ... hmm ...

Simplemente agregue espacio después de la vaca y / o antes de la leche para recortar espacios de "siempre da"

/(?<=cow ).*(?= milk)/

Pude obtener lo que necesitaba usando la solución de Martinho Fernandes a continuación. El codigo es:

var test = "My cow always gives milk";

var testRE = test.match("cow(.*)milk");
alert(testRE[1]);

Notarás que estoy alertando a la variable testRE como una matriz. Esto se debe a que testRE está regresando como una matriz, por alguna razón. La salida de:

My cow always gives milk

Cambios en:

always gives

Simplemente use la siguiente expresión regular:

(?<=My cow\s).*?(?=\smilk)

Encuentro que la expresión regular es tediosa y consume mucho tiempo dada la sintaxis. Como ya está usando JavaScript, es más fácil hacer lo siguiente sin regex:

const text = 'My cow always gives milk'
const start = `cow`;
const end = `milk`;
const middleText = text.split(start)[1].split(end)[0]
console.log(middleText) // prints "always gives"

Si los datos están en varias líneas, es posible que deba usar lo siguiente

/My cow ([\s\S]*)milk/gm

My cow always gives 
milk

Ejemplo de Regex 101

El método match () busca una cadena para una coincidencia y devuelve un objeto Array.

// Original string
var str = "My cow always gives milk";

// Using index [0] would return<br/>
// "**cow always gives milk**"
str.match(/cow(.*)milk/)**[0]**


// Using index **[1]** would return
// "**always gives**"
str.match(/cow(.*)milk/)[1]

Tarea

Extraiga la subcadena entre dos cadenas (excluyendo estas dos cadenas)

Solución

let allText = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum";
let textBefore = "five centuries,";
let textAfter = "electronic typesetting";
var regExp = new RegExp(`(?<=${textBefore}\\s)(.+?)(?=\\s+${textAfter})`, "g");
var results = regExp.exec(allText);
if (results && results.length > 1) {
    console.log(results[0]);
}