我将提供此类功能的经典实现。该代码几乎可以在所有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);
}

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

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

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

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

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

这是在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

以上代码的结果将是：

也许您应该执行某种字符串替换操作，以将一个分隔符转换为另一个分隔符，以便在拆分时只处理一个分隔符。

您可以将要用作分隔符的所有字符单独或共同打包成正则表达式，然后将它们传递给split函数。例如，您可以编写：

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

输出将是：

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

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

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

您可以将正则表达式传递给Javascript的split运算符。例如：

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

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

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

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

（示例在Safari + FF中测试）

传递正则表达式作为参数：

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