javascript parseFloat '500,000' devuelve 500 cuando necesito 500000

Question

¿Cómo sería una buena forma de manejar esto?

Ya pensé en quitar la coma y luego analizar para flotar.

¿Conoces una manera mejor/más limpia?

Gracias

Answer 1

Nope. Quita la coma

Answer 2

parseFloat(theString.replace(/,/g,'')); 

Answer 3

Puede utilizar el método de sustitución de cadenas, pero no en un trazador de líneas como lo permite una expresión regular.

while(str.indexOf(',')!=-1)str= str.replace(',',''); 
parseFloat(str); 

o para hacer una sola expresión sin una expresión regular =

return parseFloat(str.split(',').join('')); 

que haría uso de la expresión regular.

Answer 4

Basándose en la idea de @kennebec, si usted quiere asegurarse de que las comas son correctos y que no quieren reemplazar comas, que podría intentar algo como esto:

function myParse(num) { 
    var n2 = num.split(",") 
    out = 0 
    for(var i = 0; i < n2.length; i++) { 
    out *= 1000; 
    out += parseFloat(n2[i]) 
    } 
    return out 
} 
alert(myParse("1,432,85")); 
// Returns 1432085, as the comma is misplaced. 

Puede no sea tan rápido, pero quería alternativas :)

Answer 5

¿Qué tal una función simple para resolver la mayoría de los problemas comunes?

function getValue(obj) { 
    Value = parseFloat($(obj).val().replace(/,/g,'')).toFixed(2); 
    return +Value; 
} 

La función anterior se pone los valores de los campos (usando jQuery) suponiendo que los valores introducidos son numéricas (I validar campos en lugar mientras que el usuario está introduciendo datos, por lo que sé de seguro de contenido del campo es numérico).

En caso de valores de coma flotante, si está bien formateado en el campo, la función devolverá un valor de punto flotante correctamente.

Esta función está lejos de ser completa, pero rápidamente se soluciona el problema "," (coma) para los valores introducidos como 1,234.56 o 1.234.567. Devolverá un número válido siempre que el contenido sea numérico.

El + (más) delante de la variable Valor en el comando retorno es un "truco sucio" que se utiliza en JavaScript para asegurar el contenido de la variable devuelta será numérico.

es fácil de modificar la función para otros fines, tales como (por ejemplo), convertir cadenas en valores numéricos que se ocupan de la "," (coma) tema:

function parseValue(str) { 
    Value = parseFloat(str.replace(/,/g,'')).toFixed(2); 
    return +Value; 
} 

Ambas operaciones pueden incluso combinarse en una función. Es decir.:

function parseNumber(item,isField=false) { 
    Value = (isField) ? parseFloat($(item).val().replace(/,/g,'')).toFixed(2) : parseFloat(item.replace(/,/g,'')).toFixed(2) 
    return +Value; 
} 

En tal caso, si la función se llama resultado = parseNumber ('12, 092,98'); analizará el valor porque es una cadena. Pero si se llama como result = parseNumber ('# MyField', true); intentará obtener el valor de '#MyField'.

Como dije antes, estas funciones están lejos de ser completas, y se pueden ampliar de muchas maneras. Una idea es verificar el primer carácter del parámetro dado (cadena) y decidir en base al formato de cadena donde obtener el valor que se analizará (si el 1er carácter es = '#', entonces es una identificación de un objeto DOM de lo contrario, si comienza con un número, debe ser una cadena para analizarse).

Pruébalo ... Happy coding.

Answer 6

No sé por qué nadie ha sugerido esta expresión-

parseFloat(theString.replace(/[^\d\.]/g,'')); 

elimina cualquier carácter no numérico, excepto por períodos. No necesita funciones/bucles personalizados para esto tampoco, eso es exagerado.

Answer 7

no tengo la reputación suficiente para agregar un comentario, pero para cualquiera que se pregunte sobre el rendimiento de expresiones regulares vs split/join, aquí está un violín rápida: https://jsfiddle.net/uh3mmgru/

var test = "1,123,214.19"; 

var t0 = performance.now(); 
for (var i = 0; i < 1000000; i++) 
{ 
    var a = parseFloat(test.replace(/,/g,'')); 
} 
var t1 = performance.now(); 
document.write('Regex took: ' + (t1 - t0) + ' ms'); 
document.write('<br>') 

var t0 = performance.now(); 
for (var i = 0; i < 1000000; i++) 
{ 
    var b = parseFloat(test.split(',').join('')); 
} 
var t1 = performance.now(); 
document.write('Split/join took: ' + (t1 - t0) + ' ms'); 

Los resultados que obtengo son (por 1 millón de ciclos cada uno):

regex: 263.335 ms
split/join: 1035.875 ms

por lo que creo que es seguro decir que la expresión regular es el camino a seguir en este escenario