使用引号将字符串设置为小写-Javascript

我正在为a或DSL构建一个解析器，并试图将字符串转换为所有小写字母。我知道toLowerCase可以很容易地完成这个任务，但我需要保留用双引号或单引号引起来的字符串，或者在原来的情况下使用'。有关示例，请参见以下内容：

输入： 这是一个测试字符串，你们可以看到“你好，我的”

输出： 这是一个测试字符串，你们可以看到“你好，我的”

---

编辑：添加反斜杠引号

我确信有一个正则表达式解决方案，但这里有另一个解决方案，它在将引号字符串小写之前替换引号字符串：

String.prototype.toLowerCaseQuoted = function() {
   var str = this.valueOf();
   var replacements = [];
   var I = 0;
   str = str
      .replace(/((\".+\")|(\'.+\'))/g, function(s) {
         console.log(s)
         replacements.push(s);
         return "%s"+(I++)+"%"
      })
      .toLowerCase()
      .replace(/%s([0-9]+)%/g, function(s) {
         var k = parseInt(s.match(/([0-9])+/)[0]);
         console.log(k)
         return replacements[k];
      });
   return str;
}

例如：

将使用小写\引号\\'MORE QUOTED\'。ToLowercasequired

返回

---

将以小写形式引用“MORE QUOTED”

我确信有一个正则表达式解决方案，但这里有另一个解决方案，它在将带引号的字符串小写之前替换带引号的字符串：

String.prototype.toLowerCaseQuoted = function() {
   var str = this.valueOf();
   var replacements = [];
   var I = 0;
   str = str
      .replace(/((\".+\")|(\'.+\'))/g, function(s) {
         console.log(s)
         replacements.push(s);
         return "%s"+(I++)+"%"
      })
      .toLowerCase()
      .replace(/%s([0-9]+)%/g, function(s) {
         var k = parseInt(s.match(/([0-9])+/)[0]);
         console.log(k)
         return replacements[k];
      });
   return str;
}

例如：

将使用小写\引号\\'MORE QUOTED\'。ToLowercasequired

返回

---

将小写引用为'MORE QUOTED'

只是拼凑了一个快速解析器，不确定它的工作情况如何，但它应该处理无限制的反斜杠转义

function string_to_block(str) {
    var blocks = [],
        i, j, k;
    function isEscaped(str, i) {
        var escaped = false;
        while (str[--i] === '\\') escaped = !escaped;
        return escaped;
    }
    start: for (i = 0; i < str.length; i = j + 1) {
        find: for (j = i; j < str.length; ++j) {
            if (str[j] === '"' && !isEscaped(str, j)) {
                if (j > i) {
                    blocks.push({type: 'regular', str: str.slice(i, j)});
                }
                end: for (k = j + 1; k < str.length; ++k) {
                    if (str[k] === '"' && !isEscaped(str, k)) {
                        // found a "str" block
                        blocks.push({type: 'quote', str: str.slice(j, k + 1)});
                        j = k;
                        break find;
                    }
                }
                throw new SyntaxError('unclosed "str... starting at index ' + j);
            }
            if (str[j] === "'" && !isEscaped(str, j)) {
                if (j > i) {
                    blocks.push({type: 'regular', str: str.slice(i, j)});
                }
                end: for (k = j + 1; k < str.length; ++k) {
                    if (str[k] === "'" && !isEscaped(str, k)) {
                        // found a 'str' block
                        blocks.push({type: 'quote', str: str.slice(j, k + 1)});
                        j = k;
                        break find;
                    }
                }
                throw new SyntaxError("unclosed 'str... starting at index " + j);
            }
        }
    }
    if (k + 1 < str.length) {
        blocks.push({type: 'regular', str: str.slice(k + 1)});
    }
    return blocks;
}

因此，我们可以根据需要重新构建您的字符串

var i, str = '';
for (i = 0; i < foo.length; ++i) {
    if (foo[i].type === 'regular') str += foo[i].str.toLowerCase();
    else str += foo[i].str;
}
str; // this is a test "sTriNg Y'alL" as you can see 'hEllO woRl\' o miNE'

---

我们刚刚创建了一个快速解析器，不确定它的工作情况如何，但它应该能够处理无限制的反斜杠转义

function string_to_block(str) {
    var blocks = [],
        i, j, k;
    function isEscaped(str, i) {
        var escaped = false;
        while (str[--i] === '\\') escaped = !escaped;
        return escaped;
    }
    start: for (i = 0; i < str.length; i = j + 1) {
        find: for (j = i; j < str.length; ++j) {
            if (str[j] === '"' && !isEscaped(str, j)) {
                if (j > i) {
                    blocks.push({type: 'regular', str: str.slice(i, j)});
                }
                end: for (k = j + 1; k < str.length; ++k) {
                    if (str[k] === '"' && !isEscaped(str, k)) {
                        // found a "str" block
                        blocks.push({type: 'quote', str: str.slice(j, k + 1)});
                        j = k;
                        break find;
                    }
                }
                throw new SyntaxError('unclosed "str... starting at index ' + j);
            }
            if (str[j] === "'" && !isEscaped(str, j)) {
                if (j > i) {
                    blocks.push({type: 'regular', str: str.slice(i, j)});
                }
                end: for (k = j + 1; k < str.length; ++k) {
                    if (str[k] === "'" && !isEscaped(str, k)) {
                        // found a 'str' block
                        blocks.push({type: 'quote', str: str.slice(j, k + 1)});
                        j = k;
                        break find;
                    }
                }
                throw new SyntaxError("unclosed 'str... starting at index " + j);
            }
        }
    }
    if (k + 1 < str.length) {
        blocks.push({type: 'regular', str: str.slice(k + 1)});
    }
    return blocks;
}

因此，我们可以根据需要重新构建您的字符串

var i, str = '';
for (i = 0; i < foo.length; ++i) {
    if (foo[i].type === 'regular') str += foo[i].str.toLowerCase();
    else str += foo[i].str;
}
str; // this is a test "sTriNg Y'alL" as you can see 'hEllO woRl\' o miNE'

---

这是对@Paul S的后续操作。它应该处理没有引号块的字符串

function string_to_block(str) {
    var blocks = [],
        i, j, k;
    function isEscaped(str, i) {
        var escaped = false;
        while (str[--i] === '\\') escaped = !escaped;
        return escaped;
    }
    start: for (i = 0; i < str.length; i = j + 1) {
        find: for (j = i; j <= str.length; ++j) {
            if (str[j] === '"' && !isEscaped(str, j)) {
                if (j > i) {
                    blocks.push({type: 'regular', str: str.slice(i, j)});
                }
                end: for (k = j + 1; k < str.length; ++k) {
                    if (str[k] === '"' && !isEscaped(str, k)) {
                        // found a "str" block
                        blocks.push({type: 'quote', str: str.slice(j, k + 1)});
                        j = k;
                        break find;
                    }
                }
                throw new SyntaxError('unclosed "str... starting at index ' + j);
            }
            if (str[j] === "'" && !isEscaped(str, j)) {
                if (j > i) {
                    blocks.push({type: 'regular', str: str.slice(i, j)});
                }
                end: for (k = j + 1; k < str.length; ++k) {
                    if (str[k] === "'" && !isEscaped(str, k)) {
                        // found a 'str' block
                        blocks.push({type: 'quote', str: str.slice(j, k + 1)});
                        j = k;
                        break find;
                    }
                }
                throw new SyntaxError("unclosed 'str... starting at index " + j);
            }
            if (j === str.length) {
                            // We reached the end without finding any quote blocks
              if (j > i) {
                blocks.push({type: 'regular', str: str.slice(i,j)});
              }
            }
        }
    }
    return blocks;
}

---

这是对@Paul S的后续操作。它应该处理没有引号块的字符串

function string_to_block(str) {
    var blocks = [],
        i, j, k;
    function isEscaped(str, i) {
        var escaped = false;
        while (str[--i] === '\\') escaped = !escaped;
        return escaped;
    }
    start: for (i = 0; i < str.length; i = j + 1) {
        find: for (j = i; j <= str.length; ++j) {
            if (str[j] === '"' && !isEscaped(str, j)) {
                if (j > i) {
                    blocks.push({type: 'regular', str: str.slice(i, j)});
                }
                end: for (k = j + 1; k < str.length; ++k) {
                    if (str[k] === '"' && !isEscaped(str, k)) {
                        // found a "str" block
                        blocks.push({type: 'quote', str: str.slice(j, k + 1)});
                        j = k;
                        break find;
                    }
                }
                throw new SyntaxError('unclosed "str... starting at index ' + j);
            }
            if (str[j] === "'" && !isEscaped(str, j)) {
                if (j > i) {
                    blocks.push({type: 'regular', str: str.slice(i, j)});
                }
                end: for (k = j + 1; k < str.length; ++k) {
                    if (str[k] === "'" && !isEscaped(str, k)) {
                        // found a 'str' block
                        blocks.push({type: 'quote', str: str.slice(j, k + 1)});
                        j = k;
                        break find;
                    }
                }
                throw new SyntaxError("unclosed 'str... starting at index " + j);
            }
            if (j === str.length) {
                            // We reached the end without finding any quote blocks
              if (j > i) {
                blocks.push({type: 'regular', str: str.slice(i,j)});
              }
            }
        }
    }
    return blocks;
}

---

您需要编写一个解析器。没有任何内置的东西可以帮你做到这一点。我收集到了这些信息，我正在寻找关于最快和最干净的方法的建议。你需要编写一个解析器。没有任何内置的方法可以为您这样做。我收集到了这些信息，我正在寻找关于最快和最干净的方法的建议。这无法处理转义引号将是\\\LOWER\\\CASE\QUOTED\\\'MORE QUOTED\'。toLowerCaseQuoted；//将被\LOWER\CASE引用为'MORE QUOTED'这无法处理转义引号将被\\\LOWER\\\CASE\QUOTED\\'MORE QUOTED\'。ToLowerCasequed；//will be\LOWER\CASE QUOTED'MORE QUOTED'这实际上比我要求的要多，它完全符合我的要求，而且更多！有一个小问题。此测试字符串：这是一个测试\string Y'alL\如您所见'hEllO woRl\\'o miNE'，此测试字符串：这是一个测试\string Y'alL\如您所见'hEllO woRl\\\'o miNE'测试字符串不相同，但它们都生成相同的结果。如果你能解决这个问题，那就太棒了@SamWeaver我猜你的意思是最后一节，如果不是引用的一部分，就不见了。我想我在最后检查了错误的变量，请尝试新的编辑并让我知道。如果没有预设引号块，这不起作用。在本例中，它返回一个空字符串。我现在正在考虑如何修复。这实际上超出了我的要求，它完全符合我的要求，而且更多！有一个小问题。此测试字符串：这是一个测试\string Y'alL\如您所见'hEllO woRl\\'o miNE'，此测试字符串：这是一个测试\string Y'alL\如您所见'hEllO woRl\\\'o miNE'测试字符串不相同，但它们都生成相同的结果。如果你能解决这个问题，那就太棒了@SamWeaver我猜你的意思是最后一节，如果不是引用的一部分，就不见了。我想我在最后检查了错误的变量，请尝试新的编辑并让我知道。如果没有预设引号块，这不起作用。在本例中，它返回一个空字符串。我现在正在看如何修复。它可以处理双引号，但不能正确处理单引号。它可以处理双引号，但不能正确处理单引号。