如何在JavaScript中使用多个分隔符拆分字符串？

如何在JavaScript中使用多个分隔符拆分字符串

---

我试图在逗号和空格上进行拆分，但AFAIK JavaScript的

split（）

函数只支持一个分隔符。

您可以将正则表达式传递到JavaScript的方法中。例如：

“1,23”。拆分（/，|/）
["1", "2", "3"]

或者，如果要允许多个分隔符一起作为一个分隔符，请执行以下操作：

“1,2,3”。拆分（/（？：，|）+/）
["1", "2", "3"]

（您必须使用非捕获的

（？：）

括号，否则它会被拼接回结果中。或者您可以像Aaron一样聪明，使用字符类。）

---

在Safari和Firefox中测试的示例。

将regexp作为参数传递：

js> "Hello awesome, world!".split(/[\s,]+/)
Hello,awesome,world!

编辑以添加：

通过选择数组长度减去1，可以获得最后一个元素：

>>> bits = "Hello awesome, world!".split(/[\s,]+/)
["Hello", "awesome", "world!"]
>>> bit = bits[bits.length - 1]
"world!"

。。。如果模式不匹配：

>>> bits = "Hello awesome, world!".split(/foo/)
["Hello awesome, world!"]
>>> bits[bits.length - 1]
"Hello awesome, world!"

---

对于那些希望在拆分函数中进行更多自定义的人，我编写了一个递归算法，该算法使用要拆分的字符列表拆分给定字符串。我是在看到上面的帖子之前写的。我希望它能帮助一些沮丧的程序员

splitString = function(string, splitters) {
    var list = [string];
    for(var i=0, len=splitters.length; i<len; i++) {
        traverseList(list, splitters[i], 0);
    }
    return flatten(list);
}

traverseList = function(list, splitter, index) {
    if(list[index]) {
        if((list.constructor !== String) && (list[index].constructor === String))
            (list[index] != list[index].split(splitter)) ? list[index] = list[index].split(splitter) : null;
        (list[index].constructor === Array) ? traverseList(list[index], splitter, 0) : null;
        (list.constructor === Array) ? traverseList(list, splitter, index+1) : null;    
    }
}

flatten = function(arr) {
    return arr.reduce(function(acc, val) {
        return acc.concat(val.constructor === Array ? flatten(val) : val);
    },[]);
}

var stringToSplit = "people and_other/things";
var splitList = [" ", "_", "/"];
splitString(stringToSplit, splitList);

splitString=函数（字符串、拆分器）{
变量列表=[string]；
对于（var i=0，len=splitters.length；i复杂方法：

var s = "dasdnk asd, (naks) :d skldma";
var a = s.replace('(',' ').replace(')',' ').replace(',',' ').split(' ');
console.log(a);//["dasdnk", "asd", "naks", ":d", "skldma"]

您可以将所有要用作分隔符的字符单独或合并到正则表达式中，并将它们传递给split函数。例如，您可以编写：

console.log( "dasdnk asd, (naks) :d skldma".split(/[ \(,\)]+/) );

输出将是：

["dasdnk", "asd", "naks", ":d", "skldma"]

我不知道RegEx的性能如何，但这里有另一种替代方法，RegEx利用本机HashSet并在O（max（str.length，delimeter.length））复杂度下工作：

var multiSplit = function(str,delimiter){
    if (!(delimiter instanceof Array))
        return str.split(delimiter);
    if (!delimiter || delimiter.length == 0)
        return [str];
    var hashSet = new Set(delimiter);
    if (hashSet.has(""))
        return str.split("");
    var lastIndex = 0;
    var result = [];
    for(var i = 0;i<str.length;i++){
        if (hashSet.has(str[i])){
            result.push(str.substring(lastIndex,i));
            lastIndex = i+1;
        }
    }
    result.push(str.substring(lastIndex));
    return result;
}

multiSplit('1,2,3.4.5.6 7 8 9',[',','.',' ']);
// Output: ["1", "2", "3", "4", "5", "6", "7", "8", "9"]

multiSplit('1,2,3.4.5.6 7 8 9',' ');
// Output: ["1,2,3.4.5.6", "7", "8", "9"]

var multiplit=function（str，分隔符）{
if（！（数组的分隔符instanceof））
返回str.split（分隔符）；
如果（！delimiter | | delimiter.length==0）
返回[str]；
var hashSet=新集合（分隔符）；
if（hashSet.has（“”）
返回str.split（“”）；
var lastIndex=0；
var结果=[]；
对于（var i=0；i我使用regexp:

str =  'Write a program that extracts from a given text all palindromes, e.g. "ABBA", "lamal", "exe".';

var strNew = str.match(/\w+/g);

// Output: ["Write", "a", "program", "that", "extracts", "from", "a", "given", "text", "all", "palindromes", "e", "g", "ABBA", "lamal", "exe"]

我发现我需要这样做的一个主要原因是在
/
和
\
上拆分文件路径。这是一个有点棘手的正则表达式，因此我将在这里发布它以供参考：

var splitFilePath = filePath.split(/[\/\\]/);

我认为如果你指定你想留下什么，而不是你想删除什么，会更容易

就好像你只想用英语单词一样，你可以这样使用：

text.match(/[a-z'\-]+/gi);

示例（运行代码段）：


var R=[/[a-z'\-]+/gi，/[a-z'\-\s]+/gi]；
var s=document.getElementById（'s'）；
对于（var i=0；i=0）和&（x让我们保持简单：（在正则表达式中添加“[]+”表示“1或更多”）

这意味着“+”和“{1，}”是相同的

var words = text.split(/[ .:;?!~,`"&|()<>{}\[\]\r\n/\\]+/); // note ' and - are kept

var words=text.split（/[.：；？！~，`“&（{}\[\]\r\n/\\]+/）；//注释”和-
从@stephen sweriduk解决方案开始（这对我来说更有趣！），我对其进行了轻微修改，使其更通用、更可重用：

/**
 * Adapted from: http://stackoverflow.com/questions/650022/how-do-i-split-a-string-with-multiple-separators-in-javascript
*/
var StringUtils = {

  /**
   * Flatten a list of strings
   * http://rosettacode.org/wiki/Flatten_a_list
   */
  flatten : function(arr) {
    var self=this;
    return arr.reduce(function(acc, val) {
        return acc.concat(val.constructor === Array ? self.flatten(val) : val);
    },[]);
  },

  /**
   * Recursively Traverse a list and apply a function to each item
   * @param list array
   * @param expression Expression to use in func
   * @param func function of (item,expression) to apply expression to item
   *
   */
  traverseListFunc : function(list, expression, index, func) {
    var self=this;
    if(list[index]) {
        if((list.constructor !== String) && (list[index].constructor === String))
            (list[index] != func(list[index], expression)) ? list[index] = func(list[index], expression) : null;
        (list[index].constructor === Array) ? self.traverseListFunc(list[index], expression, 0, func) : null;
        (list.constructor === Array) ? self.traverseListFunc(list, expression, index+1, func) : null;
    }
  },

  /**
   * Recursively map function to string
   * @param string
   * @param expression Expression to apply to func
   * @param function of (item, expressions[i])
   */
  mapFuncToString : function(string, expressions, func) {
    var self=this;
    var list = [string];
    for(var i=0, len=expressions.length; i<len; i++) {
        self.traverseListFunc(list, expressions[i], 0, func);
    }
    return self.flatten(list);
  },

  /**
   * Split a string
   * @param splitters Array of characters to apply the split
   */
  splitString : function(string, splitters) {
    return this.mapFuncToString(string, splitters, function(item, expression) {
      return item.split(expression);
    })
  },

}

这将作为原始版本返回：

[ ' ', '_', '/' ] 'people and_other/things' [ 'people', 'and', 'other', 'things' ]

例如，如果您在字符串07:05:45PM中拆分并替换了Hi

var hour = time.replace("PM", "").split(":");

结果

[ '07', '05', '45' ]

另一个简单但有效的方法是反复使用split+join

"a=b,c:d".split('=').join(',').split(':').join(',').split(',')

从本质上讲，先进行拆分，然后进行连接就像进行全局替换一样，因此这将用逗号替换每个分隔符，然后在所有分隔符都被替换后，对逗号进行最终拆分

上述表达式的结果是：

['a', 'b', 'c', 'd']

在此基础上展开，也可以将其放置在函数中：

function splitMulti(str, tokens){
        var tempChar = tokens[0]; // We can use the first token as a temporary join character
        for(var i = 1; i < tokens.length; i++){
            str = str.split(tokens[i]).join(tempChar);
        }
        str = str.split(tempChar);
        return str;
}

如果您经常使用此功能，甚至可能值得考虑包装
String.prototype.split
，以方便使用（我认为我的函数是相当安全的-唯一需要考虑的是附加条件的开销（较小）以及在传递数组时缺少限制参数的实现）

如果使用此方法，请确保包含
splitMulti
功能（仅对其进行包装：）。还值得注意的是，有些人不赞成扩展内置功能（因为许多人做得不对，可能会发生冲突），因此如果有疑问，请在使用此功能之前与更高级别的人联系，或者询问：）

用法：

var a = "a=b,c:d";
    a.split(['=', ',', ':']); // ["a", "b", "c", "d"]

// Test to check that the built-in split still works (although our wrapper wouldn't work if it didn't as it depends on it :P)
        a.split('='); // ["a", "b,c:d"] 

享受吧

一种简单的方法是使用每个分隔符处理字符串的每个字符，并构建一个拆分数组：

@导入url（“http://fonts.googleapis.com/css?family=Roboto");
body{font:20px Roboto；}
不是最好的方法，但可以使用多个不同的分隔符/分隔符进行拆分

html

使用多个不同的分隔符/分隔符拆分


javascript

<script>
function myFunction() {

var str = "How : are | you doing : today?";
var res = str.split(' | ');

var str2 = '';
var i;
for (i = 0; i < res.length; i++) { 
    str2 += res[i];

    if (i != res.length-1) {
      str2 += ",";
    }
}
var res2 = str2.split(' : ');

//you can add countless options (with or without space)

document.getElementById("demo").innerHTML = res2;
</script>


函数myFunction（）{
var str=“你今天怎么样？”；
var res=str.split（“|”）；
var str2=''；
var i；
对于（i=0；i
a=“a=b，c:d”
数组=['='，'，'：']；
对于（i=0；i

这将返回不带特殊字符的字符串。
这里有一种在ES6中实现相同功能的新方法：


函数SplitByString（源代码，splitBy）{
var splitter=splitBy.split（“”）；
splitter.push（[source]）；//push初始值
返回拆分器。还原右（功能（累加器、曲线值）{
var k=[]；
累加器.forEach（v=>k=[…k，…v.split（曲线值）]）；
返回k；
});
}
var source=“abc，def#hijk*lmn，opq#rst*uvw，xyz”；
var splitBy=“，*#”；
log（SplitByString（source，splitBy））；
我将为这样的函数提供一个经典的实现。该代码在几乎所有版本的JavaScript中都能工作，并且在某种程度上是最佳的


它不使用regex，这很难维护
它没有使用JavaScript的新特性
    var splitOrig = String.prototype.split; // Maintain a reference to inbuilt fn
    String.prototype.split = function (){
        if(arguments[0].length > 0){
            if(Object.prototype.toString.call(arguments[0]) == "[object Array]" ) { // Check if our separator is an array
                return splitMulti(this, arguments[0]);  // Call splitMulti
            }
        }
        return splitOrig.apply(this, arguments); // Call original split maintaining context
    };

var a = "a=b,c:d";
    a.split(['=', ',', ':']); // ["a", "b", "c", "d"]

// Test to check that the built-in split still works (although our wrapper wouldn't work if it didn't as it depends on it :P)
        a.split('='); // ["a", "b,c:d"] 

splix = function ()
{
  u = [].slice.call(arguments); v = u.slice(1); u = u[0]; w = [u]; x = 0;

  for (i = 0; i < u.length; ++i)
  {
    for (j = 0; j < v.length; ++j)
    {
      if (u.slice(i, i + v[j].length) == v[j])
      {
        y = w[x].split(v[j]); w[x] = y[0]; w[++x] = y[1];
      };
    };
  };
  
  return w;
};

<button onclick="myFunction()">Split with Multiple and Different seperators/delimiters</button>
<p id="demo"></p>

<script>
function myFunction() {

var str = "How : are | you doing : today?";
var res = str.split(' | ');

var str2 = '';
var i;
for (i = 0; i < res.length; i++) { 
    str2 += res[i];

    if (i != res.length-1) {
      str2 += ",";
    }
}
var res2 = str2.split(' : ');

//you can add countless options (with or without space)

document.getElementById("demo").innerHTML = res2;
</script>

a = "a=b,c:d"

array = ['=',',',':'];

for(i=0; i< array.length; i++){ a= a.split(array[i]).join(); }

var text = "Create a function, that will return an array (of string), with the words inside the text";

println(getWords(text));

function getWords(text)
{
    let startWord = -1;
    let ar = [];

    for(let i = 0; i <= text.length; i++)
    {
        let c = i < text.length ? text[i] : " ";

        if (!isSeparator(c) && startWord < 0)
        {
            startWord = i;
        }

        if (isSeparator(c) && startWord >= 0)
        {
            let word = text.substring(startWord, i);
            ar.push(word);

            startWord = -1;
        }
    }

    return ar;
}

function isSeparator(c)
{
    var separators = [" ", "\t", "\n", "\r", ",", ";", ".", "!", "?", "(", ")"];
    return separators.includes(c);
}

url.split(/\.com\/|\.net\//)

let splitters = [",", ":", ";"]; // or ",:;".split("");
let start= "a,b;c:d";
let values = splitters.reduce((old, c) => old.map(v => v.split(c)).flat(), [start]);
// values is ["a", "b", "c", "d"]