Angenommen, ich habe einen Wert von 15.7784514 und möchte ihn mit 15.77 ohne Rundung anzeigen.

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

Ergebnisse in -

15.8
15.78
15.778
15.7784514000 

Wie zeige ich 15.77 an?

Konvertieren Sie die Zahl in eine Zeichenfolge und passen Sie die Zahl bis zur zweiten Dezimalstelle an:

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>

Die toFixedMethode schlägt in einigen Fällen anders fehl toString, seien Sie also sehr vorsichtig damit.

Update 5. November 2016

Neue Antwort, immer genau

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

Da Gleitkomma-Mathematik in Javascript immer Randfälle hat, ist die vorherige Lösung die meiste Zeit genau, was nicht gut genug ist. Es gibt einige Lösungen für dieses wie num.toPrecision, BigDecimal.js und accounting.js . Ich glaube jedoch, dass das bloße Parsen der Zeichenfolge am einfachsten und immer genauesten ist.

Basierend auf dem gut geschriebenen regulären Ausdruck der akzeptierten Antwort von @Gumbo funktioniert diese neue toFixed-Funktion immer wie erwartet.

Alte Antwort, nicht immer richtig.

Rollen Sie Ihre eigene toFixed-Funktion:

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

Ich habe mich dafür entschieden, dies stattdessen zu schreiben, um den Rest manuell mit Zeichenfolgen zu entfernen, damit ich mich nicht mit den mathematischen Problemen befassen muss, die mit Zahlen einhergehen:

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

Dies gibt Ihnen "15.77" mit num = 15.7784514;

Oktober 2017

Allgemeine Lösung zum Abschneiden (keine Rundung) einer Zahl auf die n-te Dezimalstelle und zum Konvertieren in eine Zeichenfolge mit genau n Dezimalstellen für jedes 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}`
}

Dabei kann x entweder eine Zahl (die in eine Zeichenfolge konvertiert wird) oder eine Zeichenfolge sein.

Hier sind einige Tests für n = 2 (einschließlich des von OP angeforderten):

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 *

* Wie in der Anmerkung erwähnt, liegt dies an der impliziten Umwandlung von Javascript in Exponential für "1.99e-7" und für einige andere Werte von n:

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

parseInt ist schneller als 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"

Mach das einfach

number = parseInt(number * 100)/100;

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

Dies wird 19.66 zurückgeben

Diese Lösungen funktionieren, scheinen mir aber unnötig kompliziert zu sein. Ich persönlich verwende gerne den Moduloperator, um den Rest einer Divisionsoperation zu erhalten und diesen zu entfernen. Angenommen, num = 15.7784514:

num-=num%.01;

Dies entspricht der Aussage von num = num - (num% .01).

Die Antworten hier haben mir nicht geholfen, sie haben sich immer wieder aufgerundet oder mir die falsche Dezimalstelle gegeben.

Meine Lösung konvertiert Ihre Dezimalstelle in eine Zeichenfolge, extrahiert die Zeichen und gibt dann das Ganze als Zahl zurück.

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

Meine Version für positive Zahlen:

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

Schnell, hübsch, offensichtlich. (Version für positive Zahlen)

Der folgende Code funktioniert sehr gut für mich:

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

Ich habe das Problem auf folgende einfache Weise behoben:

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

Ergebnisse werden 15,77 sein

Schneiden Sie einfach die Ziffern ab:

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

Eine weitere einzeilige Lösung:

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

Ich habe 100 verwendet, weil Sie auf die zweite Ziffer kürzen möchten, aber eine flexiblere Lösung wäre:

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

Dabei steht die Anzahl der Dezimalstellen, die beibehalten werden sollen.

Weitere Informationen und Browserkompatibilität finden Sie in den Math.trunc-Spezifikationen .

Hier sind Sie ja. Eine Antwort, die einen weiteren Weg zur Lösung des Problems zeigt:

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

Beachten Sie die Verwendung von + vor dem endgültigen Ausdruck. Das heißt, unsere abgeschnittene, in Scheiben geschnittene Zeichenfolge wird wieder in den Zahlentyp konvertiert.

Ich hoffe es hilft!

ohne Nullen abschneiden

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

oder

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

Prüfung:

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

mit Nullen abschneiden

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

Prüfung:

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

Das hat bei mir gut funktioniert. Ich hoffe, es wird auch Ihre Probleme beheben.

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>

Ein einfacher Weg, dies zu tun, ist der nächste, aber es ist notwendig sicherzustellen, dass der Betragsparameter als Zeichenfolge angegeben wird.

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

Früher (num-0.05).toFixed(1)habe ich die zweite Dezimalstelle erreicht.

Meine Lösung in Typoskript (kann leicht auf JS portiert werden):

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

Testfälle:

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

Irgendwelche Verbesserungen?

Rollen Sie Ihre eigene toFixedFunktion: Für positive Werte Math.floorfunktioniert gut.

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

Bei negativen Werten Math.floorhandelt es sich um eine Runde der Werte. Sie können also Math.ceilstattdessen verwenden.

Beispiel,

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

Gumbos zweite Lösung mit dem regulären Ausdruck funktioniert zwar, ist aber aufgrund des regulären Ausdrucks langsam. Die erste Lösung von Gumbo schlägt in bestimmten Situationen aufgrund der Ungenauigkeit der Gleitkommazahlen fehl. In der JSFiddle finden Sie eine Demonstration und einen Benchmark. Die zweite Lösung benötigt auf meinem aktuellen System, der Intel Core i5-2500-CPU mit 3,30 GHz, ungefähr 1636 Nanosekunden pro Anruf.

Die Lösung, die ich geschrieben habe, besteht darin, eine kleine Kompensation hinzuzufügen, um Gleitkomma-Ungenauigkeiten zu beseitigen. Es ist im Grunde genommen augenblicklich, dh in der Größenordnung von Nanosekunden. Ich habe 2 Nanosekunden pro Aufruf getaktet, aber die JavaScript-Timer sind nicht sehr präzise oder detailliert. Hier ist die JS Fiddle und der 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 < 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);

Aufbauend auf der Antwort von 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

Es ist zuverlässiger, zwei Gleitkommawerte ohne Rundung zu erhalten.

Referenzantwort

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

Danke !

Es gibt bereits einige passende Antworten mit regulären Ausdrücken und arithmetischen Berechnungen. Sie können dies auch versuchen

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

Hier ist, was es mit String gemacht hat

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

All diese Antworten scheinen etwas kompliziert zu sein. Ich würde nur 0,5 von Ihrer Zahl abziehen und toFixed () verwenden.

Die effizienteste Lösung (für 2 Bruchstellen) besteht darin, vor dem Aufruf 0,005 zu subtrahieren toFixed()

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

Negative Zahlen werden ebenfalls abgerundet (von Null weg). Das OP sagte nichts über negative Zahlen.

Ich weiß, dass es bereits wenige Arbeitsbeispiele gibt, aber ich denke, es lohnt sich, mein String.toFixed-Äquivalent vorzuschlagen. Einige mögen es hilfreich finden.

Das ist meine toFixed-Alternative, bei der Zahlen nicht gerundet, sondern nur abgeschnitten oder Nullen entsprechend der angegebenen Genauigkeit hinzugefügt werden. Für extra lange Zahlen wird die integrierte JS-Rundung verwendet, wenn die Genauigkeit zu lang ist. Die Funktion funktioniert für alle problematischen Nummern, die ich auf dem Stapel gefunden habe.

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

Beachten Sie, dass die Genauigkeit bei Zahlen mit einer Länge von 18 und mehr möglicherweise nicht richtig gehandhabt wird, z. B. wird 64-Bit-Chrome sie runden oder "e +" / "e-" hinzufügen, um die Länge der Zahl bei 18 zu halten.

Wenn Sie Operationen mit reellen Zahlen ausführen möchten, ist es sicherer, diese Math.sqrt(10, precision)zuerst zu multiplizieren , die Berechnungen durchzuführen und dann das Ergebnis mit dem Wert des Multiplikators zu tauchen.

Beispiel:

0.06 + 0.01ist 0.06999999999999999, und jede Formatierungsfunktion, die nicht rundet, schneidet sie ab0.06 Genauigkeit2 .

Wenn Sie jedoch dieselbe Operation mit Multiplikator und Teiler ausführen (0.06 * 100 + 0.01 * 100) / 100, erhalten Sie0.07 .

Aus diesem Grund ist es so wichtig, einen solchen Multiplikator / Teiler zu verwenden, wenn Sie mit reellen Zahlen in Javascript arbeiten, insbesondere wenn Sie Geld berechnen ...