Wie teile ich eine Zeichenfolge mit mehreren Trennzeichen in Javascript?

Wie teile ich eine Zeichenfolge mit mehreren Trennzeichen in JavaScript? Ich versuche, sowohl Kommas als auch Leerzeichen aufzuteilen, aber AFAIK, JS 'Aufteilungsfunktion unterstützt nur ein Trennzeichen.

Übergeben Sie einen regulären Ausdruck als Parameter:

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

Bearbeitet, um hinzuzufügen:

Sie können das letzte Element erhalten, indem Sie die Länge des Arrays minus 1 auswählen:

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

... und wenn das Muster nicht übereinstimmt:

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

Sie können einen regulären Ausdruck an den Split-Operator von Javascript übergeben . Zum Beispiel:

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

Oder wenn Sie zulassen möchten, dass mehrere Trennzeichen zusammen als ein Trennzeichen fungieren:

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

(Sie müssen die nicht erfassenden (? :) Parens verwenden, da sie sonst wieder in das Ergebnis eingefügt werden. Oder Sie können wie Aaron schlau sein und eine Charakterklasse verwenden.)

(Beispiele in Safari + FF getestet)

Eine andere einfache, aber effektive Methode ist die wiederholte Verwendung von split + join.

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

Im Wesentlichen ist ein Split gefolgt von einem Join wie ein globales Ersetzen, sodass jedes Trennzeichen durch ein Komma ersetzt wird. Sobald alle ersetzt sind, wird ein endgültiges Teilen durch Komma durchgeführt

Das Ergebnis des obigen Ausdrucks ist:

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

Wenn Sie dies erweitern, können Sie es auch in eine Funktion einfügen:

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

Verwendungszweck:

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

Wenn Sie diese Funktionalität häufig verwenden, lohnt es sich möglicherweise sogar, eine Umhüllung in Betracht zu ziehen String.prototype.split Einfachheit zu ziehen (ich denke, meine Funktion ist ziemlich sicher - die einzige Überlegung ist der zusätzliche Aufwand für die Bedingungen (geringfügig) und die Tatsache, dass das Limit-Argument nicht implementiert ist wenn ein Array übergeben wird).

Stellen Sie sicher, dass Sie die splitMultiFunktion einschließen , wenn Sie diesen Ansatz wie folgt verwenden: Schließen Sie ihn einfach ein :). Es ist auch erwähnenswert, dass einige Leute die Erweiterung von integrierten Funktionen missbilligen (da viele Leute es falsch machen und Konflikte auftreten können). Wenn Sie Zweifel haben, sprechen Sie mit einer älteren Person, bevor Sie dies verwenden, oder fragen Sie nach 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
    };

Verwendungszweck:

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

Genießen!

Lassen Sie es uns einfach halten: (Fügen Sie Ihrem RegEx ein "[] ​​+" hinzu, was "1 oder mehr" bedeutet)

Dies bedeutet, dass "+" und "{1,}" gleich sind.

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

Tricky Methode:

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

Für diejenigen unter Ihnen, die mehr Anpassungsmöglichkeiten in ihrer Aufteilungsfunktion wünschen, habe ich einen rekursiven Algorithmus geschrieben, der eine bestimmte Zeichenfolge mit einer Liste von Zeichen aufteilt, auf die aufgeteilt werden soll. Ich habe das geschrieben, bevor ich den obigen Beitrag gesehen habe. Ich hoffe, es hilft einigen frustrierten Programmierern.

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

Beispiel oben gibt zurück: ["people", "and", "other", "things"]

Hinweis: Die flattenFunktion wurde aus dem Rosetta-Code übernommen

Sie können einfach alle Zeichen, die Sie als Trennzeichen verwenden möchten, einzeln oder gemeinsam zu einem regulären Ausdruck zusammenfassen und an die Teilungsfunktion übergeben. Zum Beispiel könnten Sie schreiben:

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

Und die Ausgabe wird sein:

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

Vielleicht sollten Sie eine Art Zeichenfolgen ersetzen, um ein Trennzeichen in das andere zu trennen, damit Sie dann nur ein Trennzeichen in Ihrem Split haben.

Hallo zum Beispiel, wenn Sie in String 07:05:45 PM geteilt und ersetzt haben

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

Ergebnis

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

Hier ist ein neuer Weg, um dasselbe in ES6 zu erreichen :

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

Bitte beachten Sie in dieser Funktion:

• Kein Regex beteiligt
• Gibt den geteilten Wert in derselben Reihenfolge zurück, in der er angezeigt wird source

Das Ergebnis des obigen Codes wäre:

a = "a=b,c:d"

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

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

Dadurch wird die Zeichenfolge ohne ein spezielles Zeichen zurückgegeben.

Mein Refaktor von @Brian antwortet

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

Ich finde, dass einer der Hauptgründe, warum ich dies brauche, darin besteht, Dateipfade auf beiden /und zu teilen \. Es ist ein bisschen knifflig, also werde ich es hier als Referenz posten:

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

Ich denke, es ist einfacher, wenn Sie angeben, was Sie verlassen möchten, anstatt was Sie entfernen möchten.

Als ob Sie nur englische Wörter haben möchten, können Sie Folgendes verwenden:

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

Beispiele (Snippet ausführen):

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>

Ausgehend von der @ stephen-sweriduk-Lösung (das war für mich interessanter!) Habe ich sie leicht modifiziert, um sie allgemeiner und wiederverwendbarer zu machen:

/**
 * 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);
    })
  },

}

und dann

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

das gibt als original zurück:

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

Eine einfache Möglichkeit, dies zu tun, besteht darin, jedes Zeichen der Zeichenfolge mit jedem Trennzeichen zu verarbeiten und ein Array der Teilungen zu erstellen:

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

Verwendungszweck: splix(string, delimiters...)

Beispiel: splix("1.23--4", ".", "--")

Kehrt zurück: ["1", "23", "4"]

Ich werde eine klassische Implementierung für eine solche Funktion bereitstellen. Der Code funktioniert in fast allen Versionen von JavaScript und ist irgendwie optimal.

• Es wird kein regulärer Ausdruck verwendet, der schwer zu pflegen ist
• Es werden keine neuen Funktionen von JavaScript verwendet
• Es werden nicht mehrere .split () .join () -Aufrufe verwendet, die mehr Computerspeicher erfordern

Nur reiner Code:

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

Sie können den Code auf dem Spielplatz sehen: https://codeguppy.com/code.html?IJI0E4OGnkyTZnoszAzf

Ich kenne die Leistung von RegEx nicht, aber hier ist eine weitere Alternative für RegEx, die natives HashSet nutzt und stattdessen in O-Komplexität (max (str.length, delimeter.length)) arbeitet:

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

Nicht der beste Weg, aber funktioniert mit mehreren und verschiedenen Trennzeichen / Trennzeichen

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>

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