Javascript Séparateur de Milliers / format de chaîne de caractères

Mise à jour (7 ans plus tard)

La référence citée dans la réponse originale à cette question ci-dessous a été mauvais. Il y est un construit en fonction de ce qui est exactement ce que kaiser suggère ci-dessous: toLocaleString

De sorte que vous pouvez faire:

(1234567.89).toLocaleString('en')              //for numeric input
parseFloat("1234567.89").toLocaleString('en')  //for string input

La fonction de mise en œuvre ci-dessous fonctionne, mais n'est tout simplement pas nécessaire.

(J'ai pensé que je pourrais avoir de la chance et de trouver qu'il était nécessaire en 2010, mais non. Selon cette plus fiable de référence, toLocaleString a fait partie de la norme depuis ECMAScript 3e Édition [1999], qui, je crois, signifie qu'il aurait été pris en charge dès IE 5.5.)

---

Réponse Originale À Cette Question

Selon cette référence il n'y a pas une fonction intégrée pour l'ajout de virgules pour un certain nombre. Mais cette page contient un exemple de la façon de coder vous-même:

function addCommas(nStr) {
    nStr += '';
    var x = nStr.split('.');
    var x1 = x[0];
    var x2 = x.length > 1 ? '.' + x[1] : '';
    var rgx = /(\d+)(\d{3})/;
    while (rgx.test(x1)) {
            x1 = x1.replace(rgx, '$1' + ',' + '$2');
    }
    return x1 + x2;
}

Edit:
Aller dans l'autre sens (convertir en chaîne de caractères avec des virgules pour le nombre), vous pourriez faire quelque chose comme ceci:

parseFloat("1,234,567.89".replace(/,/g,''))

Mis à jour à l'aide de look-derrière soutien en ligne avec ECMAScript2018 changements.

Pour la compatibilité ascendante, faites défiler jusqu'en bas de page pour voir la solution d'origine.

Une expression régulière peut être utilisé notamment utile dans le traitement de grands nombres stockés en tant que chaînes de caractères.

JS:

const format = num => 
    String(num).replace(/(?<!\..*)(\d)(?=(?:\d{3})+(?:\.|$))/g, '$1,')

;[
    format(100),                           //"100"
    format(1000),                          //"1,000"
    format(1e10),                          //"10,000,000,000"  
    format(1000.001001),                   //"1,000.001001"
    format('100000000000000.001001001001') //"100,000,000,000,000.001001001001
]
    .forEach(n => console.log(n))

» Verbose regex explication (regex101.com)

---

Cette réponse originale à cette question peut ne pas être nécessaire, mais peut être utilisé pour assurer la compatibilité ascendante.

De tenter de traiter cela avec une seule expression régulière (sans rappel) ma capacité actuelle ne parvient pas à moi pour le manque d'un négatif look-derrière en Javascript... jamais le moins, voici un autre concis alternative qui fonctionne dans la plupart des cas généraux de la comptabilité - pour tout point décimal, en ignorant les matchs où l'indice de la correspondance apparaît après l'indice d'une période.

JS:

const format = num => {
    const n = String(num),
          p = n.indexOf('.')
    return n.replace(
        /\d(?=(?:\d{3})+(?:\.|$))/g,
        (m, i) => p < 0 || i < p ? `${m},` : m
    )
}

;[
    format(100),                           //"100"
    format(1000),                          //"1,000"
    format(1e10),                          //"10,000,000,000"  
    format(1000.001001),                   //"1,000.001001"
    format('100000000000000.001001001001') //"100,000,000,000,000.001001001001
]
    .forEach(n => console.log(n))

» Verbose regex explication (regex101.com)

//thousand separates a digit-only string using commas
//by element:  onkeyup = "ThousandSeparate(this)"
//by ID:       onkeyup = "ThousandSeparate('txt1','lbl1')"
function ThousandSeparate()
{
    if (arguments.length == 1)
    {
        var V = arguments[0].value;
        V = V.replace(/,/g,'');
        var R = new RegExp('(-?[0-9]+)([0-9]{3})'); 
        while(R.test(V))
        {
            V = V.replace(R, '$1,$2');
        }
        arguments[0].value = V;
    }
    else  if ( arguments.length == 2)
    {
        var V = document.getElementById(arguments[0]).value;
        var R = new RegExp('(-?[0-9]+)([0-9]{3})'); 
        while(R.test(V))
        {
            V = V.replace(R, '$1,$2');
        }
        document.getElementById(arguments[1]).innerHTML = V;
    }
    else return false;
}   

var number = 35002343;

console.log(number.toLocaleString());

pour la référence, vous pouvez vérifier ici
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString

number = 123456.7089;
result = parseInt( number ).toLocaleString() + "<br>";
result = number.toLocaleString( 'pt-BR' ) + "<br>";

var el = document.getElementById( 'result' );
el.innerHTML = result;

<div id="result"></div>

Tout ce que vous devez faire est de simplement vraiment cette:

123000.9123.toLocaleString()
//result will be "123,000.912"

Je n'aime pas les réponses ici, j'ai donc créé une fonction qui a fonctionné pour moi. Juste envie de partager au cas où quelqu'un d'autre le trouve utile.

function getFormattedCurrency(num) {
    num = num.toFixed(2)
    var cents = (num - Math.floor(num)).toFixed(2);
    return Math.floor(num).toLocaleString() + '.' + cents.split('.')[1];
}