Jak przekonwertować ciąg liczb na tablicę liczb?

Mam poniżej ciągu -

var a = "1,2,3,4";

kiedy robię -

var b = a.split(',');

dostaję b jak["1", "2", "3", "4"]

Mogę coś zrobić, aby uzyskać bjak [1, 2, 3, 4]?

Moje 2 centy dla golfistów:

b="1,2,3,4".split`,`.map(x=>+x)

backquote jest łańcuchem literałowym, więc możemy pominąć nawias (ze względu na naturę funkcji podziału), ale jest on równoważny split(','). Ciąg jest teraz tablicą, musimy tylko odwzorować każdą wartość za pomocą funkcji zwracającej liczbę całkowitą ciągu, więc x=>+x(która jest nawet krótsza niż Numberfunkcja (5 znaków zamiast 6)) jest równoważna z:

function(x){return parseInt(x,10)}// version from techfoobar
(x)=>{return parseInt(x)}         // lambda are shorter and parseInt default is 10
(x)=>{return +x}                  // diff. with parseInt in SO but + is better in this case
x=>+x                             // no multiple args, just 1 function call

Mam nadzieję, że to trochę bardziej jasne.

Możesz użyć Array.mapdo przekonwertowania każdego elementu na liczbę.

var a = "1,2,3,4";

var b = a.split(',').map(function(item) {
    return parseInt(item, 10);
});

Sprawdź dokumenty

Lub bardziej elegancko, jak wskazał użytkownik: thg435

var b = a.split(',').map(Number);

Gdzie Number()zrobi resztę: sprawdź tutaj

Uwaga: w przypadku starszych przeglądarek, które nie obsługują map, możesz samodzielnie dodać implementację, taką jak:

Array.prototype.map = Array.prototype.map || function(_x) {
    for(var o=[], i=0; i<this.length; i++) { 
        o[i] = _x(this[i]); 
    }
    return o;
};

Zamapuj na liczby całkowite:

a.split(',').map(function(i){
    return parseInt(i, 10);
})

mapsprawdza każdy element tablicy, przekazuje go do podanej funkcji i zwraca tablicę ze zwracanymi wartościami tej funkcji. mapnie jest dostępne w starych przeglądarkach, ale większość bibliotek, takich jak jQuery lub podkreślenie, zawiera wersję dla różnych przeglądarek.

Lub, jeśli wolisz pętle:

var res = a.split(",");
for (var i=0; i<res.length; i++)
{
    res[i] = parseInt(res[i], 10);
}

+stringspróbuje zmienić ciąg na liczbę. Następnie użyj Array.mapfunkcji, aby zmienić każdy element.

"1,2,3,4".split(',').map(function(el){ return +el;});

Array.from () w celu uzyskania szczegółowych informacji przejdź do MDN

var a = "1,2,3,4";
var b = Array.from(a.split(','),Number);

b to tablica liczb

Krótsze rozwiązanie: zamapuj i przekaż argumenty do Number:

var a = "1,2,3,4";
var b = a.split(',');
console.log(b);
var c = b.map(Number);
console.log(c);

To jest bardzo proste. Na przykład:

["1", "2", "3", "4"].map(i=>Number(i))

Jako wariant możesz użyć kombinacji _.mapi _.arymetod z biblioteki lodash . Cała transformacja będzie bardziej zwarta. Oto przykład z oficjalnej dokumentacji :

_.map(['6', '8', '10'], _.ary(parseInt, 1));
// → [6, 8, 10]

Nie ma potrzeby używania lambda i / lub podawania radixparametru parseInt, wystarczy użyć parseFloatlub Numberzamiast tego.

Powody:

1. To działa:

   var src = "1,2,5,4,3";
   var ids = src.split(',').map(parseFloat); // [1, 2, 5, 4, 3]
   
   var obj = {1: ..., 3: ..., 4: ..., 7: ...};
   var keys= Object.keys(obj); // ["1", "3", "4", "7"]
   var ids = keys.map(parseFloat); // [1, 3, 4, 7]
   
   var arr = ["1", 5, "7", 11];
   var ints= arr.map(parseFloat); // [1, 5, 7, 11]
   ints[1] === "5" // false
   ints[1] === 5   // true
   ints[2] === "7" // false
   ints[2] === 7   // true

2. Jest krótszy

3. Jest trochę szybszy i wykorzystuje pamięć podręczną, gdy parseInt-podejście - nie :

     // execution time measure function
     // keep it simple, yeah?
   > var f = (function (arr, c, n, m) {
         var i,t,m,s=n();
         for(i=0;i++<c;)t=arr.map(m);
         return n()-s
     }).bind(null, "2,4,6,8,0,9,7,5,3,1".split(','), 1000000, Date.now);
   
   > f(Number) // first launch, just warming-up cache
   > 3971 // nice =)
   
   > f(Number)
   > 3964 // still the same
   
   > f(function(e){return+e})
   > 5132 // yup, just little bit slower
   
   > f(function(e){return+e})
   > 5112 // second run... and ok.
   
   > f(parseFloat)
   > 3727 // little bit quicker than .map(Number)
   
   > f(parseFloat)
   > 3737 // all ok
   
   > f(function(e){return parseInt(e,10)})
   > 21852 // awww, how adorable...
   
   > f(function(e){return parseInt(e)})
   > 22928 // maybe, without '10'?.. nope.
   
   > f(function(e){return parseInt(e)})
   > 22769 // second run... and nothing changes.
   
   > f(Number)
   > 3873 // and again
   > f(parseFloat)
   > 3583 // and again
   > f(function(e){return+e})
   > 4967 // and again
   
   > f(function(e){return parseInt(e,10)})
   > 21649 // dammit 'parseInt'! >_<

Uwaga: W przeglądarce Firefox parseIntdziała około 4 razy szybciej, ale nadal wolniej niż inne. W sumie: +e< Number< parseFloat<parseInt

Sposób podkreślenia js -

var a = "1,2,3,4",
  b = a.split(',');

//remove falsy/empty values from array after split
b = _.compact(b);
//then Convert array of string values into Integer
b = _.map(b, Number);

console.log('Log String to Int conversion @b =', b);

Wersja Matta Zeunerta z funkcją Arraw (ES6)

const nums = a.split(',').map(x => parseInt(x, 10));

Jedna wkładka

Array.from(a.split(','), Number)

Ponieważ wszystkie odpowiedzi pozwalają NaNna uwzględnienie, pomyślałem, że dodam, że jeśli chcesz szybko rzucić tablicę mieszanych wartości na liczby, możesz to zrobić.

var a = "1,2,3,4,foo,bar";

var b = a.split(',');

var result = b.map(_=>_|0) // Floors the number (32-bit signed integer) so this wont work if you need all 64 bits.

// or b.map(_=>_||0) if you know your array is just numbers but may include NaN.