Come convertire una stringa di numeri in una matrice di numeri?

Ho sotto la stringa -

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

quando io faccio -

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

Ottengo bcome["1", "2", "3", "4"]

posso fare qualcosa per ottenere bcome [1, 2, 3, 4]?

I miei 2 centesimi per i golfisti:

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

il backquote è stringa litteral, quindi possiamo omettere la parentesi (a causa della natura della funzione split) ma è equivalente a split(','). La stringa ora è un array, dobbiamo solo mappare ogni valore con una funzione che restituisca l'intero della stringa in modo x=>+xche (che è anche più breve della Numberfunzione (5 caratteri anziché 6)) equivale a:

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

Spero sia un po 'più chiaro.

Puoi usare Array.mapper convertire ogni elemento in un numero.

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

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

Controlla i documenti

O più elegantemente come indicato dall'utente: thg435

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

Dove Number()farebbe il resto: controlla qui

Nota: per i browser meno recenti che non supportano map, puoi aggiungere tu stesso un'implementazione come:

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

Mappa su numeri interi:

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

mapesamina ogni elemento dell'array, lo passa alla funzione fornita e restituisce un array con i valori di ritorno di quella funzione. mapnon è disponibile nei browser precedenti, ma la maggior parte delle librerie come jQuery o il carattere di sottolineatura include una versione cross-browser.

Oppure, se preferisci i loop:

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

+stringproverà a cambiare la stringa in un numero. Quindi utilizzare la Array.mapfunzione per modificare ogni elemento.

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

Array.from () per i dettagli vai a MDN

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

b è una matrice di numeri

Una soluzione più breve: mappare e passare gli argomenti a Number:

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

Questo è molto semplice, ad esempio:

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

Come variante puoi usare combinazioni_.map e _.arymetodi dalla libreria lodash . L'intera trasformazione sarà più compatta. Ecco un esempio dalla documentazione ufficiale :

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

Non è necessario usare lambda e / o dare radix parametro parseInt, basta usare parseFloato Numberinvece.

Motivi:

1. Sta funzionando:

   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. È più corto

3. È un po 'più veloce e sfrutta la cache, quando parseInt-approach - no :

     // 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'! >_<

Avviso: in Firefox parseIntfunziona circa 4 volte più velocemente, ma ancora più lentamente di altri. In totale: +e< Number< parseFloat<parseInt

La sottolineatura js way -

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

La versione di Matt Zeunert con uso della funzione arraw (ES6)

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

Una fodera

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

Dal momento che tutte le risposte lo consentono NaN di essere incluse, ho pensato di aggiungere che se si desidera trasmettere rapidamente una matrice di valori misti ai numeri, è possibile farlo.

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.