Pourquoi le tableau est-il préféré dans la collection ordonnée cyclique de Javascript ?

Préférez utiliser des tableaux plutôt que des types d'objet pour représenter des collections ordonnées

La norme ECMAScript ne spécifie pas l'ordre de stockage des propriétés dans le type d'objet de JavaScript.

Mais lorsque vous utilisez une boucle for..in pour parcourir les propriétés dans Object, vous devez vous fier à un certain ordre. Précisément parce qu'ECMAScript ne standardise pas explicitement cette séquence, chaque moteur d'exécution JavaScript peut être implémenté selon ses propres caractéristiques, de sorte que la cohérence comportementale de la boucle for..in ne peut pas être garantie dans différents environnements d'exécution.

Par exemple, le résultat du code suivant lors de l'appel de la méthode report est incertain :

function report(highScores) { 
  var result = ""; 
  var i = 1; 
  for (var name in highScores) { // unpredictable order 
    result += i + ". " + name + ": " + 
    highScores[name] + "\n"; 
    i++; 
  } 
  return result; 
} 
report([{ name: "Hank", points: 1110100 }, 
{ name: "Steve", points: 1064500 }, 
{ name: "Billy", points: 1050200 }]); 
// ?

Si vous avez vraiment besoin de vous assurer que le résultat de l'exécution est basé sur l'ordre des données , utilisez d'abord un type de tableau pour représenter les données au lieu d'utiliser directement le type Object. En même temps, essayez d'éviter d'utiliser des boucles for..in et d'utiliser des boucles for explicites :

function report(highScores) { 
  var result = ""; 
  for (var i = 0, n = highScores.length; i < n; i++) { 
    var score = highScores[i]; 
    result += (i + 1) + ". " + 
    score.name + ": " + score.points + "\n"; 
  } 
  return result; 
} 
report([{ name: "Hank", points: 1110100 }, 
{ name: "Steve", points: 1064500 }, 
{ name: "Billy", points: 1050200 }]); 
// "1. Hank: 1110100 2. Steve: 1064500 3. Billy: 1050200\n"

Un autre comportement particulièrement dépendant de l'ordre est le calcul de nombres à virgule flottante :

var ratings = { 
  "Good Will Hunting": 0.8, 
  "Mystic River": 0.7, 
  "21": 0.6, 
  "Doubt": 0.9 
};

Au point 2, il est mentionné que l'opération d'addition de nombres à virgule flottante ne peut même pas satisfaire la loi commutative : Les résultats de
(0,1 + 0,2) + 0,3 et les résultats de 0,1 + (0,2 + 0,3) sont
0,6000000000000001 et 0,6 respectivement

Donc pour les opérations arithmétiques sur les nombres à virgule flottante, un ordre arbitraire ne peut pas être utilisé :

var total = 0, count = 0; 
for (var key in ratings) { // unpredictable order 
  total += ratings[key]; 
  count++; 
} 
total /= count; 
total; // ?

Lorsque l'ordre de parcours de for..in est différent, le résultat total final est C'est différent. Voici les deux ordres de calcul et leurs résultats correspondants :

(0.8 + 0.7 + 0.6 +0.9) / 4 // 0.75
(0.6 + 0.8 + 0.7 +0.9) / 4 // 0.7499999999999999

Bien entendu, pour des problèmes tels que les calculs en virgule flottante, une solution consiste à utiliser des nombres entiers pour les représenter. , tel que Nous agrandissons d'abord le nombre à virgule flottante ci-dessus 10 fois en données entières, puis le réduisons 10 fois une fois le calcul terminé :

(8+ 7 + 6 + 9) / 4 / 10  // 0.75
(6+ 8 + 7 + 9) / 4 / 10  // 0.75

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!