Wie kann ich eine kommagetrennte Zeichenkette in ein Array umwandeln?

Question

Ich habe eine kommagetrennte Zeichenkette, die ich in ein Array konvertieren möchte, damit ich sie in einer Schleife durchlaufen kann.

Gibt es irgendetwas, das dies ermöglicht?

Ich habe zum Beispiel diese Zeichenfolge

var str = "January,February,March,April,May,June,July,August,September,October,November,December";

Jetzt möchte ich dies durch ein Komma trennen und dann in einem Array speichern.

Answer 1

var array = string.split(',');

MDN-Referenz die vor allem für das möglicherweise unerwartete Verhalten des limit Parameter. (Hinweis: "a,b,c".split(",", 2) kommt heraus zu ["a", "b"] no ["a", "b,c"] .)

Answer 2

Passen Sie auf, wenn Sie auf ganze Zahlen zielen, wie 1,2,3,4,5. Wenn Sie beabsichtigen, die Elemente Ihres Arrays nach dem Aufteilen der Zeichenkette als Ganzzahlen und nicht als Strings zu verwenden, sollten Sie sie in solche umwandeln.

var str = "1,2,3,4,5,6";
var temp = new Array();
// This will return an array with strings "1", "2", etc.
temp = str.split(",");

Hinzufügen einer Schleife wie dieser,

for (a in temp ) {
    temp[a] = parseInt(temp[a], 10); // Explicitly include base as per Álvaro's comment
}

ein Array zurück, das Ganzzahlen und keine Zeichenketten enthält.

Answer 3

Hmm, split ist IMHO gefährlich, da ein String immer ein Komma enthalten kann. Beachten Sie das Folgende:

var myArr = "a,b,c,d,e,f,g,','";
result = myArr.split(',');

Wie würden Sie das also interpretieren? Und was tun Sie wollen das Ergebnis sein? Ein Array mit:

['a', 'b', 'c', 'd', 'e', 'f', 'g', '\'', '\''] or
['a', 'b', 'c', 'd', 'e', 'f', 'g', ',']

Selbst wenn Sie das Komma weglassen, haben Sie ein Problem.

Ich habe das schnell zusammengebastelt:

(function($) {
    $.extend({
        splitAttrString: function(theStr) {
            var attrs = [];

            var RefString = function(s) {
                this.value = s;
            };
            RefString.prototype.toString = function() {
                return this.value;
            };
            RefString.prototype.charAt = String.prototype.charAt;
            var data = new RefString(theStr);

            var getBlock = function(endChr, restString) {
                var block = '';
                var currChr = '';
                while ((currChr != endChr) && (restString.value !== '')) {
                    if (/'|"/.test(currChr)) {
                        block = $.trim(block) + getBlock(currChr, restString);
                    }
                    else if (/\{/.test(currChr)) {
                        block = $.trim(block) + getBlock('}', restString);
                    }
                    else if (/\[/.test(currChr)) {
                        block = $.trim(block) + getBlock(']', restString);
                    }
                    else {
                        block += currChr;
                    }
                    currChr = restString.charAt(0);
                    restString.value = restString.value.slice(1);
                }
                return $.trim(block);
            };

            do {
                var attr = getBlock(',', data);
                attrs.push(attr);
            }
            while (data.value !== '')
                ;
            return attrs;
        }
    });
})(jQuery);

Answer 4

Die Methode split() wird verwendet, um eine Zeichenkette in ein Array von Teilzeichenfolgen aufzuteilen, und gibt das neue Array zurück.

var array = string.split(',');

Answer 5

Verbessert str.split(',')

Die einfache str.split(',') hat nicht viel Grips. Hier sind einige Upgrades für verschiedene Bedürfnisse. Sie können die Funktionalität nach Herzenslust anpassen.

const str = "a, b,c,  d  ,e  ,f,,g"
const num = "1, 2,3,  4  ,5  ,6,,7.495"
const mix = "a, 2,3,  d  ,5  ,f,,7.495,g"

console.log(    str.split(',')
) // spaces NOT trimmed, empty values included
  // ["a", " b", "c", "  d  ", "e  ", "f", "", "g"] 

console.log(    str.split(/[ ,]+/)
) // spaces trimmed, empty values skipped
  // ["a", "b", "c", "d", "e", "f", "g"] 

console.log(    str.split(/\s*,\s*/)
) // spaces trimmed, empty values NOT skipped
  // ["a", "b", "c", "d", "e", "f", "", "g"]

console.log(    num.split(',').map(Number)
) // numbers, empty values default to zero
  // [1, 2, 3, 4, 5, 6, 0, 7.495] 

console.log(    num.split(/[ ,]+/).map(Number)
) // numbers, skips empty values
  // [1, 2, 3, 4, 5, 6, 7.495]

console.log(    mix.split(/\s*,\s*/)
                .map(x => (x === '') ? '' : (isNaN(Number(x)) ? x : Number(x)) )
) // mixed values, empty values included
  // ["a", 2, 3, "d", 5, "f", "", 7.495, "g"]

Verwendung von JSON.parse

Es mag sich wie ein kleiner Hack anfühlen, aber es ist einfach und wird von den meisten Javascript-Maschinen optimiert.

Es hat noch einige andere Vorteile, wie zum Beispiel die Unterstützung von verschachtelten Listen. Aber es gibt auch Nachteile, wie z. B. die Anforderung, dass die Eingabe richtig formatiertes JSON sein muss.

Durch die Verwendung von string.replace ähnlich wie bei der Verwendung von string.split oben, können Sie die Eingabe korrigieren. In den ersten beiden Beispielen unten passe ich an, wie ich leere Werte behandeln möchte:

const num = "1, 2,3,  4  ,5  ,6,,7.495"
const mix = "a, 2,3,  d  ,5  ,f,7.495,g"

console.log(    JSON.parse('['+num.replace(/,\s*,/,',0,')+']')
) // numbers, empty values default to zero
  // [1, 2, 3, 4, 5, 6, 0, 7.495]

console.log(    JSON.parse('['+num.replace(/,\s*,/,',')+']')
) // numbers, skips empty values
  // [1, 2, 3, 4, 5, 6, 7.495]

console.log(    JSON.parse('['+mix.replace(/(^|,)\s*([^,]*[^0-9, ][^,]*?)\s*(?=,|$)/g,'$1"$2"')+']') 
) // mixed values, will ERROR on empty values
  // ["a", 2, 3, "d", 5, "f", "7.495", "g"]