Question

如何在JavaScript中拆分包含多个分隔符的字符串？我试图在逗号和空格上分开但是，AFAIK，JS的分割功能只支持一个分隔符。

Answer 1

传入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!"

Answer 2

您可以将正则表达式传递给Javascript's split operator。例如：

"1,2 3".split(/,| /) 
["1", "2", "3"]

或者，如果您想允许多个分隔符一起充当一个：

"1, 2, , 3".split(/(?:,| )+/) 
["1", "2", "3"]

（你必须使用非捕获（？:) parens，否则它会被拼接回到结果中。或者你可以像Aaron一样聪明并使用一个字符类。）

（在Safari + FF中测试的示例）

Answer 3

另一个简单但有效的方法是重复使用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;
}

用法：

splitMulti('a=b,c:d', ['=', ',', ':']) // ["a", "b", "c", "d"]

如果你经常使用这个功能，为了方便起见甚至可能值得考虑包装String.prototype.split（我认为我的功能相当安全 - 唯一的考虑因素是条件（次要）的额外开销以及事实如果传递数组，它缺少limit参数的实现。）

如果使用以下方法简单地包装它，请确保包含splitMulti函数:)。另外值得注意的是，有些人不喜欢扩展内置插件（因为许多人做错了，可能会发生冲突），所以如果有疑问，请在使用之前与更高级的人交谈或者问SO :)

    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"]

享受！

Answer 4

让我们保持简单：（添加＆＃34; [] +＆＃34;到您的RegEx意味着＆＃34; 1或更多＆＃34;）

这意味着＆＃34; +＆＃34;和＆＃34; {1，}＆＃34;是一样的。

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

Answer 5

棘手的方法：

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

Answer 6

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

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);

上面的示例返回：["people", "and", "other", "things"]

注意：flatten函数取自Rosetta Code

Answer 7

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

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

输出将是：

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

Answer 8

嗨，例如，如果你在字符串07:05:45 PM中拆分并替换

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

结果

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

Answer 9

也许您应该进行某种字符串替换以将一个分隔符转换为另一个分隔符，这样您就可以在拆分中只处理一个分隔符。

Answer 10

以下是使用正则表达式可能会有所帮助的一些情况：

\W 匹配任何字符 else word 字符 [a-zA-Z0-9_]。示例：

("Hello World,I-am code").split(/\W+/); // would return [ 'Hello', 'World', 'I', 'am', 'code' ]

\s+ 匹配一个或多个空格
\d 匹配一个数字
如果您只想按某些字符拆分，我们只说 , 和 -，您可以使用 str.split(/[,-]+/)...etc

Answer 11

从@ 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);
    })
  },

}

然后

var stringToSplit = "people and_other/things";
var splitList = [" ", "_", "/"];
var splittedString=StringUtils.splitString(stringToSplit, splitList);
console.log(splitList, stringToSplit, splittedString);

返回原作：

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

Answer 12

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

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;
};

console.logg = function ()
{
  document.body.innerHTML += "<br>" + [].slice.call(arguments).join();
}

splix = function() {
  u = [].slice.call(arguments);
  v = u.slice(1);
  u = u[0];
  w = [u];
  x = 0;
  console.logg("Processing: <code>" + JSON.stringify(w) + "</code>");

  for (i = 0; i < u.length; ++i) {
    for (j = 0; j < v.length; ++j) {
      console.logg("Processing: <code>[\x22" + u.slice(i, i + v[j].length) + "\x22, \x22" + v[j] + "\x22]</code>");
      if (u.slice(i, i + v[j].length) == v[j]) {
        y = w[x].split(v[j]);
        w[x] = y[0];
        w[++x] = y[1];
        console.logg("Currently processed: " + JSON.stringify(w) + "\n");
      };
    };
  };

  console.logg("Return: <code>" + JSON.stringify(w) + "</code>");
};

setTimeout(function() {
  console.clear();
  splix("1.23--4", ".", "--");
}, 250);

@import url("http://fonts.googleapis.com/css?family=Roboto");

body {font: 20px Roboto;}

用法：splix(string, delimiters...)

示例：splix("1.23--4", ".", "--")

返回：["1", "23", "4"]

Answer 13

a = "a=b,c:d"

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

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

这将返回不带特殊字符的字符串。

Answer 14

通过 .com / 或 .net /

分割URL

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

Answer 15

我在寻找 C# string.Split() 函数的替代品时遇到了这个问题，该函数使用参数中的字符拆分字符串。

在 JavaScript 中，您可以使用 map 和 reduce 来迭代拆分字符和中间值：

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"]

flat() 用于展平中间结果，因此每次迭代都处理没有嵌套数组的字符串列表。每次迭代将 split 应用于 old 中的所有值，然后返回要由 splitters 中的下一个值拆分的中间结果列表。 reduce() 使用包含初始字符串值的数组进行初始化。

Answer 16

如果您指定要离开的内容，而不是您要删除的内容，我认为这会更容易。

好像你只想要英文单词，你可以使用这样的东西：

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

示例（运行代码段）：

＆＃13;

var R=[/[a-z'\-]+/gi,/[a-z'\-\s]+/gi];
var s=document.getElementById('s');
for(var i=0;i<R.length;i++)
 {
  var o=document.createElement('option');
  o.innerText=R[i]+'';
  o.value=i;
  s.appendChild(o);
 }
var t=document.getElementById('t');
var r=document.getElementById('r');

s.onchange=function()
 {
  r.innerHTML='';
  var x=s.value;
  if((x>=0)&&(x<R.length))
   x=t.value.match(R[x]);
  for(i=0;i<x.length;i++)
   {
    var li=document.createElement('li');
    li.innerText=x[i];
    r.appendChild(li);
   }
 }

＆＃13;

<textarea id="t" style="width:70%;height:12em">even, test; spider-man

But saying o'er what I have said before:
My child is yet a stranger in the world;
She hath not seen the change of fourteen years,
Let two more summers wither in their pride,
Ere we may think her ripe to be a bride.

—Shakespeare, William. The Tragedy of Romeo and Juliet</textarea>

<p><select id="s">
 <option selected>Select a regular expression</option>
 <!-- option value="1">/[a-z'\-]+/gi</option>
 <option value="2">/[a-z'\-\s]+/gi</option -->
</select></p>
 <ol id="r" style="display:block;width:auto;border:1px inner;overflow:scroll;height:8em;max-height:10em;"></ol>
</div>

＆＃13;

Answer 17

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

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

Answer 18

我不知道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"]

Answer 19

不是最好的方法，但是可以使用多个不同的分隔符/分隔符进行分割

html

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

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>

Answer 20

这是在 ES6 中实现这一目标的新方法：

function SplitByString(source, splitBy) {
  var splitter = splitBy.split('');
  splitter.push([source]); //Push initial value

  return splitter.reduceRight(function(accumulator, curValue) {
    var k = [];
    accumulator.forEach(v => k = [...k, ...v.split(curValue)]);
    return k;
  });
}

var source = "abc,def#hijk*lmn,opq#rst*uvw,xyz";
var splitBy = ",*#";
console.log(SplitByString(source, splitBy));

请注意此功能：

不涉及正则表达式
以与source

以上代码的结果为：

Answer 21

我将提供此类功能的经典实现。该代码几乎可以在所有JavaScript版本中使用，并且在某种程度上是最佳的。

它不使用正则表达式，很难维护
它不使用JavaScript的新功能
它不使用需要更多计算机内存的多个.split（）.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);
}

您可以看到在Playground中运行的代码： https://codeguppy.com/code.html?IJI0E4OGnkyTZnoszAzf

Answer 22

我对@Brian的重构

var string = 'and this is some kind of information and another text and simple and some egample or red or text';
var separators = ['and', 'or'];

function splitMulti(str, separators){
            var tempChar = 't3mp'; //prevent short text separator in split down
            
            //split by regex e.g. \b(or|and)\b
            var re = new RegExp('\\b(' + separators.join('|') + ')\\b' , "g");
            str = str.replace(re, tempChar).split(tempChar);
            
            // trim & remove empty
            return str.map(el => el.trim()).filter(el => el.length > 0);
}

console.log(splitMulti(string, separators))

Answer 23

为了娱乐，我用reduce和filter解决了这个问题。在现实生活中，我可能会使用Aarons answere here。不过，我认为我的版本并非完全不可读或效率低下：

[' ','_','-','.',',',':','@'].reduce(
(segs, sep) => segs.reduce(
(out, seg) => out.concat(seg.split(sep)), []), 
['E-mail Address: user@domain.com, Phone Number: +1-800-555-0011']
).filter(x => x)

或作为功能：

function msplit(str, seps) {
  return seps.reduce((segs, sep) => segs.reduce(
    (out, seg) => out.concat(seg.split(sep)), []
  ), [str]).filter(x => x);
}

这将输出：

['E','mail','Address','user','domain','com','0','Phone','Number','+1','800','555','0011']

最后没有过滤器，您会在数组中得到空字符串，其中两个不同的分隔符彼此相邻。

Answer 24

我使用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"]

如何在javascript中拆分包含多个分隔符的字符串？

24 个答案: