我在寻找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()用于平滑中间结果，因此每次迭代都处理没有嵌套数组的字符串列表。每次迭代对old中的所有值应用split，然后返回拆分器中要被下一个值拆分的中间结果列表。Reduce()使用包含初始字符串值的数组进行初始化。

另一个简单而有效的方法是重复使用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(我认为我的函数是相当安全的——唯一需要考虑的是附加的条件开销(minor)，以及如果传递一个数组，它缺乏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"] 

享受吧!

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

如果你只想要英语单词，你可以这样用:

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

示例(运行片段):

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

我用缩减和过滤解决了这个问题。它可能不是最易读的解决方案，也不是最快的，在现实生活中，我可能会在这里使用aaron的答案，但写起来很有趣。

[' ','_','-','.',',',':','@'].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']

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

我使用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中运行，并且在某种程度上是最优的。

它不使用正则表达式，这很难维护 它没有使用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