【问题标题】:Regular expression to get a string between two strings in Javascript正则表达式在Javascript中获取两个字符串之间的字符串
【发布时间】:2011-08-04 06:43:34
【问题描述】:

我发现了非常相似的帖子,但我无法在这里找到我的正则表达式。

我正在尝试编写一个正则表达式,它返回一个位于其他两个字符串之间的字符串。例如:我想获取位于字符串“cow”和“milk”之间的字符串。

我的奶牛总是产奶

会回来

“总是给予”

这是我目前拼凑出来的表达方式:

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

但是,这会返回字符串“cow always give”。

【问题讨论】:

  • 我偶然发现了这个老问题,想弄清楚为什么 testRE 是一个数组。 test.match 返回一个数组,其中第一个索引作为总匹配(因此,匹配牛(。*)牛奶的字符串),然后,如果有第二组括号,所有被困的字符串,如(。*)然后在 testRE[2]
  • 如果您搜索包含换行符的字符串,此解决方案将不起作用。在这种情况下,您应该使用“STRING_ONE([\\s\\S]*?)STRING_TWO”。 stackoverflow.com/questions/22531252/…

标签: javascript regex string


【解决方案1】:

您可以使用方法match() 来提取两个字符串之间的子字符串。试试下面的代码:

var str = "My cow always gives milk";
var subStr = str.match("cow(.*)milk");
console.log(subStr[1]);

输出:

总是给予

在此处查看完整示例:How to find sub-string between two strings。

【讨论】:

    【解决方案2】:

    您可以使用解构来只关注您感兴趣的部分。

    所以你可以这样做:

    let str = "My cow always gives milk";
    
    let [, result] = str.match(/\bcow\s+(.*?)\s+milk\b/) || [];
    
    console.log(result);

    这样你就忽略了第一部分(完整的匹配),只得到捕获组的匹配。如果您不确定是否会有匹配,添加|| [] 可能会很有趣。在这种情况下,match 将返回无法解构的null,因此在这种情况下我们返回[],然后result 将是null。

    附加的\b 确保周围的单词“cow”和“milk”是真正独立的单词(例如不是“milky”)。还需要\s+ 以避免匹配包含一些外部间距。

    【讨论】:

      【解决方案3】:

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

      适用于绝大多数情况的最完整的解决方案是使用具有惰性点匹配模式的捕获组。但是,JavaScript 正则表达式中的点 . 与换行符不匹配,因此,在 100% 的情况下有效的是 [^] 或 [\s\S]/[\d\D]/[\w\W] 构造。

      ECMAScript 2018 和更新的兼容解决方案

      在支持 ECMAScript 2018 的 JavaScript 环境中,s 修饰符允许 . 匹配任何字符,包括换行字符,并且正则表达式引擎支持可变长度的后视。所以,你可以使用像

      这样的正则表达式
      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 在cow 之后的任何1/0 或更多空格,然后匹配并消耗尽可能少的任何0+ 个字符(=添加到匹配值) ,然后检查milk(在此子字符串之前有任何 1/0 或更多空格)。

      场景一:单行输入

      所有 JavaScript 环境都支持此场景和以下所有其他场景。请参阅答案底部的用法示例。

      cow (.*?) milk
      

      首先找到cow,然后是一个空格,然后是除换行符之外的任何 0+ 字符,尽可能少的 *? 是一个惰性量词,被捕获到第 1 组,然后是一个带有 @987654343 的空格@ 必须跟在后面(并且它们也被匹配和消耗)。

      场景 2:多行输入

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

      这里首先匹配cow和一个空格,然后匹配尽可能少的任何0+个字符并捕获到第1组,然后匹配一个带有milk的空格。

      场景 3:重叠匹配

      如果您有一个类似&gt;&gt;&gt;15 text&gt;&gt;&gt;67 text2&gt;&gt;&gt; 的字符串,并且您需要在&gt;&gt;&gt;+number+whitespace 和&gt;&gt;&gt; 之间获得2 个匹配项,则不能使用/&gt;&gt;&gt;\d+\s(.*?)&gt;&gt;&gt;/g,因为这只会找到 1 个匹配项,因为在找到第一个匹配项时,67 之前的 &gt;&gt;&gt; 已经消耗。您可以使用 positive lookahead 来检查文本是否存在而不实际“吞噬”它(即附加到匹配项):

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

      查看online regex demo 产生text1 和text2 作为第1 组的内容。

      另见How to get all possible overlapping matches for a string。

      性能考虑

      如果输入很长,正则表达式模式中的惰性点匹配模式 (.*?) 可能会减慢脚本执行速度。在许多情况下,unroll-the-loop technique 的帮助更大。尝试从"Their\ncow\ngives\nmore\nmilk" 中获取cow 和milk 之间的所有内容,我们看到我们只需要匹配所有不以milk 开头的行,因此,我们可以使用cow\n([\s\S]*?)\nmilk 而不是:

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

      查看regex demo(如果有\r\n,请使用/cow\r?\n(.*(?:\r?\n(?!milk$).*)*)\r?\nmilk/gm)。使用这么小的测试字符串,性能提升可以忽略不计,但是对于非常大的文本,您会感觉到差异(尤其是在行长且换行符不是很多的情况下)。

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

      使用现代的String#matchAll 方法

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

      【讨论】:

      【解决方案4】:

      如果数据在多行上,那么您可能必须使用以下内容,

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

      Regex 101 example

      【讨论】:

        【解决方案5】:

        任务

        提取两个字符串之间的子字符串(不包括这两个字符串)

        解决方案

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

        【讨论】:

          【解决方案6】:

          鉴于语法,我发现正则表达式既乏味又耗时。由于您已经在使用 javascript,因此无需正则表达式即可更轻松地执行以下操作:

          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"
          

          【讨论】:

          • 为我工作!很棒的答案,因为它真的很简单! :)
          • 它错过了两个边缘情况。 1. 如果主字符串中缺少 start ,则会抛出异常。 2.如果主字符串中缺少end,那么它仍然会返回结果,这将是错误的匹配。
          【解决方案7】:

          只需使用以下正则表达式:

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

          【讨论】:

          • 在 Javascript 中不支持查看 ?&lt;=。会是这样做的方式。
          • JavaScript 支持。 Safari 和 Mozilla(目前)不支持它,只有 Chrome 和 Opera 支持。
          【解决方案8】:

          我能够使用以下 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
          

          【讨论】:

          【解决方案9】:

          方法 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]
          

          【讨论】:

            【解决方案10】:

            选择的答案对我不起作用...嗯...

            只需在奶牛之后和/或牛奶之前添加空格来修剪“总是给”的空格

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

            【讨论】:

            • 在 Javascript 中不支持查看 ?&lt;=。
            • @MarkCarpenterJr 如果您通过regextester.com 对其进行了测试,您将得到该提示。该站点似乎基于旧规范的规则。现在支持 Lookbehind。请参阅stackoverflow.com/questions/30118815/… 并且该模式适用于现代浏览器而不会出错。试试这个检查器regex101.com
            【解决方案11】:

            这是一个正则表达式,它将抓取牛奶和牛奶之间的内容(没有前导/尾随空格):

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

            一个例子:http://jsfiddle.net/entropo/tkP74/

            【讨论】:

              【解决方案12】:
              • 您需要捕获.*
              • 您可以(但不是必须)使 .* 不贪婪
              • 真的不需要前瞻。

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

              【讨论】:

              • 在这种特殊情况下,如果它是贪婪的,它会到达终点并回溯(大概)。
              【解决方案13】:

              前瞻((?= 部分)不消耗任何输入。这是一个零宽度断言(边界检查和后视也是如此)。

              您希望在这里进行常规匹配,以消耗 cow 部分。要捕获两者之间的部分,请使用捕获组(只需将要捕获的模式部分放在括号内):

              cow(.*)milk
              

              根本不需要前瞻。

              【讨论】:

              • 当我测试这个时,提供的正则表达式同时包含“cow”和“milk”...
              • 这缺少一个步骤。当你得到匹配的结果时,你需要提取第一个捕获组与matched[1]的匹配文本,而不是与matched[0]匹配的整个文本。
              • 在Javascript中,你实际上需要使用([\s\S]*?)而不是(.*?)。
              • 虽然这是一种有用的技术,但它被否决了,因为恕我直言,这不是问题的正确答案,因为它包括“奶牛”和“牛奶”,正如 @TheCascadian 所述
              • @sborn - 感谢您指出这一点。我认为这个问题为解释提供了空间。我想到的是一个(尽可能多的香草)正则表达式,它过滤原始消息并提供所要求的结果。这个正则表达式就是这种情况:/([^(my cow)])(.*)[^(milk)]/g 请检查jsfiddle.net/almircampos/4L2wam0u/5 的小提琴,让我们知道你的想法。
              猜你喜欢
              • 2014-12-08
              • 2013-09-02
              • 1970-01-01
              • 1970-01-01
              • 1970-01-01
              • 1970-01-01
              • 1970-01-01
              相关资源
              最近更新 更多