Giả sử tôi có giá trị 15.7784514, tôi muốn hiển thị nó 15.77 mà không làm tròn số.

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

Kết quả trong -

15.8
15.78
15.778
15.7784514000 

Làm cách nào để hiển thị 15.77?

Chuyển đổi số thành một chuỗi, khớp số đến vị trí thập phân thứ hai:

function calc(theform) {
    var num = theform.original.value, rounded = theform.rounded
    var with2Decimals = num.toString().match(/^-?\d+(?:\.\d{0,2})?/)[0]
    rounded.value = with2Decimals
}

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

Các toFixedphương pháp thất bại trong một số trường hợp không giống toString, vì vậy phải rất cẩn thận với nó.

Cập nhật ngày 5 tháng 11 năm 2016

Câu trả lời mới, luôn chính xác

function toFixed(num, fixed) {
    var re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fixed || -1) + '})?');
    return num.toString().match(re)[0];
}

Vì toán học dấu phẩy động trong javascript sẽ luôn có các trường hợp cạnh, giải pháp trước đó sẽ chính xác hầu hết thời gian không đủ tốt. Có một số các giải pháp này như num.toPrecision, BigDecimal.js , và accounting.js . Tuy nhiên, tôi tin rằng chỉ cần phân tích cú pháp chuỗi sẽ đơn giản nhất và luôn chính xác.

Dựa trên bản cập nhật trên regex được viết tốt từ câu trả lời được chấp nhận bởi @Gumbo, chức năng toFixed mới này sẽ luôn hoạt động như mong đợi.

Câu trả lời cũ, không phải lúc nào cũng chính xác.

Cuộn chức năng toFixed của riêng bạn:

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

Thay vào đó, tôi đã chọn viết phần này để xóa phần còn lại bằng các chuỗi để tôi không phải xử lý các vấn đề toán học đi kèm với các con số:

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

Điều này sẽ cung cấp cho bạn "15,77" với num = 15,7784514;

Tháng 10 năm 2017

Giải pháp chung để cắt bớt (không làm tròn) một số thành chữ số thập phân thứ n và chuyển đổi nó thành một chuỗi có chính xác n chữ số thập phân, cho bất kỳ n≥0.

function toFixedTrunc(x, n) {
  const v = (typeof x === 'string' ? x : x.toString()).split('.');
  if (n <= 0) return v[0];
  let f = v[1] || '';
  if (f.length > n) return `${v[0]}.${f.substr(0,n)}`;
  while (f.length < n) f += '0';
  return `${v[0]}.${f}`
}

trong đó x có thể là một số (được chuyển thành chuỗi) hoặc chuỗi.

Dưới đây là một số thử nghiệm cho n = 2 (bao gồm cả thử nghiệm do OP yêu cầu):

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
0.000000199 => 1.99 *

* Như đã đề cập trong ghi chú, đó là do chuyển đổi ngầm định javascript thành số mũ cho "1.99e-7" và đối với một số giá trị khác của n:

15.001097   => 15.0010 (n=4)
0.000003298 => 0.0000032 (n=7)
0.000003298257899 => 0.000003298257 (n=12)

parseInt nhanh hơn Math.floor

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"

Đơn giản làm điều này

number = parseInt(number * 100)/100;

num = 19.66752
f = num.toFixed(3).slice(0,-1)
alert(f)

Điều này sẽ trở lại 19,66

Những giải pháp này có tác dụng, nhưng với tôi có vẻ phức tạp không cần thiết. Cá nhân tôi thích sử dụng toán tử mô đun để có được phần còn lại của phép toán chia và loại bỏ điều đó. Giả sử rằng num = 15.7784514:

num-=num%.01;

Điều này tương đương với việc nói num = num - (num% .01).

Các câu trả lời ở đây không giúp tôi, nó cứ làm tròn hoặc cho tôi số thập phân sai.

giải pháp của tôi chuyển đổi số thập phân của bạn thành một chuỗi, trích xuất các ký tự và sau đó trả về toàn bộ dưới dạng một số.

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

Phiên bản của tôi cho số dương:

function toFixed_norounding(n,p)
{
    var result = n.toFixed(p);
    return result <= n ? result: (result - Math.pow(0.1,p)).toFixed(p);
}

Nhanh, đẹp, rõ ràng. (phiên bản cho số dương)

Các mã sau hoạt động rất tốt cho tôi:

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

Tôi đã sửa bằng cách sử dụng cách đơn giản sau-

var num = 15.7784514;
Math.floor(num*100)/100;

Kết quả sẽ là 15,77

Chỉ cần cắt bớt các chữ số:

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

Một giải pháp đơn dòng khác:

number = Math.trunc(number*100)/100

Tôi đã sử dụng 100 vì bạn muốn cắt bớt chữ số thứ hai, nhưng một giải pháp linh hoạt hơn sẽ là:

number = Math.trunc(number*Math.pow(10, digits))/Math.pow(10, digits)

trong đó chữ số là số chữ số thập phân cần giữ.

Xem thông số kỹ thuật Math.trunc để biết chi tiết và tương thích trình duyệt.

Của bạn đây. Một câu trả lời cho thấy một cách khác để giải quyết vấn đề:

// 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 > -1 ? ++numOfDecimals + pointIndex : undefined));
}

Lưu ý việc sử dụng + trước biểu thức cuối cùng. Đó là để chuyển đổi chuỗi bị cắt, cắt của chúng tôi trở lại loại số.

Hy vọng nó giúp!

cắt ngắn mà không có số không

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

hoặc là

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

kiểm tra:

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

cắt ngắn với số không

function toTruncFixed(value,n){
    return toTrunc(value,n).toFixed(n);
}

kiểm tra:

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

Điều này làm việc tốt cho tôi. Tôi hy vọng nó sẽ khắc phục vấn đề của bạn quá.

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

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

// 5.56789      ---->  $5.56
// 0.342        ---->  $0.34
// -10.3484534  ---->  $-10.34 
// 600          ---->  $600.00

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 '$'+spitedValues[0] + '.' + decimalValue;
}

<div>
  <input type="text" id="valueText" placeholder="Input value here..">
  <br>
  <button onclick="convertNumber()" >Convert</button>
  <br><hr>
  <input type="text" id="resultText" placeholder="result" readonly="true">
</div>

Một cách dễ dàng để làm điều đó là tiếp theo nhưng cần thiết để đảm bảo rằng tham số lượng được đưa ra dưới dạng chuỗi.

function truncate(amountAsString, decimals = 2){
  var dotIndex = amountAsString.indexOf('.');
  var toTruncate = dotIndex !== -1  && ( amountAsString.length > 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);

}

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

Tôi đã sử dụng (num-0.05).toFixed(1)để có được số thập phân thứ hai trôi nổi.

Giải pháp của tôi trong bản thảo (có thể dễ dàng chuyển sang JS):

/**
 * 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 + decimalPlaces + 1);
};

Các trường hợp thử nghiệm:

  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');

Có cải tiến gì không?

Cuộn toFixedchức năng của riêng bạn : cho các giá trị tích cực Math.floorhoạt động tốt.

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

Đối với các giá trị âm Math.floorlà vòng của các giá trị. Vì vậy, bạn có thể sử dụngMath.ceil thay thế.

Thí dụ,

Math.ceil(-15.778665 * 10000) / 10000 = -15.7786
Math.floor(-15.778665 * 10000) / 10000 = -15.7787 // wrong.

Giải pháp thứ hai của Gumbo, với biểu thức chính quy, không hoạt động nhưng chậm vì biểu thức chính quy. Giải pháp đầu tiên của Gumbo thất bại trong một số tình huống do sự thiếu chính xác về số lượng dấu phẩy động. Xem JSFiddle để trình diễn và điểm chuẩn. Giải pháp thứ hai mất khoảng 1636 nano giây mỗi cuộc gọi trên hệ thống hiện tại của tôi, CPU Intel Core i5-2500 tốc độ 3,30 GHz.

Giải pháp tôi đã viết liên quan đến việc thêm một khoản bồi thường nhỏ để xử lý sự thiếu chính xác của dấu phẩy động. Về cơ bản là tức thời, tức là theo thứ tự nano giây. Tôi đã chạy 2 nano giây mỗi cuộc gọi nhưng bộ định thời JavaScript không chính xác hoặc chi tiết. Đây là Fiddle JS và mã.

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 < values.length; i++)
{
    var value = values[i];
    console.log(value + " --> " + toFixedWithoutRounding(value, 2));
}

for (var i = 0; i < values.length; i++)
{
    var value = values[i];
    console.log(value + " --> " + 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 < 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);

Dựa trên câu trả lời của David D :

function NumberFormat(num,n) {
  var num = (arguments[0] != null) ? arguments[0] : 0;
  var n = (arguments[1] != null) ? arguments[1] : 2;
  if(num > 0){
    num = String(num);
    if(num.indexOf('.') !== -1) {
      var numarr = num.split(".");
      if (numarr.length > 1) {
        if(n > 0){
          var temp = numarr[0] + ".";
          for(var i = 0; i < n; i++){
            if(i < numarr[1].length){
              temp += numarr[1].charAt(i);
            }
          }
          num = Number(temp);
        }
      }
    }
  }
  return Number(num);
}

console.log('NumberFormat(123.85,2)',NumberFormat(123.85,2));
console.log('NumberFormat(123.851,2)',NumberFormat(123.851,2));
console.log('NumberFormat(0.85,2)',NumberFormat(0.85,2));
console.log('NumberFormat(0.851,2)',NumberFormat(0.851,2));
console.log('NumberFormat(0.85156,2)',NumberFormat(0.85156,2));
console.log('NumberFormat(0.85156,4)',NumberFormat(0.85156,4));
console.log('NumberFormat(0.85156,8)',NumberFormat(0.85156,8));
console.log('NumberFormat(".85156",2)',NumberFormat(".85156",2));
console.log('NumberFormat("0.85156",2)',NumberFormat("0.85156",2));
console.log('NumberFormat("1005.85156",2)',NumberFormat("1005.85156",2));
console.log('NumberFormat("0",2)',NumberFormat("0",2));
console.log('NumberFormat("",2)',NumberFormat("",2));
console.log('NumberFormat(85156,8)',NumberFormat(85156,8));
console.log('NumberFormat("85156",2)',NumberFormat("85156",2));
console.log('NumberFormat("85156.",2)',NumberFormat("85156.",2));

// NumberFormat(123.85,2) 123.85
// NumberFormat(123.851,2) 123.85
// NumberFormat(0.85,2) 0.85
// NumberFormat(0.851,2) 0.85
// NumberFormat(0.85156,2) 0.85
// NumberFormat(0.85156,4) 0.8515
// NumberFormat(0.85156,8) 0.85156
// NumberFormat(".85156",2) 0.85
// NumberFormat("0.85156",2) 0.85
// NumberFormat("1005.85156",2) 1005.85
// NumberFormat("0",2) 0
// NumberFormat("",2) 0
// NumberFormat(85156,8) 85156
// NumberFormat("85156",2) 85156
// NumberFormat("85156.",2) 85156

Đáng tin cậy hơn để có được hai điểm nổi mà không làm tròn.

Câu trả lời tham khảo

var number = 10.5859;
var fixed2FloatPoints = parseInt(number * 100) / 100;
console.log(fixed2FloatPoints);

Cảm ơn bạn !

Đã có một số câu trả lời phù hợp với biểu thức chính quy và tính toán số học, bạn cũng có thể thử điều này

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

Đây là những gì đã làm với chuỗi

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 + end);
  }
  return str;
}

Tất cả những câu trả lời này có vẻ hơi phức tạp. Tôi sẽ chỉ trừ 0,5 từ số của bạn và sử dụng toFixed ().

Giải pháp hiệu quả nhất (cho 2 chữ số phân số) là trừ 0,005 trước khi gọi toFixed()

function toFixed2( num ) { return (num-0.005).toFixed(2) }

Các số âm cũng sẽ được làm tròn xuống (cách xa 0). OP đã không nói gì về số âm.

Tôi biết đã có một vài ví dụ hoạt động, nhưng tôi nghĩ rằng đáng để đề xuất tương đương String.toFixed của tôi, một số có thể thấy nó hữu ích.

Đó là sự thay thế hoàn hảo của tôi, không làm tròn số, chỉ cắt bớt nó hoặc thêm số không theo độ chính xác đã cho. Đối với số lượng dài thêm, nó sử dụng làm tròn tích hợp JS khi độ chính xác là dài. Hàm hoạt động cho tất cả các số có vấn đề tôi đã tìm thấy trên ngăn xếp.

function toFixedFixed(value, precision = 0) {
    let stringValue = isNaN(+value) ? '0' : String(+value);

    if (stringValue.indexOf('e') > -1 || stringValue === 'Infinity' || stringValue === '-Infinity') {
        throw new Error('To large number to be processed');
    }

    let [ beforePoint, afterPoint ] = stringValue.indexOf('.') > -1 ? stringValue.split('.') : [ stringValue, ''];

    // Force automatic rounding for some long real numbers that ends with 99X, by converting it to string, cutting off last digit, then adding extra nines and casting it on number again
    // e.g. 2.0199999999999996: +('2.019999999999999' + '9999') will give 2.02
    if (stringValue.length >= 17 && afterPoint.length > 2 && +afterPoint.substr(afterPoint.length - 3) > 995) {
        stringValue = String(+(stringValue.substr(0, afterPoint.length - 1) + '9'.repeat(stringValue.split('.').shift().length + 4)));
        [ beforePoint, afterPoint ] = String(stringValue).indexOf('.') > -1 ? stringValue.split('.') : [ stringValue, ''];
    }

    if (precision === 0) {
        return beforePoint;
    } else if (afterPoint.length > precision) {
        return `${beforePoint}.${afterPoint.substr(0, precision)}`;
    } else {
        return `${beforePoint}.${afterPoint}${'0'.repeat(precision - afterPoint.length)}`;
    }
}

Hãy nhớ rằng độ chính xác có thể không được xử lý đúng đối với các số có độ dài từ 18 trở lên, ví dụ Chrome 64 bit sẽ làm tròn nó hoặc thêm "e +" / "e-" để giữ độ dài của số ở mức 18.

Nếu bạn muốn thực hiện các thao tác trên các số thực, an toàn hơn là nhân nó với số Math.sqrt(10, precision)đầu tiên, thực hiện các phép tính, sau đó kết quả bằng cách nhân giá trị của số nhân.

Thí dụ:

0.06 + 0.01là 0.06999999999999999, và mọi chức năng định dạng không làm tròn sẽ cắt 0.06chính xác nó 2.

Nhưng nếu bạn thực hiện cùng một thao tác với số nhân & bộ chia:, (0.06 * 100 + 0.01 * 100) / 100bạn sẽ nhận được 0.07.

Đó là lý do tại sao việc sử dụng số nhân / chia như vậy rất quan trọng khi xử lý các số thực trong javascript, đặc biệt là khi bạn đang tính tiền ...