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()方法来修正小数的专位数，以达到属最好的效果。