如何在JavaScript中使用类似于PHP的preg_match_all()的正则表达式匹配多个匹配项?

2020/10/29 03:43 · javascript ·  · 0评论

我正在尝试解析由以key&value分隔的key = value对组成的url编码的字符串&

以下内容仅与第一次出现的内容匹配,将键和值拆分为单独的结果元素:

var result = mystring.match(/(?:&|&)?([^=]+)=([^&]+)/)

字符串'1111342 = Adam%20Franco&348572 = Bob%20Jones'的结果为:

['1111342', 'Adam%20Franco']

使用全局标志'g'将匹配所有匹配项,但仅返回完全匹配的子字符串,而不返回分隔的键和值:

var result = mystring.match(/(?:&|&)?([^=]+)=([^&]+)/g)

字符串'1111342 = Adam%20Franco&348572 = Bob%20Jones'的结果为:

['1111342=Adam%20Franco', '&348572=Bob%20Jones']

虽然我可以将字符串分割开来&并分别拆分每个键/值对,但是有没有办法使用JavaScript的正则表达式支持来匹配多次出现的/(?:&|&)?([^=]+)=([^&]+)/类似于PHPpreg_match_all()函数的模式

我的目标是通过一些子匹配来获得结果,例如:

[['1111342', '348572'], ['Adam%20Franco', 'Bob%20Jones']]

要么

[['1111342', 'Adam%20Franco'], ['348572', 'Bob%20Jones']]

从评论中悬挂

2020年评论:现在,我们不再使用regex,而是URLSearchParams为我们完成了所有这些工作,因此不再需要自定义代码,更不用说regex了。

Mike'Pomax'Kamermans

浏览器支持在此处列出https://caniuse.com/#feat=urlsearchparams


我建议使用另一种正则表达式,使用子组分别捕获参数的名称和值以及re.exec()

function getUrlParams(url) {
  var re = /(?:\?|&(?:amp;)?)([^=&#]+)(?:=?([^&#]*))/g,
      match, params = {},
      decode = function (s) {return decodeURIComponent(s.replace(/\+/g, " "));};

  if (typeof url == "undefined") url = document.location.href;

  while (match = re.exec(url)) {
    params[decode(match[1])] = decode(match[2]);
  }
  return params;
}

var result = getUrlParams("http://maps.google.de/maps?f=q&source=s_q&hl=de&geocode=&q=Frankfurt+am+Main&sll=50.106047,8.679886&sspn=0.370369,0.833588&ie=UTF8&ll=50.116616,8.680573&spn=0.35972,0.833588&z=11&iwloc=addr");

result 是一个对象:

{
  f:“ q”
  地理编码:“”
  hl:“ de”
  即:“ UTF8”
  iwloc:“地址”
  ll:“ 50.116616,8.680573”
  问:“美因河畔法兰克福”
  sll:“ 50.106047,8.679886”
  来源:“ s_q”
  spn:“ 0.35972,0.833588”
  sspn:“ 0.370369,0.833588”
  z:“ 11”
}

正则表达式分解如下:

(?:#非捕获组
  \?|&#“?” 要么 ”&”
  (?:amp;)?#(允许“&”,用于错误地HTML编码的URL)
)#结束非捕获组
(#组1
  [^ =&#] +#除“ =“,“&”或“#”外的任何字符;至少一次
)#结束组1-这将是参数的名称
(?:#非捕获组
  =?#一个“ =”,可选
  (#组2
    [^&#] *#除“&”或“#”外的任何字符;任何次数
  )#结束组2-这将是参数的值
)#结束非捕获组

您需要使用“ g”开关进行全局搜索

var result = mystring.match(/(&|&)?([^=]+)=([^&]+)/g)

2020年

使用URLSearchParams,因为此作业不再需要任何类型的自定义代码。浏览器可以使用一个构造函数为您完成此操作:

const str = "1111342=Adam%20Franco&348572=Bob%20Jones";
const data = new URLSearchParams(str);
for (pair of data) console.log(pair)

产量

Array [ "1111342", "Adam Franco" ]
Array [ "348572", "Bob Jones" ]

因此,没有理由再使用正则表达式了。

原始答案

如果您不想依赖运行exec样式匹配所附带的“盲目匹配” ,那么JavaScript确实内置了“全部匹配”功能,但是replace当使用“与捕获有关的内容”时,它是函数调用的一部分。组的处理功能

var data = {};

var getKeyValue = function(fullPattern, group1, group2, group3) {
  data[group2] = group3;
};

mystring.replace(/(?:&|&)?([^=]+)=([^&]+)/g, getKeyValue);

完成。

与其使用捕获组处理功能实际返回替换字符串(对于替换处理,第一个arg是完全模式匹配,而随后的args是单独的捕获组),我们只需要捕获第2组和第3组捕获,并缓存该对。

因此,不要写复杂的解析函数,而要记住,JavaScript中的“ matchAll”函数只是用替换处理函数简单地“替换”,并且可以获得很多模式匹配效率。

对于捕获组,我习惯于preg_match_all在PHP中使用,并且尝试在此处复制其功能:

<script>

// Return all pattern matches with captured groups
RegExp.prototype.execAll = function(string) {
    var match = null;
    var matches = new Array();
    while (match = this.exec(string)) {
        var matchArray = [];
        for (i in match) {
            if (parseInt(i) == i) {
                matchArray.push(match[i]);
            }
        }
        matches.push(matchArray);
    }
    return matches;
}

// Example
var someTxt = 'abc123 def456 ghi890';
var results = /[a-z]+(\d+)/g.execAll(someTxt);

// Output
[["abc123", "123"],
 ["def456", "456"],
 ["ghi890", "890"]]

</script>

g修饰符设置为全局匹配:

/…/g

来源:https :
//developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec

寻找连续的比赛

如果您的正则表达式使用“ g”标志,则可以多次使用exec()方法在同一字符串中查找连续的匹配项。这样做时,搜索将从正则表达式的lastIndex属性指定的str的子字符串开始(test()还将使lastIndex属性前进)。例如,假设您具有以下脚本:

var myRe = /ab*/g;
var str = 'abbcdefabh';
var myArray;
while ((myArray = myRe.exec(str)) !== null) {
  var msg = 'Found ' + myArray[0] + '. ';
  msg += 'Next match starts at ' + myRe.lastIndex;
  console.log(msg);
}

该脚本显示以下文本:

Found abb. Next match starts at 3
Found ab. Next match starts at 912

注意:请勿将正则表达式文字(或RegExp构造函数)放在while条件内,否则由于每次迭代都会重置lastIndex属性而导致匹配时,它将创建无限循环。还要确保设置了全局标志,否则也会在此处发生循环。

如果某人(例如我)需要具有数组支持的Tomalak方法(例如,多选),则为:

function getUrlParams(url) {
  var re = /(?:\?|&(?:amp;)?)([^=&#]+)(?:=?([^&#]*))/g,
      match, params = {},
      decode = function (s) {return decodeURIComponent(s.replace(/\+/g, " "));};

  if (typeof url == "undefined") url = document.location.href;

  while (match = re.exec(url)) {
    if( params[decode(match[1])] ) {
        if( typeof params[decode(match[1])] != 'object' ) {
            params[decode(match[1])] = new Array( params[decode(match[1])], decode(match[2]) );
        } else {
            params[decode(match[1])].push(decode(match[2]));
        }
    }
    else
        params[decode(match[1])] = decode(match[2]);
  }
  return params;
}
var urlParams = getUrlParams(location.search);

输入 ?my=1&my=2&my=things

结果1,2,things(仅先前返回:事物)

只是坚持标题所建议的问题,实际上您可以使用来遍历字符串中的每个匹配项String.prototype.replace()例如,以下操作只是基于正则表达式获取所有单词的数组:

function getWords(str) {
  var arr = [];
  str.replace(/\w+/g, function(m) {
    arr.push(m);
  });
  return arr;
}

var words = getWords("Where in the world is Carmen Sandiego?");
// > ["Where", "in", "the", "world", "is", "Carmen", "Sandiego"]

如果我想获取捕获组甚至每个比赛的索引,我也可以这样做。下面显示了如何将整个匹配,第一个捕获组和索引与每个匹配一起返回:

function getWords(str) {
  var arr = [];
  str.replace(/\w+(?=(.*))/g, function(m, remaining, index) {
    arr.push({ match: m, remainder: remaining, index: index });
  });
  return arr;
}

var words = getWords("Where in the world is Carmen Sandiego?");

运行上面的之后,words将如下所示:

[
  {
    "match": "Where",
    "remainder": " in the world is Carmen Sandiego?",
    "index": 0
  },
  {
    "match": "in",
    "remainder": " the world is Carmen Sandiego?",
    "index": 6
  },
  {
    "match": "the",
    "remainder": " world is Carmen Sandiego?",
    "index": 9
  },
  {
    "match": "world",
    "remainder": " is Carmen Sandiego?",
    "index": 13
  },
  {
    "match": "is",
    "remainder": " Carmen Sandiego?",
    "index": 19
  },
  {
    "match": "Carmen",
    "remainder": " Sandiego?",
    "index": 22
  },
  {
    "match": "Sandiego",
    "remainder": "?",
    "index": 29
  }
]

为了匹配类似于PHP中可用的多次出现,preg_match_all您可以使用这种思维方式自己创造或使用类似的方式YourJS.matchAll()YourJS或多或少定义了以下功能:

function matchAll(str, rgx) {
  var arr, extras, matches = [];
  str.replace(rgx.global ? rgx : new RegExp(rgx.source, (rgx + '').replace(/[\s\S]+\//g , 'g')), function() {
    matches.push(arr = [].slice.call(arguments));
    extras = arr.splice(-2);
    arr.index = extras[0];
    arr.input = extras[1];
  });
  return matches[0] ? matches : null;
}

如果您可以避免使用map此方法,则可以采用以下四行解决方案:

var mystring = '1111342=Adam%20Franco&348572=Bob%20Jones';

var result = mystring.match(/(&|&amp;)?([^=]+)=([^&]+)/g) || [];
result = result.map(function(i) {
  return i.match(/(&|&amp;)?([^=]+)=([^&]+)/);
});

console.log(result);

不够漂亮,效率不高,但至少它是紧凑的。;)

用途window.URL

> s = 'http://www.example.com/index.html?1111342=Adam%20Franco&348572=Bob%20Jones'
> u = new URL(s)
> Array.from(u.searchParams.entries())
[["1111342", "Adam Franco"], ["348572", "Bob Jones"]]

从2020年开始。请让我注意String.prototype.matchAll()

let regexp = /(?:&|&amp;)?([^=]+)=([^&]+)/g;
let str = '1111342=Adam%20Franco&348572=Bob%20Jones';

for (let match of str.matchAll(regexp)) {
    let [full, key, value] = match;
    console.log(key + ' => ' + value);
}

输出:

1111342 => Adam%20Franco
348572 => Bob%20Jones

为了使用相同的名称捕获多个参数,我在Tomalak的方法中修改了while循环,如下所示:

  while (match = re.exec(url)) {
    var pName = decode(match[1]);
    var pValue = decode(match[2]);
    params[pName] ? params[pName].push(pValue) : params[pName] = [pValue];
  }

输入: ?firstname=george&lastname=bush&firstname=bill&lastname=clinton

返回: {firstname : ["george", "bill"], lastname : ["bush", "clinton"]}

嗯...我有一个类似的问题...我想用RegExp进行增量/逐步搜索(例如:开始搜索...进行一些处理...继续搜索直到最后一次匹配)

经过大量的互联网搜索之后……像往常一样(现在正在养成习惯),我最终在StackOverflow中找到了答案……

什么都没有被提及,值得提及的是“ lastIndex”我现在理解为什么RegExp对象实现“ lastIndex”属性。

拆分它似乎是我的最佳选择:

'1111342=Adam%20Franco&348572=Bob%20Jones'.split('&').map(x => x.match(/(?:&|&amp;)?([^=]+)=([^&]+)/))

为了避免正则表达式地狱,您可以找到第一个匹配项,将其切碎,然后尝试在子字符串中找到下一个匹配项。在C#中看起来像这样,很抱歉,我没有为您移植到JavaScript。

        long count = 0;
        var remainder = data;
        Match match = null;
        do
        {
            match = _rgx.Match(remainder);
            if (match.Success)
            {
                count++;
                remainder = remainder.Substring(match.Index + 1, remainder.Length - (match.Index+1));
            }
        } while (match.Success);
        return count;
本文地址:http://javascript.askforanswer.com/ruhezaijavascriptzhongshiyongleisiyuphpdepreg_match_alldezhengzebiaodashipipeiduogepipeia.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!