float - remove decimals javascript
¿Por qué ToPrecision devuelve una cadena? (6)
Ver este código:
function testprecision(){
var isNotNumber = parseFloat(''1.3'').toPrecision(6);
alert(typeof isNotNumber); //=> string
}
Hubiera esperado un número. Si ''isNotNumber'' debe ser un número real, la refundición es la solución:
alert(typeof parseFloat(isNotNumber)) //=> number
[Editar] gracias por tus respuestas. La precisión no es un término tan preciso que concluya. Puede representar la cantidad total de dígitos de un número o la cantidad de dígitos fraccionarios . La mayoría de las personas en los Países Bajos (de donde vengo) piensan en la precisión en el "número de dígitos fraccionarios". El método JavascriptPrecision se refiere a la primera representación, por lo que es confuso. De todos modos, el método hace posible introducir ''precisión falsa'', ¿estoy en lo cierto? Para el segundo significado que tenemos ajustado, lo mismo vale para eso (devuelve cadena, posibilidad de precisión falsa).
De todos modos, después de haber reinventado la rueda de mi hobby principal, jugué para construir un objeto de flotación javascript, usando el conocimiento que reuní aquí. Tal vez sea útil para alguien, o tal vez alguno de ustedes tenga mejores ideas.
function Float(f,nDec) {
var Base = this,val;
setPrecision( nDec || 2 );
set( f || 0, nDec || Base.precision );
Base.set = set;
Base.ndec = setPrecision;
/** public setprecision
* sets a value for the number of fractional
* digits (decimals) you would like getf to
* return. NB: can''t be more than 20.
* Returns the Float object, so allows method
* chaining
* @param {Number} iPrecision
*/
function setPrecision(iPrecision) {
var ix = parseInt(iPrecision,10) || 2;
Base.precision = ix >= 21 ? 20 : ix;
return Base;
}
/** public set
* sets the ''internal'' value of the object. Returns
* the Float object, so allows method chaining
* @param {Number} f
* @param {Number} ndec
*/
function set(f,ndec) {
val = parseFloat(f) || 0;
if (ndec) { setPrecision(ndec); }
Base.val = val;
return Base;
}
/** public get:
* return number value (as a float)
*/
Base.get = function(){
var ndec = Math.pow(10,Base.precision),
ival = parseInt(val*ndec,10)/ndec;
Base.val = ival;
return Base.val;
};
/** public getf
* returns formatted string with precision
* (see Base.setPrecision)
* if [hx] is supplied, it returns
* the float as hexadecimal, otherwise
* @param {Boolean} hx
*/
Base.getf = function(hx){
var v = Base.val.toFixed(Base.precision);
return hx ? v.toString(16) : v;
};
/** public add
* adds [f] to the current value (if [f] is a
* Float, otherwise returns current value)
* optionally sets a new number of decimals
* from parameter [ndec]
* @param {Number} f
* @param {Number} ndec
*/
Base.add = function(f,ndec){
if ( parseFloat(f) || val===0) {
set(Base.val+parseFloat(f));
if (ndec) { setPrecision(ndec);}
}
return Base.get();
};
/** toString
* returns the internal value of the Float object
* functions like a getter (supposedly)
*/
Base.toString = Base.get;
}
uso / ejemplo:
var xf = new Float(); //=> value now 0.0
xf.set(0.86/0.8765,17).add(3.459);
alert(xf+''|''+xf.getf()); //=> 4.440175128351398|4.44017512835139800
El propósito de toPrecision es truncar los dígitos decimales significativos de un Number en una cantidad específica. Pero el tipo de datos de las representaciones internas de Number s es binario IEEE-754 doble. Por lo tanto, es imposible almacenar el valor de retorno preciso en un Number mayoría de las veces. Como resultado de esta imprecisión, el valor de retorno tendría una cantidad infinita de dígitos decimales que harían que la toPrecision nula.
Entonces, la única solución razonable para este problema es devolver dígitos decimales. Y actualmente, el único tipo de datos JS razonable para los dígitos decimales es una Cadena.
Aquí hay un ejemplo para aclarar la imprecisión de Number s si se usa para dígitos decimales:
// the following looks like something with 2 decimal digits:
var number = 1.6;
// but in fact it''s a number with an infinite amount of decimal digits.
// let''s look at the first 30 of them:
alert(number.toPrecision(30));
// 1.60000000000000008881784197001
Necesita una cadena para ceros al final. La visualización de divisas es un buen ejemplo.
Porque es una función de formateo.
Supongamos que tiene un número como ''1.6''. Si lo formatea para tener 6 ceros a la derecha, obtendría un ''1.600000''. Para la computadora, sigue siendo el mismo número que 1.6, pero para usted y su sitio web, no es lo mismo si todos sus números son de diferentes longitudes (lo que podría dañar un analizador, por ejemplo).
Entonces, para evitarlo, toPrecision devuelve una cadena, o de lo contrario el intérprete volverá a formatear el número para volverse a ''1.6''.
De los documentos: "Devuelve una cadena que representa el objeto Número con la precisión especificada".
toPrecision () parece destinado a dar formato a la salida, en cuyo caso una cadena es el resultado más razonable. Representa el resultado final en una forma que no se arruinará por manipulación adicional.
Si buscas hacer un truncamiento de la precisión por razones de cálculo, tiendo a multiplicar por 10 ^ n donde n son los dígitos que quiero mantener, tomar un número entero de eso y luego dividir de nuevo por el mismo. Sin embargo, esto no es perfecto: en algunas situaciones, puede invitar a un desbordamiento. Francamente, prefiero hacer cálculos financieros más complejos en el servidor, donde tengo una moneda, un código decimal binario o tipos numéricos similares.
El problema es el uso de toPrecision . Pruébalo sin.
var isNotNumber = parseFloat(''1.3'');
alert(typeof isNotNumber); //=> number