正则表达式从查询字符串中删除一个参数

Question

我正在寻找一个正则表达式来从查询字符串中删除单个参数,我想在可能的情况下在单个正则表达式中执行此操作.

说我想删除foo参数.现在我用这个:

/&?foo\=[^&]+/

只要foo不是查询字符串中的第一个参数,它就可以工作.如果是,那么我的新查询字符串以&符号开头.(例如," foo=123&bar=456"给出" "的结果&bar=456.)现在,我只是在正则表达式后检查,如果查询字符串以&符号开头,如果是,则将其砍掉.

示例边缘情况:

Input                    |  Expected Output
-------------------------+--------------------
foo=123                  |  (empty string)
foo=123&bar=456          |  bar=456
bar=456&foo=123          |  bar=456
abc=789&foo=123&bar=456  |  abc=789&bar=456

---

编辑

好的,正如评论中指出的那样,有更多的边缘案例比我最初考虑的更多.我得到以下正则表达式与他们一起工作:

/&foo(\=[^&]*)?(?=&|$)|^foo(\=[^&]*)?(&|$)/

这是从马克拜尔斯的回答中修改的,这就是为什么我接受那个,但罗杰佩特的投入也帮助了很多.

以下是我正在使用的全套测试用例,以及一个测试它们的Javascript代码段:

$(function() {
    var regex = /&foo(\=[^&]*)?(?=&|$)|^foo(\=[^&]*)?(&|$)/;
    
    var escapeHtml = function (str) {
        var map = {
          '&': '&',
          '<': '&lt;',
          '>': '&gt;',
          '"': '&quot;',
          "'": '&#039;'
        };
        
        return str.replace(/[&<>"']/g, function(m) { return map[m]; });
    };

    
    //test cases
    var tests = [
        'foo'     , 'foo&bar=456'     , 'bar=456&foo'     , 'abc=789&foo&bar=456'
       ,'foo='    , 'foo=&bar=456'    , 'bar=456&foo='    , 'abc=789&foo=&bar=456'
       ,'foo=123' , 'foo=123&bar=456' , 'bar=456&foo=123' , 'abc=789&foo=123&bar=456'
       ,'xfoo'    , 'xfoo&bar=456'    , 'bar=456&xfoo'    , 'abc=789&xfoo&bar=456'
       ,'xfoo='   , 'xfoo=&bar=456'   , 'bar=456&xfoo='   , 'abc=789&xfoo=&bar=456'
       ,'xfoo=123', 'xfoo=123&bar=456', 'bar=456&xfoo=123', 'abc=789&xfoo=123&bar=456'
       ,'foox'    , 'foox&bar=456'    , 'bar=456&foox'    , 'abc=789&foox&bar=456'
       ,'foox='   , 'foox=&bar=456'   , 'bar=456&foox='   , 'abc=789&foox=&bar=456'
       ,'foox=123', 'foox=123&bar=456', 'bar=456&foox=123', 'abc=789&foox=123&bar=456'
    ];
    
    //expected results
    var expected = [
        ''        , 'bar=456'         , 'bar=456'         , 'abc=789&bar=456'
       ,''        , 'bar=456'         , 'bar=456'         , 'abc=789&bar=456'
       ,''        , 'bar=456'         , 'bar=456'         , 'abc=789&bar=456'
       ,'xfoo'    , 'xfoo&bar=456'    , 'bar=456&xfoo'    , 'abc=789&xfoo&bar=456'
       ,'xfoo='   , 'xfoo=&bar=456'   , 'bar=456&xfoo='   , 'abc=789&xfoo=&bar=456'
       ,'xfoo=123', 'xfoo=123&bar=456', 'bar=456&xfoo=123', 'abc=789&xfoo=123&bar=456'
       ,'foox'    , 'foox&bar=456'    , 'bar=456&foox'    , 'abc=789&foox&bar=456'
       ,'foox='   , 'foox=&bar=456'   , 'bar=456&foox='   , 'abc=789&foox=&bar=456'
       ,'foox=123', 'foox=123&bar=456', 'bar=456&foox=123', 'abc=789&foox=123&bar=456'
    ];
    
    for(var i = 0; i < tests.length; i++) {
        var output = tests[i].replace(regex, '');
        var success = (output == expected[i]);
        
        $('#output').append(
            '<tr class="' + (success ? 'passed' : 'failed') + '">'
            + '<td>' + (success ? 'PASS' : 'FAIL') + '</td>'
            + '<td>' + escapeHtml(tests[i]) + '</td>'
            + '<td>' + escapeHtml(output) + '</td>'
            + '<td>' + escapeHtml(expected[i]) + '</td>'
            + '</tr>'
        );
    }
    
});

#output {
    border-collapse: collapse;
    
}
#output tr.passed { background-color: #af8; }
#output tr.failed { background-color: #fc8; }
#output td, #output th {
    border: 1px solid black;
    padding: 2px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<table id="output">
    <tr>
        <th>Succ?</th>
        <th>Input</th>
        <th>Output</th>
        <th>Expected</th>
    </tr>
</table>

Answer 1

如果您只想在一个正则表达式中执行此操作,则可以执行以下操作:

/&foo(=[^&]*)?|^foo(=[^&]*)?&?/

这是因为你需要在foo = ...之前匹配一个&符号,或者在一个之后匹配,或者两个都不匹配,但不能两者都匹配.

说实话,我认为你做的方式更好:在一个单独的步骤中删除尾随的&符号.

Answer 2

/(?<=&|\?)foo(=[^&]*)?(&|$)/

使用lookbehind和最后一组来"锚定"匹配,并允许缺少值.更改\?到^,如果你已经从查询字符串剥下问号.

但是,正则表达式仍然不能替代查询字符串的真正解析器.

更新:测试脚本:(在codepad.org运行)

import re

regex = r"(^|(?<=&))foo(=[^&]*)?(&|$)"

cases = {
  "foo=123": "",
  "foo=123&bar=456": "bar=456",
  "bar=456&foo=123": "bar=456",
  "abc=789&foo=123&bar=456": "abc=789&bar=456",

  "oopsfoo=123": "oopsfoo=123",
  "oopsfoo=123&bar=456": "oopsfoo=123&bar=456",
  "bar=456&oopsfoo=123": "bar=456&oopsfoo=123",
  "abc=789&oopsfoo=123&bar=456": "abc=789&oopsfoo=123&bar=456",

  "foo": "",
  "foo&bar=456": "bar=456",
  "bar=456&foo": "bar=456",
  "abc=789&foo&bar=456": "abc=789&bar=456",

  "foo=": "",
  "foo=&bar=456": "bar=456",
  "bar=456&foo=": "bar=456",
  "abc=789&foo=&bar=456": "abc=789&bar=456",
}

failures = 0
for input, expected in cases.items():
  got = re.sub(regex, "", input)
  if got != expected:
    print "failed: input=%r expected=%r got=%r" % (input, expected, got)
    failures += 1
if not failures:
  print "Success"

它显示了我的方法失败的地方,马克有权利 - 这应该说明为什么你不应该用正则表达式做这个...:P

问题是将查询参数与一个&符号相关联,并且 - 如果你必须使用正则表达式(如果你还没有使用它:P,我会使用一个单独的解析器,它可能在其中使用正则表达式,但实际上仍然是了解格式) - 一个解决方案是确保每个参数只有一个&符号:?用a 替换前导&.

这给了/&foo(=[^&]*)?(?=&|$)/,这是非常直接的,你将获得最好的.删除&最终结果中的前导(或将其更改回a ?等).修改测试用例来执行此操作使用与上面相同的情况,并将循环更改为:

failures = 0
for input, expected in cases.items():
  input = "&" + input
  got = re.sub(regex, "", input)
  if got[:1] == "&":
    got = got[1:]
  if got != expected:
    print "failed: input=%r expected=%r got=%r" % (input, expected, got)
    failures += 1
if not failures:
  print "Success"