Wie kann ich eine Zeichenfolge mit einem Komma-Tausender-Trennzeichen zu einer Zahl analysieren?

Ich habe 2,299.00als Zeichenfolge und ich versuche, es auf eine Zahl zu analysieren. Ich habe versucht, zu verwenden parseFloat, was zu 2 führt. Ich denke, das Komma ist das Problem, aber wie würde ich dieses Problem richtig lösen? Komma einfach entfernen?

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

Ja, entfernen Sie die Kommas:

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

Das Entfernen von Kommas ist möglicherweise gefährlich, da viele Gebietsschemas, wie andere in den Kommentaren erwähnt haben, ein Komma verwenden, um etwas anderes zu bedeuten (z. B. eine Dezimalstelle).

Ich weiß nicht, woher du deine Saite hast, aber an einigen Orten auf der Welt "2,299.00"=2.299

Das IntlObjekt hätte ein guter Weg sein können, um dieses Problem anzugehen, aber irgendwie gelang es ihnen, die Spezifikation nur mit einer Intl.NumberFormat.format()API und ohne parseGegenstück zu versenden :(

Die einzige Möglichkeit, eine Zeichenfolge mit darin enthaltenen kulturellen numerischen Zeichen auf eine vernünftige Weise in eine maschinenerkennbare Zahl zu analysieren, besteht darin, eine Bibliothek zu verwenden, die CLDR-Daten nutzt, um alle Möglichkeiten zur Formatierung von Zahlenzeichenfolgen abzudecken. Http: //cldr.unicode. org /

Die zwei besten JS-Optionen, die mir bisher begegnet sind:

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

In modernen Browsern können Sie das integrierte Intl.NumberFormat verwenden , um die Zahlenformatierung des Browsers zu erkennen und die Eingabe entsprechend zu normalisieren.

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

Es gibt offensichtlich Raum für Optimierungen und Caching, aber dies funktioniert zuverlässig in allen Sprachen.

Entfernen Sie alles, was keine Ziffer, kein Dezimalpunkt oder Minuszeichen ist ( -):

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

Geige aktualisiert

Beachten Sie, dass es für Zahlen in wissenschaftlicher Notation nicht funktioniert. Wenn Sie es wollen , die ändern replaceZeile hinzufügen e, Eund +auf die Liste der zulässigen Zeichen:

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

Normalerweise sollten Sie Eingabefelder verwenden, die keine Freitexteingabe für numerische Werte zulassen. Es kann jedoch Fälle geben, in denen Sie das Eingabeformat erraten müssen. Zum Beispiel bedeutet 1,234,56 in Deutschland 1.234,56 in den USA. Unter https://salesforce.stackexchange.com/a/21404 finden Sie eine Liste der Länder, die Komma als Dezimalzahl verwenden.

Ich benutze die folgende Funktion, um eine bestmögliche Vermutung anzustellen und alle nicht numerischen Zeichen zu entfernen:

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

Probieren Sie es hier aus: https://plnkr.co/edit/9p5Y6H?p=preview

Beispiele:

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

Die Funktion hat eine Schwachstelle: Es ist nicht möglich, das Format zu erraten, wenn Sie 1.123 oder 1.123 haben - da je nach Gebietsschema-Format beide ein Komma oder ein Tausendertrennzeichen sein können. In diesem speziellen Fall behandelt die Funktion das Trennzeichen als Tausendertrennzeichen und gibt 1123 zurück.

Es ist rätselhaft , dass sie eine inbegriffen toLocaleString aber keine Parse - Methode. Zumindest toLocaleString ohne Argumente wird in IE6 + gut unterstützt.

Für eine i18n- Lösung habe ich Folgendes entwickelt:

Ermitteln Sie zuerst das Dezimaltrennzeichen für das Gebietsschema des Benutzers:

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

Normalisieren Sie dann die Zahl, wenn der String mehr als ein Dezimaltrennzeichen enthält:

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

Entfernen Sie zum Schluss alles, was keine Zahl oder kein Dezimaltrennzeichen ist:

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

Dies ist ein einfacher, unauffälliger Wrapper um die parseFloatFunktion.

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

Wenn Sie das von David Meister gepostete Problem vermeiden möchten und sich über die Anzahl der Dezimalstellen sicher sind, können Sie alle Punkte und Kommas ersetzen und durch 100 teilen, z.

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

oder wenn Sie 3 Dezimalstellen haben

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

Es liegt an Ihnen, ob Sie parseInt, parseFloat oder Number verwenden möchten. Wenn Sie die Anzahl der Dezimalstellen beibehalten möchten, können Sie die Funktion .toFixed (...) verwenden.

Alle diese Antworten schlagen fehl, wenn Sie eine Zahl in Millionenhöhe haben.

3.456.789 würden einfach 3456 mit der Ersetzungsmethode zurückgeben.

Die richtigste Antwort zum einfachen Entfernen der Kommas müsste sein.

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

Oder einfach geschrieben.

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

Dadurch wird eine Nummer in einem beliebigen Gebietsschema in eine normale Nummer konvertiert. Funktioniert auch für Dezimalstellen:

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

Mit dieser Funktion können Sie Werte in verschiedenen Formaten wie 1.234,56und 1,234.56und sogar mit Fehlern wie 1.234.56und formatieren1,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"

Wenn Sie eine l10n-Antwort wünschen, tun Sie dies auf diese Weise. Beispiel verwendet Währung, aber das brauchen Sie nicht. Die internationale Bibliothek muss mehrfach gefüllt sein, wenn Sie ältere Browser unterstützen müssen.

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

Ersetzen Sie das Komma durch eine leere Zeichenfolge:

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

Wenn Sie eine kleine Anzahl von Gebietsschemas unterstützen möchten, sind Sie wahrscheinlich besser dran, wenn Sie nur ein paar einfache Regeln fest codieren:

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

Die Split-Funktion teilt die Zeichenfolge mit "," als Trennzeichen in ein Array auf und gibt ein Array zurück.
Die Join-Funktion verbindet die Elemente des Arrays, die von der Split-Funktion zurückgegeben werden.
Die Funktion Number () konvertiert die verknüpfte Zeichenfolge in eine Zahl.