blocks|key|276207|text|lookahead+(该(?=部件)不使用任何输入。它是一个零宽度断言(正如边界检查和lookbehinds一样)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|276208|您希望在这里进行常规匹配，以使用cow部分。要捕获中间的部分，可以使用一个捕获组(只需将要捕获的模式部分放在括号内)：|276209|cow(.*)milk|code-block|syntax|javascript|276210|根本不需要lookaheads。|276211|entityMap^0|C|3|0|G|3|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

<p>A lookahead (that <code>(?=</code> part) does not consume any input. It is a <em>zero-width assertion</em> (as are boundary checks and lookbehinds).</p>

<p>You want a regular match here, to consume the <code>cow</code> portion. To capture the portion in between, you use a capturing group (just put the portion of pattern you want to capture inside parenthesis):</p>



<pre class="lang-regex prettyprint-override"><code>cow(.*)milk
</code></pre>

<p>No lookaheads are needed at all.</p>


blocks|key|272666|text|你需要捕获牛奶可以(但不必)让奶牛真的不需要挤奶‘)；“lookahead.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|272667|/cow(.*?)milk/i.exec('My+.*You+|blockquote|offset|length|style|CODE|272668|”，“always+.*+"|unordered-list-item|272669|272670|
”，“always+|272671|.*|272672|272673|entityMap^0|0|P|2|0|A|2|0|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@$E|V|F|W|G|H]]|9|@]|A|$]]|$1|I|3|J|5|K|7|X|8|@$E|Y|F|Z|G|H]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|K|7|12|8|@$E|13|F|14|G|H]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|S|$]]

<ul>
<li>You need capture the <code>.*</code></li>
<li>You can (but don't have to) make the <code>.*</code> nongreedy</li>
<li><p>There's really no need for the lookahead.</p>

<pre><code>&gt; /cow(.*?)milk/i.exec('My cow always gives milk');
["cow always gives milk", " always gives "]
</code></pre></li>
</ul>


blocks|key|272681|text|下面是一个正则表达式，它将获取奶牛和牛奶之间的内容(没有前导/尾随空格)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|272682|srctext+=+"My+cow+always+gives+milk.";
var+re+=+/(.*cow\s%2B)(.*)(\s%2Bmilk.*)/;
var+newtext+=+srctext.replace(re,+"$2");|code-block|syntax|javascript|272683|一个例子：http://jsfiddle.net/entropo/tkP74/|offset|length|272684|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/entropo/tkP74/^0|0|0|5|Y|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<p>Here's a regex which will grab what's between cow and milk (without leading/trailing space):</p>

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

<p>An example: <a href="http://jsfiddle.net/entropo/tkP74/" rel="noreferrer">http://jsfiddle.net/entropo/tkP74/</a></p>


blocks|key|274247|text|只需使用以下正则表达式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|274248|(?<=My+cow\s).*?(?=\smilk)|code-block|syntax|javascript|274249|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Just use the following regular expression:</p>

<pre><code>(?&lt;=My cow\s).*?(?=\smilk)
</code></pre>


blocks|key|274329|text|用于在JavaScript中获取两个字符串之间的字符串的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|274330|正则表达式|blockquote|274331|274332|274333|在绝大多数情况下，最完整的解决方案是使用捕获组和惰点匹配模式。但是，JavaScript正则表达式中的点结构与换行符不匹配，因此，在100%25的情况下，可以使用[%5E]或[\s\S]/[\d\D]/[\w\W]构造。|offset|length|style|BOLD|CODE|274334|ECMAScript+2018和更新版本的兼容解决方案|274335|在支持ECMAScript+2018的JavaScript环境中，s修饰符允许.匹配任何字符，包括换行符，并且正则表达式引擎支持可变长度的lookbehinds。因此，您可以使用如下所示的正则表达式|274336|var+result+=+s.match(/(?<=cow\s%2B).*?(?=\s%2Bmilk)/gs);+//+Returns+multiple+matches+if+any
//+Or
var+result+=+s.match(/(?<=cow\s*).*?(?=\s*milk)/gs);+//+Same+but+whitespaces+are+optional|code-block|syntax|javascript|274337|在这两种情况下，都会检查当前位置是否存在cow之后具有任意1/0或更多空格的cow，然后匹配并使用尽可能少的0%2B字符(=添加到匹配值中)，然后检查milk+(在此子字符串之前包含任意1/0或更多空格)。|274338|场景1:单行输入|274339|所有JavaScript环境都支持此方案以及下面的所有其他方案。请参阅答案底部的用法示例。|274340|cow+(.*?)+milk|274341|首先找到cow，然后是一个空格，然后是除换行符之外的任何0%2B字符，尽可能少的*?是一个惰性限定符，被捕获到组1中，然后必须跟上一个带有milk的空格(这些字符也会被匹配和使用)。|274342|场景2:多行输入|274343|cow+([\s\S]*?)+milk|274344|在这里，首先匹配cow和空格，然后匹配尽可能少的0%2B字符并将其捕获到组1中，然后匹配带有milk的空格。|274345|场景3:重叠匹配|274346|如果你有一个像>>>15+text>>>67+text2>>>这样的字符串，并且你需要在>>>%2Bnumber%2Bwhitespace和>>>之间获得2个匹配项，你不能使用/>>>\d%2B\s(.*?)>>>/g，因为这将只找到一个匹配项，因为在找到第一个匹配项时，67之前的>>>已经被消耗了。你可以使用来检查文本的存在，而不需要真正地“吞噬”它(即附加到匹配中)：|274347|/>>>\d%2B\s(.*?)(?=>>>)/g|274348|如找到的第1组内容，请参阅生成text1和text2的online+regex+demo。|274349|另请参阅。|274350|性能注意事项|274351|如果给定很长的输入，正则表达式模式中的惰性点匹配模式(.*?)可能会减慢脚本执行速度。在许多情况下，在更大程度上有帮助。尝试从"Their\ncow\ngives\nmore\nmilk"获取cow和milk之间的所有内容，我们看到我们只需要匹配所有不以milk开头的行，因此，我们可以使用cow\n([\s\S]*?)\nmilk代替cow\n([\s\S]*?)\nmilk：|274352|/cow\n(.*(?:\n(?!milk$).*)*)\nmilk/gm|274353|查看regex+demo+(如果可以使用\r\n，请使用/cow\r?\n(.*(?:\r?\n(?!milk$).*)*)\r?\nmilk/gm)。使用这个小的测试字符串，性能增益可以忽略不计，但是对于非常大的文本，您会感觉到不同之处(特别是如果行很长，换行符不是很多)。|274354|JavaScript:+//Single/First+match中的|274355|示例正则表达式用法预期:不使用全局修饰符并访问match1+console.log("My+cow+always+gives“.match(/cow+(.*?)牛奶/)1)；//多个匹配:使用全局修饰符获取多个匹配，并//在已知前导/尾部分隔符长度的情况下修剪结果var+s=“我的牛总是产奶，他的牛也产奶”；console.log(/cow+(.*?).map/g).map(function(X)+{return+x.substr(4，x.length-9);}))；//或在循环内使用RegExp#exec收集所有第一组内容var+result+=+[]，m，rx+=+/cow+(.*?)牛奶/克；while+((m=rx.exec(s))+!==+null)+{+result.push(m1)；}+console.log(result)；使用现代的String#matchAll方法const+s=“我的牛总是挤奶，他的牛也挤奶”；const+matches+=+s.matchAll(/cow+(.*?)+)牛奶/克)；console.log(Array.from(matches，x+=>+x1));|274356|274357|entityMap|0|LINK|mutability|MUTABLE|url|https://regex101.com/r/Vtw7W1/2|1|https://regex101.com/r/Vtw7W1/3|2|https://regex101.com/r/e1W8DA/1|3|4|https://regex101.com/r/4xWB0S/2^0|0|0|0|0|K|3|O|6|27|3|2B|6|2I|6|2P|6|0|0|X|1|13|1|0|0|K|3|12|3|21|4|0|0|H|S|0|0|4|3|12|2|1V|4|0|0|0|8|3|18|4|0|0|7|O|18|3|1C|6|1J|A|1U|3|2C|J|3M|2|3R|3|2C|J|0|0|0|F|5|L|5|R|H|1|0|0|0|R|3|1R|V|2O|3|2S|4|3J|4|41|L|4O|L|41|L|2|4O|L|3|0|0|K|4|S|1A|2|A|4|0|0|AK|F|0|0^^$0|@$1|2|3|4|5|6|7|2E|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|2F|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|2G|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|2I|8|@$I|2J|J|2K|K|L]|$I|2L|J|2M|K|L]|$I|2N|J|2O|K|M]|$I|2P|J|2Q|K|M]|$I|2R|J|2S|K|M]|$I|2T|J|2U|K|M]]|9|@]|A|$]]|$1|N|3|O|5|6|7|2V|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|2W|8|@$I|2X|J|2Y|K|M]|$I|2Z|J|30|K|M]]|9|@]|A|$]]|$1|R|3|S|5|T|7|31|8|@]|9|@]|A|$U|V]]|$1|W|3|X|5|6|7|32|8|@$I|33|J|34|K|M]|$I|35|J|36|K|M]|$I|37|J|38|K|M]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|39|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|3A|8|@$I|3B|J|3C|K|L]]|9|@]|A|$]]|$1|12|3|13|5|T|7|3D|8|@]|9|@]|A|$U|V]]|$1|14|3|15|5|6|7|3E|8|@$I|3F|J|3G|K|M]|$I|3H|J|3I|K|M]|$I|3J|J|3K|K|M]]|9|@]|A|$]]|$1|16|3|17|5|6|7|3L|8|@]|9|@]|A|$]]|$1|18|3|19|5|T|7|3M|8|@]|9|@]|A|$U|V]]|$1|1A|3|1B|5|6|7|3N|8|@$I|3O|J|3P|K|M]|$I|3Q|J|3R|K|M]]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|3S|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|3T|8|@$I|3U|J|3V|K|M]|$I|3W|J|3X|K|M]|$I|3Y|J|3Z|K|M]|$I|40|J|41|K|M]|$I|42|J|43|K|M]|$I|44|J|45|K|M]|$I|46|J|47|K|M]|$I|48|J|49|K|M]]|9|@$I|4A|J|4B|1|4C]]|A|$]]|$1|1G|3|1H|5|T|7|4D|8|@]|9|@]|A|$U|V]]|$1|1I|3|1J|5|6|7|4E|8|@$I|4F|J|4G|K|M]|$I|4H|J|4I|K|M]]|9|@$I|4J|J|4K|1|4L]]|A|$]]|$1|1K|3|1L|5|6|7|4M|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|6|7|4N|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|6|7|4O|8|@$I|4P|J|4Q|K|M]|$I|4R|J|4S|K|M]|$I|4T|J|4U|K|M]|$I|4V|J|4W|K|M]|$I|4X|J|4Y|K|M]|$I|4Z|J|50|K|M]|$I|51|J|52|K|M]]|9|@$I|53|J|54|1|55]|$I|56|J|57|1|58]]|A|$]]|$1|1Q|3|1R|5|T|7|59|8|@]|9|@]|A|$U|V]]|$1|1S|3|1T|5|6|7|5A|8|@$I|5B|J|5C|K|M]|$I|5D|J|5E|K|M]]|9|@$I|5F|J|5G|1|5H]]|A|$]]|$1|1U|3|1V|5|6|7|5I|8|@]|9|@]|A|$]]|$1|1W|3|1X|5|D|7|5J|8|@$I|5K|J|5L|K|M]]|9|@]|A|$]]|$1|1Y|3|-4|5|6|7|5M|8|@]|9|@]|A|$]]|$1|1Z|3|-4|5|6|7|5N|8|@]|9|@]|A|$]]]|20|$21|$5|22|23|24|A|$25|26]]|27|$5|22|23|24|A|$25|28]]|29|$5|22|23|24|A|$25|2A]]|2B|$5|22|23|24|A|$25|2A]]|2C|$5|22|23|24|A|$25|2D]]]]

<blockquote>
<p>Regular expression to get a string between two strings in JavaScript</p>
</blockquote>
<p>The most complete solution that will work in the vast majority of cases is using a <strong>capturing group</strong> with a <strong>lazy dot matching pattern</strong>. However, a dot <code>.</code> in JavaScript regex does not match line break characters, so, what will work in 100% cases is a <code>[^]</code> or <code>[\s\S]</code>/<code>[\d\D]</code>/<code>[\w\W]</code> constructs.</p>
<h2>ECMAScript 2018 and newer compatible solution</h2>
<p>In JavaScript environments supporting <em>ECMAScript 2018</em>, <code>s</code> modifier allows <code>.</code> to match any char including line break chars, and the regex engine supports lookbehinds of variable length. So, you may use a regex like</p>
<pre><code>var result = s.match(/(?&lt;=cow\s+).*?(?=\s+milk)/gs); // Returns multiple matches if any
// Or
var result = s.match(/(?&lt;=cow\s*).*?(?=\s*milk)/gs); // Same but whitespaces are optional
</code></pre>
<p>In both cases, the current position is checked for <code>cow</code> with any 1/0 or more whitespaces after <code>cow</code>, then any 0+ chars as few as possible are matched and consumed (=added to the match value), and then <code>milk</code> is checked for (with any 1/0 or more whitespaces before this substring).</p>
<h2>Scenario 1: Single-line input</h2>
<p><em><strong>This and all other scenarios below are supported by all JavaScript environments. See usage examples at the bottom of the answer.</strong></em></p>
<pre><code>cow (.*?) milk
</code></pre>
<p><code>cow</code> is found first, then a space, then any 0+ chars other than line break chars, as few as possible as <code>*?</code> is a lazy quantifier, are captured into Group 1 and then a space with <code>milk</code> must follow (and those are matched and <em>consumed</em>, too).</p>
<h2>Scenario 2: Multiline input</h2>
<pre><code>cow ([\s\S]*?) milk
</code></pre>
<p>Here, <code>cow</code> and a space are matched first, then any 0+ chars as few as possible are matched and captured into Group 1, and then a space with <code>milk</code> are matched.</p>
<h2>Scenario 3: Overlapping matches</h2>
<p>If you have  a string like <code>&gt;&gt;&gt;15 text&gt;&gt;&gt;67 text2&gt;&gt;&gt;</code> and you need to get 2 matches in-between <code>&gt;&gt;&gt;</code>+<code>number</code>+<code>whitespace</code> and <code>&gt;&gt;&gt;</code>, you can't use <a href="https://regex101.com/r/Vtw7W1/2" rel="noreferrer"><code>/&gt;&gt;&gt;\d+\s(.*?)&gt;&gt;&gt;/g</code></a> as this will only find 1 match due to the fact the <code>&gt;&gt;&gt;</code> before <code>67</code> is already <em>consumed</em> upon finding the first match. You may use a <a href="http://www.regular-expressions.info/lookaround.html" rel="noreferrer"><strong>positive lookahead</strong></a> to check for the text presence without actually &quot;gobbling&quot; it (i.e. appending to the match):</p>
<pre><code>/&gt;&gt;&gt;\d+\s(.*?)(?=&gt;&gt;&gt;)/g
</code></pre>
<p>See the <a href="https://regex101.com/r/Vtw7W1/3" rel="noreferrer">online regex demo</a> yielding <code>text1</code> and <code>text2</code> as Group 1 contents found.</p>
<p>Also see <a href="https://stackoverflow.com/questions/18029487/how-to-get-all-possible-overlapping-matches-for-a-string"><em>How to get all possible overlapping matches for a string</em></a>.</p>
<h2>Performance considerations</h2>
<p>Lazy dot matching pattern (<code>.*?</code>) inside regex patterns may slow down script execution if very long input is given. In many cases, <a href="http://www.softec.lu/site/RegularExpressions/UnrollingTheLoop" rel="noreferrer"><em>unroll-the-loop technique</em></a> helps to a greater extent. Trying to grab all between <code>cow</code> and <code>milk</code> from <code>&quot;Their\ncow\ngives\nmore\nmilk&quot;</code>, we see that we just need to match all lines that do not start with <code>milk</code>, thus, instead of <a href="https://regex101.com/r/e1W8DA/1" rel="noreferrer"><code>cow\n([\s\S]*?)\nmilk</code></a> we can use:</p>
<pre><code>/cow\n(.*(?:\n(?!milk$).*)*)\nmilk/gm
</code></pre>
<p>See the <a href="https://regex101.com/r/4xWB0S/2" rel="noreferrer">regex demo</a> (if there can be <code>\r\n</code>, use <code>/cow\r?\n(.*(?:\r?\n(?!milk$).*)*)\r?\nmilk/gm</code>). With this small test string, the performance gain is negligible, but with very large text, you will feel the difference (especially if the lines are long and line breaks are not very numerous).</p>
<blockquote>
<h3>Sample regex usage in JavaScript:</h3>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>//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);</code></pre>
</div>
</div>
</p>
</blockquote>
<blockquote>
<h3>Using the modern <code>String#matchAll</code> method</h3>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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 =&gt; x[1]));</code></pre>
</div>
</div>
</p>
</blockquote>


blocks|key|2974850|text|我能够使用Martinho+Fernandes的解决方案得到我需要的东西。代码是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2974851|var+test+=+"My+cow+always+gives+milk";

var+testRE+=+test.match("cow(.*)milk");
alert(testRE[1]);|code-block|syntax|javascript|2974852|您会注意到，我将testRE变量作为数组发出警报。这是因为出于某种原因，testRE以数组的形式返回。以下内容的输出：|2974853|My+cow+always+gives+milk|2974854|更改为：|2974855|always+gives|2974856|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

<p>I was able to get what I needed using Martinho Fernandes' solution below. The code is:</p>

<pre><code>var test = "My cow always gives milk";

var testRE = test.match("cow(.*)milk");
alert(testRE[1]);
</code></pre>

<p>You'll notice that I am alerting the testRE variable as an array. This is because testRE is returning as an array, for some reason. The output from:</p>

<pre><code>My cow always gives milk
</code></pre>

<p>Changes into:</p>

<pre><code>always gives
</code></pre>


blocks|key|276342|text|选择的答案对me...hmm不起作用...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|276343|只需在奶牛之后和/或牛奶之前添加空格，以删除“总是给予”的空格。|276344|/(?<=cow+).*(?=+milk)/|code-block|syntax|javascript|276345|​|276346|📷|atomic|offset|length|276347|276348|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/60f76d8700478cb929c0861dca630500.png|imageAlt^0|0|0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|12|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|13|8|@]|9|@$N|14|O|15|1|16]]|A|$]]|$1|P|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X|Y|-4]]]]

<p>The chosen answer didn't work for me...hmm...</p>

<p>Just add space after cow and/or before milk to trim spaces from " always gives "</p>

<pre><code>/(?&lt;=cow ).*(?= milk)/
</code></pre>

<p><a href="https://i.stack.imgur.com/CwDOy.png" rel="noreferrer"><img src="https://i.stack.imgur.com/CwDOy.png" alt="enter image description here"></a></p>


blocks|key|270724|text|方法match()在字符串中搜索匹配项，并返回一个Array对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|270725|//+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]|code-block|syntax|javascript|270726|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>The method match() searches a string for a match and returns an Array object.</p>

<pre><code>// Original string
var str = "My cow always gives milk";

// Using index [0] would return&lt;br/&gt;
// "**cow always gives milk**"
str.match(/cow(.*)milk/)**[0]**


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


blocks|key|276358|text|考虑到语法，我发现正则表达式既乏味又耗时。由于您已经在使用javascript，因此在不使用regex的情况下执行以下操作会更容易：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|276359|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"|code-block|syntax|javascript|276360|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I find regex to be tedious and time consuming given the syntax. Since you are already using javascript it is easier to do the following without regex: </p>

<pre class="lang-js prettyprint-override"><code>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"
</code></pre>


blocks|key|272813|text|任务|type|unstyled|depth|inlineStyleRanges|entityRanges|data|272814|提取两个字符串之间的子串(不包括这两个字符串)|272815|解决方案|272816|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)(.%2B?)(?=\\s%2B${textAfter})`,+"g");
var+results+=+regExp.exec(allText);
if+(results+&&+results.length+>+1)+{
++++console.log(results[0]);
}|code-block|syntax|javascript|272817|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<h2>Task</h2>

<p>Extract substring between two string (excluding this two strings)</p>

<h2>Solution</h2>

<pre><code>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(`(?&lt;=${textBefore}\\s)(.+?)(?=\\s+${textAfter})`, "g");
var results = regExp.exec(allText);
if (results &amp;&amp; results.length &gt; 1) {
    console.log(results[0]);
}
</code></pre>


blocks|key|2974975|text|如果数据在多行上，那么您可能需要使用以下代码，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2974976|/My+cow+([\s\S]*)milk/gm

My+cow+always+gives+
milk|code-block|syntax|javascript|2974977|Regex+101+example+|offset|length|2974978|entityMap|0|LINK|mutability|MUTABLE|url|https://regex101.com/r/wDHQ8i/2^0|0|0|0|I|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<p>If the data is on multiple lines then you may have to use the following,</p>

<pre><code>/My cow ([\s\S]*)milk/gm

My cow always gives 
milk
</code></pre>

<p><a href="https://regex101.com/r/wDHQ8i/2" rel="nofollow noreferrer">Regex 101 example </a></p>


blocks|key|270741|text|你可以使用解构来只关注你感兴趣的那部分。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|270742|所以你可以这样做：|270743|​|270744|let+str+=+"My+cow+always+gives+milk";

let+[,+result]+=+str.match(/\bcow\s%2B(.*?)\s%2Bmilk\b/)+%7C%7C+[];

console.log(result);|code-block|syntax|javascript|270745|270746|这样，您就忽略了第一部分(完全匹配)，而只获得了捕获组的匹配。如果您根本不确定是否会有匹配，那么添加%7C%7C+[]可能会很有趣。在这种情况下，match将返回无法解构的null，因此我们在这种情况下返回[]，然后result将为null。|offset|length|style|CODE|270747|额外的\b确保了周围的单词“奶牛”和“牛奶”是真正分开的单词(例如，不是“牛奶”)。此外，还需要\s%2B来避免匹配包含一些外部间距。|270748|entityMap^0|0|0|0|0|0|1E|5|1X|5|2A|4|2R|2|2W|6|34|4|0|3|2|1C|3|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Y|8|@]|9|@]|A|$I|J]]|$1|K|3|E|5|6|7|Z|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|10|8|@$N|11|O|12|P|Q]|$N|13|O|14|P|Q]|$N|15|O|16|P|Q]|$N|17|O|18|P|Q]|$N|19|O|1A|P|Q]|$N|1B|O|1C|P|Q]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1D|8|@$N|1E|O|1F|P|Q]|$N|1G|O|1H|P|Q]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|U|$]]

<p>You can use destructuring to only focus on the part of your interest.</p>
<p>So you can do:</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let str = "My cow always gives milk";

let [, result] = str.match(/\bcow\s+(.*?)\s+milk\b/) || [];

console.log(result);</code></pre>
</div>
</div>
</p>
<p>In this way you ignore the first part (the complete match) and only get the capture group's match. The addition of <code>|| []</code> may be interesting if you are not sure there will be a match at all. In that case <code>match</code> would return <code>null</code> which cannot be destructured, and so we return <code>[]</code> instead in that case, and then <code>result</code> will be <code>null</code>.</p>
<p>The additional <code>\b</code> ensures the surrounding words &quot;cow&quot; and &quot;milk&quot; are really separate words (e.g. not &quot;milky&quot;). Also <code>\s+</code> is needed to avoid that the match includes some outer spacing.</p>


blocks|key|2975032|text|您可以使用match()方法提取两个字符串之间的子字符串。尝试以下代码：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2975033|var+str+=+"My+cow+always+gives+milk";
var+subStr+=+str.match("cow(.*)milk");
console.log(subStr[1]);|code-block|syntax|javascript|2975034|输出：|2975035|2975036|总是给出|blockquote|2975037|2975038|2975039|这里有一个完整的例子：How+to+find+sub-string+between+two+strings。|2975040|entityMap|0|LINK|mutability|MUTABLE|url|https://stackhowto.com/how-to-find-sub-string-between-the-two-words-using-jquery/^0|5|7|0|0|0|0|0|0|0|B|16|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|17|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|18|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|19|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1B|8|@]|D|@$9|1C|A|1D|1|1E]]|E|$]]|$1|U|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]]]

<p>You can use the method <code>match()</code> to extract a substring between two strings. Try the following code:</p>
<pre><code>var str = &quot;My cow always gives milk&quot;;
var subStr = str.match(&quot;cow(.*)milk&quot;);
console.log(subStr[1]);
</code></pre>
<p>Output:</p>
<blockquote>
<p>always gives</p>
</blockquote>
<p>See a complete example here : <a href="https://stackhowto.com/how-to-find-sub-string-between-the-two-words-using-jquery/" rel="nofollow noreferrer">How to find sub-string between two strings</a>.</p>


<p>I have found very similar posts, but I can't quite get my regular expression right here.</p>

<p>I am trying to write a regular expression which returns a string which is between two other strings. For example: I want to get the string which resides between the strings "cow" and "milk".</p>

<blockquote>
  <p>My cow always gives milk</p>
</blockquote>

<p>would return</p>

<blockquote>
  <p>"always gives"</p>
</blockquote>

<p>Here is the expression I have pieced together so far:</p>

<pre><code>(?=cow).*(?=milk)
</code></pre>

<p>However, this returns the string "cow always gives".</p>


Regular expression to get a string between two strings in Javascript

我找到了非常相似的帖子，但我不能在这里得到我的正则表达式。我正在尝试编写一个正则表达式，它返回一个字符串，该字符串位于另外两个字符串之间。例如:我想要获取位于字符串"cow“和"milk”之间的字符串。我的母牛总是产奶将会返回“总是给予”下面是我到目前为止拼凑的表达式：(?=cow).*(?=milk)但是，这将返回字...

问正则表达式在Javascript中获取两个字符串之间的字符串
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问正则表达式在Javascript中获取两个字符串之间的字符串EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问正则表达式在Javascript中获取两个字符串之间的字符串
EN