Suponha que eu tenha um valor de 15.7784514, desejo exibi-lo 15.77 sem arredondamento.

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

Resulta em -

15.8
15.78
15.778
15.7784514000 

Como eu mostro 15.77?

Converta o número em uma string, combine o número até a segunda casa decimal:

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>

O toFixedmétodo falha em alguns casos toString, diferentemente , portanto, tenha muito cuidado com ele.

Atualização 5 de novembro de 2016

Nova resposta, sempre precisa

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

Como a matemática de ponto flutuante em javascript sempre terá casos extremos, a solução anterior será precisa na maior parte do tempo, o que não é bom o suficiente. Existem algumas soluções para isso num.toPrecision, como BigDecimal.js e accounting.js . No entanto, acredito que apenas analisar a string será a mais simples e sempre precisa.

Baseando a atualização no regex bem escrito da resposta aceita pelo @Gumbo, essa nova função toFixed sempre funcionará conforme o esperado.

Resposta antiga, nem sempre precisa.

Role sua própria função toFixed:

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

Optei por escrever isso em vez de remover manualmente o restante com strings, para não precisar lidar com os problemas de matemática que acompanham os números:

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

Isso fornecerá "15,77" com num = 15,7784514;

Outubro 2017

Solução geral para truncar (sem arredondamento) um número para o n-ésimo dígito decimal e convertê-lo em uma sequência com exatamente n dígitos decimais, para qualquer 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}`
}

onde x pode ser um número (que é convertido em uma sequência) ou uma sequência.

Aqui estão alguns testes para n = 2 (incluindo o solicitado pelo 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 *

* Conforme mencionado na nota, isso se deve à conversão implícita do javascript em exponencial para "1.99e-7" E para alguns outros valores de n:

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

parseInt é mais rápido que 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"

Simples faça isso

number = parseInt(number * 100)/100;

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

Isso retornará 19,66

Essas soluções funcionam, mas para mim parecem desnecessariamente complicadas. Pessoalmente, gosto de usar o operador de módulo para obter o restante de uma operação de divisão e removê-lo. Supondo que num = 15.7784514:

num-=num%.01;

Isso é equivalente a dizer num = num - (num% .01).

As respostas aqui não me ajudaram, continuaram arredondando ou me dando o decimal errado.

minha solução converte seu decimal em uma string, extrai os caracteres e retorna a coisa toda como um número.

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

Minha versão para números positivos:

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

Rápido, bonito, óbvio. (versão para números positivos)

O código a seguir funciona muito bem para mim:

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

Corrigi usando as seguintes maneiras simples:

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

Os resultados serão 15,77

Apenas trunque os dígitos:

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

Outra solução de linha única:

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

Usei 100 porque você deseja truncar para o segundo dígito, mas uma solução mais flexível seria:

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

onde dígitos é a quantidade de dígitos decimais a serem mantidos.

Consulte Especificações do Math.trunc para obter detalhes e compatibilidade do navegador.

Olha Você aqui. Uma resposta que mostra mais uma maneira de resolver o problema:

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

Observe o uso de + antes da expressão final. Isso é para converter nossa sequência truncada e fatiada de volta ao tipo de número.

Espero que ajude!

truncar sem zeros

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

ou

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

teste:

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

truncar com zeros

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

teste:

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

Isto funcionou bem para mim. Espero que isso também resolva seus problemas.

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>

Uma maneira fácil de fazer isso é a próxima, mas é necessário garantir que o parâmetro amount seja fornecido como uma string.

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

Eu costumava (num-0.05).toFixed(1)colocar o segundo decimal no chão.

Minha solução em texto datilografado (pode ser facilmente portada para 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);
};

Casos de teste:

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

Alguma melhoria?

Role sua própria toFixedfunção: para valores positivos Math.floorfunciona bem.

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

Para valores negativos Math.flooré o arredondamento dos valores. Então você pode usarMath.ceil .

Exemplo,

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

A segunda solução da Gumbo, com a expressão regular, funciona, mas é lenta por causa da expressão regular. A primeira solução da Gumbo falha em determinadas situações devido à imprecisão no número de pontos flutuantes. Veja o JSFiddle para uma demonstração e uma referência. A segunda solução leva cerca de 1636 nanossegundos por chamada no meu sistema atual, CPU Intel Core i5-2500 a 3,30 GHz.

A solução que eu escrevi envolve adicionar uma pequena compensação para cuidar da imprecisão de ponto flutuante. É basicamente instantâneo, ou seja, da ordem de nanossegundos. Cronometrei 2 nanossegundos por chamada, mas os timers do JavaScript não são muito precisos ou granulares. Aqui está o JS Fiddle e o código.

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

Com base na resposta de 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

É mais confiável obter dois pontos flutuantes sem arredondar.

Resposta de referência

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

Obrigado !

Já existe uma resposta adequada com expressão regular e cálculo aritmético, você também pode tentar isso

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

Aqui está o que fez com string

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

Todas essas respostas parecem um pouco complicadas. Eu apenas subtrairia 0,5 do seu número e usaria toFixed ().

A solução mais eficiente (para dois dígitos da fração) é subtrair 0,005 antes de chamar toFixed()

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

Os números negativos também serão arredondados para baixo (longe de zero). O OP não falou nada sobre números negativos.

Sei que já existem poucos exemplos de trabalho, mas acho que vale a pena propor meu equivalente String.toFixed, alguns podem achar útil.

Essa é a minha alternativa toFixed, que não arredonda números, apenas o trunca ou adiciona zeros de acordo com a precisão fornecida. Para um número extra longo, ele usa o arredondamento JS embutido quando a precisão é longa. A função funciona para todos os números problemáticos que encontrei na pilha.

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

Lembre-se de que a precisão pode não ser tratada adequadamente para números de comprimento 18 e superior; por exemplo, o Chrome de 64 bits o arredondará ou adicionará "e +" / "e-" para manter o comprimento do número em 18.

Se você deseja executar operações em números reais, é mais seguro multiplicá-lo por Math.sqrt(10, precision) primeiro, faça os cálculos e depois mergulhe o resultado pelo valor do multiplicador.

Exemplo:

0.06 + 0.01é 0.06999999999999999, e toda função de formatação que não seja arredondada a truncará 0.06para precisão2 .

Mas se você realizar a mesma operação com multiplicador e divisor:, (0.06 * 100 + 0.01 * 100) / 100obterá 0.07.

É por isso que é tão importante usar esse multiplicador / divisor ao lidar com números reais em javascript, especialmente quando você está calculando dinheiro ...