Troncare (non arrotondare) i numeri decimali in javascript

Sto cercando di troncare i numeri decimali in posizioni decimali. Qualcosa come questo:

5.467   -> 5.46  
985.943 -> 985.94

toFixed(2)fa quasi la cosa giusta ma arrotonda il valore. Non ho bisogno di arrotondare il valore. Spero che questo sia possibile in javascript.

aggiornamento :

Quindi, dopo tutto si è scoperto, gli insetti arrotondati ti perseguiteranno sempre, non importa quanto cerchi di compensarli. Quindi il problema dovrebbe essere affrontato rappresentando i numeri esattamente in notazione decimale.

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]

Vecchia soluzione soggetta a errori basata sulla compilazione di altri:

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

La risposta di Dogbert è buona, ma se il tuo codice potrebbe avere a che fare con numeri negativi, Math.floorda solo potrebbe dare risultati inaspettati.

Ad esempio Math.floor(4.3) = 4, maMath.floor(-4.3) = -5

Usa invece una funzione di supporto come questa per ottenere risultati coerenti:

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

Ecco una versione più conveniente di questa funzione:

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

Se questo non è il comportamento desiderato, inserisci una chiamata a Math.absnella prima riga:

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

EDIT: shendz sottolinea correttamente che l'utilizzo di questa soluzione con a = 17.56produrrà in modo errato 17.55. Per ulteriori informazioni sul motivo per cui ciò accade, leggi Quello che ogni informatico dovrebbe sapere sull'aritmetica in virgola mobile . Sfortunatamente, scrivere una soluzione che elimini tutte le fonti di errore in virgola mobile è piuttosto complicato con javascript. In un'altra lingua useresti numeri interi o forse un tipo Decimal, ma con javascript ...

Questa soluzione dovrebbe essere precisa al 100%, ma sarà anche più lenta:

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

Per coloro che hanno bisogno di velocità ma vogliono anche evitare errori in virgola mobile, prova qualcosa come BigDecimal.js . Puoi trovare altre librerie BigDecimal javascript in questa domanda SO: "Esiste una buona libreria BigDecimal Javascript?" ed ecco un buon post sul blog sulle librerie matematiche per Javascript

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

È possibile correggere l'arrotondamento sottraendo 0,5 per toFixed, ad es

(f - 0.005).toFixed(2)

Considerare approfittando del doppio tilde:~~ .

Prendi il numero. Moltiplicare per cifre significative dopo il decimale in modo da poter troncare a zero posizioni con ~~. Dividi di nuovo quel moltiplicatore. Profitto.

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

Sto cercando di resistere a racchiudere la ~~chiamata in parentesi; l'ordine delle operazioni dovrebbe farlo funzionare correttamente, credo.

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

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

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

Collegamento JSFiddle .

EDIT: Ripensando, ho involontariamente gestito anche i casi per arrotondare anche a sinistra del decimale.

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

La logica è un po 'stravagante alla ricerca di tale utilizzo e potrebbe trarre vantaggio da un rapido refactoring. Ma funziona ancora. Più fortunato che buono.

Bella soluzione a una riga:

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

Quindi chiamalo con:

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

Ho pensato di inserire una risposta usando |poiché è semplice e funziona bene.

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

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

Troncare utilizzando operatori bit per bit:

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

La risposta di @ Dogbert può essere migliorata con Math.trunc, che tronca invece di arrotondare.

C'è una differenza tra l'arrotondamento e il troncamento. Il troncamento è chiaramente il comportamento che questa domanda sta cercando. Se chiamo truncate (-3.14) e ricevo -4 indietro, lo definirei sicuramente indesiderabile. - @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

Ho scritto una risposta usando un metodo più breve. Ecco cosa mi è venuto in mente

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

    return temp / step;
}

Il metodo può essere utilizzato in questo modo

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

Oppure, se vuoi una sintassi più breve, ecco qui

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

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

Penso che questa funzione possa essere una soluzione semplice:

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

Ho trovato un problema: considerando la prossima situazione: 2.1 o 1.2 o -6.4

E se vuoi sempre 3 decimali o due o wharever, quindi, devi completare gli zeri iniziali a destra

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

Questa è la funzione fissa di 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

La risposta di @kirilloid sembra essere la risposta corretta, tuttavia, il codice principale deve essere aggiornato. La sua soluzione non si prende cura dei numeri negativi (che qualcuno ha menzionato nella sezione commenti ma non è stato aggiornato nel codice principale).

Aggiornandolo a una soluzione finale testata completa:

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

Utilizzo di esempio:

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

Violino: numero JS arrotondato per difetto

PS: non abbastanza repo per commentare quella soluzione.

Ecco una funzione semplice ma funzionante per troncare il numero fino a 2 cifre decimali.

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

Il tipo risultante rimane un numero ...

/* 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 ha alcuni metodi di utilità matematici che possono arrotondare , pavimento e soffitto un numero per una determinata precisione decimale. Questo esclude gli zeri finali.

Adottano un approccio interessante, utilizzando l'esponente di un numero. Apparentemente questo evita problemi di arrotondamento.

(Nota: funcè Math.roundo ceilo floornel codice sottostante)

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

Collegamento al codice sorgente

Ecco la mia opinione sull'argomento:

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

È solo una versione leggermente più elaborata di

(f - 0.005).toFixed(2)

Quella contrassegnata come soluzione è la soluzione migliore che ho trovato fino ad oggi, ma ha un problema serio con 0 (ad esempio, 0.toFixedDown (2) dà -0.01). Quindi suggerisco di usare questo:

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

Ecco cosa uso:

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

lavora con:

• numeri negativi
• numeri molto piccoli (precisione Number.EPSILON)

solo per indicare una soluzione semplice che ha funzionato per me

convertirlo in stringa e quindi regexarlo ...

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)

Può essere abbreviato in

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

Ecco un codice ES6 che fa quello che vuoi

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

Puoi lavorare con le stringhe. Controlla se "." esiste, quindi rimuove parte della stringa.

troncare (7.88, 1) -> 7.8

troncare (7.889, 2) -> 7.89

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

Sono un po 'confuso sul motivo per cui ci sono così tante risposte diverse a una domanda così fondamentalmente semplice; ci sono solo due approcci che ho visto che sembrava valesse la pena guardare. Ho fatto un rapido benchmark per vedere la differenza di velocità usando https://jsbench.me/ .

Questa è la soluzione che è attualmente (26/9/2020) contrassegnata come risposta:

function truncate(n, digits) {
    var re = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)"),
        m = n.toString().match(re);
    return m ? parseFloat(m[1]) : n.valueOf();
};

[   truncate(5.467,2),
    truncate(985.943,2),
    truncate(17.56,2),
    truncate(0, 1),
    truncate(1.11, 1) + 22];

Tuttavia, questo sta facendo cose di stringa e regex, che di solito non è molto efficiente, e c'è una funzione Math.trunc che fa esattamente ciò che l'OP vuole solo senza decimali. Pertanto, puoi facilmente usarlo più un po 'di aritmetica extra per ottenere la stessa cosa.

Ecco un'altra soluzione che ho trovato su questo thread, che è quella che userei:

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

    return temp / step;
}

[   truncate(5.467,2),
    truncate(985.943,2),
    truncate(17.56,2),
    truncate(0, 1),
    truncate(1.11, 1) + 22];
    

Il primo metodo è "99,92% più lento" del secondo, quindi il secondo è sicuramente quello che consiglierei di usare.

Ok, torniamo a trovare altri modi per evitare il lavoro ...