Cắt bớt (không làm tròn số) số thập phân trong javascript

Tôi đang cố gắng cắt ngắn số thập phân thành số thập phân. Một cái gì đó như thế này:

5.467   -> 5.46  
985.943 -> 985.94

toFixed(2)không chỉ về điều đúng nhưng nó làm tròn giá trị. Tôi không cần giá trị được làm tròn. Hy vọng điều này có thể thực hiện được trong javascript.

cập nhật :

Vì vậy, sau tất cả, những lỗi làm tròn sẽ luôn ám ảnh bạn, cho dù bạn có cố gắng đền bù thế nào đi chăng nữa. Do đó, vấn đề sẽ được tấn công bằng cách biểu diễn các số chính xác trong ký hiệu thập phân.

Number.prototype.toFixedDown = function(digits) {
    var re = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)"),
        m = this.toString().match(re);
    return m ? parseFloat(m[1]) : this.valueOf();
};

[   5.467.toFixedDown(2),
    985.943.toFixedDown(2),
    17.56.toFixedDown(2),
    (0).toFixedDown(1),
    1.11.toFixedDown(1) + 22];

// [5.46, 985.94, 17.56, 0, 23.1]

Giải pháp cũ dễ xảy ra lỗi dựa trên tổng hợp của những người khác:

Number.prototype.toFixedDown = function(digits) {
  var n = this - Math.pow(10, -digits)/2;
  n += n / Math.pow(2, 53); // added 1360765523: 17.56.toFixedDown(2) === "17.56"
  return n.toFixed(digits);
}

Câu trả lời của Dogbert là tốt, nhưng nếu mã của bạn có thể phải xử lý các số âm, thì Math.floorbản thân nó có thể cho kết quả không mong đợi.

Vd Math.floor(4.3) = 4, nhưngMath.floor(-4.3) = -5

Thay vào đó, hãy sử dụng một chức năng trợ giúp như chức năng này để nhận được kết quả nhất quán:

truncateDecimals = function (number) {
    return Math[number < 0 ? 'ceil' : 'floor'](number);
};

// Applied to Dogbert's answer:
var a = 5.467;
var truncated = truncateDecimals(a * 100) / 100; // = 5.46

Đây là một phiên bản tiện lợi hơn của chức năng này:

truncateDecimals = function (number, digits) {
    var multiplier = Math.pow(10, digits),
        adjustedNum = number * multiplier,
        truncatedNum = Math[adjustedNum < 0 ? 'ceil' : 'floor'](adjustedNum);

    return truncatedNum / multiplier;
};

// Usage:
var a = 5.467;
var truncated = truncateDecimals(a, 2); // = 5.46

// Negative digits:
var b = 4235.24;
var truncated = truncateDecimals(b, -2); // = 4200

Nếu đó không phải là hành vi mong muốn, hãy chèn một cuộc gọi đến Math.abstrên dòng đầu tiên:

var multiplier = Math.pow(10, Math.abs(digits)),

CHỈNH SỬA: shendz chỉ ra một cách chính xác rằng sử dụng dung dịch này với a = 17.56sẽ tạo ra không chính xác 17.55. Để biết thêm về lý do tại sao điều này xảy ra, hãy đọc Điều mà mọi nhà khoa học máy tính nên biết về số học dấu chấm động . Thật không may, việc viết một giải pháp loại bỏ tất cả các nguồn gây ra lỗi dấu phẩy động lại khá phức tạp với javascript. Trong một ngôn ngữ khác, bạn sẽ sử dụng số nguyên hoặc có thể là kiểu Thập phân, nhưng với javascript ...

Giải pháp này phải chính xác 100%, nhưng nó cũng sẽ chậm hơn:

function truncateDecimals (num, digits) {
    var numS = num.toString(),
        decPos = numS.indexOf('.'),
        substrLength = decPos == -1 ? numS.length : 1 + decPos + digits,
        trimmedResult = numS.substr(0, substrLength),
        finalResult = isNaN(trimmedResult) ? 0 : trimmedResult;

    return parseFloat(finalResult);
}

Đối với những người cần tốc độ nhưng cũng muốn tránh lỗi dấu phẩy động, hãy thử một cái gì đó như BigDecimal.js . Bạn có thể tìm thấy các thư viện Javascript BigDecimal khác trong câu hỏi SO này: "Có thư viện Javascript BigDecimal tốt không?" và đây là một bài đăng blog hay về các thư viện toán học cho Javascript

var a = 5.467;
var truncated = Math.floor(a * 100) / 100; // = 5.46

Bạn có thể sửa lỗi làm tròn bằng cách trừ đi 0,5 cho toFixed, ví dụ:

(f - 0.005).toFixed(2)

Cân nhắc lợi dụng các dấu ngã kép:~~ .

Nhận số. Nhân với các chữ số có nghĩa sau số thập phân để bạn có thể cắt bớt các vị trí bằng không ~~. Chia số nhân đó ra. Lợi nhuận.

function truncator(numToTruncate, intDecimalPlaces) {    
    var numPower = Math.pow(10, intDecimalPlaces); // "numPowerConverter" might be better
    return ~~(numToTruncate * numPower)/numPower;
}

Tôi đang cố gắng chống lại việc gói ~~cuộc gọi trong parens; Tôi tin rằng thứ tự của các hoạt động sẽ làm cho nó hoạt động chính xác.

alert(truncator(5.1231231, 1)); // is 5.1

alert(truncator(-5.73, 1)); // is -5.7

alert(truncator(-5.73, 0)); // is -5

Liên kết JSFiddle .

CHỈNH SỬA: Nhìn lại, tôi cũng đã vô tình xử lý các trường hợp làm tròn bên trái của số thập phân.

alert(truncator(4343.123, -2)); // gives 4300.

Logic hơi kỳ cục khi tìm kiếm cách sử dụng đó và có thể được hưởng lợi từ một bộ tái cấu trúc nhanh chóng. Nhưng nó vẫn hoạt động. Thà may mắn hơn tốt.

Giải pháp một dòng tuyệt vời:

function truncate (num, places) {
  return Math.trunc(num * Math.pow(10, places)) / Math.pow(10, places);
}

Sau đó gọi nó bằng:

truncate(3.5636232, 2); // returns 3.56
truncate(5.4332312, 3); // returns 5.433
truncate(25.463214, 4); // returns 25.4632

Tôi nghĩ rằng tôi sẽ đưa ra một câu trả lời bằng cách sử dụng |vì nó đơn giản và hoạt động tốt.

truncate = function(number, places) {
  var shift = Math.pow(10, places);

  return ((number * shift) | 0) / shift;
};

Cắt ngắn bằng cách sử dụng toán tử bitwise:

~~0.5 === 0
~~(-0.5) === 0
~~14.32794823 === 14
~~(-439.93) === -439

Câu trả lời của @ Dogbert có thể được cải thiện bằng cách Math.trunccắt bớt thay vì làm tròn.

Có một sự khác biệt giữa làm tròn và cắt bớt. Cắt ngắn rõ ràng là hành vi mà câu hỏi này đang tìm kiếm. Nếu tôi gọi truncate (-3.14) và nhận lại -4, tôi chắc chắn sẽ gọi điều đó là không mong muốn. - @NickKnowlson

var a = 5.467;
var truncated = Math.trunc(a * 100) / 100; // = 5.46

var a = -5.467;
var truncated = Math.trunc(a * 100) / 100; // = -5.46

Tôi đã viết một câu trả lời bằng một phương pháp ngắn hơn. Đây là những gì tôi nghĩ ra

function truncate(value, precision) {
    var step = Math.pow(10, precision || 0);
    var temp = Math.trunc(step * value);

    return temp / step;
}

Phương pháp có thể được sử dụng như vậy

truncate(132456.25456789, 5)); // Output: 132456.25456
truncate(132456.25456789, 3)); // Output: 132456.254
truncate(132456.25456789, 1)); // Output: 132456.2   
truncate(132456.25456789));    // Output: 132456

Hoặc, nếu bạn muốn một cú pháp ngắn hơn, hãy truy cập vào đây

function truncate(v, p) {
    var s = Math.pow(10, p || 0);
    return Math.trunc(s * v) / s;
}

Number.prototype.trim = function(decimals) {
    var s = this.toString();
    var d = s.split(".");
    d[1] = d[1].substring(0, decimals);
    return parseFloat(d.join("."));
}

console.log((5.676).trim(2)); //logs 5.67

Tôi nghĩ rằng chức năng này có thể là một giải pháp đơn giản:

function trunc(decimal,n=2){
  let x = decimal + ''; // string 
  return x.lastIndexOf('.')>=0?parseFloat(x.substr(0,x.lastIndexOf('.')+(n+1))):decimal; // You can use indexOf() instead of lastIndexOf()
}

console.log(trunc(-241.31234,2));
console.log(trunc(241.312,5));
console.log(trunc(-241.233));
console.log(trunc(241.2,0));  
console.log(trunc(241));

Tôi đã tìm thấy vấn đề: xem xét tình huống tiếp theo: 2.1 hoặc 1.2 hoặc -6.4

Điều gì sẽ xảy ra nếu bạn muốn luôn luôn có 3 hoặc hai số thập phân hoặc cá voi, vì vậy, bạn phải điền vào các số 0 ở đầu bên phải

// 3 decimals numbers
0.5 => 0.500

// 6 decimals
0.1 => 0.10000

// 4 decimales
-2.1 => -2.1000

// truncate to 3 decimals
3.11568 => 3.115

Đây là chức năng cố định của Nick Knowlson

function truncateDecimals (num, digits) 
{
    var numS = num.toString();
    var decPos = numS.indexOf('.');
    var substrLength = decPos == -1 ? numS.length : 1 + decPos + digits;
    var trimmedResult = numS.substr(0, substrLength);
    var finalResult = isNaN(trimmedResult) ? 0 : trimmedResult;

    // adds leading zeros to the right
    if (decPos != -1){
        var s = trimmedResult+"";
        decPos = s.indexOf('.');
        var decLength = s.length - decPos;

            while (decLength <= digits){
                s = s + "0";
                decPos = s.indexOf('.');
                decLength = s.length - decPos;
                substrLength = decPos == -1 ? s.length : 1 + decPos + digits;
            };
        finalResult = s;
    }
    return finalResult;
};

https://jsfiddle.net/huttn155/7/

function toFixed(number, digits) {
    var reg_ex = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)")
    var array = number.toString().match(reg_ex);
    return array ? parseFloat(array[1]) : number.valueOf()
}

var test = 10.123456789
var __fixed = toFixed(test, 6)
console.log(__fixed)
// => 10.123456

Câu trả lời của @kirilloid có vẻ là câu trả lời chính xác, tuy nhiên, mã chính cần được cập nhật. Giải pháp của anh ấy không quan tâm đến số âm (mà ai đó đã đề cập trong phần bình luận nhưng chưa được cập nhật trong mã chính).

Cập nhật nó thành một giải pháp hoàn chỉnh được thử nghiệm cuối cùng:

Number.prototype.toFixedDown = function(digits) {
    var re = new RegExp("([-]*\\d+\\.\\d{" + digits + "})(\\d)"),
    m = this.toString().match(re);
    return m ? parseFloat(m[1]) : this.valueOf();
};

Sử dụng mẫu:

var x = 3.1415629;
Logger.log(x.toFixedDown(2)); //or use whatever you use to log

Fiddle: Số JS làm tròn xuống

PS: Không đủ repo để bình luận về giải pháp đó.

Đây là một hàm đơn giản nhưng hoạt động để cắt bớt số lên đến 2 chữ số thập phân.

           function truncateNumber(num) {
                var num1 = "";
                var num2 = "";
                var num1 = num.split('.')[0];
                num2 = num.split('.')[1];
                var decimalNum = num2.substring(0, 2);
                var strNum = num1 +"."+ decimalNum;
                var finalNum = parseFloat(strNum);
                return finalNum;
            }

Loại kết quả vẫn là một số ...

/* Return the truncation of n wrt base */
var trunc = function(n, base) {
    n = (n / base) | 0;
    return base * n;
};
var t = trunc(5.467, 0.01);

Lodash có một số phương pháp tiện ích Toán học có thể làm tròn , sàn và ngắt một số đến độ chính xác thập phân nhất định. Điều này loại bỏ các số 0 ở cuối.

Họ thực hiện một cách tiếp cận thú vị, sử dụng số mũ của một số. Rõ ràng điều này tránh các vấn đề làm tròn.

(Lưu ý: funclà Math.roundhoặc ceilhoặc floortrong mã bên dưới)

// Shift with exponential notation to avoid floating-point issues.
var pair = (toString(number) + 'e').split('e'),
    value = func(pair[0] + 'e' + (+pair[1] + precision));

pair = (toString(value) + 'e').split('e');
return +(pair[0] + 'e' + (+pair[1] - precision));

Liên kết đến mã nguồn

Đây là chủ đề của tôi:

convert.truncate = function(value, decimals) {
  decimals = (decimals === undefined ? 0 : decimals);
  return parseFloat((value-(0.5/Math.pow(10, decimals))).toFixed(decimals),10);
};

Nó chỉ là một phiên bản phức tạp hơn một chút của

(f - 0.005).toFixed(2)

Giải pháp được đánh dấu là giải pháp là giải pháp tốt hơn mà tôi đã tìm thấy cho đến ngày hôm nay, nhưng có một vấn đề nghiêm trọng với 0 (ví dụ: 0.toFixedDown (2) cho -0.01). Vì vậy, tôi đề nghị sử dụng cái này:

Number.prototype.toFixedDown = function(digits) {
  if(this == 0) {
    return 0;
  }
  var n = this - Math.pow(10, -digits)/2;
  n += n / Math.pow(2, 53); // added 1360765523: 17.56.toFixedDown(2) === "17.56"
  return n.toFixed(digits);
}

Đây là những gì tôi sử dụng:

var t = 1;
for (var i = 0; i < decimalPrecision; i++)
    t = t * 10;

var f = parseFloat(value);
return (Math.floor(f * t)) / t;

const TO_FIXED_MAX = 100;

function truncate(number, decimalsPrecison) {
  // make it a string with precision 1e-100
  number = number.toFixed(TO_FIXED_MAX);

  // chop off uneccessary digits
  const dotIndex = number.indexOf('.');
  number = number.substring(0, dotIndex + decimalsPrecison + 1);

  // back to a number data type (app specific)
  return Number.parseFloat(number);
}

// example
truncate(0.00000001999, 8);
0.00000001

làm việc với:

• số âm
• số rất nhỏ (độ chính xác Number.EPSILON)

chỉ để chỉ ra một giải pháp đơn giản phù hợp với tôi

chuyển đổi nó thành chuỗi và sau đó regex nó ...

var number = 123.45678;
var number_s = '' + number;
var number_truncated_s = number_s.match(/\d*\.\d{4}/)[0]
var number_truncated = parseFloat(number_truncated_s)

Nó có thể được viết tắt thành

var number_truncated = parseFloat(('' + 123.4568908).match(/\d*\.\d{4}/)[0])

Đây là mã ES6 mà bạn muốn

const truncateTo = (unRouned, nrOfDecimals = 2) => {
      const parts = String(unRouned).split(".");

      if (parts.length !== 2) {
          // without any decimal part
        return unRouned;
      }

      const newDecimals = parts[1].slice(0, nrOfDecimals),
        newString = `${parts[0]}.${newDecimals}`;

      return Number(newString);
    };

// your examples 

 console.log(truncateTo(5.467)); // ---> 5.46

 console.log(truncateTo(985.943)); // ---> 985.94

// other examples 

 console.log(truncateTo(5)); // ---> 5

 console.log(truncateTo(-5)); // ---> -5

 console.log(truncateTo(-985.943)); // ---> -985.94

Number.prototype.truncate = function(places) {
  var shift = Math.pow(10, places);

  return Math.trunc(this * shift) / shift;
};

Bạn có thể làm việc với chuỗi. Nó Kiểm tra nếu '.' tồn tại, và sau đó loại bỏ một phần của chuỗi.

cắt ngắn (7,88, 1) -> 7,8

cắt ngắn (7,889, 2) -> 7,89

cắt ngắn (-7,88, 1) -> -7,88

function  truncate(number, decimals) {
    const tmp = number + '';
    if (tmp.indexOf('.') > -1) {
        return +tmp.substr(0 , tmp.indexOf('.') + decimals+1 );
    } else {
        return +number
    }
 }

Tôi hơi bối rối tại sao lại có nhiều câu trả lời khác nhau cho một câu hỏi về cơ bản đơn giản như vậy; chỉ có hai cách tiếp cận mà tôi thấy có vẻ đáng xem xét. Tôi đã thực hiện một điểm chuẩn nhanh để xem sự khác biệt về tốc độ bằng cách sử dụng https://jsbench.me/ .

Đây là giải pháp hiện đang được (26/9/2020) gắn cờ là câu trả lời:

function truncate(n, digits) {
    var re = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)"),
        m = n.toString().match(re);
    return m ? parseFloat(m[1]) : n.valueOf();
};

[   truncate(5.467,2),
    truncate(985.943,2),
    truncate(17.56,2),
    truncate(0, 1),
    truncate(1.11, 1) + 22];

Tuy nhiên, điều này đang thực hiện nội dung chuỗi và regex, thường không hiệu quả lắm và có một hàm Math.trunc thực hiện chính xác những gì OP muốn mà không có số thập phân. Do đó, bạn có thể dễ dàng sử dụng nó cộng thêm một chút số học để có được điều tương tự.

Đây là một giải pháp khác mà tôi đã tìm thấy trên chủ đề này, đó là giải pháp tôi sẽ sử dụng:

function truncate(n, digits) {
    var step = Math.pow(10, digits || 0);
    var temp = Math.trunc(step * n);

    return temp / step;
}

[   truncate(5.467,2),
    truncate(985.943,2),
    truncate(17.56,2),
    truncate(0, 1),
    truncate(1.11, 1) + 22];
    

Phương pháp đầu tiên "chậm hơn 99,92%" so với phương pháp thứ hai, vì vậy phương pháp thứ hai chắc chắn là phương pháp tôi muốn khuyên bạn sử dụng.

Được rồi, quay lại tìm các cách khác để tránh việc ...