用Java替换正则表达式匹配的第n个实例

javascript regex

15602 观看

3回复

4165 作者的声誉

我正在尝试编写一个正则表达式函数,该函数将识别和替换字符串中匹配项的单个实例,而不影响其他实例。例如,我有以下字符串:

12||34||56

我想用&符号替换第二组管道以获取此字符串:

12||34&&56

regex函数需要能够处理x数量的管道,并允许我替换第n组管道,因此我可以使用相同的函数进行以下替换:

23||45||45||56||67 -> 23&&45||45||56||67

23||34||98||87 -> 23||34||98&&87

我知道我可以在管道上拆分/替换/合并字符串,而且我还可以匹配/\|\|/并迭代结果数组,但是我想知道是否有可能编写一个可以做这个。请注意,这是针对Javascript的,因此可以使用运行时生成正则表达式eval(),但不能使用任何Perl特定的正则表达式指令。

作者: Ant 的来源 发布者: 2008 年 8 月 30 日

回应 (3)


20

11429 作者的声誉

决定

这是可行的:

"23||45||45||56||67".replace(/^((?:[0-9]+\|\|){n})([0-9]+)\|\|/,"$1$2&&")

其中n是小于第n个管道的那个(当然,如果n = 0,则不需要该第一个子表达式)

如果您想要一个函数来执行此操作:

function pipe_replace(str,n) {
   var RE = new RegExp("^((?:[0-9]+\\|\\|){" + (n-1) + "})([0-9]+)\|\|");
   return str.replace(RE,"$1$2&&");
}
作者: Sam Hasler 发布者: 30.08.2008 05:40

0

0 作者的声誉

function pipe_replace(str,n) {
    m = 0;
    return str.replace(/\|\|/g, function (x) {
        //was n++ should have been m++
        m++;
        if (n==m) {
            return "&&";
        } else {
            return x;
        }
    });
}
作者: Binda 发布者: 25.07.2009 07:42

31

77480 作者的声誉

更通用的功能

我遇到了这个问题,尽管标题很笼统,但可接受的答案仅处理该问题的特定用例。

我需要一个更通用的解决方案,所以我写了一个,并认为我会在这里分享它。

用法

此函数要求您向其传递以下参数:

  • original:您要搜索的字符串
  • pattern:要搜索的字符串或带有捕获组的RegExp 。没有捕获组,它将引发错误。这是因为该函数调用split原始字符串,并且仅当提供的RegExp包含捕获组时,结果数组才会包含matchs
  • n:要查找的顺序出现;例如,如果您想要第二场比赛,请传入2
  • replace:要么是用来替换匹配项的字符串,要么是将匹配项带入并返回替换字符串的函数。

例子

// Pipe examples like the OP's
replaceNthMatch("12||34||56", /(\|\|)/, 2, '&&') // "12||34&&56"
replaceNthMatch("23||45||45||56||67", /(\|\|)/, 1, '&&') // "23&&45||45||56||67"

// Replace groups of digits
replaceNthMatch("foo-1-bar-23-stuff-45", /(\d+)/, 3, 'NEW') // "foo-1-bar-23-stuff-NEW"

// Search value can be a string
replaceNthMatch("foo-stuff-foo-stuff-foo", "foo", 2, 'bar') // "foo-stuff-bar-stuff-foo"

// No change if there is no match for the search
replaceNthMatch("hello-world", "goodbye", 2, "adios") // "hello-world"

// No change if there is no Nth match for the search
replaceNthMatch("foo-1-bar-23-stuff-45", /(\d+)/, 6, 'NEW') // "foo-1-bar-23-stuff-45"

// Passing in a function to make the replacement
replaceNthMatch("foo-1-bar-23-stuff-45", /(\d+)/, 2, function(val){
  //increment the given value
  return parseInt(val, 10) + 1;
}); // "foo-1-bar-24-stuff-45"

编码

  var replaceNthMatch = function (original, pattern, n, replace) {
    var parts, tempParts;

    if (pattern.constructor === RegExp) {

      // If there's no match, bail
      if (original.search(pattern) === -1) {
        return original;
      }

      // Every other item should be a matched capture group;
      // between will be non-matching portions of the substring
      parts = original.split(pattern);

      // If there was a capture group, index 1 will be
      // an item that matches the RegExp
      if (parts[1].search(pattern) !== 0) {
        throw {name: "ArgumentError", message: "RegExp must have a capture group"};
      }
    } else if (pattern.constructor === String) {
      parts = original.split(pattern);
      // Need every other item to be the matched string
      tempParts = [];

      for (var i=0; i < parts.length; i++) {
        tempParts.push(parts[i]);

        // Insert between, but don't tack one onto the end
        if (i < parts.length - 1) {
          tempParts.push(pattern);
        }
      }
      parts = tempParts;
    }  else {
      throw {name: "ArgumentError", message: "Must provide either a RegExp or String"};
    }

    // Parens are unnecessary, but explicit. :)
    indexOfNthMatch = (n * 2) - 1;

  if (parts[indexOfNthMatch] === undefined) {
    // There IS no Nth match
    return original;
  }

  if (typeof(replace) === "function") {
    // Call it. After this, we don't need it anymore.
    replace = replace(parts[indexOfNthMatch]);
  }

  // Update our parts array with the new value
  parts[indexOfNthMatch] = replace;

  // Put it back together and return
  return parts.join('');

  }

另一种定义方式

此函数最不吸引人的部分是它带有4个参数。通过将其作为方法添加到String原型,可以简化为仅需要3个参数,如下所示:

String.prototype.replaceNthMatch = function(pattern, n, replace) {
  // Same code as above, replacing "original" with "this"
};

如果这样做,则可以在任何字符串上调用该方法,如下所示:

"foo-bar-foo".replaceNthMatch("foo", 2, "baz"); // "foo-bar-baz"

通过考试

以下是此功能通过的Jasmine测试。

describe("replaceNthMatch", function() {

  describe("when there is no match", function() {

    it("should return the unmodified original string", function() {
      var str = replaceNthMatch("hello-there", /(\d+)/, 3, 'NEW');
      expect(str).toEqual("hello-there");
    });

  });

  describe("when there is no Nth match", function() {

    it("should return the unmodified original string", function() {
      var str = replaceNthMatch("blah45stuff68hey", /(\d+)/, 3, 'NEW');
      expect(str).toEqual("blah45stuff68hey");
    });

  });

  describe("when the search argument is a RegExp", function() {

    describe("when it has a capture group", function () {

      it("should replace correctly when the match is in the middle", function(){
        var str = replaceNthMatch("this_937_thing_38_has_21_numbers", /(\d+)/, 2, 'NEW');
        expect(str).toEqual("this_937_thing_NEW_has_21_numbers");
      });

      it("should replace correctly when the match is at the beginning", function(){
        var str = replaceNthMatch("123_this_937_thing_38_has_21_numbers", /(\d+)/, 2, 'NEW');
        expect(str).toEqual("123_this_NEW_thing_38_has_21_numbers");
      });

    });

    describe("when it has no capture group", function() {

      it("should throw an error", function(){
        expect(function(){
          replaceNthMatch("one_1_two_2", /\d+/, 2, 'NEW');
        }).toThrow('RegExp must have a capture group');
      });

    });


  });

  describe("when the search argument is a string", function() {

    it("should should match and replace correctly", function(){
      var str = replaceNthMatch("blah45stuff68hey", 'stuff', 1, 'NEW');
      expect(str).toEqual("blah45NEW68hey");
    });

  });

  describe("when the replacement argument is a function", function() {

    it("should call it on the Nth match and replace with the return value", function(){

      // Look for the second number surrounded by brackets
      var str = replaceNthMatch("foo[1][2]", /(\[\d+\])/, 2, function(val) {

        // Get the number without the [ and ]
        var number = val.slice(1,-1);

        // Add 1
        number = parseInt(number,10) + 1;

        // Re-format and return
        return '[' + number + ']';
      });
      expect(str).toEqual("foo[1][3]");

    });

  });

});

可能无法在IE7中使用

该代码可以在IE7中失败,因为该浏览器使用正则表达式正确分割字符串,如讨论在这里。[在IE7上握拳)。我相信是解决方案;如果您需要支持IE7,祝您好运。:)

作者: Nathan Long 发布者: 31.10.2011 07:24
32x32