Supposons que j'ai une valeur de 15,7784514, je veux l'afficher 15,77 sans arrondi.

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

Résulte en -

15.8
15.78
15.778
15.7784514000 

Comment afficher 15,77?

Convertissez le nombre en une chaîne, faites correspondre le nombre jusqu'à la deuxième décimale:

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>

La toFixedméthode échoue dans certains cas contrairement à toString, alors soyez très prudent avec elle.

Mise à jour 5 novembre 2016

Nouvelle réponse, toujours précise

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

Comme les calculs en virgule flottante en javascript auront toujours des cas marginaux, la solution précédente sera précise la plupart du temps, ce qui n'est pas suffisant. Il y a quelques solutions à ce comme num.toPrecision, BigDecimal.js et accounting.js . Pourtant, je crois que le simple fait d'analyser la chaîne sera le plus simple et toujours précis.

Basant la mise à jour sur l'expression rationnelle bien écrite de la réponse acceptée par @Gumbo, cette nouvelle fonction toFixed fonctionnera toujours comme prévu.

Ancienne réponse, pas toujours exacte.

Faites rouler votre propre fonction toFixed:

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

J'ai choisi d'écrire ceci à la place pour supprimer manuellement le reste avec des chaînes, donc je n'ai pas à gérer les problèmes mathématiques liés aux nombres:

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

Cela vous donnera "15,77" avec num = 15,7784514;

Octobre 2017

Solution générale pour tronquer (sans arrondir) un nombre au nième chiffre décimal et le convertir en une chaîne avec exactement n chiffres décimaux, pour tout 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}`
}

où x peut être soit un nombre (qui est converti en chaîne) soit une chaîne.

Voici quelques tests pour n = 2 (dont celui demandé par 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 *

* Comme mentionné dans la note, cela est dû à la conversion implicite javascript en exponentielle pour "1.99e-7" Et pour certaines autres valeurs de n:

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

parseInt est plus rapide 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"

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

Cela retournera 19,66

Faites cela simplement

number = parseInt(number * 100)/100;

Ces solutions fonctionnent, mais elles me semblent inutilement compliquées. Personnellement, j'aime utiliser l'opérateur de module pour obtenir le reste d'une opération de division et le supprimer. En supposant que num = 15,7784514:

num-=num%.01;

Cela équivaut à dire num = num - (num% .01).

Les réponses ici ne m'ont pas aidé, elles ont continué à être arrondies ou à me donner la mauvaise décimale.

ma solution convertit votre décimale en une chaîne, extrait les caractères puis renvoie le tout sous forme de nombre.

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

Ma version pour les nombres positifs:

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

Rapide, joli, évident. (version pour les nombres positifs)

Le code suivant fonctionne très bien pour moi:

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

J'ai corrigé en utilisant la manière simple suivante-

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

Les résultats seront 15,77

Tronquez simplement les chiffres:

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

Une autre solution monoligne:

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

J'ai utilisé 100 parce que vous voulez tronquer au deuxième chiffre, mais une solution plus flexible serait:

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

où chiffres est la quantité de chiffres décimaux à conserver.

Voir les spécifications Math.trunc pour plus de détails et la compatibilité du navigateur.

Vous voilà. Une réponse qui montre encore une autre façon de résoudre le problème:

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

Notez l'utilisation de + avant l'expression finale. C'est pour reconvertir notre chaîne tronquée et tranchée en type numérique.

J'espère que ça aide!

tronquer sans zéros

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

tester:

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

tronquer avec des zéros

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

tester:

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

Cela a bien fonctionné pour moi. J'espère que cela résoudra également vos problèmes.

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>

Un moyen facile de le faire est le suivant mais il est nécessaire de s'assurer que le paramètre de quantité est donné sous forme de chaîne.

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

J'avais l'habitude (num-0.05).toFixed(1)d'obtenir la deuxième décimale au sol.

Ma solution en dactylographie (peut facilement être portée sur 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);
};

Cas de test:

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

Des améliorations?

Lancez votre propre toFixedfonction: pour les valeurs positives, cela Math.floorfonctionne très bien.

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

Pour les valeurs négatives, Math.floorarrondissez les valeurs. Vous pouvez donc utiliser à la Math.ceilplace.

Exemple,

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

La deuxième solution de Gumbo, avec l'expression régulière, fonctionne mais est lente à cause de l'expression régulière. La première solution de Gumbo échoue dans certaines situations en raison de l'imprécision des nombres à virgule flottante. Voir le JSFiddle pour une démonstration et une référence. La deuxième solution prend environ 1636 nanosecondes par appel sur mon système actuel, le processeur Intel Core i5-2500 à 3,30 GHz.

La solution que j'ai écrite consiste à ajouter une petite compensation pour prendre soin de l'imprécision en virgule flottante. Elle est essentiellement instantanée, c'est-à-dire de l'ordre des nanosecondes. J'ai cadencé 2 nanosecondes par appel mais les temporisateurs JavaScript ne sont pas très précis ni granuleux. Voici le JS Fiddle et le 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);

S'appuyant sur la réponse 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

Il est plus fiable d'obtenir deux virgules flottantes sans arrondir.

Réponse de référence

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

Je vous remercie !

Il existe déjà une réponse appropriée avec l'expression régulière et le calcul arithmétique, vous pouvez également essayer ceci

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

Voici ce que l'on a fait avec de la ficelle

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

Toutes ces réponses semblent un peu compliquées. Je voudrais simplement soustraire 0,5 de votre nombre et utiliser toFixed ().

La solution la plus efficace (pour 2 chiffres de fraction) consiste à soustraire 0,005 avant d'appeler toFixed()

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

Les nombres négatifs seront également arrondis vers le bas (loin de zéro). L'OP n'a rien dit sur les chiffres négatifs.

Je sais qu'il y a déjà quelques exemples de travail, mais je pense qu'il vaut la peine de proposer mon équivalent String.toFixed, certains peuvent le trouver utile.

C'est mon alternative à ToFixed, qui n'arrondit pas les nombres, les tronque ou ajoute des zéros selon une précision donnée. Pour un nombre très long, il utilise l'arrondi intégré JS lorsque la précision est trop longue. La fonction fonctionne pour tous les numéros problématiques que j'ai trouvés sur la pile.

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

Gardez à l'esprit que la précision peut ne pas être gérée correctement pour les nombres de longueur 18 et plus, par exemple Chrome 64 bits l'arrondira ou ajoutera "e +" / "e-" pour garder la longueur du nombre à 18.

Si vous souhaitez effectuer des opérations sur des nombres réels, il est plus sûr de le multiplier d' Math.sqrt(10, precision)abord, de faire les calculs, puis de plonger le résultat par la valeur du multiplicateur.

Exemple:

0.06 + 0.01est 0.06999999999999999, et chaque fonction de mise en forme qui n'est pas arrondie la tronquera pour plus 0.06de précision 2.

Mais si vous effectuez la même opération avec le multiplicateur et le diviseur:, (0.06 * 100 + 0.01 * 100) / 100vous obtiendrez 0.07.

C'est pourquoi il est si important d'utiliser un tel multiplicateur / diviseur lorsque vous traitez avec des nombres réels en javascript, en particulier lorsque vous calculez de l'argent ...