如何删除指定字符之间的字符串并存储删除的字符串（Javascript）

假设我有一个字符串：

"but i [C#min] do [G#min] believe there's"

如何将该字符串转换为：

"but i  do  believe there's" (basically removing everything in-between '[' and ']')

---

我希望将

[C#min]

和

[G#min]

存储在另一个数组中。

尝试以下简单方法：

var str=“但是我[C#min]确实[G#min]相信有”；
var start、stop、newStr=''、removed=''、counter=1；
而（str.search（/\[.\]/g）>0）{
start=str.indexOf（'['）；
stop=str.indexOf（']'）；
newStr+=str.substring（0，开始）；
移除+=str.substring（开始、停止+1）；
str=str.substring（stop+1，str.length）；
计数器++；
如果（计数器>3）中断；
}
newStr+=str；
console.log（newStr）尝试以下直截了当的方法：


var str=“但是我[C#min]确实[G#min]相信有”；
var start、stop、newStr=''、removed=''、counter=1；
而（str.search（/\[.\]/g）>0）{
start=str.indexOf（'['）；
stop=str.indexOf（']'）；
newStr+=str.substring（0，开始）；
移除+=str.substring（开始、停止+1）；
str=str.substring（stop+1，str.length）；
计数器++；
如果（计数器>3）中断；
}
newStr+=str；
console.log（newStr）
var a=“但我[C#min]确实[G#min]相信有”；
console.log（a.replace（/\[（.[^\[\]]*）\]/g'，）；//“但我相信有”
console.log（a.match（/\[（.[^\[\]*）\]/g））；//[“[C#min]”，“[G#min]”
var a=“但我[C#min]确实[G#min]相信有”；
console.log（a.replace（/\[（.[^\[\]]*）\]/g'，）；//“但我相信有”
console.log（a.match（/\[（.[^\[\]*）\]/g））；//[“[C#min]”、“[G#min]”
不带正则表达式，简单方法：


var string=“但是我[C#min]确实[G#min]相信有”；
数组=[]；
filteredString=“”
对于（i=0；i无正则表达式，简单方法：


var string=“但是我[C#min]确实[G#min]相信有”；
数组=[]；
filteredString=“”
对于（i=0；i可以使用正则表达式：


var text=“但我[C#min]确实[G#min]相信有”；
var regexp=/（\[^\]*\]）/g；
var matches=text.match（regexp）；
text=text.replace（regexp'，）.replace（//g'，）；
console.log（text）；
您可以使用正则表达式：


var text=“但我[C#min]确实[G#min]相信有”；
var regexp=/（\[^\]*\]）/g；
var matches=text.match（regexp）；
text=text.replace（regexp'，）.replace（//g'，）；
console.log（text）；
您可以使用正则表达式查找带括号的字符串，然后使用
String.replace（）
将它们剥离出来。剥离出来的部分将在一个数组中，供您使用


var input=“但我[C#min]确实[G#min]相信有”；
var reg=/\[（.*？\]/g；///要查找的参数
var matches=input.match（reg）；//查找匹配项并用它们填充数组
var output=input.replace（reg，“”）。replace（//\s\s/g，“”；//去掉匹配项并固定间距
console.log（匹配）；//仅用于测试
console.log（output）；//Result
您可以使用正则表达式查找括号中的字符串，然后使用
String.replace（）
将它们剥离出来。剥离出来的部分将在一个数组中，供您使用


var input=“但我[C#min]确实[G#min]相信有”；
var reg=/\[（.*？\]/g；///要查找的参数
var matches=input.match（reg）；//查找匹配项并用它们填充数组
var output=input.replace（reg，“”）。replace（//\s\s/g，“”；//去掉匹配项并固定间距
console.log（匹配）；//仅用于测试
console.log（output）；//Result
您可以将字符串拆分为[：

function parseString(input) {
    output = {
        values: [],
        result: ""
    };
    input = input.split('[');
    for (var index = 0; index < input.length; index++) {
        var closingPosition = input[index].indexOf("]");
        if ((index > 0) && (closingPosition + 1)) {
            output.values.push('[' + input[index].substring(0, closingPosition) + ']');
            if (input[index].length > closingPosition) {
                output.result += input[index].substring(closingPosition + 1);
            }
        } else {
            output.result += input[index];
        }
    }
    return output;
}

函数解析字符串（输入）{
输出={
值：[]，
结果：“”
};
input=input.split（'['）；
对于（var索引=0；索引0）和（&（关闭位置+1））{
output.values.push（'['+input[index].substring（0，closingPosition）+']'）；
如果（输入[索引].length>closingPosition）{
output.result+=输入[index]。子字符串（closingPosition+1）；
}
}否则{
output.result+=输入[索引]；
}
}
返回输出；
}
您可以将字符串拆分为[：

function parseString(input) {
    output = {
        values: [],
        result: ""
    };
    input = input.split('[');
    for (var index = 0; index < input.length; index++) {
        var closingPosition = input[index].indexOf("]");
        if ((index > 0) && (closingPosition + 1)) {
            output.values.push('[' + input[index].substring(0, closingPosition) + ']');
            if (input[index].length > closingPosition) {
                output.result += input[index].substring(closingPosition + 1);
            }
        } else {
            output.result += input[index];
        }
    }
    return output;
}

函数解析字符串（输入）{
输出={
值：[]，
结果：“”
};
input=input.split（'['）；
对于（var索引=0；索引0）和（&（关闭位置+1））{
output.values.push（'['+input[index].substring（0，closingPosition）+']'）；
如果（输入[索引].length>closingPosition）{
output.result+=输入[index]。子字符串（closingPosition+1）；
}
}否则{
output.result+=输入[索引]；
}
}
返回输出；
}
您尝试了什么？您具体需要什么帮助？不遵循逻辑使用正则表达式获取括号内的内容。在不确切了解您尝试执行的操作的情况下，您可能能够使用此函数返回一个新字符串，而括号之间没有文本（经过适当编辑后）。存储删除的项会删除它们的上下文。您也需要存储位置数据。您尝试了什么？您具体需要什么帮助？不遵循logicuse regex获取括号内的内容。如果您不确切知道您尝试执行的操作，您可能能够使用此操作将返回一个新字符串，而不会返回介于t和t之间的文本他用括号括起来（经过适当编辑）。存储删除的项目会删除它们的上下文。您还需要存储位置数据。