Javascript 如何避免重复以下替换代码？

这是输入：

[ 'markdown',
  [ 'para', '"a paragraph"' ],
  [ 'hr' ],
  [ 'para', '\'another paragraph\'' ],
  [ 'bulletlist', [ 'listitem', '"a list item"' ] ] ]

下面的代码循环遍历数组的每个元素。如果元素是另一个数组，则代码会进一步深入并应用

replace

，如果不是，则会立即应用

replace

（如果我没有在数组上使用If语句

replace

，则会导致错误）

  for (i = 1; i < tree.length; i++) {
    var node = tree[i]
    var x = node.length - 1
    var y = node[x].length - 1

    if (Array.isArray(node[x])) {
      node[x] = node[x][y].replace(/"(?=\b)/g, '“')
                          .replace(/"(?!\b)/g, "”")
    } else {
      node[x] = node[x].replace(/"(?=\b)/g, '“')
                       .replace(/"(?!\b)/g, "”")
    }
  }

for（i=1；i

---

困扰我的是

replace

的重复。我如何修改代码以便只执行

。replace（/“（？=\b）/g，”）。replace（/“（？！\b）/g，”）

一次？

提取函数中的逻辑：

   function replaceMe(element) {
        return element.replace(/"(?=\b)/g, '“')
                      .replace(/"(?!\b)/g, "”");
    }


...
  for (i = 1; i < tree.length; i++) {
    var node = tree[i]
    var x = node.length - 1
    var y = node[x].length - 1

    if (Array.isArray(node[x])) {
      node[x] = replaceMe(node[x][y]);
    } else {
      node[x] = replaceMe(node[x]);
    }
  }
...

函数替换名（元素）{
返回元素。替换（/“（？=\b）/g，”）
.替换（/“（？！\b）/g，”）；
}
...
对于（i=1；i

提取函数中的逻辑：

   function replaceMe(element) {
        return element.replace(/"(?=\b)/g, '“')
                      .replace(/"(?!\b)/g, "”");
    }


...
  for (i = 1; i < tree.length; i++) {
    var node = tree[i]
    var x = node.length - 1
    var y = node[x].length - 1

    if (Array.isArray(node[x])) {
      node[x] = replaceMe(node[x][y]);
    } else {
      node[x] = replaceMe(node[x]);
    }
  }
...

函数替换名（元素）{
返回元素。替换（/“（？=\b）/g，”）
.替换（/“（？！\b）/g，”）；
}
...
对于（i=1；i

使用迭代，对N维数组有效

function doWork(tree){
  for (i = 1; i < tree.length; i++) {
    var node = tree[i]
    var x = node.length - 1
    var y = node[x].length - 1

    if (Array.isArray(node[x])) {
      doWork(node[x]);
    } else {
      node[x] = node[x].replace(/"(?=\b)/g, '“')
                       .replace(/"(?!\b)/g, "”")
    }
  }
}

// use it
doWork(tree);

功能定位（树）{
对于（i=1；i

使用迭代，对N维数组有效

function doWork(tree){
  for (i = 1; i < tree.length; i++) {
    var node = tree[i]
    var x = node.length - 1
    var y = node[x].length - 1

    if (Array.isArray(node[x])) {
      doWork(node[x]);
    } else {
      node[x] = node[x].replace(/"(?=\b)/g, '“')
                       .replace(/"(?!\b)/g, "”")
    }
  }
}

// use it
doWork(tree);

功能定位（树）{
对于（i=1；i

有时两个简单的正则表达式比一个复杂的正则表达式快

但您可以尝试以下不同的方法：

var example_string = '"some_string"',
    regex = /"(.*?)"/g;

var result = example_string.replace(regex, "“$1”");

console.log(result); // “some_string”

---

```有时两个简单的正则表达式比一个复杂的正则表达式快

但您可以尝试以下不同的方法：

var example_string = '"some_string"',
    regex = /"(.*?)"/g;

var result = example_string.replace(regex, "“$1”");

console.log(result); // “some_string”

---

```

是的，@Sphaso的解决方案很好，我更喜欢

递归的

一个，它可以工作到无穷远。是的，@Sphaso的解决方案很好，我更喜欢

递归的

一个，它可以工作到无穷远。