Adding thousand separators to numbers in your documents, data, and program output is a simple but effective way to improve their readability and appearance.

Some of the programming languages covered by this book provide built-in methods to add locale-aware thousand separators to numbers. For instance, in Python you can use locale.format('%d', 1000000, True) to convert the number 1000000 to the string '1,000,000', assuming you’ve previously set your program to use a locale that uses commas as the thousand separator. For other locales, the number might be separated using dots, underscores, apostrophes, or spaces.

However, locale-aware processing is not always available, reliable, or appropriate. In the finance world, for example, using commas as thousand separators is the norm, regardless of location. Internationalization might not be a relevant issue to begin with when working in a text editor rather than programming. For these reasons, and for simplicity, in this recipe we’ve assumed you always want to use commas as the thousand separator. In the upcoming section, we’ve also assumed you want to use dots as decimal points. If you need to use other characters, feel free to swap them in.

This regular expression matches any single digit that has digits on the right in exact sets of three. It therefore matches twice in the string 12345678, finding the digits 2 and 5. All the other digits are not followed by an exact multiple of three digits.

The accompanying replacement text puts back the matched digit using backreference zero (the entire match), and follows it with a comma. That leaves us with 12,345,678. Voilà!

To explain how the regex determines which digits to match, we’ll split it into two parts. The first part is the leading character class ‹[0-9]› that matches any single digit. The second part is the positive lookahead ‹(?=(?:[0-9]{3})+(?![0-9]))› that causes the match attempt to fail unless it’s at a position followed by digits in exact sets of three. In other words, the lookahead ensures that the regex matches only the digits that should be followed by a comma. Recipe 2.16 explains how lookahead works.

The ‹(?:[0-9]{3})+› within the lookahead matches digits in sets of three. The negative lookahead ‹(?![0-9])› that follows is there to ensure that no digits come immediately after the digits we matched in sets of three. Otherwise, the outer positive lookahead would be satisfied by any number of following digits, so long as there were at least three.

This adaptation of the previous regex doesn’t match any digits at all. Instead, it matches only the positions where we want to insert commas within numbers. These positions are wherever there are digits on the right in exact sets of three, and at least one digit on the left.

The lookahead used to search for sets of exactly three digits on the right is the same as in the last regex. The difference here is that, instead of starting the regex with ‹[0-9]› to match a digit, we instead assert that there is at least one digit to the left by using the positive lookbehind ‹(?<=[0-9])›. Without the lookbehind, the regex would match the position to the left of 123 and therefore the search-and-replace would convert it to ,100. Lookbehind is explained together with lookahead in Recipe 2.16.

JavaScript and Ruby 1.8 don’t support lookbehind, so they cannot use this version of the regular expression.

The preceding regexes add commas to any sequence of four or more digits. A rather glaring issue with this basic approach is that it can add commas to digits that come after a dot as the decimal separator, so long as there are at least four digits after the dot. Following are two ways to fix this.

[0-9](?=(?:[0-9]{3})+(?![0-9]))(?<!\.[0-9]+)

[0-9](?=(?:[0-9]{3})+(?![0-9]))(?<!\.[0-9]{1,100})

$0,

\b(?<!\.)[0-9]{4,}

subject.gsub(/\b(?<!\.)[0-9]{4,}/) {|match|
    match.gsub(/[0-9](?=(?:[0-9]{3})+(?![0-9]))/, '\0,')
}

subject.replace(/(^|[^0-9.])([0-9]{4,})/g, function($0, $1, $2) {
    return $1 + $2.replace(/[0-9](?=(?:[0-9]{3})+(?![0-9]))/g, "$&,");
});