Pourquoi la soustraction décimale javascript a-t-elle une longue liste de décimales ?

Raison : le type entier sera automatiquement converti en type entier pour le calcul, et le type décimal sera directement converti en type double pour le calcul et le type double doit être précis à 15 chiffres après le ; point décimal, donc une longue chaîne apparaîtra lors de la soustraction de décimales en JavaScript de décimales.

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

La raison pour laquelle la soustraction décimale javascript produit une longue liste de décimales

<script>
var a=&#39;38.8&#39;;
var b=&#39;6.8&#39;;
alert(parseFloat(a)-parseFloat(b));
var a=134.22;
var b=6;
alert(a*b);
</script>

Pourquoi le code ci-dessus produit-il une longue liste de décimales bien qu'il soit plus précis ? , c'est possible. Ce n'est pas nécessaire.

Ceci est lié à la structure des données. Le type entier est automatiquement converti en type positif pour le calcul, et le type décimal est directement converti en type double pour le calcul. Ceci est nécessaire lors du calcul en mémoire. Il faut savoir que l'ordinateur ne reconnaît que 0 et 1. Le problème spécifique est la précision de la virgule flottante.

• flotteur précis à 7 décimales

• double précision à 15 décimales

javascript:document.write( (11.3-10.1).toFixed(2) )

La méthode toFixed() tronque non seulement les décimales en excès, mais arrondit également en fonction de la décimale suivante à la position d'interception. Par exemple, pour la valeur 10,739, tronquée à deux chiffres après la virgule, le résultat serait 10,74. Pour la valeur 10,732, tronquée à deux chiffres après la virgule, le résultat sera 10,73.

Notez qu'en JavaScript, nous ne pouvons intercepter que les décimales de 0 à 20 chiffres après la virgule. La méthode

toFixed() n'est supportée que par les versions supérieures des navigateurs, il est donc préférable de vérifier si le navigateur prend en charge cette méthode avant de l'utiliser. Le code à vérifier est le suivant :

var varNumber = 22.234;
 
if (varNumber.toFixed)
{
varNumber = varNumber.toFixed(2);
}
else //浏览器不支持toFixed()就使用其他方法
{
var div = Math.pow(10,2);
varNumber = Math.round(varNumber * div) / div;
}

Ceci peut être résolu, mais vous souhaitez vous demander comment il est possible d'avoir autant de points décimaux.

Pourquoi y a-t-il une réponse aussi incompréhensible ?

Je l'ai recherché sur Google et j'ai découvert qu'il s'agissait d'un bug dans les opérations JavaScript en virgule flottante.

Par exemple : 7*0,8 Le calcul JavaScript est : 5,6000000000000005

J'ai trouvé des solutions en ligne, qui consistent à réécrire certaines fonctions d'opérations à virgule flottante.

Ces méthodes sont extraites ci-dessous pour référence par les amis qui rencontrent le même problème :

Code du programme

//除法函数，用来得到精确的除法结果
//说明：javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。
//调用：accDiv(arg1,arg2)
//返回值：arg1除以arg2的精确结果
 
function accDiv(arg1,arg2){
var t1=0,t2=0,r1,r2;
try{t1=arg1.toString().split(".")[1].length}catch(e){}
try{t2=arg2.toString().split(".")[1].length}catch(e){}
with(Math){
r1=Number(arg1.toString().replace(".",""))
r2=Number(arg2.toString().replace(".",""))
return (r1/r2)*pow(10,t2-t1);
}
}
//给Number类型增加一个div方法，调用起来更加方便。
Number.prototype.div = function (arg){
return accDiv(this, arg);
}
//乘法函数，用来得到精确的乘法结果
//说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。
//调用：accMul(arg1,arg2)
//返回值：arg1乘以arg2的精确结果
function accMul(arg1,arg2)
{
var m=0,s1=arg1.toString(),s2=arg2.toString();
try{m+=s1.split(".")[1].length}catch(e){}
try{m+=s2.split(".")[1].length}catch(e){}
return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)
}
//给Number类型增加一个mul方法，调用起来更加方便。
Number.prototype.mul = function (arg){
return accMul(arg, this);
}
//加法函数，用来得到精确的加法结果
//说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
//调用：accAdd(arg1,arg2)
//返回值：arg1加上arg2的精确结果
function accAdd(arg1,arg2){
var r1,r2,m;
try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2))
return (arg1*m+arg2*m)/m
}
//给Number类型增加一个add方法，调用起来更加方便。
Number.prototype.add = function (arg){
return accAdd(arg,this);
}

Incluez ces fonctions là où vous souhaitez les utiliser, puis appelez simplement il faut calculer.

Par exemple, si vous souhaitez calculer : 7*0,8, remplacez-le par (7).mul(8)

D'autres opérations sont similaires et vous pouvez obtenir des résultats plus précis.

[Recommandations associées :

Tutoriel d'apprentissage javascript

]

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!