¿Cómo puedo analizar una cadena con un separador de miles de coma en un número?

Lo tengo 2,299.00como una cadena y estoy tratando de analizarlo en un número. Intenté usar parseFloat, lo que da como resultado 2. Supongo que la coma es el problema, pero ¿cómo podría resolver este problema de la manera correcta? ¿Solo quita la coma?

var x = parseFloat("2,299.00")
alert(x);

Sí, elimine las comas:

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

Eliminar las comas es potencialmente peligroso porque, como otros han mencionado en los comentarios, muchas configuraciones regionales usan una coma para significar algo diferente (como un lugar decimal).

No sé de dónde sacaste tu cuerda, pero en algunos lugares del mundo "2,299.00"=2.299

El Intlobjeto podría haber sido una buena manera de abordar este problema, pero de alguna manera lograron enviar la especificación con solo una Intl.NumberFormat.format()API y sin parsecontraparte :(

La única forma de analizar una cadena con caracteres numéricos culturales en un número reconocible por la máquina de cualquier manera sana es usar una biblioteca que aproveche los datos CLDR para cubrir todas las formas posibles de formatear cadenas numéricas http: //cldr.unicode. org /

Las dos mejores opciones de JS que he encontrado para esto hasta ahora:

• https://github.com/google/closure-library/tree/master/closure/goog/i18n
• https://github.com/globalizejs/globalize

En los navegadores modernos, puede utilizar el Intl.NumberFormat integrado para detectar el formato de número del navegador y normalizar la entrada para que coincida.

function parseNumber(value, locale = navigator.language) {
  const example = Intl.NumberFormat(locale).format('1.1');
  const cleanPattern = new RegExp(`[^-+0-9${ example.charAt( 1 ) }]`, 'g');
  const cleaned = value.replace(cleanPattern, '');
  const normalized = cleaned.replace(example.charAt(1), '.');

  return parseFloat(normalized);
}

const corpus = {
  '1.123': {
    expected: 1.123,
    locale: 'en-US'
  },
  '1,123': {
    expected: 1123,
    locale: 'en-US'
  },
  '2.123': {
    expected: 2123,
    locale: 'fr-FR'
  },
  '2,123': {
    expected: 2.123,
    locale: 'fr-FR'
  },
}


for (const candidate in corpus) {
  const {
    locale,
    expected
  } = corpus[candidate];
  const parsed = parseNumber(candidate, locale);

  console.log(`${ candidate } in ${ corpus[ candidate ].locale } == ${ expected }? ${ parsed === expected }`);
}

Obviamente, hay espacio para algunas optimizaciones y almacenamiento en caché, pero esto funciona de manera confiable en todos los idiomas.

Quite todo lo que no sea un dígito, punto decimal o signo menos ( -):

var str = "2,299.00";
str = str.replace(/[^\d\.\-]/g, ""); // You might also include + if you want them to be able to type it
var num = parseFloat(str);

Violín actualizado

Tenga en cuenta que no funcionará para números en notación científica. Si usted quiere que, cambiar la replacelínea para añadir e, Ey +la lista de caracteres aceptables:

str = str.replace(/[^\d\.\-eE+]/g, "");

Por lo general, debe considerar el uso de campos de entrada que no permitan la entrada de texto libre para valores numéricos. Pero puede haber casos en los que necesite adivinar el formato de entrada. Por ejemplo, 1.234,56 en Alemania significa 1.234,56 en EE. UU. Consulte https://salesforce.stackexchange.com/a/21404 para obtener una lista de países que utilizan coma como decimal.

Utilizo la siguiente función para hacer una mejor estimación y eliminar todos los caracteres no numéricos:

function parseNumber(strg) {
    var strg = strg || "";
    var decimal = '.';
    strg = strg.replace(/[^0-9$.,]/g, '');
    if(strg.indexOf(',') > strg.indexOf('.')) decimal = ',';
    if((strg.match(new RegExp("\\" + decimal,"g")) || []).length > 1) decimal="";
    if (decimal != "" && (strg.length - strg.indexOf(decimal) - 1 == 3) && strg.indexOf("0" + decimal)!==0) decimal = "";
    strg = strg.replace(new RegExp("[^0-9$" + decimal + "]","g"), "");
    strg = strg.replace(',', '.');
    return parseFloat(strg);
}   

Pruébelo aquí: https://plnkr.co/edit/9p5Y6H?p=preview

Ejemplos:

1.234,56 € => 1234.56
1,234.56USD => 1234.56
1,234,567€ => 1234567
1.234.567 => 1234567
1,234.567 => 1234.567
1.234 => 1234 // might be wrong - best guess
1,234 => 1234 // might be wrong - best guess
1.2345 => 1.2345
0,123 => 0.123

La función tiene un punto débil: no es posible adivinar el formato si tiene 1.123 o 1.123, porque dependiendo del formato de la configuración regional, ambos pueden ser una coma o un separador de miles. En este caso especial, la función tratará el separador como un separador de miles y devolverá 1123.

Es desconcertante que hayan incluido un método toLocaleString pero no un método de análisis . Al menos toLocaleString sin argumentos está bien soportado en IE6 +.

Para una solución i18n , se me ocurrió esto:

Primero detecte el separador decimal de la configuración regional del usuario:

var decimalSeparator = 1.1;
decimalSeparator = decimalSeparator.toLocaleString().substring(1, 2);

Luego, normalice el número si hay más de un separador decimal en la Cadena:

var pattern = "([" + decimalSeparator + "])(?=.*\\1)";separator
var formatted = valor.replace(new RegExp(pattern, "g"), "");

Finalmente, elimine todo lo que no sea un número o un separador decimal:

formatted = formatted.replace(new RegExp("[^0-9" + decimalSeparator + "]", "g"), '');
return Number(formatted.replace(decimalSeparator, "."));

Esta es una envoltura simplista y discreta alrededor de la parseFloatfunción.

function parseLocaleNumber(str) {
  // Detect the user's locale decimal separator:
  var decimalSeparator = (1.1).toLocaleString().substring(1, 2);
  // Detect the user's locale thousand separator:
  var thousandSeparator = (1000).toLocaleString().substring(1, 2);
  // In case there are locales that don't use a thousand separator
  if (thousandSeparator.match(/\d/))
    thousandSeparator = '';

  str = str
    .replace(new RegExp(thousandSeparator, 'g'), '')
    .replace(new RegExp(decimalSeparator), '.')

  return parseFloat(str);
}

Si desea evitar el problema que publicó David Meister y está seguro del número de decimales, puede reemplazar todos los puntos y comas y dividir por 100, ej .:

var value = "2,299.00";
var amount = parseFloat(value.replace(/"|\,|\./g, ''))/100;

o si tienes 3 decimales

var value = "2,299.001";
var amount = parseFloat(value.replace(/"|\,|\./g, ''))/1000;

Depende de usted si desea utilizar parseInt, parseFloat o Number. Además, si desea mantener el número de lugares decimales, puede usar la función .toFixed (...).

Todas estas respuestas fallan si tiene un número de millones.

3.456.789 simplemente devolvería 3456 con el método de reemplazo.

La respuesta más correcta para simplemente eliminar las comas tendría que ser.

var number = '3,456,789.12';
number.split(',').join('');
/* number now equips 3456789.12 */
parseFloat(number);

O simplemente escrito.

number = parseFloat(number.split(',').join(''));

Esto convierte un número en cualquier lugar en un número normal. También funciona para puntos decimales:

function numberFromLocaleString(stringValue, locale){
    var parts = Number(1111.11).toLocaleString(locale).replace(/\d+/g,'').split('');
    if (stringValue === null)
        return null;
    if (parts.length==1) {
        parts.unshift('');
    }   
    return Number(String(stringValue).replace(new RegExp(parts[0].replace(/\s/g,' '),'g'), '').replace(parts[1],"."));
}

//Use default browser locale
numberFromLocaleString("1,223,333.567") //1223333.567

//Use specific locale
numberFromLocaleString("1 223 333,567", "ru") //1223333.567

Con esta función podrás formatear valores en múltiples formatos como 1.234,56y 1,234.56, e incluso con errores como 1.234.56y1,234,56

/**
 * @param {string} value: value to convert
 * @param {bool} coerce: force float return or NaN
 */
function parseFloatFromString(value, coerce) {
    value = String(value).trim();

    if ('' === value) {
        return value;
    }

    // check if the string can be converted to float as-is
    var parsed = parseFloat(value);
    if (String(parsed) === value) {
        return fixDecimals(parsed, 2);
    }

    // replace arabic numbers by latin
    value = value
    // arabic
    .replace(/[\u0660-\u0669]/g, function(d) {
        return d.charCodeAt(0) - 1632;
    })

    // persian
    .replace(/[\u06F0-\u06F9]/g, function(d) {
        return d.charCodeAt(0) - 1776;
    });

    // remove all non-digit characters
    var split = value.split(/[^\dE-]+/);

    if (1 === split.length) {
        // there's no decimal part
        return fixDecimals(parseFloat(value), 2);
    }

    for (var i = 0; i < split.length; i++) {
        if ('' === split[i]) {
            return coerce ? fixDecimals(parseFloat(0), 2) : NaN;
        }
    }

    // use the last part as decimal
    var decimal = split.pop();

    // reconstruct the number using dot as decimal separator
    return fixDecimals(parseFloat(split.join('') +  '.' + decimal), 2);
}

function fixDecimals(num, precision) {
    return (Math.floor(num * 100) / 100).toFixed(precision);
}

parseFloatFromString('1.234,56')
"1234.56"
parseFloatFromString('1,234.56')
"1234.56"
parseFloatFromString('1.234.56')
"1234.56"
parseFloatFromString('1,234,56')
"1234.56"

Si quieres una respuesta l10n, hazlo de esta manera. El ejemplo usa moneda, pero no la necesita. La biblioteca de Intl deberá estar rellenada con polimerización si tiene que admitir navegadores más antiguos.

var value = "2,299.00";
var currencyId = "USD";
var nf = new Intl.NumberFormat(undefined, {style:'currency', currency: currencyId, minimumFractionDigits: 2});

value = nf.format(value.replace(/,/g, ""));

Reemplaza la coma con una cadena vacía:

var x = parseFloat("2,299.00".replace(",",""))
alert(x);

Si tiene un pequeño conjunto de configuraciones regionales para admitir, probablemente estaría mejor codificando un par de reglas simples:

function parseNumber(str, locale) {
  let radix = ',';
  if (locale.match(/(en|th)([-_].+)?/)) {
    radix = '.';
  }
  return Number(str
    .replace(new RegExp('[^\\d\\' + radix + ']', 'g'), '')
    .replace(radix, '.'));
}

const parseLocaleNumber = strNum => {
    const decSep = (1.1).toLocaleString().substring(1, 2);
    const formatted = strNum
        .replace(new RegExp(`([${decSep}])(?=.*\\1)`, 'g'), '')
        .replace(new RegExp(`[^0-9${decSep}]`, 'g'), '');
    return Number(formatted.replace(decSep, '.'));
};

Number("2,299.00".split(',').join(''));   // 2299

La función split divide la cadena en una matriz usando "," como separador y devuelve una matriz.
La función de unión une los elementos de la matriz devueltos por la función de división.
La función Number () convierte la cadena unida en un número.