blocks|key|1090379|text|将数字转换为字符串，将数字匹配到小数点后第二位：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1090380|​|1090381|function+calc(theform)+{
++++var+num+=+theform.original.value,+rounded+=+theform.rounded
++++var+with2Decimals+=+num.toString().match(/%5E-?\d%2B(?:\.\d{0,2})?/)[0]
++++rounded.value+=+with2Decimals
}|code-block|syntax|javascript|1090382|<form+onsubmit="return+calc(this)">
Original+number:+<input+name="original"+type="text"+onkeyup="calc(form)"+onchange="calc(form)"+/>
<br+/>"Rounded"+number:+<input+name="rounded"+type="text"+placeholder="readonly"+readonly>
</form>|1090383|1090384|与toString不同，toFixed方法在某些情况下会失败，因此要非常小心地使用它。|offset|length|style|CODE|1090385|entityMap^0|0|0|0|0|0|1|8|C|7|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|K|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|Y|8|@$N|Z|O|10|P|Q]|$N|11|O|12|P|Q]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|S|$]]

Convert the number into a string, match the number up to the second decimal place:

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function calc(theform) {
 var num = theform.original.value, rounded = theform.rounded
 var with2Decimals = num.toString().match(/^-?\d+(?:\.\d{0,2})?/)[0]
 rounded.value = with2Decimals
}</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;form onsubmit="return calc(this)"&gt;
Original number: &lt;input name="original" type="text" onkeyup="calc(form)" onchange="calc(form)" /&gt;
&lt;br /&gt;"Rounded" number: &lt;input name="rounded" type="text" placeholder="readonly" readonly&gt;
&lt;/form&gt;</code></pre>
</div>
</div>


The <code>toFixed</code> method fails in some cases unlike <code>toString</code>, so be very careful with it.

blocks|key|875808|text|我选择这样写，而不是手动删除字符串的余数，这样我就不必处理数字带来的数学问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|875809|num+=+num.toString();+//If+it's+not+already+a+String
num+=+num.slice(0,+(num.indexOf("."))%2B3);+//With+3+exposing+the+hundredths+place
Number(num);+//If+you+need+it+back+as+a+Number|code-block|syntax|javascript|875810|这将给你"15.77“，num+=+15.7784514；|875811|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I opted to write this instead to manually remove the remainder with strings so I don't have to deal with the math issues that come with numbers:

<pre><code>num = num.toString(); //If it's not already a String
num = num.slice(0, (num.indexOf("."))+3); //With 3 exposing the hundredths place
Number(num); //If you need it back as a Number
</code></pre>

This will give you "15.77" with num = 15.7784514;

blocks|key|1091100|text|另一个单行解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1091101|number+=+Math.trunc(number*100)/100|code-block|syntax|javascript|1091102|我使用100，因为您希望截断到第二位，但更灵活的解决方案是：|1091103|number+=+Math.trunc(number*Math.pow(10,+digits))/Math.pow(10,+digits)|1091104|其中digits是要保留的十进制位数。|1091105|有关详细信息和浏览器兼容性，请参阅Math.trunc+specs。|offset|length|1091106|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc^0|0|0|0|0|0|H|G|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@$O|14|P|15|1|16]]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

Another single-line solution :
<pre><code>number = Math.trunc(number*100)/100
</code></pre>
I used 100 because you want to truncate to the second digit, but a more flexible solution would be :
<pre><code>number = Math.trunc(number*Math.pow(10, digits))/Math.pow(10, digits)
</code></pre>
where digits is the amount of decimal digits to keep.
See <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc" rel="noreferrer">Math.trunc specs</a> for details and browser compatibility.

blocks|key|876406|text|更新(2021年1月)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876407|根据其范围的不同，javascript中的数字可以用科学记数法表示。例如，如果您在控制台中键入0.0000001，您可能会看到它为1e-7，而0.000001显示为未更改的(0.000001)。如果您的应用程序在不涉及科学记数法的数字范围上工作，您可以忽略此更新，并使用下面的原始答案。|876408|这个更新是关于添加一个函数，该函数检查数字是否为科学格式，如果是，则将其转换为十进制格式。我在这里提出了这个one，但您可以根据应用程序的需要，使用任何其他实现相同目标的函数：|offset|length|876409|function+toFixed(x)+{
++if+(Math.abs(x)+<+1.0)+{
++++var+e+=+parseInt(x.toString().split('e-')[1]);
++++if+(e)+{
++++++++x+*=+Math.pow(10,e-1);
++++++++x+=+'0.'+%2B+(new+Array(e)).join('0')+%2B+x.toString().substring(2);
++++}
++}+else+{
++++var+e+=+parseInt(x.toString().split('%2B')[1]);
++++if+(e+>+20)+{
++++++++e+-=+20;
++++++++x+/=+Math.pow(10,e);
++++++++x+%2B=+(new+Array(e%2B1)).join('0');
++++}
++}
++return+x;
}|code-block|syntax|javascript|876410|现在只需将该函数应用于参数(这是相对于原始答案的唯一更改)：|876411|function+toFixedTrunc(x,+n)+{
++++++x+=+toFixed(x)+

++++++//+From+here+on+the+code+is+the+same+than+the+original+answer
++++++const+v+=+(typeof+x+===+'string'+?+x+:+x.toString()).split('.');
++++++if+(n+<=+0)+return+v[0];
++++++let+f+=+v[1]+%7C%7C+'';
++++++if+(f.length+>+n)+return+`${v[0]}.${f.substr(0,n)}`;
++++++while+(f.length+<+n)+f+%2B=+'0';
++++++return+`${v[0]}.${f}`
++++}|876412|这个更新版本还解决了评论中提到的一个案例：|876413|toFixedTrunc(0.000000199,+2)+=>+"0.00"+|876414|同样，选择最适合您的应用程序需要的内容。|876415|原答案(2017年10月)|876416|一般解决方案是将一个数字截断(不舍入)到第n位十进制数字，并将其转换为恰好有n位十进制数字的字符串，对于任意n个≥0。|876417|function+toFixedTrunc(x,+n)+{
++const+v+=+(typeof+x+===+'string'+?+x+:+x.toString()).split('.');
++if+(n+<=+0)+return+v[0];
++let+f+=+v[1]+%7C%7C+'';
++if+(f.length+>+n)+return+`${v[0]}.${f.substr(0,n)}`;
++while+(f.length+<+n)+f+%2B=+'0';
++return+`${v[0]}.${f}`
}|876418|其中x可以是数字(转换为字符串)或字符串。|876419|下面是一些针对n=2的测试(包括OP请求的测试)：|876420|0+++++++++++=>+0.00
0.01++++++++=>+0.01
0.5839++++++=>+0.58
0.999+++++++=>+0.99
1.01++++++++=>+1.01
2+++++++++++=>+2.00
2.551+++++++=>+2.55
2.99999+++++=>+2.99
4.27++++++++=>+4.27
15.7784514++=>+15.77
123.5999++++=>+123.59|876421|对于n的其他一些值：|876422|15.001097+++=>+15.0010+(n=4)
0.000003298+=>+0.0000032+(n=7)
0.000003298257899+=>+0.000003298257+(n=12)|876423|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1685680/how-to-avoid-scientific-notation-for-large-numbers-in-javascript^0|0|0|1I|3|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1L|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1M|8|@]|9|@$F|1N|G|1O|1|1P]]|A|$]]|$1|H|3|I|5|J|7|1Q|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1R|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1S|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1T|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|1U|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|1V|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1W|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1X|8|@]|9|@]|A|$]]|$1|10|3|11|5|J|7|1Y|8|@]|9|@]|A|$K|L]]|$1|12|3|13|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|20|8|@]|9|@]|A|$]]|$1|16|3|17|5|J|7|21|8|@]|9|@]|A|$K|L]]|$1|18|3|19|5|6|7|22|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|J|7|23|8|@]|9|@]|A|$K|L]]|$1|1C|3|-4|5|6|7|24|8|@]|9|@]|A|$]]]|1D|$1E|$5|1F|1G|1H|A|$1I|1J]]]]

<h1>Update (Jan 2021)</h1>
Depending on its range, a number in javascript may be shown in scientific notation. For example, if you type 0.0000001 in the console, you may see it as 1e-7, whereas 0.000001 appears unchanged (0.000001).
If your application works on a range of numbers for which scientific notation is not involved, you can just ignore this update and use the original answer below. 
This update is about adding a function that checks if the number is in scientific format and, if so, converts it into decimal format. Here I'm proposing this <a href="https://stackoverflow.com/questions/1685680/how-to-avoid-scientific-notation-for-large-numbers-in-javascript">one</a>, but you can use any other function that achieves the same goal, according to your application's needs:
<pre><code>function toFixed(x) {
 if (Math.abs(x) &lt; 1.0) {
 var e = parseInt(x.toString().split('e-')[1]);
 if (e) {
 x *= Math.pow(10,e-1);
 x = '0.' + (new Array(e)).join('0') + x.toString().substring(2);
 }
 } else {
 var e = parseInt(x.toString().split('+')[1]);
 if (e &gt; 20) {
 e -= 20;
 x /= Math.pow(10,e);
 x += (new Array(e+1)).join('0');
 }
 }
 return x;
}
</code></pre>
Now just apply that function to the parameter (that's the only change with respect to the original answer):
<pre><code>function toFixedTrunc(x, n) {
 x = toFixed(x) 

 // From here on the code is the same than the original answer
 const v = (typeof x === 'string' ? x : x.toString()).split('.');
 if (n &lt;= 0) return v[0];
 let f = v[1] || '';
 if (f.length &gt; n) return `${v[0]}.${f.substr(0,n)}`;
 while (f.length &lt; n) f += '0';
 return `${v[0]}.${f}`
 }
</code></pre>
This updated version addresses also a case mentioned in a comment:
<pre><code>toFixedTrunc(0.000000199, 2) =&gt; &quot;0.00&quot; 
</code></pre>
Again, choose what fits your application needs at best.
<h1>Original answer (October 2017)</h1>
General solution to truncate (no rounding) a number to the n-th decimal digit and convert it to a string with exactly n decimal digits, for any n≥0.
<pre><code>function toFixedTrunc(x, n) {
 const v = (typeof x === 'string' ? x : x.toString()).split('.');
 if (n &lt;= 0) return v[0];
 let f = v[1] || '';
 if (f.length &gt; n) return `${v[0]}.${f.substr(0,n)}`;
 while (f.length &lt; n) f += '0';
 return `${v[0]}.${f}`
}
</code></pre>
where x can be either a number (which gets converted into a string) or a string.
Here are some tests for n=2 (including the one requested by OP):
<pre><code>0 =&gt; 0.00
0.01 =&gt; 0.01
0.5839 =&gt; 0.58
0.999 =&gt; 0.99
1.01 =&gt; 1.01
2 =&gt; 2.00
2.551 =&gt; 2.55
2.99999 =&gt; 2.99
4.27 =&gt; 4.27
15.7784514 =&gt; 15.77
123.5999 =&gt; 123.59
</code></pre>
And for some other values of n:
<pre><code>15.001097 =&gt; 15.0010 (n=4)
0.000003298 =&gt; 0.0000032 (n=7)
0.000003298257899 =&gt; 0.000003298257 (n=12)
</code></pre>

blocks|key|875832|text|parseInt比Math.floor更快|type|unstyled|depth|inlineStyleRanges|entityRanges|data|875833|function+floorFigure(figure,+decimals){
++++if+(!decimals)+decimals+=+2;
++++var+d+=+Math.pow(10,decimals);
++++return+(parseInt(figure*d)/d).toFixed(decimals);
};

floorFigure(123.5999)++++=>+++"123.59"
floorFigure(123.5999,+3)+=>+++"123.599"|code-block|syntax|javascript|875834|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

parseInt is faster then Math.floor

<pre><code>function floorFigure(figure, decimals){
 if (!decimals) decimals = 2;
 var d = Math.pow(10,decimals);
 return (parseInt(figure*d)/d).toFixed(decimals);
};

floorFigure(123.5999) =&gt; "123.59"
floorFigure(123.5999, 3) =&gt; "123.599"
</code></pre>

blocks|key|876447|text|num+=+19.66752
f+=+num.toFixed(3).slice(0,-1)
alert(f)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|876448|这将返回19.66|unstyled|876449|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>num = 19.66752
f = num.toFixed(3).slice(0,-1)
alert(f)
</code></pre>

This will return 19.66

blocks|key|876516|text|简单地这样做|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876517|number+=+parseInt(number+*+100)/100;|code-block|syntax|javascript|876518|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Simple do this

<pre><code>number = parseInt(number * 100)/100;
</code></pre>

blocks|key|876331|text|我的正数版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876332|function+toFixed_norounding(n,p)
{
++++var+result+=+n.toFixed(p);
++++return+result+<=+n+?+result:+(result+-+Math.pow(0.1,p)).toFixed(p);
}|code-block|syntax|javascript|876333|快，漂亮，明显。(正数的版本)|876334|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

My version for positive numbers:

<pre><code>function toFixed_norounding(n,p)
{
 var result = n.toFixed(p);
 return result &lt;= n ? result: (result - Math.pow(0.1,p)).toFixed(p);
}
</code></pre>

Fast, pretty, obvious. (version for positive numbers)

blocks|key|876660|text|只需截断数字即可：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876661|function+truncDigits(inputNumber,+digits)+{
++const+fact+=+10+**+digits;
++return+Math.floor(inputNumber+*+fact)+/+fact;
}|code-block|syntax|javascript|876662|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just truncate the digits:

<pre><code>function truncDigits(inputNumber, digits) {
 const fact = 10 ** digits;
 return Math.floor(inputNumber * fact) / fact;
}
</code></pre>

blocks|key|876857|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876858|//+typescript
//+function+formatLimitDecimals(value:+number,+decimals:+number)+{

function+formatLimitDecimals(value,+decimals)+{
++const+parts+=+value.toString().split('.')

++if+(parts.length+===+2)+{
++++return+Number([parts[0],+parts[1].slice(0,+decimals)].join('.'))
++}+else+{
++++return+Number(parts[0]);
++}
}

console.log(formatLimitDecimals(4.156,+2));+//+4.15
console.log(formatLimitDecimals(4.156,+8));+//+4.156
console.log(formatLimitDecimals(4.156,+0));+//+4|code-block|syntax|javascript|876859|876860|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>// typescript
// function formatLimitDecimals(value: number, decimals: number) {

function formatLimitDecimals(value, decimals) {
 const parts = value.toString().split('.')

 if (parts.length === 2) {
 return Number([parts[0], parts[1].slice(0, decimals)].join('.'))
 } else {
 return Number(parts[0]);
 }
}

console.log(formatLimitDecimals(4.156, 2)); // 4.15
console.log(formatLimitDecimals(4.156, 8)); // 4.156
console.log(formatLimitDecimals(4.156, 0)); // 4</code></pre>
</div>
</div>

blocks|key|1090507|text|这些解决方案确实有效，但对我来说似乎是不必要的复杂。我个人喜欢使用模运算符来获得除法运算的剩余部分，并将其删除。假设num+=+15.7784514：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1090508|num-=num%25.01;|code-block|syntax|javascript|1090509|这相当于说num+=+num+-+(num+%25+.01)。|1090510|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

These solutions do work, but to me seem unnecessarily complicated. I personally like to use the modulus operator to obtain the remainder of a division operation, and remove that. Assuming that num = 15.7784514:

<pre><code>num-=num%.01;
</code></pre>

This is equivalent to saying num = num - (num % .01).

blocks|key|876014|text|这里的答案对我没有帮助，它总是四舍五入，或者给我错误的小数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876015|我的解决方案将您的小数转换为字符串，提取字符，然后将整个内容作为数字返回。|876016|function+Dec2(num)+{
++num+=+String(num);
++if(num.indexOf('.')+!==+-1)+{
++++var+numarr+=+num.split(".");
++++if+(numarr.length+==+1)+{
++++++return+Number(num);
++++}
++++else+{
++++++return+Number(numarr[0]%2B"."%2Bnumarr[1].charAt(0)%2Bnumarr[1].charAt(1));
++++}
++}
++else+{
++++return+Number(num);
++}++
}

Dec2(99);+//+99
Dec2(99.9999999);+//+99.99
Dec2(99.35154);+//+99.35
Dec2(99.8);+//+99.8
Dec2(10265.985475);+//+10265.98|code-block|syntax|javascript|876017|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The answers here didn't help me, it kept rounding up or giving me the wrong decimal.

my solution converts your decimal to a string, extracts the characters and then returns the whole thing as a number. 

<pre><code>function Dec2(num) {
 num = String(num);
 if(num.indexOf('.') !== -1) {
 var numarr = num.split(".");
 if (numarr.length == 1) {
 return Number(num);
 }
 else {
 return Number(numarr[0]+"."+numarr[1].charAt(0)+numarr[1].charAt(1));
 }
 }
 else {
 return Number(num);
 } 
}

Dec2(99); // 99
Dec2(99.9999999); // 99.99
Dec2(99.35154); // 99.35
Dec2(99.8); // 99.8
Dec2(10265.985475); // 10265.98
</code></pre>

blocks|key|876096|text|下面的代码非常适合我：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876097|num.toString().match(/.\*\\..{0,2}%7C.\*/)[0];|code-block|syntax|javascript|876098|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The following code works very good for me: 

<pre><code>num.toString().match(/.\*\\..{0,2}|.\*/)[0];
</code></pre>

blocks|key|876595|text|一种简单的方法是next，但必须确保amount参数是以字符串形式给出的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876596|function+truncate(amountAsString,+decimals+=+2){
++var+dotIndex+=+amountAsString.indexOf('.');
++var+toTruncate+=+dotIndex+!==+-1++&&+(+amountAsString.length+>+dotIndex+%2B+decimals+%2B+1);
++var+approach+=+Math.pow(10,+decimals);
++var+amountToTruncate+=+toTruncate+?+amountAsString.slice(0,+dotIndex+%2B+decimals+%2B1)+:+amountAsString;++
++return+toTruncate
++++?++Math.floor(parseFloat(amountToTruncate)+*+approach+)+/+approach
++++:++parseFloat(amountAsString);|code-block|syntax|javascript|876597|}|876598|console.log(truncate("7.99999"));+//OUTPUT+==>+7.99
console.log(truncate("7.99999",+3));+//OUTPUT+==>+7.999
console.log(truncate("12.799999999999999"));+//OUTPUT+==>+7.99|876599|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

An Easy way to do it is the next but is necessary ensure that the amount parameter is given as a string. 

<pre><code>function truncate(amountAsString, decimals = 2){
 var dotIndex = amountAsString.indexOf('.');
 var toTruncate = dotIndex !== -1 &amp;&amp; ( amountAsString.length &gt; dotIndex + decimals + 1);
 var approach = Math.pow(10, decimals);
 var amountToTruncate = toTruncate ? amountAsString.slice(0, dotIndex + decimals +1) : amountAsString; 
 return toTruncate
 ? Math.floor(parseFloat(amountToTruncate) * approach ) / approach
 : parseFloat(amountAsString);
</code></pre>

}

<pre><code>console.log(truncate("7.99999")); //OUTPUT ==&gt; 7.99
console.log(truncate("7.99999", 3)); //OUTPUT ==&gt; 7.999
console.log(truncate("12.799999999999999")); //OUTPUT ==&gt; 7.99
</code></pre>

blocks|key|876633|text|这对我来说效果很好。我希望它也能解决你的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876634|function+toFixedNumber(number)+{
++++const+spitedValues+=+String(number.toLocaleString()).split('.');
++++let+decimalValue+=+spitedValues.length+>+1+?+spitedValues[1]+:+'';
++++decimalValue+=+decimalValue.concat('00').substr(0,2);

++++return+'$'%2BspitedValues[0]+%2B+'.'+%2B+decimalValue;
}

//+5.56789++++++---->++$5.56
//+0.342++++++++---->++$0.34
//+-10.3484534++---->++$-10.34+
//+600++++++++++---->++$600.00|code-block|syntax|javascript|876635|​|876636|function+convertNumber(){
++var+result+=+toFixedNumber(document.getElementById("valueText").value);
++document.getElementById("resultText").value+=+result;
}


function+toFixedNumber(number)+{
++++++++const+spitedValues+=+String(number.toLocaleString()).split('.');
++++++++let+decimalValue+=+spitedValues.length+>+1+?+spitedValues[1]+:+'';
++++++++decimalValue+=+decimalValue.concat('00').substr(0,2);

++++++++return+'$'%2BspitedValues[0]+%2B+'.'+%2B+decimalValue;
}|876637|<div>
++<input+type="text"+id="valueText"+placeholder="Input+value+here..">
++ 
++<button+onclick="convertNumber()"+>Convert</button>
++ <hr>
++<input+type="text"+id="resultText"+placeholder="result"+readonly="true">
</div>|876638|876639|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|R|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|M|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|O|$]]

This worked well for me. I hope it will fix your issues too. 

<pre><code>function toFixedNumber(number) {
 const spitedValues = String(number.toLocaleString()).split('.');
 let decimalValue = spitedValues.length &gt; 1 ? spitedValues[1] : '';
 decimalValue = decimalValue.concat('00').substr(0,2);

 return '$'+spitedValues[0] + '.' + decimalValue;
}

// 5.56789 ----&gt; $5.56
// 0.342 ----&gt; $0.34
// -10.3484534 ----&gt; $-10.34 
// 600 ----&gt; $600.00
</code></pre>

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function convertNumber(){
 var result = toFixedNumber(document.getElementById("valueText").value);
 document.getElementById("resultText").value = result;
}


function toFixedNumber(number) {
 const spitedValues = String(number.toLocaleString()).split('.');
 let decimalValue = spitedValues.length &gt; 1 ? spitedValues[1] : '';
 decimalValue = decimalValue.concat('00').substr(0,2);

 return '$'+spitedValues[0] + '.' + decimalValue;
}</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;div&gt;
 &lt;input type="text" id="valueText" placeholder="Input value here.."&gt;
 &lt;br&gt;
 &lt;button onclick="convertNumber()" &gt;Convert&lt;/button&gt;
 &lt;br&gt;&lt;hr&gt;
 &lt;input type="text" id="resultText" placeholder="result" readonly="true"&gt;
&lt;/div&gt;</code></pre>
</div>
</div>

blocks|key|876057|text|给你。一个答案展示了另一种解决问题的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876058|//+For+the+sake+of+simplicity,+here+is+a+complete+function:
function+truncate(numToBeTruncated,+numOfDecimals)+{
++++var+theNumber+=+numToBeTruncated.toString();
++++var+pointIndex+=+theNumber.indexOf('.');
++++return+%2B(theNumber.slice(0,+pointIndex+>+-1+?+%2B%2BnumOfDecimals+%2B+pointIndex+:+undefined));
}|code-block|syntax|javascript|876059|注意%2B在最后一个表达式之前的用法。也就是说，将我们截断的、分片的字符串转换回number类型。|876060|希望它能帮上忙！|876061|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here you are. An answer that shows yet another way to solve the problem: 

<pre><code>// For the sake of simplicity, here is a complete function:
function truncate(numToBeTruncated, numOfDecimals) {
 var theNumber = numToBeTruncated.toString();
 var pointIndex = theNumber.indexOf('.');
 return +(theNumber.slice(0, pointIndex &gt; -1 ? ++numOfDecimals + pointIndex : undefined));
}
</code></pre>

Note the use of + before the final expression. That is to convert our truncated, sliced string back to number type.

Hope it helps!

blocks|key|1091160|text|不带零的截断|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1091161|function+toTrunc(value,n){++
++++return+Math.floor(value*Math.pow(10,n))/(Math.pow(10,n));
}|code-block|syntax|javascript|1091162|或|1091163|function+toTrunc(value,n){
++++x=(value.toString()%2B".0").split(".");
++++return+parseFloat(x[0]%2B"."%2Bx[1].substr(0,n));
}|1091164|测试：|1091165|toTrunc(17.4532,2)++//17.45
toTrunc(177.4532,1)+//177.4
toTrunc(1.4532,1)+++//1.4
toTrunc(.4,2)+++++++//0.4|1091166|用零截断|1091167|function+toTruncFixed(value,n){
++++return+toTrunc(value,n).toFixed(n);
}|1091168|1091169|toTrunc(17.4532,2)++//17.45
toTrunc(177.4532,1)+//177.4
toTrunc(1.4532,1)+++//1.4
toTrunc(.4,2)+++++++//0.40|1091170|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|11|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|13|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|S|3|L|5|6|7|15|8|@]|9|@]|A|$]]|$1|T|3|U|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|V|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|W|$]]

truncate without zeroes

<pre><code>function toTrunc(value,n){ 
 return Math.floor(value*Math.pow(10,n))/(Math.pow(10,n));
}
</code></pre>

or

<pre><code>function toTrunc(value,n){
 x=(value.toString()+".0").split(".");
 return parseFloat(x[0]+"."+x[1].substr(0,n));
}
</code></pre>

test:

<pre><code>toTrunc(17.4532,2) //17.45
toTrunc(177.4532,1) //177.4
toTrunc(1.4532,1) //1.4
toTrunc(.4,2) //0.4
</code></pre>

truncate with zeroes

<pre><code>function toTruncFixed(value,n){
 return toTrunc(value,n).toFixed(n);
}
</code></pre>

test:

<pre><code>toTrunc(17.4532,2) //17.45
toTrunc(177.4532,1) //177.4
toTrunc(1.4532,1) //1.4
toTrunc(.4,2) //0.40
</code></pre>

blocks|key|1091622|text|如果你想截断到两位数的精度，你可以用一个简单的逻辑：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1091623|function+myFunction(number)+{
++var+roundedNumber+=+number.toFixed(2);
++if+(roundedNumber+>+number)
++{
++++++roundedNumber+=+roundedNumber+-+0.01;
++}
++return+roundedNumber;
}|code-block|syntax|javascript|1091624|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you exactly wanted to truncate to 2 digits of precision, you can go with a simple logic:
<pre><code>function myFunction(number) {
 var roundedNumber = number.toFixed(2);
 if (roundedNumber &gt; number)
 {
 roundedNumber = roundedNumber - 0.01;
 }
 return roundedNumber;
}
</code></pre>

blocks|key|876184|text|我使用(num-0.05).toFixed(1)将第二个十进制数设置为底线。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|876185|entityMap^0|3|L|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

I used <code>(num-0.05).toFixed(1)</code> to get the second decimal floored.

blocks|key|876821|text|我的typescript解决方案(可以很容易地移植到JS)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876822|/**
+*+Returns+the+price+with+correct+precision+as+a+string
+*
+*+@param+++price+The+price+in+decimal+to+be+formatted.
+*+@param+++decimalPlaces+The+number+of+decimal+places+to+use
+*+@return++string+The+price+in+Decimal+formatting.
+*/
type+toDecimal+=+(price:+number,+decimalPlaces?:+number)+=>+string;
const+toDecimalOdds:+toDecimal+=+(
++price:+number,
++decimalPlaces:+number+=+2,
):+string+=>+{
++const+priceString:+string+=+price.toString();
++const+pointIndex:+number+=+priceString.indexOf('.');

++//+Return+the+integer+part+if+decimalPlaces+is+0
++if+(decimalPlaces+===+0)+{
++++return+priceString.substr(0,+pointIndex);
++}

++//+Return+value+with+0s+appended+after+decimal+if+the+price+is+an+integer
++if+(pointIndex+===+-1)+{
++++const+padZeroString:+string+=+'0'.repeat(decimalPlaces);

++++return+`${priceString}.${padZeroString}`;
++}

++//+If+numbers+after+decimal+are+less+than+decimalPlaces,+append+with+0s
++const+padZeroLen:+number+=+priceString.length+-+pointIndex+-+1;
++if+(padZeroLen+>+0+&&+padZeroLen+<+decimalPlaces)+{
++++const+padZeroString:+string+=+'0'.repeat(padZeroLen);

++++return+`${priceString}${padZeroString}`;
++}

++return+priceString.substr(0,+pointIndex+%2B+decimalPlaces+%2B+1);
};|code-block|syntax|javascript|876823|测试用例：|876824|++expect(filters.toDecimalOdds(3.14159)).toBe('3.14');
++expect(filters.toDecimalOdds(3.14159,+2)).toBe('3.14');
++expect(filters.toDecimalOdds(3.14159,+0)).toBe('3');
++expect(filters.toDecimalOdds(3.14159,+10)).toBe('3.1415900000');
++expect(filters.toDecimalOdds(8.2)).toBe('8.20');|876825|有什么改进吗？|876826|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

My solution in typescript (can easily be ported to JS):

<pre><code>/**
 * Returns the price with correct precision as a string
 *
 * @param price The price in decimal to be formatted.
 * @param decimalPlaces The number of decimal places to use
 * @return string The price in Decimal formatting.
 */
type toDecimal = (price: number, decimalPlaces?: number) =&gt; string;
const toDecimalOdds: toDecimal = (
 price: number,
 decimalPlaces: number = 2,
): string =&gt; {
 const priceString: string = price.toString();
 const pointIndex: number = priceString.indexOf('.');

 // Return the integer part if decimalPlaces is 0
 if (decimalPlaces === 0) {
 return priceString.substr(0, pointIndex);
 }

 // Return value with 0s appended after decimal if the price is an integer
 if (pointIndex === -1) {
 const padZeroString: string = '0'.repeat(decimalPlaces);

 return `${priceString}.${padZeroString}`;
 }

 // If numbers after decimal are less than decimalPlaces, append with 0s
 const padZeroLen: number = priceString.length - pointIndex - 1;
 if (padZeroLen &gt; 0 &amp;&amp; padZeroLen &lt; decimalPlaces) {
 const padZeroString: string = '0'.repeat(padZeroLen);

 return `${priceString}${padZeroString}`;
 }

 return priceString.substr(0, pointIndex + decimalPlaces + 1);
};
</code></pre>

Test cases:

<pre><code> expect(filters.toDecimalOdds(3.14159)).toBe('3.14');
 expect(filters.toDecimalOdds(3.14159, 2)).toBe('3.14');
 expect(filters.toDecimalOdds(3.14159, 0)).toBe('3');
 expect(filters.toDecimalOdds(3.14159, 10)).toBe('3.1415900000');
 expect(filters.toDecimalOdds(8.2)).toBe('8.20');
</code></pre>

Any improvements?

blocks|key|1090562|text|使用您自己的toFixed函数:对于正值，Math.floor可以很好地工作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1090563|function+toFixed(num,+fixed)+{
++++fixed+=+fixed+%7C%7C+0;
++++fixed+=+Math.pow(10,+fixed);
++++return+Math.floor(num+*+fixed)+/+fixed;
}|code-block|syntax|javascript|1090564|对于负值，Math.floor是值的四舍五入。因此，您可以改用Math.ceil。|1090565|例如，|1090566|Math.ceil(-15.778665+*+10000)+/+10000+=+-15.7786
Math.floor(-15.778665+*+10000)+/+10000+=+-15.7787+//+wrong.|1090567|entityMap^0|6|7|L|A|0|0|5|A|V|9|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|13|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|R|$]]

Roll your own <code>toFixed</code> function: for positive values <code>Math.floor</code> works fine.


<pre><code>function toFixed(num, fixed) {
 fixed = fixed || 0;
 fixed = Math.pow(10, fixed);
 return Math.floor(num * fixed) / fixed;
}
</code></pre>

For negative values <code>Math.floor</code> is round of the values. So you can use <code>Math.ceil</code> instead.

Example,


<pre><code>Math.ceil(-15.778665 * 10000) / 10000 = -15.7786
Math.floor(-15.778665 * 10000) / 10000 = -15.7787 // wrong.
</code></pre>

blocks|key|1090781|text|Gumbo的第二个解决方案，使用正则表达式，确实可以工作，但由于使用正则表达式，速度很慢。Gumbo的第一个解决方案在某些情况下由于浮点数的不精确而失败。有关演示和基准测试，请参阅JSFiddle。第二种解决方案在我当前的系统上，英特尔酷睿i5-2500CPU在3.30+GHz下，每次调用大约需要1636纳秒。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1090782|我写的解决方案包括添加一个小的补偿来处理浮点不精确度。它基本上是瞬时的，即在纳秒量级上。我为每个调用计时2纳秒，但JavaScript计时器不是非常精确或细粒度。这是JS+Fiddle和代码。|1090783|function+toFixedWithoutRounding+(value,+precision)
{
++++var+factorError+=+Math.pow(10,+14);
++++var+factorTruncate+=+Math.pow(10,+14+-+precision);
++++var+factorDecimal+=+Math.pow(10,+precision);
++++return+Math.floor(Math.floor(value+*+factorError+%2B+1)+/+factorTruncate)+/+factorDecimal;
}

var+values+=+[1.1299999999,+1.13,+1.139999999,+1.14,+1.14000000001,+1.13+*+100];

for+(var+i+=+0;+i+<+values.length;+i%2B%2B)
{
++++var+value+=+values[i];
++++console.log(value+%2B+"+-->+"+%2B+toFixedWithoutRounding(value,+2));
}

for+(var+i+=+0;+i+<+values.length;+i%2B%2B)
{
++++var+value+=+values[i];
++++console.log(value+%2B+"+-->+"+%2B+toFixedWithoutRounding(value,+4));
}

console.log("type+of+result+is+"+%2B+typeof+toFixedWithoutRounding(1.13+*+100+/+100,+2));

//+Benchmark
var+value+=+1.13+*+100;
var+startTime+=+new+Date();
var+numRun+=+1000000;
var+nanosecondsPerMilliseconds+=+1000000;

for+(var+run+=+0;+run+<+numRun;+run%2B%2B)
++++toFixedWithoutRounding(value,+2);

var+endTime+=+new+Date();
var+timeDiffNs+=+nanosecondsPerMilliseconds+*+(endTime+-+startTime);
var+timePerCallNs+=+timeDiffNs+/+numRun;
console.log("Time+per+call+(nanoseconds):+"+%2B+timePerCallNs);|code-block|syntax|javascript|1090784|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/sQXdE/16/|1|http://jsfiddle.net/sQXdE/17/^0|2I|8|0|0|2B|9|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

Gumbo's second solution, with the regular expression, does work but is slow because of the regular expression. Gumbo's first solution fails in certain situations due to imprecision in floating points numbers. See the <a href="http://jsfiddle.net/sQXdE/16/" rel="nofollow">JSFiddle</a> for a demonstration and a benchmark. The second solution takes about 1636 nanoseconds per call on my current system, Intel Core i5-2500 CPU at 3.30 GHz.

The solution I've written involves adding a small compensation to take care of floating point imprecision. It is basically instantaneous, i.e. on the order of nanoseconds. I clocked 2 nanoseconds per call but the JavaScript timers are not very precise or granular. Here is the <a href="http://jsfiddle.net/sQXdE/17/" rel="nofollow" title="JS Fiddle">JS Fiddle</a> and the code.

<pre><code>function toFixedWithoutRounding (value, precision)
{
 var factorError = Math.pow(10, 14);
 var factorTruncate = Math.pow(10, 14 - precision);
 var factorDecimal = Math.pow(10, precision);
 return Math.floor(Math.floor(value * factorError + 1) / factorTruncate) / factorDecimal;
}

var values = [1.1299999999, 1.13, 1.139999999, 1.14, 1.14000000001, 1.13 * 100];

for (var i = 0; i &lt; values.length; i++)
{
 var value = values[i];
 console.log(value + " --&gt; " + toFixedWithoutRounding(value, 2));
}

for (var i = 0; i &lt; values.length; i++)
{
 var value = values[i];
 console.log(value + " --&gt; " + toFixedWithoutRounding(value, 4));
}

console.log("type of result is " + typeof toFixedWithoutRounding(1.13 * 100 / 100, 2));

// Benchmark
var value = 1.13 * 100;
var startTime = new Date();
var numRun = 1000000;
var nanosecondsPerMilliseconds = 1000000;

for (var run = 0; run &lt; numRun; run++)
 toFixedWithoutRounding(value, 2);

var endTime = new Date();
var timeDiffNs = nanosecondsPerMilliseconds * (endTime - startTime);
var timePerCallNs = timeDiffNs / numRun;
console.log("Time per call (nanoseconds): " + timePerCallNs);
</code></pre>

blocks|key|876280|text|已经有一些适合正则表达式和算术计算的答案，你也可以试试这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876281|function+myFunction()+{
++++var+str+=+12.234556;+
++++str+=+str.toString().split('.');
++++var+res+=+str[1].slice(0,+2);
++++document.getElementById("demo").innerHTML+=+str[0]%2B'.'%2Bres;
}

//+output:+12.23|code-block|syntax|javascript|876282|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Already there are some suitable answer with regular expression and arithmetic calculation, you can also try this 

<pre><code>function myFunction() {
 var str = 12.234556; 
 str = str.toString().split('.');
 var res = str[1].slice(0, 2);
 document.getElementById("demo").innerHTML = str[0]+'.'+res;
}

// output: 12.23
</code></pre>

blocks|key|1091207|text|下面是使用字符串完成的操作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1091208|export+function+withoutRange(number)+{
++const+str+=+String(number);
++const+dotPosition+=+str.indexOf('.');
++if+(dotPosition+>+0)+{
++++const+length+=+str.substring().length;
++++const+end+=+length+>+3+?+3+:+length;
++++return+str.substring(0,+dotPosition+%2B+end);
++}
++return+str;
}|code-block|syntax|javascript|1091209|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is what is did it with string

<pre><code>export function withoutRange(number) {
 const str = String(number);
 const dotPosition = str.indexOf('.');
 if (dotPosition &gt; 0) {
 const length = str.substring().length;
 const end = length &gt; 3 ? 3 : length;
 return str.substring(0, dotPosition + end);
 }
 return str;
}
</code></pre>

blocks|key|876707|text|所有这些答案看起来都有点复杂。我只需从您的数字中减去0.5，然后使用toFixed()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876708|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

All these answers seem a bit complicated. I would just subtract 0.5 from your number and use toFixed().

blocks|key|1091528|text|综合所有先前答案的知识，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1091529|这是我想出的解决方案：|1091530|function+toFixedWithoutRounding(num,+fractionDigits)+{
++if+((num+>+0+&&+num+<+0.000001)+%7C%7C+(num+<+0+&&+num+>+-0.000001))+{
++++//+HACK:+below+this+js+starts+to+turn+numbers+into+exponential+form+like+1e-7.
++++//+This+gives+wrong+results+so+we+are+just+changing+the+original+number+to+0+here
++++//+as+we+don't+need+such+small+numbers+anyway.
++++num+=+0;
++}
++const+re+=+new+RegExp('%5E-?\\d%2B(?:\.\\d{0,'+%2B+(fractionDigits+%7C%7C+-1)+%2B+'})?');
++return+Number(num.toString().match(re)[0]).toFixed(fractionDigits);
}|code-block|syntax|javascript|1091531|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Taking the knowledge from all the previous answers combined,

this is what I came up with as a solution:

<pre><code>function toFixedWithoutRounding(num, fractionDigits) {
 if ((num &gt; 0 &amp;&amp; num &lt; 0.000001) || (num &lt; 0 &amp;&amp; num &gt; -0.000001)) {
 // HACK: below this js starts to turn numbers into exponential form like 1e-7.
 // This gives wrong results so we are just changing the original number to 0 here
 // as we don't need such small numbers anyway.
 num = 0;
 }
 const re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fractionDigits || -1) + '})?');
 return Number(num.toString().match(re)[0]).toFixed(fractionDigits);
}
</code></pre>

blocks|key|876921|text|function+toFixed(num,+fixed)+{
++++fixed+=+fixed+%7C%7C+0;
++++var+front+=+Math.floor(num);
++++var+back+=+0;
++++for+(var+i+=+1;+i+<=+fixed;+i%2B%2B)+{
++++++++var+value+=+Math.floor(num+*+Math.pow(10,+i))+%25+10;
++++++++back+%2B=+value+/+Math.pow(10,+i);
++++}
++++return+front+%2B+back;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|876922|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function toFixed(num, fixed) {
 fixed = fixed || 0;
 var front = Math.floor(num);
 var back = 0;
 for (var i = 1; i &lt;= fixed; i++) {
 var value = Math.floor(num * Math.pow(10, i)) % 10;
 back += value / Math.pow(10, i);
 }
 return front + back;
}
</code></pre>

blocks|key|876754|text|最有效的解决方案(对于2个小数位)是在调用toFixed()之前减去0.005|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|876755|function+toFixed2(+num+)+{+return+(num-0.005).toFixed(2)+}|code-block|syntax|javascript|876756|负数也将向下舍入(远离零)。行动没有透露任何关于负数的信息。|876757|entityMap^0|L|9|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

The most efficient solution (for 2 fraction digits) is to subtract 0.005 before calling <code>toFixed()</code>

<pre><code>function toFixed2( num ) { return (num-0.005).toFixed(2) }
</code></pre>

Negative numbers will be rounded down too (away from zero). The OP didn't tell anything about negative numbers.

blocks|key|876902|text|const+toFixed+=+(value)+=>+value.toString().slice(0,5);|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|876903|entityMap^0|0|1J|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

<code>const toFixed = (value) =&gt; value.toString().slice(0,5);</code>

blocks|key|876229|text|这是另一个保存.toFixed(数字)函数而不对浮点变量进行舍入的变体：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876230|Number.prototype.toRealFixed+=+function(digits)+{
++++return+Math.floor(this.valueOf()+*+Math.pow(10,+digits))+/+Math.pow(10,+digits);
};|code-block|syntax|javascript|876231|和呼叫：|876232|var+float_var+=+0.02209062;
float_var.toRealFixed();|876233|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is another one variant to save .toFixed([digits]) functional without rounding float variable:

<pre><code>Number.prototype.toRealFixed = function(digits) {
 return Math.floor(this.valueOf() * Math.pow(10, digits)) / Math.pow(10, digits);
};
</code></pre>

And calling:

<pre><code>var float_var = 0.02209062;
float_var.toRealFixed();
</code></pre>

Suppose I have a value of 15.7784514, I want to display it 15.77 with no rounding.

<pre><code>var num = parseFloat(15.7784514);
document.write(num.toFixed(1)+"&lt;br /&gt;");
document.write(num.toFixed(2)+"&lt;br /&gt;");
document.write(num.toFixed(3)+"&lt;br /&gt;");
document.write(num.toFixed(10));
</code></pre>

Results in -

<pre><code>15.8
15.78
15.778
15.7784514000 
</code></pre>

How do I display 15.77?

Truncate number to two decimal places without rounding

假设我有一个值15.7784514，我想显示它15.77时不进行舍入。var num = parseFloat(15.7784514);document.write(num.toFixed(1)+" ");document.write(num.toFixed(2)+" ");document.write(num.toFixed(3)+" ");document.wri

问将数字截断到两位小数，不进行舍入
EN

回答 30

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将数字截断到两位小数，不进行舍入EN

回答 30

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将数字截断到两位小数，不进行舍入
EN