Comment convertir une chaîne de nombres en un tableau de nombres?

J'ai sous la chaîne -

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

quand je fais -

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

Je reçois bcomme["1", "2", "3", "4"]

puis-je faire quelque chose pour obtenir bcomme [1, 2, 3, 4]?

Mes 2 cents pour les golfeurs:

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

backquote est une chaîne littérale, nous pouvons donc omettre la parenthèse (à cause de la nature de la fonction de division) mais elle est équivalente à split(','). La chaîne est maintenant un tableau, il suffit de mapper chaque valeur avec une fonction retournant l'entier de la chaîne donc x=>+x(qui est encore plus courte que la Numberfonction (5 caractères au lieu de 6)) équivaut à:

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

J'espère que c'est un peu plus clair.

Vous pouvez utiliser Array.mappour convertir chaque élément en un nombre.

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

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

Consultez les documents

Ou plus élégamment comme indiqué par l'utilisateur: thg435

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

Où Number()ferait le reste: vérifiez ici

Remarque: pour les navigateurs plus anciens qui ne prennent pas en charge map, vous pouvez ajouter vous-même une implémentation comme:

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

Mappez-le à des entiers:

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

mapexamine chaque élément du tableau, le transmet à la fonction fournie et renvoie un tableau avec les valeurs de retour de cette fonction. mapn'est pas disponible dans les anciens navigateurs, mais la plupart des bibliothèques comme jQuery ou underscore incluent une version multi-navigateurs.

Ou, si vous préférez les boucles:

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

+stringessaiera de changer la chaîne en un nombre. Ensuite, utilisez la Array.mapfonction pour changer chaque élément.

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

Array.from () pour plus de détails, accédez à MDN

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

b est un tableau de nombres

Une solution plus courte: mappez et passez les arguments à Number:

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

C'est très simple, comme:

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

En variante, vous pouvez utiliser la combinaison _.mapet les _.aryméthodes de la bibliothèque lodash . Toute la transformation sera un plus compact. Voici un exemple de la documentation officielle :

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

Il n'est pas nécessaire d'utiliser des lambdas et / ou de donner un radixparamètre à parseInt, utilisez simplement parseFloatou à la Numberplace.

Les raisons:

1. Ça marche:

   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. C'est plus court.

3. C'est un peu plus rapide et tire parti du cache, quand parseInt-approach - ne :

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

Remarque: dans Firefox parseIntfonctionne environ 4 fois plus vite, mais toujours plus lent que les autres. Au total: +e< Number< parseFloat<parseInt

Le trait de soulignement 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);

Version de Matt Zeunert avec fonction use arraw (ES6)

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

Bon mot

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

Étant donné que toutes les réponses permettent NaNd'être incluses, j'ai pensé ajouter que si vous voulez convertir rapidement un tableau de valeurs mixtes en nombres, vous pouvez le faire.

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.