


Au-delà de JavaScript – Pourquoi n'est-ce pas égal en programmation
JavaScript est fréquemment ridiculisé lorsque les développeurs rencontrent pour la première fois ce résultat apparemment déroutant :
0.1 + 0.2 == 0.30000000000000004
Les mèmes sur la gestion des nombres par JavaScript sont très répandus, ce qui amène souvent beaucoup à croire que ce comportement est propre au langage.
Cependant, cette bizarrerie ne se limite pas à JavaScript. C'est une conséquence de la façon dont la plupart des langages de programmation gèrent l'arithmétique à virgule flottante.
Par exemple, voici des extraits de code de Java et Go qui produisent des résultats similaires :
Les ordinateurs ne peuvent stocker nativement que des entiers. Ils ne comprennent pas les fractions. (Comment le feront-ils ? La seule manière pour les ordinateurs de faire du calcul est d'allumer ou d'éteindre certaines lumières. La lumière peut être allumée ou éteinte. Elle ne peut pas être « à moitié » allumée !) Ils ont besoin d'un moyen de représenter les nombres à virgule flottante. . Comme cette représentation n'est pas parfaitement précise, le plus souvent, 0,1 0,2 n'est pas égal à 0,3.
Toutes les fractions dont les dénominateurs sont constitués de facteurs premiers de la base du système numérique peuvent être exprimées proprement, tandis que toutes les autres fractions auraient des décimales répétitives. Par exemple, dans le système numérique en base 10, les fractions comme 1/2, 1/4, 1/5, 1/10 sont clairement représentées car les dénominateurs dans chaque cas sont constitués de 2 ou 5 - les facteurs premiers de 10. . Cependant, les fractions comme 1/3, 1/6, 1/7 ont toutes des décimales récurrentes.
.De même, dans le système binaire, les fractions comme 1/2, 1/4, 1/8 sont exprimées proprement tandis que toutes les autres fractions ont des décimales récurrentes. Lorsque vous effectuez des opérations arithmétiques sur ces décimales récurrentes, vous vous retrouvez avec des restes qui sont conservés lorsque vous convertissez la représentation binaire des nombres de l'ordinateur en une représentation en base 10 lisible par l'homme. C'est ce qui conduit à des résultats à peu près corrects.
Maintenant que nous avons établi que ce problème n'est pas exclusif à JavaScript, explorons comment les nombres à virgule flottante sont représentés et traités sous le capot pour comprendre pourquoi ce comportement se produit.
Afin de comprendre comment les nombres à virgule flottante sont représentés et traités sous le capot, nous devons d'abord comprendre la norme IEEE 754 à virgule flottante.
La norme IEEE 754 est une spécification largement utilisée pour représenter et effectuer des opérations arithmétiques sur des nombres à virgule flottante dans les systèmes informatiques. Il a été créé pour garantir la cohérence lors de l'utilisation de l'arithmétique à virgule flottante sur diverses plates-formes informatiques. La plupart des langages de programmation et des implémentations matérielles (CPU, GPU, etc.) adhèrent à cette norme.
Voici comment un nombre est noté au format IEEE 754 :
Ici s est le bit de signe (0 pour positif, 1 pour négatif), M est la mantisse (contient les chiffres du nombre) et E est l'exposant qui détermine l'échelle du nombre.
Vous ne pourrez pas trouver de valeurs entières pour M et E pouvant représenter exactement des nombres comme 0,1, 0,2 ou 0,3 dans ce format. Nous ne pouvons choisir que les valeurs pour M et E qui donnent le résultat le plus proche.
Voici un outil que vous pouvez utiliser pour déterminer les notations IEEE 754 des nombres décimaux : https://www.h-schmidt.net/FloatConverter/IEEE754.html
IEEE 754notation de 0,25 :
Notation IEEE 754 de 0,1 et 0,2 respectivement :
Veuillez noter que l'erreur due à la conversion dans le cas de 0,25 était de 0, tandis que 0,1 et 0,2 avaient des erreurs non nulles.
IEEE 754 définit les formats suivants pour représenter les nombres à virgule flottante :
Simple précision (32 bits) : 1 bit pour le signe, 8 bits pour l'exposant, 23 bits pour la mantisse
Double précision (64 bits) : 1 bit pour le signe, 11 bits pour l'exposant, 52 bits pour la mantisse
Par souci de simplicité, considérons le format simple précision qui utilise 32 bits.
La représentation 32 bits de 0,1 est :
0 01111011 10011001100110011001101
Here the first bit represents the sign (0 which means positive in this case), the next 8 bits (01111011) represent the exponent and the final 23 bits (10011001100110011001101) represent the mantissa.
This is not an exact representation. It represents ≈ 0.100000001490116119384765625
Similarly, the 32 bit representation of 0.2 is:
0 01111100 10011001100110011001101
This is not an exact representation either. It represents ≈ 0.20000000298023223876953125
When added, this results in:
0 01111101 11001101010011001100110
which is ≈ 0.30000001192092896 in decimal representation.
In conclusion, the seemingly perplexing result of 0.1 + 0.2 not yielding 0.3 is not an anomaly specific to JavaScript, but a consequence of the limitations of floating-point arithmetic across programming languages. The roots of this behaviour lie in the binary representation of numbers, which inherently leads to precision errors when handling certain fractions.
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!

Outils d'IA chauds

Undress AI Tool
Images de déshabillage gratuites

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

La portée de JavaScript détermine la portée d'accessibilité des variables, qui sont divisées en étendue globale, fonction et au niveau du bloc; Le contexte détermine la direction de cela et dépend de la méthode d'appel de fonction. 1. Les étendues incluent la portée globale (accessible n'importe où), la portée de la fonction (valide uniquement dans la fonction) et la portée au niveau du bloc (LET et const sont valides dans {}). 2. Le contexte d'exécution contient l'objet variable, la chaîne de portée et les valeurs de cela. Cela pointe vers global ou non défini dans la fonction ordinaire, l'appel de méthode pointe vers l'objet d'appel, le constructeur pointe vers le nouvel objet, et peut également être explicitement spécifié par appel / application / liaison. 3. La fermeture fait référence aux fonctions accédant et en se souvenant des variables de portée externes. Ils sont souvent utilisés pour l'encapsulation et le cache, mais peuvent provoquer

CompositionAPI dans Vue3 convient plus à la logique complexe et à la dérivation de type, et OptionsAPI convient aux scénarios et débutants simples; 1. OptionsAPI organise le code en fonction d'options telles que les données et les méthodes, et a une structure claire mais les composants complexes sont fragmentés; 2. CompositionAPI utilise la configuration pour concentrer la logique liée, ce qui est propice à la maintenance et à la réutilisation; 3. CompositionAPI réalise la réutilisation logique sans conflit et paramétrisable par le biais de fonctions composables, ce qui est mieux que le mixin; 4. CompositionAPI a une meilleure prise en charge de la dérivation de type dactylographiée et de type plus précise; 5. Il n'y a pas de différence significative dans le volume de performances et d'emballage des deux; 6.

Il existe une différence essentielle entre les travailleurs Web de JavaScript et Javathreads dans un traitement simultané. 1. JavaScript adopte un modèle unique. WebWorkers est un fil indépendant fourni par le navigateur. Il convient pour effectuer des tâches longues qui ne bloquent pas l'interface utilisateur, mais ne peuvent pas utiliser le DOM; 2. Java prend en charge le multithreading réel à partir du niveau de la langue, créé via la classe de threads, adapté à un traitement simultanée complexe et côté serveur; 3. Les travailleurs Web utilisent PostMessage () pour communiquer avec le fil principal, qui est hautement sécurisé et isolé; Les threads Java peuvent partager la mémoire, de sorte que les problèmes de synchronisation doivent être prêts à prêter attention; 4. Les travailleurs Web sont plus adaptés à l'informatique parallèle frontale, comme le traitement d'image, et

Initialiser le projet et créer package.json; 2. Créez un script d'entrée index.js avec shebang; 3. Registre des commandes via des champs bin dans package.json; 4. Utilisez des Yargs et d'autres bibliothèques pour analyser les paramètres de ligne de commande; 5. Utilisez le test local NPMLink; 6. Ajouter l'aide, la version et les options pour améliorer l'expérience; 7. Publier éventuellement via NPMPublish; 8. Affectuer éventuellement l'achèvement automatique avec Yargs; Enfin, créez des outils CLI pratiques grâce à une structure raisonnable et à une conception de l'expérience utilisateur, effectuer des tâches d'automatisation ou distribuer des widgets et se terminer par des phrases complètes.

Utilisez Document.CreateElement () pour créer de nouveaux éléments; 2. Personnaliser les éléments via TextContent, ClassList, SetAttribute et d'autres méthodes; 3. Utilisez des méthodes APPEDCHILD () ou plus flexibles APPEND () pour ajouter des éléments au DOM; 4. Utiliser éventuellement INSERTBEFORE (), avant () et d'autres méthodes pour contrôler la position d'insertion; Le processus complet consiste à créer → Personnaliser → Ajouter, et vous pouvez mettre à jour dynamiquement le contenu de la page.

Les types de conditions avancées de TypeScript implémentent le jugement logique entre les types via TextendU? X: Y Syntaxe. Ses capacités de base se reflètent dans les types de conditions distribuées, l'inférence de type inférieure et la construction d'outils de type complexe. 1. Le type conditionnel est distribué dans les paramètres de type nu et peut automatiquement diviser le type de joint, tel que pour obtenir la chaîne [] | nombre []. 2. Utiliser la distribution pour construire des outils de filtrage et d'extraction: exclut exclut les types via TextendU? Never: T, extraire extrait les points communs via TextendU? T: jamais, et des filtres non nuls nuls / non définis. 3

MicrofronttendSSolvescalingCallegengeSInLargeTeamsByAnabled indépendante développement et élaboration de choOsanIntegrationsStrategy: UseModuleFederationInwebpack5ForruntimeLoadingAndTrue Independence, Build-Time IntegrationForsIpleSetups, Oriframes / webcomponents webcomponents

Pour obtenir la longueur d'un tableau JavaScript, vous pouvez utiliser la propriété de longueur intégrée. 1. Utilisez l'attribut .Length pour renvoyer le nombre d'éléments dans le tableau, tels que constfruits = ['Apple', 'banana', 'orange']; console.log (fruits.length); // output: 3; 2. Cet attribut convient aux tableaux contenant tout type de données telles que des chaînes, des nombres, des objets ou des tableaux; 3. L'attribut de longueur sera automatiquement mis à jour et sa valeur changera en conséquence lorsque des éléments seront ajoutés ou supprimés; 4. Il renvoie un décompte basé sur un zéro et la longueur du tableau vide est de 0; 5. L'attribut de longueur peut être modifié manuellement pour tronquer ou étendre le tableau,
