Les erreurs de point flottantes se produisent lorsque le fonctionnement de la multiplication de la multiplication décimale dans JS.
<cript>
Alerte (11 * 22,9)
</cript>
Le résultat a été 251.8999999999998 au lieu de 251.9
Il doit y avoir des maux de tête de nombreuses personnes. Alors, comment le résoudre? Ici, la solution est donnée.
1,
Copier le code du code comme suit:
<cript>
Alerte (11 * (22,9 * 10) / 10);
</cript>
L'idée approximative de résoudre le problème est que le facteur est élargi dans un entier d'abord, et finalement divisé par le multiple correspondant, de sorte que le résultat correct peut être obtenu.
2,
Copier le code du code comme suit:
<Regard de script>
Numéro.prototype.raate = function () {
var os.toString ();
if (ostr.indexof (".") == - 1)
Retour 1;
autre
Return math.pow (10, parseInt (osr.length-organ.indexof (".");
}
fonction trans () {
args = trans.arguments;
Var test = 1;
pour (i = 0; i <args.length; i ++)
temp * = args [i] * args [i] .raate ();
pour (i = 0; i <args.length; i ++)
temp / = args [i] .raate ();
Retour à la température
}
Alerte (trans (11,22,9));
</cript>
Cette solution est une méthode plus gênante, mais elle peut vous faire comprendre probablement le processus réel de résolution de ce problème.
Vous pouvez également utiliser la méthode de quatre maisons et cinq méthodes entrantes. .
Copier le code du code comme suit:
Fonction Fordight (Dight, How) {
Dight = Math.round (Dight * Math.Pow (10, How)) / Math.Pow (10, How);
Return dign;
}
// sauf la méthode pour obtenir la méthode précise pour supprimer la méthode
// Description: Les résultats de JavaScript auront une erreur, et il sera évident lorsque les deux nombres de points flottants seront supprimés. Cette fonction renvoie un résultat de suppression plus précis.
// Appel: AccDiv (Arg1, Arg2)
// Valeur de retour: arg1 sauf les résultats précis de l'ARG2
Fonction accdiv (arg1, arg2) {{
var t1 = 0, t2 = 0, r1, r2;
essayez {t1 = arg1.toString ().
essayez {t2 = arg2.tostring ().
avec (math) {
R1 = nombre (arg1.toString (). Remplacer (".", ""))
r2 = nombre (arg2.ToString (). Remplacer (".", ""))
Return (r1 / r2) * pow (10, t2-t1);
}
}
// Ajoutez une méthode div au type de nombre, ce qui est plus pratique à appeler.
Nombre.prototype.div = fonction (arg) {
Retourner accdiv (ceci, arg);
}
// Fonction de multiplication pour obtenir des résultats de multiplication précis
// Description: Les résultats des résultats de la multiplication JavaScript auront une erreur, et il sera évident lorsque les deux nombres de points flottants seront multipliés. Cette fonction renvoie un résultat de multiplication plus précis.
// Appel: Accmul (Arg1, Arg2)
// Valeur de retour: Arg1 est multiplié par les résultats précis d'Arg2
Fonction accmul (arg1, arg2)
{{
varm m = 0, s1 = arg1.toString (), s2 = arg2.ToString ();
Try {m + = s1.split (".") [1] .length} catch (e) {}
Essayez {m + = s2.split (".") [1] .length} catch (e) {}
Numéro de retour (s1.replace (".", "") * Numéro (s2.replace (".", "") /Math.pow (10, m)
}
// Ajoutez une méthode MUL au type de nombre, ce qui est plus pratique à appeler.
Nombre.prototype.mul = fonction (arg) {
Retour accmul (arg, this);
}
// Ajouter une méthode pour obtenir des résultats supplémentaires précis
// Description: Les résultats de JavaScript auront une erreur, et ce sera plus évident lorsque les deux nombres flottants sont ajoutés. Cette fonction renvoie un résultat plus précis de l'addition.
// Appel: acnidd (arg1, arg2)
// Valeur de retour: arg1 plus les résultats précis de l'ARG2
Fonction acadd (arg1, arg2) {{
var r1, r2, m;
essayez {r1 = arg1.toString ().
essayez {r2 = arg2.tostring ().
m = math.pow (10, math.max (r1, r2))))
Retour (arg1 * m + arg2 * m) / m
}
// Ajouter une méthode ADD au type de nombre, qui est plus pratique à appeler.
Nombre.prototype.add = fonction (arg) {
Retour acadd (arg, ceci);
}