Dezimalzahlen in Javascript abschneiden (nicht abrunden)

Ich versuche, Dezimalzahlen auf Dezimalstellen zu kürzen. Etwas wie das:

5.467   -> 5.46  
985.943 -> 985.94

toFixed(2)macht genau das Richtige, aber es rundet den Wert ab. Ich brauche den Wert nicht abgerundet. Hoffe das ist in Javascript möglich.

upd :

Es hat sich also herausgestellt, dass Rundungsfehler Sie immer verfolgen werden, egal wie sehr Sie versuchen, sie zu kompensieren. Daher sollte das Problem angegriffen werden, indem Zahlen genau in Dezimalschreibweise dargestellt werden.

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]

Alte fehleranfällige Lösung basierend auf der Zusammenstellung anderer:

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

Dogberts Antwort ist gut, aber wenn Ihr Code möglicherweise mit negativen Zahlen umgehen Math.floormuss, kann dies zu unerwarteten Ergebnissen führen.

ZB Math.floor(4.3) = 4aberMath.floor(-4.3) = -5

Verwenden Sie stattdessen eine Hilfsfunktion wie diese, um konsistente Ergebnisse zu erzielen:

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

Hier ist eine bequemere Version dieser Funktion:

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

Wenn dies nicht erwünscht ist, fügen Sie in Math.absder ersten Zeile einen Anruf ein :

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

BEARBEITEN : shendz weist richtig darauf hin, dass die Verwendung dieser Lösung mit a = 17.56falsch erzeugt 17.55. Weitere Informationen dazu finden Sie unter Was jeder Informatiker über Gleitkomma-Arithmetik wissen sollte . Leider ist es mit Javascript ziemlich schwierig, eine Lösung zu schreiben, die alle Ursachen für Gleitkommafehler beseitigt. In einer anderen Sprache würden Sie Ganzzahlen oder vielleicht einen Dezimaltyp verwenden, aber mit Javascript ...

Diese Lösung sollte 100% genau sein, ist aber auch langsamer:

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

Für diejenigen, die Geschwindigkeit benötigen, aber auch Gleitkommafehler vermeiden möchten, versuchen Sie etwas wie BigDecimal.js . Weitere Javascript BigDecimal-Bibliotheken finden Sie in dieser SO-Frage: "Gibt es eine gute Javascript BigDecimal-Bibliothek?" und hier ist ein guter Blog-Beitrag über Mathematikbibliotheken für Javascript

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

Sie können die Rundung korrigieren, indem Sie 0,5 für toFixed subtrahieren, z

(f - 0.005).toFixed(2)

Betrachten wir den Vorteil der doppelten Tilde unter:~~ .

Nimm die Nummer auf. Multipliziert mit signifikanten Stellen nach dem Komma , so dass Sie gestutzt mit Null Plätzen ~~. Teilen Sie diesen Multiplikator wieder heraus. Profitieren.

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

Ich versuche zu widerstehen, den ~~Anruf in Parens zu verpacken . Die Reihenfolge der Operationen sollte dafür sorgen, dass das richtig funktioniert, glaube ich.

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

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

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

JSFiddle-Link .

EDIT: Rückblickend habe ich unbeabsichtigt auch Fälle behandelt, um auch links von der Dezimalstelle abzurunden.

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

Die Logik ist ein wenig verrückt nach dieser Verwendung und kann von einem schnellen Refactor profitieren. Aber es funktioniert immer noch. Besser glücklich als gut.

Schöne einzeilige Lösung:

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

Dann nenne es mit:

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

Ich dachte, ich würde eine Antwort mit geben, |da es einfach ist und gut funktioniert.

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

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

Mit bitweisen Operatoren abschneiden:

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

@ Dogberts Antwort kann mit verbessert werden Math.trunc, was abschneidet anstatt zu runden.

Es gibt einen Unterschied zwischen Runden und Abschneiden. Abschneiden ist eindeutig das Verhalten, nach dem diese Frage sucht. Wenn ich Truncate (-3.14) anrufe und -4 zurückerhalte, würde ich das definitiv als unerwünscht bezeichnen. - @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

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

Ich habe eine Antwort mit einer kürzeren Methode geschrieben. Folgendes habe ich mir ausgedacht

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

    return temp / step;
}

Die Methode kann so verwendet werden

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

Wenn Sie eine kürzere Syntax wünschen, können Sie loslegen

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

Ich denke, diese Funktion könnte eine einfache Lösung sein:

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

Ich habe ein Problem gefunden: unter Berücksichtigung der nächsten Situation: 2.1 oder 1.2 oder -6.4

Was ist, wenn Sie immer 3 Dezimalstellen oder zwei oder was auch immer wollen, also müssen Sie die führenden Nullen rechts vervollständigen

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

Dies ist die feste Funktion von 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

Hier ist eine einfache, aber funktionierende Funktion zum Abschneiden von Zahlen mit bis zu 2 Dezimalstellen.

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

Der resultierende Typ bleibt eine Zahl ...

/* 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 hat ein paar nützliche Methoden Math das kann rund , Boden und ceil eine Zahl zu einer bestimmten Dezimalgenauigkeit. Dies lässt nachgestellte Nullen aus.

Sie verfolgen einen interessanten Ansatz, indem sie den Exponenten einer Zahl verwenden. Anscheinend vermeidet dies Rundungsprobleme.

(Hinweis: funcist Math.roundoder ceiloder floorim Code unten)

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

Link zum Quellcode

Die Antwort von @kirilloid scheint die richtige Antwort zu sein, der Hauptcode muss jedoch aktualisiert werden. Seine Lösung kümmert sich nicht um negative Zahlen (die jemand im Kommentarbereich erwähnt hat, aber im Hauptcode nicht aktualisiert wurde).

Aktualisierung auf eine vollständig endgültig getestete Lösung:

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();
};

Beispielnutzung:

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

Geige: JS-Nummer Abrunden

PS: Nicht genug Repo, um diese Lösung zu kommentieren.

Hier meine Sicht auf das Thema:

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

Es ist nur eine etwas ausgefeiltere Version von

(f - 0.005).toFixed(2)

Diejenige, die als Lösung markiert ist, ist die bessere Lösung, die ich bis heute gefunden habe, hat aber ein ernstes Problem mit 0 (zum Beispiel ergibt 0.toFixedDown (2) -0.01). Also schlage ich vor, dies zu verwenden:

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

Folgendes benutze ich:

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

arbeitet mit:

• negative Zahlen
• sehr kleine Zahlen (Number.EPSILON Genauigkeit)

Nur um auf eine einfache Lösung hinzuweisen, die für mich funktioniert hat

konvertiere es in einen String und regex es dann neu ...

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)

Es kann mit abgekürzt werden

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

Hier ist ein ES6-Code, der macht, was Sie wollen

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

Sie können mit Zeichenfolgen arbeiten. Es prüft, ob '.' existiert und entfernt dann einen Teil der Zeichenfolge.

abschneiden (7,88, 1) -> 7,8

abschneiden (7.889, 2) -> 7.89

abschneiden (-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
    }
 }