RegEx может мне помочь только получить содержимое внутри (# CONTENT #) [duplicate]

Выбранный ответ не сработал для меня ... hmm ...

Просто добавьте пробел после коровы и / или перед молоком, чтобы обрезать пробелы из «всегда дает»

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

Вот регулярное выражение, которое будет захватывать то, что находится между коровой и молоком (без начального / конечного пространства):

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

Пример: http://jsfiddle.net/entropo/tkP74/

• Вам нужно захватить .*
• Вы можете (но не обязательно) сделать .* nongreedy
• В действительности нет необходимости в поиске ,

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

Как насчет использования следующего регулярного выражения:

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

Я смог получить то, что мне нужно, используя решение Martinho Fernandes ниже. Код:

var test = "My cow always gives milk";

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

Вы заметите, что я предупреждаю переменную testRE как массив. Это связано с тем, что по какой-то причине testRE возвращается как массив. Выход из:

My cow always gives milk

Изменяется на:

always gives

Метод match () ищет строку для соответствия и возвращает объект 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]

Регулярное выражение для получения строки между двумя строками в Javascript

Наиболее полным решением, которое будет работать в подавляющем большинстве случаев, является использование группы захвата с ленивой точкой сопоставив образец. Однако точка . в регулярном выражении JS не соответствует символам разрыва строки, поэтому в 100% случаях будет работать конструкция [^] или [\s\S] / [\d\D] / [\w\W].

ECMAScript 2018 и более новое совместимое решение

В средах JS, поддерживающих ECMAScript 2018 , модификатор s позволяет . соответствовать любому символу, включая символы разрыва строки , а механизм регулярных выражений поддерживает lookbehinds переменной длины. Таким образом, вы можете использовать регулярное выражение, подобное

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

. В обоих случаях текущая позиция проверяется на cow с любыми пробелами 1/0 или более после cow, тогда любые символы 0+ как как минимум, сопоставляются и потребляются (= добавлено к значению соответствия), а затем milk проверяется (с любыми пробелами 1/0 или более перед этой подстрокой).

Сценарий 1: линейный вход

Этот и все другие сценарии, приведенные ниже, поддерживаются всеми средами JS. См. Примеры использования в нижней части ответа.

cow (.*?) milk

cow находится сначала, затем пробел, затем любые символы 0+, отличные от символов разрыва строки, как можно меньше поскольку *? является ленивым квантификатором, захватываются в группу 1, а затем следует пробел с milk (и они совпадают и потребляется тоже).

Сценарий 2: Многострочный вход

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

Здесь сначала будут сопоставлены cow и пробел, а любые символы 0+ как можно меньше сопоставляются и записываются в группу 1, а затем пробел с milk сопоставлены.

Сценарий 3: совпадение совпадений

Если у вас есть строка типа >>>15 text>>>67 text2>>>, и вам нужно получить 2 совпадения между >>> + number + whitespace и >>>, вы не можете использовать />>>\d+\s(.*?)>>>/g , так как это будет только найти 1 совпадение из-за того, что >>> до 67 уже потребляется при нахождении первого матча. Вы можете использовать положительный lookahead , чтобы проверить наличие текста, фактически не «сжимая» его (то есть добавляя к совпадению):

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

См. Интерактивное регулярное выражение demo , приведя text1 и text2 к содержимому группы 1.

Также см. . Как получить все возможные совпадающие совпадения для строки .

Показатели производительности

Шаблон сопоставления в стиле латинских точек (.*?) внутри шаблонов регулярных выражений может замедлить выполнение скрипта, если задан очень длинный ввод. Во многих случаях метод unroll-the-loop помогает в большей степени. Попытка захватить все между cow и milk из "Their\ncow\ngives\nmore\nmilk", мы видим, что нам просто нужно сопоставить все строки, которые не начинаются с milk, поэтому вместо cow\n([\s\S]*?)\nmilk мы можем использовать:

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

См. демонстрацию regex (если есть \r\n, используйте /cow\r?\n(.*(?:\r?\n(?!milk$).*)*)\r?\nmilk/gm). С помощью этой небольшой тестовой строки прирост производительности пренебрежимо мал, но с очень большим текстом вы почувствуете разницу (особенно если линии длинны, а разрывы строк не очень многочисленны).

Образец regex в 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);