Je veux convertir la chaîne suivante '14 2'en un tableau de deux entiers. Comment puis-je le faire ?

Vous pouvez .split()obtenir un tableau de chaînes , puis effectuer une boucle pour les convertir en nombres, comme ceci:

var myArray = "14 2".split(" ");
for(var i=0; i<myArray.length; i++) { myArray[i] = +myArray[i]; } 
//use myArray, it's an array of numbers

C'est +myArray[i]juste un moyen rapide de faire la conversion des nombres, si vous êtes sûr qu'il s'agit d'entiers, vous pouvez simplement faire:

for(var i=0; i<myArray.length; i++) { myArray[i] = parseInt(myArray[i], 10); } 

Un rapide pour les navigateurs modernes:

'14 2'.split(' ').map(Number);

// [14, 2]`

SO ... un fil plus ancien, je sais, mais ...

ÉDITER

@RoccoMusolino a eu une belle prise; voici une alternative:

TL; DR:

 const intArray = [...("5 6 7 69 foo 0".split(' ').filter(i => /\d/g.test(i)))]

FAUX :"5 6 note this foo".split(" ").map(Number).filter(Boolean); // [5, 6]

Il y a une faille subtile dans les solutions les plus élégantes énumérées ici, en particulier les belles réponses de @amillara et @Marcus.

Le problème se produit lorsqu'un élément du tableau de chaînes n'est pas de type entier, peut-être dans un cas sans validation sur une entrée. Pour un exemple artificiel ...

Le problème:

var effedIntArray = "5 6 7 69 foo".split(' ').map(Number); // [5, 6, 7, 69, NaN]

Puisque vous voulez évidemment un tableau PURE int, c'est un problème. Honnêtement , je n'ai pas compris cela avant d'avoir copié le code SO dans mon script ...: /

Le correctif (légèrement moins baller) :

var intArray = "5 6 7 69 foo".split(" ").map(Number).filter(Boolean); // [5, 6, 7, 69]

Donc, maintenant même lorsque vous avez une chaîne crap int, votre sortie est un tableau d'entiers purs. Les autres sont vraiment sexy dans la plupart des cas, mais je voulais vraiment offrir ma façon de faire la plupart du temps . C'est toujours un one-liner cependant, à mon crédit ...

J'espère que cela fera gagner du temps à quelqu'un!

var result = "14 2".split(" ").map(function(x){return parseInt(x)});

Une alternative à la réponse de Tushar Gupta serait:

'14 2'.split(' ').map(x=>+x);

// [14, 2]`

Dans le code golf, vous enregistrez 1 caractère. Ici, le "+" est l'opérateur "unaire plus", fonctionne comme parseInt.

Commencez par diviser la chaîne sur des espaces:

var result = '14 2'.split(' ');

Puis convertissez le tableau de chaînes de résultats en nombres entiers:

for (var i in result) {
    result[i] = parseInt(result[i], 10);
}

Le point contre parseInt-approche:

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

Juste pour le plaisir, j'ai pensé ajouter une forEach(f())solution aussi.

var a=[];
"14 2".split(" ").forEach(function(e){a.push(parseInt(e,10))});

// a = [14,2]

let idsArray = ids.split(',').map((x) => parseInt(x));

Meilleure solution en une ligne:

var answerInt = [];
var answerString = "1 2 3 4";
answerString.split(' ').forEach(function (item) {
   answerInt.push(parseInt(item))
});

nous la fonction de division :

var splitresult = "14 2".split(" ");