javascriptの10進数を切り捨てます（丸めない）
小数点以下を切り捨てようとしています。このようなもの：
5.467 -> 5.46
985.943 -> 985.94
toFixed(2)はほぼ正しいことを行いますが、値を四捨五入します。値を四捨五入する必要はありません。これがjavascriptで可能になることを願っています。
pd：
そのため、結局のところ、丸めのバグは、あなたがそれらを補償しようとしても、常にあなたを悩ませます。したがって、数値を10進表記で正確に表すことにより、問題を攻撃する必要があります。
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]
他人のコンパイルに基づく、エラーが発生しやすい古いソリューション：
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);
}
Dogbertの答えは良いですが、コードで負の数を処理する必要がある場合、Math.floor自体で予期しない結果が生じる可能性があります。
例えば。 Math.floor(4.3) = 4、ただしMath.floor(-4.3) = -5
代わりに、次のようなヘルパー関数を使用して、一貫した結果を取得します。
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
この関数のより便利なバージョンは次のとおりです。
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
それが望ましくない場合は、最初の行にMath.absへの呼び出しを挿入します。
var multiplier = Math.pow(10, Math.abs(digits)),
EDIT：shendzは、このソリューションをa = 17.56とともに使用すると17.55を誤って生成することを正しく指摘しています。これが起こる理由の詳細については、 すべてのコンピューター科学者が浮動小数点演算について知っておくべきこと をお読みください。残念ながら、すべての浮動小数点エラーの原因を排除するソリューションを作成することは、javascriptではかなり注意が必要です。別の言語では、整数またはDecimal型を使用しますが、javascriptを使用します...
このソリューションは100％正確である必要がありますが、遅くなります：
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);
}
速度が必要であるが、浮動小数点エラーを回避したい場合は、 BigDecimal.js のようなものを試してください。このSO質問で他のjavascript BigDecimalライブラリを見つけることができます： "良いJavascript BigDecimalライブラリはありますか？" 、ここ に関する良いブログ投稿Javascript 用の数学ライブラリ
var a = 5.467;
var truncated = Math.floor(a * 100) / 100; // = 5.46
ToFixedで0.5を引くことにより、丸めを修正できます。
(f - 0.005).toFixed(2)
二重チルダを利用する：~~ を検討してください。
番号を入力してください。 ~~でゼロ桁まで truncate できるように、小数点以下の有効数字を掛けます。その乗数を除算します。利益。
function truncator(numToTruncate, intDecimalPlaces) {
var numPower = Math.pow(10, intDecimalPlaces); // "numPowerConverter" might be better
return ~~(numToTruncate * numPower)/numPower;
}
私は括弧で~~呼び出しをラップすることに抵抗しようとしています。操作の順序により、それが正しく機能するはずです。
alert(truncator(5.1231231, 1)); // is 5.1
alert(truncator(-5.73, 1)); // is -5.7
alert(truncator(-5.73, 0)); // is -5
EDIT：振り返ってみると、意図せずに小数の左端を丸めるケースも処理しました。
alert(truncator(4343.123, -2)); // gives 4300.
ロジックは、その使用法を探すのに少し奇抜であり、迅速なリファクタリングの恩恵を受ける可能性があります。しかし、それでも動作します。幸運よりも幸運です。
|を使用して答えを投げると思ったのは、それが単純でうまく機能するからです。
truncate = function(number, places) {
var shift = Math.pow(10, places);
return ((number * shift) | 0) / shift;
};
素敵な1行のソリューション：
function truncate (num, places) {
return Math.trunc(num * Math.pow(10, places)) / Math.pow(10, places);
}
次に、それを呼び出します：
truncate(3.5636232, 2); // returns 3.56
truncate(5.4332312, 3); // returns 5.433
truncate(25.463214, 4); // returns 25.4632
@Dogbertの答えは Math.trunc で改善できます。これは丸めの代わりに切り捨てられます。
丸めと切り捨てには違いがあります。切り捨ては明らかにこの質問が求めている行動です。 truncate（-3.14）を呼び出して-4を受け取ったら、間違いなくそれを望ましくないものと呼ぶでしょう。 – @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
ビットごとの演算子を使用して切り捨てます。
~~0.5 === 0
~~(-0.5) === 0
~~14.32794823 === 14
~~(-439.93) === -439
問題が見つかりました：次の状況を考慮して：2.1または1.2または-6.4
常に小数点以下3桁または2桁以上を常に必要とする場合は、先行ゼロを右側に入力する必要があります
// 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
これは、ニックノウルソンの固定機能です
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;
};
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
この関数は簡単な解決策になると思います。
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));@kirilloidによる答えは正しい答えのようですが、メインコードを更新する必要があります。彼の解決策は負の数値を処理しません（誰かがコメントセクションで言及しましたが、メインコードでは更新されていません）。
それを完全な最終テスト済みソリューションに更新します。
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();
};
サンプル使用法：
var x = 3.1415629;
Logger.log(x.toFixedDown(2)); //or use whatever you use to log
フィドル： JS Number Round down
PS：そのソリューションについてコメントするのに十分なレポではありません。
Lodashには、 round 、 floor 、および ceil を指定した10進精度の数値にすることができるいくつかのMathユーティリティメソッドがあります。これにより、末尾のゼロが残ります。
彼らは、数値の指数を使用して、興味深いアプローチを取ります。これにより、丸めの問題が回避されるようです。
（注：以下のコードのfuncはMath.roundまたはceilまたはfloorです）
// 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));
以下は、小数点以下2桁までの数値を切り捨てるシンプルだが機能する関数です。
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;
}
結果の型は数字のままです...
/* 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);
解決策としてマークされているものは、今日まで見つかったより良い解決策ですが、0に深刻な問題があります（たとえば、0.toFixedDown（2）は-0.01を与えます）。したがって、これを使用することをお勧めします。
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);
}
短い方法で答えを書きました。ここに私が思いついたものがあります
function truncate(value, precision) {
var step = Math.pow(10, precision || 0);
var temp = Math.trunc(step * value);
return temp / step;
}
メソッドは次のように使用できます
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
または、より短い構文が必要な場合は、ここに行きます
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
Number.prototype.truncate = function(places) {
var shift = Math.pow(10, places);
return Math.trunc(this * shift) / shift;
};
ここで私の主題についての私の見解：
convert.truncate = function(value, decimals) {
decimals = (decimals === undefined ? 0 : decimals);
return parseFloat((value-(0.5/Math.pow(10, decimals))).toFixed(decimals),10);
};
それはほんの少し精巧なバージョンです
(f - 0.005).toFixed(2)
私が使用するものは次のとおりです。
var t = 1;
for (var i = 0; i < decimalPrecision; i++)
t = t * 10;
var f = parseFloat(value);
return (Math.floor(f * t)) / t;
私のために働いた簡単な解決策を指摘するだけ
文字列に変換してから正規表現します...
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)
に短縮できます
var number_truncated = parseFloat(('' + 123.4568908).match(/\d*\.\d{4}/)[0])
ここにあなたが望むことをするES6コードがあります
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