javascript精確計算

⑴ js編寫一個函數，計算兩個數字的和、差、積、商（要求：使用傳參的形式）

/**
**除法函數，用來得到精確的除法結果
**說明：javascript的除法結果會有誤差，在兩個浮點數相除的時候會比較明顯。這個函數返回較為精確的除法結果。
**調用：accDiv(arg1,arg2)
**返回值：arg1除以arg2的精確結果
**/functionaccDiv(arg1,arg2){vart1=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){returnaccDiv(this,arg);
};/**
**乘法函數，用來得到精確的乘法結果
**說明：javascript的乘法結果會有誤差，在兩個浮點數相乘的時候會比較明顯。這個函數返回較為精確的乘法結果。
**調用：accMul(arg1,arg2)
**返回值：arg1乘以arg2的精確結果
**/functionaccMul(arg1,arg2){varm=0,s1=arg1.toString(),s2=arg2.toString();try{
m+=s1.split(".")[1].length;
}catch(e){
}try{
m+=s2.split(".")[1].length;
}catch(e){
}returnNumber(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m);
}//給Number類型增加一個mul方法，調用起來更加方便。Number.prototype.mul=function(arg){returnaccMul(arg,this);
};/**
**減法函數，用來得到精確的減法結果
**說明：javascript的減法結果會有誤差，在兩個浮點數相減的時候會比較明顯。這個函數返回較為精確的減法結果。
**調用：accSub(arg1,arg2)
**返回值：arg1加上arg2的精確結果
**/functionaccSub(arg1,arg2){varr1,r2,m,n;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));//lastmodifybydeeka//動態控制精度長度
n=(r1>=r2)?r1:r2;return((arg1*m-arg2*m)/m).toFixed(n);
}//給Number類型增加一個mul方法，調用起來更加方便。Number.prototype.sub=function(arg){returnaccMul(arg,this);
};/**
**加法函數，用來得到精確的加法結果
**說明：javascript的加法結果會有誤差，在兩個浮點數相加的時候會比較明顯。這個函數返回較為精確的加法結果。
**調用：accAdd(arg1,arg2)
**返回值：arg1加上arg2的精確結果
**/functionaccAdd(arg1,arg2){varr1,r2,m,c;try{
r1=arg1.toString().split(".")[1].length;
}catch(e){
r1=0;
}try{
r2=arg2.toString().split(".")[1].length;
}catch(e){
r2=0;
}
c=Math.abs(r1-r2);
m=Math.pow(10,Math.max(r1,r2));if(c>0){varcm=Math.pow(10,c);if(r1>r2){
arg1=Number(arg1.toString().replace(".",""));
arg2=Number(arg2.toString().replace(".",""))*cm;
}else{
arg1=Number(arg1.toString().replace(".",""))*cm;
arg2=Number(arg2.toString().replace(".",""));
}
}else{
arg1=Number(arg1.toString().replace(".",""));
arg2=Number(arg2.toString().replace(".",""));
}return(arg1+arg2)/m;
}//給Number類型增加一個add方法，調用起來更加方便。Number.prototype.add=function(arg){returnaccAdd(arg,this);
};

⑵ javascript怎麼解決浮點數計算不精確的問題

Math.add=function(v1,v2)
{
///<summary>精確計算加法。語法：Math.add(v1,v2)</summary>
///<paramname="v1"type="number">操作數。</param>
///<paramname="v2"type="number">操作數。</param>
///<returnstype="number">計算結果。</returns>
	varr1,r2,m;
	try
	{
		=v1.toString().split(".")[1].length;
	}
	catch(e)
	{
		r1=0;
	}
	try
	{
		r2=v2.toString().split(".")[1].length;
	}
	catch(e)
	{
		r2=0;
	}
	m=Math.pow(10,Math.max(r1,r2));
	
	return(v1*m+v2*m)/m;
}


Number.prototype.add=function(v)
{
///<summary>精確計算加法。語法：number1.add(v)</summary>
///<paramname="v"type="number">操作數。</param>
///<returnstype="number">計算結果。</returns>
	returnMath.add(v,this);
}


Math.sub=function(v1,v2)
{
///<summary>精確計算減法。語法：Math.sub(v1,v2)</summary>
///<paramname="v1"type="number">操作數。</param>
///<paramname="v2"type="number">操作數。</param>
///<returnstype="number">計算結果。</returns>
	returnMath.add(v1,-v2);
}


Number.prototype.sub=function(v)
{
///<summary>精確計算減法。語法：number1.sub(v)</summary>
///<paramname="v"type="number">操作數。</param>
///<returnstype="number">計算結果。</returns>
	returnMath.sub(this,v);
}


Math.mul=function(v1,v2)
{
///<summary>精確計算乘法。語法：Math.mul(v1,v2)</summary>
///<paramname="v1"type="number">操作數。</param>
///<paramname="v2"type="number">操作數。</param>
///<returnstype="number">計算結果。</returns>
	varm=0;
	vars1=v1.toString();
	vars2=v2.toString();
	try
	{
		m+=s1.split(".")[1].length;
	}
	catch(e)
	{
	}
	try
	{
		m+=s2.split(".")[1].length;
	}
	catch(e)
	{
	}
	
	returnNumber(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m);
}


Number.prototype.mul=function(v)
{
///<summary>精確計算乘法。語法：number1.mul(v)</summary>
///<paramname="v"type="number">操作數。</param>
///<returnstype="number">計算結果。</returns>
	returnMath.mul(v,this);
}


Math.div=function(v1,v2)
{
///<summary>精確計算除法。語法：Math.div(v1,v2)</summary>
///<paramname="v1"type="number">操作數。</param>
///<paramname="v2"type="number">操作數。</param>
///<returnstype="number">計算結果。</returns>
	vart1=0;
	vart2=0;
	varr1,r2;
	try
	{
		t1=v1.toString().split(".")[1].length;
	}
	catch(e)
	{
	}
	try
	{
		t2=v2.toString().split(".")[1].length;
	}
	catch(e)
	{
	}

	with(Math)
	{
		r1=Number(v1.toString().replace(".",""));
		r2=Number(v2.toString().replace(".",""));
		return(r1/r2)*pow(10,t2-t1);
	}
}


Number.prototype.div=function(v)
{
///<summary>精確計算除法。語法：number1.div(v)</summary>
///<paramname="v"type="number">操作數。</param>
///<returnstype="number">計算結果。</returns>
	returnMath.div(this,v);
}

⑶ 如何精確計算JS程序運行時間，進而優化代碼

一、 讓代碼簡潔：一些簡略的表達方式也會產生很好的優化
eg：x=x+1;在不影響功能的情況下可以簡寫為x++;
二、 變數名方法名盡量在不影響語意的情況下簡單。（可以選擇首字母命名）
eg：定義數組的長度可以取名為：ArrLen而不需要取為ArrayLength。
三、 關於JS的循環，循環是一種常用的流程式控制制。
JS提供了三種循環：for(;;)、while()、for(in)。在這三種循環中for(in)的效率最差，因為它需要查詢Hash鍵，因此應盡量少用for(in)循環，for(;;)、while()循環的性能基本持平。當然，推薦使用for循環，如果循環變數遞增或遞減，不要單獨對循環變數賦值，而應該使用嵌套的++或–運算符。
四、 如果需要遍歷數組，應該先緩存數組長度，將數組長度放入局部變數中，避免多次查詢數組長度。
因為我們常常要根據字元串、數組的長度進行循環，而通常這個長度是不變的，比如每次查詢a.length，就要額外進行一個操作，而預先把var len=a.length，則就少了一次查詢。
五、 盡量選用局部變數而不是全局變數。
局部變數的訪問速度要比全局變數的訪問速度更快，因為全局變數其實是window對象的成員，而局部變數是放在函數的棧里的。
六、 盡量少使用eval。
每次使用eval需要消耗大量時間，這時候使用JS所支持的閉包可以實現函數模板。
七、 減少對象查找
因為JavaScript的解釋性，所以a.b.c.d.e，需要進行至少4次查詢操作，先檢查a再檢查a中的b，再檢查b中的c，如此往下。所以如果這樣的表達式重復出現，只要可能，應該盡量少出現這樣的表達式，可以利用局部變數，把它放入一個臨時的地方進行查詢。
八、 字元串連接。
如果是追加字元串，最好使用s+=anotherStr操作，而不是要使用s=s+anotherStr。
如果要連接多個字元串，應該少使用+=，如s+=a;s+=b;s+=c;應該寫成s+=a + b + c；
而如果是收集字元串，比如多次對同一個字元串進行+=操作的話，最好使用一個緩存。怎麼用呢？使用JavaScript數組來收集，最後使用join方法連接起來，如下
var buf = new Array();for(var i = 0; i < 100; i++){ buf.push(i.toString());}var all = buf.join("");
九、 類型轉換
1. 把數字轉換成字元串，應用"" + 1，雖然看起來比較丑一點，但事實上這個效率是最高的，性能上來說：("" +) > String() > .toString() > new String()
盡量使用編譯時就能使用的內部操作要比運行時使用的用戶操作要快。
String()屬於內部函數，所以速度很快，而.toString()要查詢原型中的函數，所以速度遜色一些，new String()用於返回一個精確的副本。
2. 浮點數轉換成整型，這個更容易出錯，很多人喜歡使用parseInt()，其實parseInt()是用於將字元串轉換成數字，而不是浮點數和整型之間的轉換，我們應該使用Math.floor()或者Math.round()。Math是內部對象，所以Math.floor()其實並沒有多少查詢方法和調用的時間，速度是最快的。
3. 對於自定義的對象，如果定義了toString()方法來進行類型轉換的話，推薦顯式調用toString()，因為內部的操作在嘗試所有可能性之後，會嘗試對象的toString()方法嘗試能否轉化為String，所以直接調用這個方法效率會更高
十、 盡量作用JSON格式來創建對象，而不是var obj=new Object()方法。

⑷ javascript計算19.99*100得到了1998.999999循環，如何處理才能讓計算精確

var i="19.99";
var j="100";
i=parseFloat(i);
j=parseFloat(j);
res=i*j;
document.write(res.toFixed(0));

PS：因為編程語言是用二進制計算的，轉換的時候有誤差沒辦法，只能用toFixed()方法來修正小數的專位數，以達到屬最好的效果。