Załóżmy, że mam wartość 15.7784514, chcę wyświetlić ją 15,77 bez zaokrąglania.

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

Prowadzi do -

15.8
15.78
15.778
15.7784514000 

Jak wyświetlić 15,77?

Konwertuj liczbę na ciąg znaków, dopasuj liczbę do drugiego miejsca po przecinku:

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>

W toFixedniektórych przypadkach metoda ta zawiedzie toString, więc bądź bardzo ostrożny.

Aktualizacja 5 listopada 2016 r

Nowa odpowiedź, zawsze dokładna

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

Ponieważ matematyka zmiennoprzecinkowa w javascript zawsze będzie miała przypadki krawędzi, poprzednie rozwiązanie będzie przez większość czasu dokładne, co nie jest wystarczająco dobre. Istnieje kilka rozwiązań tego typu num.toPrecision, takich jak BigDecimal.js i rachunkowości.js . Uważam jednak, że samo parsowanie łańcucha będzie najprostsze i zawsze dokładne.

Opierając aktualizację na dobrze napisanym wyrażeniu regularnym z zaakceptowanej odpowiedzi @Gumbo, ta nowa funkcja toFixed zawsze będzie działać zgodnie z oczekiwaniami.

Stara odpowiedź, nie zawsze dokładna.

Rzuć własną funkcję toFixed:

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

Zdecydowałem się napisać to zamiast tego, aby ręcznie usunąć resztę za pomocą ciągów, aby nie musieć zajmować się matematyką związaną z liczbami:

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

To da ci „15,77” z num = 15,7784514;

Październik 2017 r

Ogólne rozwiązanie w celu obcięcia (bez zaokrąglania) liczby do n-tej cyfry dziesiętnej i przekształcenia jej w ciąg o dokładnie n cyfr dziesiętnych dla dowolnego 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}`
}

gdzie x może być liczbą (która jest konwertowana na ciąg) lub ciągiem.

Oto kilka testów dla n = 2 (włączając ten wymagany przez OP):

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 *

* Jak wspomniano w notatce, wynika to z domyślnej konwersji javascript na wykładniczą dla „1.99e-7” i dla niektórych innych wartości n:

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

parseInt jest szybszy niż 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"

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

Zwróci 19,66

Po prostu zrób to

number = parseInt(number * 100)/100;

Te rozwiązania działają, ale dla mnie wydają się niepotrzebnie skomplikowane. Osobiście lubię używać operatora modułu, aby uzyskać pozostałą część operacji dzielenia, i usunąć ją. Zakładając, że num = 15,7784514:

num-=num%.01;

Jest to równoważne z wypowiedzeniem num = num - (num% .01).

Odpowiedzi tutaj nie pomogły mi, zaokrąglały się w górę lub podawały niewłaściwy ułamek dziesiętny.

moje rozwiązanie konwertuje liczbę dziesiętną na ciąg, wyodrębnia znaki, a następnie zwraca całość jako liczbę.

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

Moja wersja na liczby dodatnie:

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

Szybki, ładny, oczywisty. (wersja na liczby dodatnie)

Poniższy kod działa dla mnie bardzo dobrze:

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

Naprawiłem za pomocą następującego prostego sposobu-

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

Wyniki będą 15.77

Po prostu skróć cyfry:

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

Inne rozwiązanie jednowierszowe:

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

Użyłem 100, ponieważ chcesz skrócić do drugiej cyfry, ale bardziej elastycznym rozwiązaniem byłoby:

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

gdzie cyfry to liczba cyfr dziesiętnych do zachowania.

Zobacz specyfikacje Math.trunc, aby uzyskać szczegółowe informacje i zgodność przeglądarki.

Tu masz. Odpowiedź, która pokazuje jeszcze inny sposób rozwiązania problemu:

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

Zwróć uwagę na użycie znaku + przed końcowym wyrażeniem. Oznacza to konwersję naszego obciętego, pokrojonego łańcucha z powrotem na typ liczbowy.

Mam nadzieję, że to pomoże!

obcinaj bez zer

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

lub

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

test:

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

obciąć zerami

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

test:

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

To działało dla mnie dobrze. Mam nadzieję, że rozwiąże to również twoje problemy.

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>

Łatwy sposób to zrobić, ale koniecznie upewnij się, że parametr kwota jest podany jako ciąg.

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

Kiedyś (num-0.05).toFixed(1)dostawałem drugiego miejsca po przecinku.

Moje rozwiązanie w maszynopisie (może być łatwo przeniesione do 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);
};

Przypadki testowe:

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

Jakieś ulepszenia?

Rzuć własną toFixedfunkcję: dla wartości dodatnich Math.floordziała dobrze.

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

Dla wartości ujemnych Math.floorjest to runda wartości. Możesz więc użyć Math.ceilzamiast tego.

Przykład,

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

Drugie rozwiązanie Gumbo, z wyrażeniem regularnym, działa, ale jest powolne z powodu wyrażenia regularnego. Pierwsze rozwiązanie Gumbo zawodzi w niektórych sytuacjach z powodu niedokładności liczb zmiennoprzecinkowych. Zobacz JSFiddle aby zobaczyć demonstrację i test porównawczy. Drugie rozwiązanie zajmuje około 1636 nanosekund na połączenie w moim obecnym systemie, procesor Intel Core i5-2500 przy 3,30 GHz.

Rozwiązanie, które napisałem, polega na dodaniu niewielkiej kompensacji w celu wyeliminowania niedokładności zmiennoprzecinkowej. Jest to w zasadzie natychmiastowe, tj. Rzędu nanosekund. Taktowałem 2 nanosekundy na każde połączenie, ale liczniki JavaScript nie są bardzo precyzyjne ani szczegółowe. Oto skrzypce JS i kod.

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

Opierając się na Davida D's odpowiedzi:

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

Bardziej niezawodne jest uzyskanie dwóch punktów zmiennoprzecinkowych bez zaokrąglania.

Referencyjna odpowiedź

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

Dziękuję Ci !

Już istnieje odpowiednia odpowiedź z wyrażeniem regularnym i obliczeniami arytmetycznymi, możesz także spróbować tego

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

Oto, co zrobiono z łańcuchem

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

Wszystkie te odpowiedzi wydają się nieco skomplikowane. Chciałbym odjąć 0,5 od twojego numeru i użyć toFixed ().

Najbardziej wydajnym rozwiązaniem (dla 2 cyfr ułamkowych) jest odjęcie 0,005 przed wywołaniem toFixed()

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

Liczby ujemne również zostaną zaokrąglone w dół (od zera). OP nie powiedział nic o liczbach ujemnych.

Wiem, że istnieje już kilka działających przykładów, ale myślę, że warto zaproponować mój odpowiednik String.toFixed, niektórzy mogą uznać to za pomocne.

To moja alternatywa dla toFixed, która nie zaokrągla liczb, po prostu ją obciąża lub dodaje zera zgodnie z podaną precyzją. W przypadku bardzo długiej liczby używa wbudowanego zaokrąglania JS, gdy precyzja jest za długa. Funkcja działa dla wszystkich problematycznych liczb, które znalazłem na stosie.

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

Pamiętaj, że precyzja może nie być właściwie obsługiwana dla liczb o długości 18 i większej, np. 64-bitowy Chrome zaokrągli ją lub doda „e +” / „e-”, aby utrzymać liczbę na 18.

Jeśli chcesz wykonywać operacje na liczbach rzeczywistych, bezpieczniej jest pomnożyć go przez Math.sqrt(10, precision)pierwsze, wykonać obliczenia, a następnie zanotować wynik według wartości mnożnika.

Przykład:

0.06 + 0.01jest 0.06999999999999999, a każda funkcja formatowania, która nie jest zaokrąglana, obetnie ją 0.06dla precyzji 2.

Ale jeśli wykonasz tę samą operację za pomocą mnożnika i dzielnika: (0.06 * 100 + 0.01 * 100) / 100otrzymasz 0.07.

Dlatego tak ważne jest, aby używać takiego mnożnika / dzielnika, gdy mamy do czynienia z liczbami rzeczywistymi w javascript, szczególnie przy obliczaniu pieniędzy ...