it-swarm-eu.dev

Comment convertir tous les éléments d'un tableau en entier en JavaScript?

Je reçois un tableau après quelques manipulations. J'ai besoin de convertir toutes les valeurs d'un tableau sous forme d'entiers.

Mon exemple de code

var result_string = 'a,b,c,d|1,2,3,4';
result = result_string.split("|");
alpha = result[0];
count = result[1];
// console.log(alpha);
// console.log(count);
count_array = count.split(",");

count_array Contient maintenant 1,2,3,4 Mais j'ai besoin que cette valeur soit en entier.

J'avais utilisé parseInt(count_array);, mais cela a échoué. JS considère chaque valeur de ce tableau comme une chaîne.

56
Mohan Ram

Vous devez parcourir et analyser/convertir les éléments de votre tableau, comme ceci:

var result_string = 'a,b,c,d|1,2,3,4',
    result = result_string.split("|"),
    alpha = result[0],
    count = result[1],
    count_array = count.split(",");
for(var i=0; i<count_array.length;i++) count_array[i] = +count_array[i];
//now count_array contains numbers

Vous pouvez le tester ici . Si la +, jette, pensez-y:

for(var i=0; i<count_array.length;i++) count_array[i] = parseInt(count_array[i], 10);
18
Nick Craver

ECMAScript5 fournit une méthode map pour Arrays, en appliquant une fonction à tous les éléments d'un tableau. Voici un exemple:

var a = ['1','2','3']
var result = a.map(function (x) { 
  return parseInt(x, 10); 
});

console.log(result);

Pour plus d'informations, consultez https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/map

117
dheerosaur

Tu peux faire

var arrayOfNumbers = arrayOfStrings.map(Number);

Pour les navigateurs plus anciens qui ne prennent pas en charge Array.map, vous pouvez utiliser nderscore

var arrayOfNumbers = _.map(arrayOfStrings, Number);
72
Jonas Anseeuw
var arr = ["1", "2", "3"];
arr = arr.map(Number);
console.log(arr); // [1, 2, 3]
22
chzwzrd

Il suffit de boucler le tableau et de convertir les éléments:

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

N'oubliez pas le deuxième argument de parseInt.

7
Álvaro González

Le point contre parseInt - approche:

Il n'est pas nécessaire d'utiliser lambdas et/ou de donner le paramètre radix à parseInt, utilisez simplement parseFloat ou Number .


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 tout petit peu plus rapide et tire parti du cache lorsque parseInt - approche - ne fait pas :

      // 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 parseInt fonctionne environ 4 fois plus vite, mais reste plus lent que les autres. Au total: +e <Number <parseFloat <parseInt

6
ankhzet

var inp=readLine();//reading the input as one line string var nums=inp.split(" ").map(Number);//making an array of numbers console.log(nums);

entrée: 1 9 0 65 5 7 sortie: [1, 9, 0, 65, 5, 7]

et si nous n'utilisions pas .map (Number)

code var inp=readLine();//reading the input as one line string var nums=inp.split(" ");//making an array of strings console.log(nums);

entrée: 1 9 0 65 5 7 sortie: ['1', '9', '0', '65', '5', '7']

2
Rithik Singh
const arrString = ["1","2","3","4","5"];
const arrInteger = arrString.map(x => Number.parseInt(x, 10));

Au dessus on devrait être assez simple,

Une partie délicate est lorsque vous essayez d'utiliser le point fonction libre pour la carte comme ci-dessous

const arrString = ["1","2","3","4","5"];
const arrInteger = arrString.map(Number.parseInt);

Dans ce cas, le résultat sera [1, NaN, NaN, NaN, NaN] puisque la signature des arguments de fonction pour map et parseInt diffère

la carte attend - (value, index, array) où, comme parseInt l’attend - (value, radix)

1
Mohan Ram

Que dis-tu de ça:

let x = [1,2,3,4,5]
let num = +x.join("")
0
梅云飞

Si vous voulez convertir un tableau de chiffres en un nombre unique, utilisez simplement:

Number(arrayOfDigits.join(''));

Exemple

const arrayOfDigits = [1,2,3,4,5];

const singleNumber = Number(arrayOfDigits.join(''));

console.log(singleNumber); //12345
0
Juanma Menendez

En utilisant jQuery, vous pouvez aimer la méthode map() like so;

 $.map(arr, function(val,i) { 
     return parseInt(val); 
 });
0
nitzan