JavaScript非正则表达式替换

是否有任何现有JavaScript框架具有非正则表达式

replace（）

函数， 或者这已经作为一项一次性功能发布在web上的某个地方了

---

例如，我想替换

“@！#$123=%”

，我不想担心要转义哪些字符。大多数语言似乎都有两种替换方法。我希望添加这个简单的东西。

我可能误解了你的问题，但是javascript确实有一个

编辑：（见评论）第五版似乎确实包含了这些信息，尽管当我看到它时它没有显示出来。以下是相关部分：

replace（）方法执行搜索和替换操作。它将正则表达式作为第一个参数，替换字符串作为第二个参数。它搜索调用它的字符串，以查找与指定模式的匹配项。如果正则表达式设置了g标志，replace（）方法将用替换字符串替换字符串中的所有匹配项；否则，它将仅替换找到的第一个匹配项如果replace（）的第一个参数是字符串而不是正则表达式，则该方法会逐字搜索该字符串，而不是像search（）那样使用RegExp（）构造函数将其转换为正则表达式。

---

我在搜索非正则javascript字符串replace（）方法时遇到了完全相同的问题。我的解决方案是使用split（）和join（）的组合：

其中：

“一些包含正则表达式解释字符的文本：£1.00”

与replace（）比较：

奇怪的是：

“某些包含正则表达式解释字符的文本：$1.00”

试试这个：

function replaceAllTemp(str,find, replace) { 
var ignoreCase=true;
var _token;
var token=find;
var newToken=replace;
var i = -1;

if ( typeof token === "string" ) {

    if ( ignoreCase ) {

        _token = token.toLowerCase();

        while( (
            i = str.toLowerCase().indexOf(
                token, i >= 0 ? i + newToken.length : 0
            ) ) !== -1
        ) {
            str = str.substring( 0, i ) +
                newToken +
                str.substring( i + token.length );
        }

    } else {
        return this.split( token ).join( newToken );
    }

}
return str;
};

---

您可以忽略大小写敏感度，也可以不忽略大小写敏感度
遗憾的是，JavaScript的indexOf并没有将locale vs.invariant作为参数，因此如果您想保持区域性的特殊性，就必须将

toLowerCase

替换为

tolocallowercase

function replaceAll(str, find, newToken, ignoreCase)
{
    var i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

    while ((
        i = (ignoreCase ? str.toLowerCase() : str).indexOf(
            find, i >= 0 ? i + newToken.length : 0
        )) !== -1
    )
    {
        str = str.substring(0, i) +
            newToken +
            str.substring(i + find.length);
    } // Whend 

    return str;
}

或作为原型：

if (!String.prototype.replaceAll ) {  
String.prototype.replaceAll = function (find, replace) {
    var str = this, i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

    while ((
        i = (ignoreCase ? str.toLowerCase() : str).indexOf(
            find, i >= 0 ? i + newToken.length : 0
        )) !== -1
    )
    {
        str = str.substring(0, i) +
            newToken +
            str.substring(i + find.length);
    } // Whend 

    return str;
};
}

---

呵呵。也许我在看一个旧版本的“Javascript:The Definitive Guide”，它只显示了regex示例。所以我从未尝试过上面的代码。现在我觉得自己很笨-10点对我来说很酷。有人能看看最新版本的“Javascript：权威指南”吗？现在包括这种示例了吗？Nick下面的回答对于“No regex”选项更可靠，因为原生替换方法在替换字符串中使用特殊字符。因此，虽然将文本替换为“hi”很好，但替换为任何包含“$”的内容都可能导致意外结果。请尝试“a”。替换（“a”，“$$b”）作为示例：）javascript函数仅替换第一个条目。此答案回答了OP fine。关键是

replace（）

将字符串搜索值视为文本字符串。在这种情况下，“$”不是特别处理的。如果显式调用了

RegExp（）

，这与

replace（）

无关，因为一个RegExp对象被传递给

replace（）

，而不是一个字符串。没有足够的在线示例会向您展示简单的replace方法-“一些包含regex解释字符的文本：$1.00”。replace（$，“；”）；这就是网络编程：重新发明轮子。JavaScript的

replace（）

是一个糟糕的笑话。谢谢你的帮助。我认为这是最好的解决办法+1«$»表示正则表达式中的行尾！因此，

RegExp（“$”）

与预期的行尾匹配没有什么奇怪的。您应该在将美元发送到RegExp之前对其进行转义：

RegExp（\$”

注意：这会整齐地替换所有出现的情况。因此，

s.split（“$”）.join（“£”）

相当于

s.replace（/\$/g，“£”）

或

s.replace（RegExp（“\\$”，“g”），“£”）

。

function replaceAllTemp(str,find, replace) { 
var ignoreCase=true;
var _token;
var token=find;
var newToken=replace;
var i = -1;

if ( typeof token === "string" ) {

    if ( ignoreCase ) {

        _token = token.toLowerCase();

        while( (
            i = str.toLowerCase().indexOf(
                token, i >= 0 ? i + newToken.length : 0
            ) ) !== -1
        ) {
            str = str.substring( 0, i ) +
                newToken +
                str.substring( i + token.length );
        }

    } else {
        return this.split( token ).join( newToken );
    }

}
return str;
};

function replaceAll(str, find, newToken, ignoreCase)
{
    var i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

    while ((
        i = (ignoreCase ? str.toLowerCase() : str).indexOf(
            find, i >= 0 ? i + newToken.length : 0
        )) !== -1
    )
    {
        str = str.substring(0, i) +
            newToken +
            str.substring(i + find.length);
    } // Whend 

    return str;
}

if (!String.prototype.replaceAll ) {  
String.prototype.replaceAll = function (find, replace) {
    var str = this, i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

    while ((
        i = (ignoreCase ? str.toLowerCase() : str).indexOf(
            find, i >= 0 ? i + newToken.length : 0
        )) !== -1
    )
    {
        str = str.substring(0, i) +
            newToken +
            str.substring(i + find.length);
    } // Whend 

    return str;
};
}