Warum hat die Javascript-Dezimalsubtraktion eine lange Liste von Dezimalstellen?

Grund: Der Integer-Typ wird zur Berechnung automatisch in einen Integer-Typ konvertiert, und der Dezimaltyp wird zur Berechnung direkt in einen Double-Typ konvertiert. Der Double-Typ muss also auf 15 Stellen nach dem Komma genau sein Die JavaScript-Dezimalsubtraktion führt zu einer langen Liste von Dezimalstellen.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, JavaScript-Version 1.8.5, Dell G3-Computer.

Der Grund, warum beim Subtrahieren von Dezimalstellen in JavaScript eine lange Folge von Dezimalstellen erscheint

<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>

Warum erzeugt der obige Code eine lange Folge von Dezimalstellen, obwohl er genauer ist, ist er nicht notwendig.

Dies hängt mit der Datenstruktur zusammen. Der Ganzzahltyp wird zur Berechnung automatisch in einen positiven Typ konvertiert, und der Dezimaltyp wird zur Berechnung direkt in einen Doppeltyp konvertiert. Dies ist bei Berechnungen im Speicher erforderlich. Sie sollten wissen, dass der Computer nur 0 und 1 erkennt. Das spezifische Problem ist die Gleitkommagenauigkeit.

• float ist auf 7 Nachkommastellen genau

• double ist auf 15 Nachkommastellen genau

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

toFixed()-Methode schneidet nicht nur überschüssige Dezimalstellen ab, sondern basiert auch auf der nächsten Dezimalstelle an der Abfangposition Ziffern werden gerundet. Für den Wert 10,739, gekürzt auf zwei Nachkommastellen, wäre das Ergebnis beispielsweise 10,74. Für den Wert 10,732, gekürzt auf zwei Nachkommastellen, ist das Ergebnis 10,73.

Beachten Sie, dass wir in JavaScript nur Dezimalstellen von 0 bis 20 Nachkommastellen abfangen können. Die

toFixed()-Methode wird nur von Browsern höherer Versionen unterstützt. Überprüfen Sie daher am besten, ob der Browser diese Methode unterstützt, bevor Sie sie verwenden. Der Prüfcode lautet wie folgt:

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;
}

Das kann gelöst werden, aber Sie möchten Fragen Sie, wie könnte es so einen zusätzlichen Dezimalpunkt geben?

Warum gibt es so unverständliche Antworten?

Ich habe es gegoogelt und herausgefunden, dass dies ein Fehler in JavaScript-Gleitkommaoperationen ist.

Zum Beispiel: 7*0,8 JavaScript berechnet es als: 5,6000000000000005

Ich habe online einige Lösungen gefunden, die darin bestehen, einige Gleitkommaoperationsfunktionen neu zu schreiben.

Diese Methoden sind unten als Referenz für Freunde aufgeführt, die auf das gleiche Problem stoßen:

Programmcode

//除法函数，用来得到精确的除法结果
//说明：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);
}

Fügen Sie diese Funktionen dort ein, wo Sie sie verwenden möchten, und rufen Sie sie dann zur Berechnung auf.

Wenn Sie beispielsweise Folgendes berechnen möchten: 7*0,8, ändern Sie es in (7).mul(8)

Andere Operationen sind ähnlich und Sie können genauere Ergebnisse erhalten.

【Verwandte Empfehlungen: Javascript-Lern-Tutorial】

Das obige ist der detaillierte Inhalt vonWarum hat die Javascript-Dezimalsubtraktion eine lange Liste von Dezimalstellen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!