convertir une chaîne de caractères en un tableau d'entiers

Question

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

Answer 1

D'abord, diviser la chaîne de caractères sur les espaces :

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

Ensuite, convertissez le tableau de résultats des chaînes de caractères en nombres entiers :

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

Answer 2

Le point contre parseInt -approche :

Il n'y a pas besoin d'utiliser des lambdas et/ou de donner des radix pour parseInt il suffit d'utiliser parseFloat o Number à la place.

---

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, lorsque parseInt -approche - 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'! >_<

Avis : Dans Firefox parseInt fonctionne environ 4 fois plus vite, mais reste plus lent que les autres. Au total : +e < Number < parseFloat < parseInt

Answer 3

Si les chiffres peuvent être séparés par plus d'un espace, il est plus sûr de diviser la chaîne sur un ou plusieurs caractères d'espacement consécutifs (ce qui inclut les tabulations et les espaces ordinaires). Avec une expression régulière, ce serait \s+ .

Vous pouvez alors map chaque élément en utilisant le Number pour le convertir. Notez que parseInt ne fonctionnera pas (c'est-à-dire que arr.map(parseInt) ) car map passe trois arguments à la fonction de mappage : l'élément, l'index et le tableau original. parseInt accepte la base ou le radix comme second paramètre, il finira donc par prendre l'index comme base, ce qui donne souvent lieu à de nombreux cas de figure. NaN dans le résultat. Cependant, Number ignore tout argument autre que le premier, donc il fonctionne directement.

const str = '1\t\t2   3 4';
const result = str.split(/\s+/).map(Number); //[1,2,3,4]

Pour supprimer les éléments qui ne sont pas des chiffres, Array#filter peut être utilisé en conjonction avec isNaN .

const str = '1\t\t2   3 ab  4 c';
const result = str.split(/\s+/).map(Number).filter(x => !isNaN(x)); //[1,2,3,4]

Vous pouvez également utiliser une fonction anonyme pour le rappel du mappage avec l'opérateur unaire plus pour convertir chaque élément en un nombre.

const str = '1\t\t2   3 4';
const result = str.split(/\s+/).map(x => +x); //[1,2,3,4]

Avec une fonction anonyme pour le callback, vous pouvez décider des paramètres à utiliser, ainsi parseInt peut également fonctionner.

const str = '1\t\t2   3 4';
const result = str.split(/\s+/).map(x => parseInt(x)); //[1,2,3,4]

Answer 4

Juste pour le plaisir, j'ai pensé que j'allais lancer un forEach(f()) en plus.

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

// a = [14,2]

Answer 5

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