Como posso analisar uma string com um separador de milhar de vírgula para um número?

Eu tenho 2,299.00uma string e estou tentando analisá-la em um número. Tentei usar parseFloat, que resultou em 2. Acho que o problema é a vírgula, mas como resolveria esse problema da maneira certa? Basta remover a vírgula?

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

Sim, remova as vírgulas:

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

Remover vírgulas é potencialmente perigoso porque, como outros mencionaram nos comentários, muitas localidades usam vírgulas para significar algo diferente (como uma casa decimal).

Eu não sei de onde você tirou sua corda, mas em alguns lugares do mundo "2,299.00"=2.299

O Intlobjeto poderia ter sido uma boa maneira de resolver este problema, mas de alguma forma eles conseguiram enviar a especificação com apenas uma Intl.NumberFormat.format()API e nenhuma parsecontraparte :(

A única maneira de analisar uma string com caracteres numéricos culturais em um número reconhecível por máquina de qualquer maneira sã é usar uma biblioteca que aproveita os dados CLDR para cobrir todas as maneiras possíveis de formatar strings numéricas http: //cldr.unicode. org /

As duas melhores opções de JS que encontrei para isso até agora:

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

Em navegadores modernos, você pode usar o Intl.NumberFormat integrado para detectar a formatação de número do navegador e normalizar a entrada para corresponder.

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 há espaço para alguma otimização e armazenamento em cache, mas isso funciona de maneira confiável em todas as linguagens.

Remova tudo o que não seja um dígito, ponto decimal ou sinal de 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);

Violino atualizado

Observe que isso não funciona para números em notação científica. Se você deseja que ele, altere a replacelinha para adicionar e, Ee +para a lista de caracteres aceitáveis:

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

Normalmente, você deve considerar o uso de campos de entrada que não permitem a entrada de texto livre para valores numéricos. Mas pode haver casos em que você precisa adivinhar o formato de entrada. Por exemplo 1.234,56 na Alemanha significa 1.234,56 nos EUA. Consulte https://salesforce.stackexchange.com/a/21404 para obter uma lista de países que usam vírgula como decimal.

Eu uso a seguinte função para fazer uma melhor estimativa e remover todos os caracteres não 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);
}   

Experimente aqui: https://plnkr.co/edit/9p5Y6H?p=preview

Exemplos:

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

A função tem um ponto fraco: não é possível adivinhar o formato se você tiver 1.123 ou 1.123 - porque dependendo do formato do local, ambos podem ser uma vírgula ou um separador de milhares. Neste caso especial, a função tratará o separador como um separador de milhares e retornará 1123.

É desconcertante que incluíram um toLocaleString, mas não um método de análise . Pelo menos toLocaleString sem argumentos é bem suportado no IE6 +.

Para uma solução i18n , pensei nisso:

Primeiro detecte o separador decimal de localidade do usuário:

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

Em seguida, normalize o número se houver mais de um separador decimal na string:

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

Por fim, remova tudo o que não seja um número ou separador decimal:

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

Este é um invólucro simples e discreto em torno da parseFloatfunção.

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

Se você quiser evitar o problema que David Meister postou e tiver certeza do número de casas decimais, pode substituir todos os pontos e vírgulas e dividir por 100, ex .:

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

ou se você tiver 3 casas decimais

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

Você decide se deseja usar parseInt, parseFloat ou Number. Além disso, se você quiser manter o número de casas decimais, pode usar a função .toFixed (...).

Todas essas respostas falharão se você tiver um número na casa dos milhões.

3.456.789 simplesmente retornaria 3456 com o método de substituição.

A resposta mais correta para simplesmente remover as vírgulas teria que ser.

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

Ou simplesmente escrito.

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

Isso converte um número em qualquer local para um número normal. Funciona para pontos decimais também:

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

Com esta função você poderá formatar valores em vários formatos como 1.234,56e 1,234.56, e até mesmo com erros como 1.234.56e1,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"

Se você quer uma resposta l10n, faça desta forma. O exemplo usa moeda, mas você não precisa disso. A biblioteca internacional precisará ser polyfilled se você tiver que oferecer suporte a navegadores mais antigos.

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

Substitua a vírgula por uma string vazia:

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

Se você tiver um pequeno conjunto de localidades para oferecer suporte, provavelmente seria melhor apenas codificar algumas regras 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

A função de divisão divide a string em uma matriz usando "," como separador e retorna uma matriz.
A função de junção junta os elementos da matriz retornada da função de divisão.
A função Number () converte a string associada em um número.