Where in your code do you handle localization?

For example Germany uses comma as the decimal separator and dot as the thousands separator. Especially in a web application, this is an important point to acknowledge.

Coincidentially, the Booking.com dev blog has an article about this.

Hi K, I took your comment that this is difficult with regex as a challenge. As I do not speak any Javascript, I have no idea whether my little code can be translated, so it will most likely not fit your purpose. I found it more difficult than expected, especially when trying to add variables for the separators. So here is my piece, not to be taken as a competitor to yours:

use strict;
use warnings;

sub fmthd { # number, decimal separator, thousands separator
  my ( $dec, $thd ) = ( $_[1] // ".", $_[2] // "," );
  my ( $n, $d ) = split /\Q$dec\E/, shift;
  my $s = $n<0?"-":"";
  $n = reverse $n;
  return $s.reverse( $n = join $thd, $n =~ /(\d{1,3})/g ).($d?"$dec$d"
+:"${dec}00");
}

print fmthd( 1234567.14 ), "\n";
print fmthd( 1234567 ), "\n";
print fmthd( 12.14 ), "\n";
print fmthd( 123456.14343 ), "\n";
print fmthd( 1234567.14 ), "\n";
print fmthd( 8881234567.14 ), "\n";
print fmthd( -8881234567.14 ), "\n";
print fmthd( "-8881234567,14", ",", "." ), "\n";
[download]

One comment though: your Perl code seems to lose the minus sign for negative numbers.

Thx

This snippet is anyway only thought as a base. It needs to be customized for your requirements. I found this solution nice because it is short and easy to understand (and to debug!). Accordingly you can easily add features in JavaScript or PERL without ending up with a code monster. I use the same principle for example to format the IBAN account number (a financial standard to identify an account made of 12 to 34 alphanumeric characters) for display purposes.

As I searched the net I found a lot of solutions with regexp especially in the area of JavaScript. Things like /\B(?=(\d{3})+(?!\d))/'/g, if it may inspire you. I tried two or three of them and gave up because they did not work.

An expert in C would also tell you, there is a solution with the printf function family. Not being an expert, I could not find a format mask allowing for any number size (in fact it takes more time to read the man page than to write this).

Effectively this code is loosing the signs. It was designed to format amounts for a banking application. In this application the amounts are always positive. So I did not have the issue.

K

The best medicine against depression is a cold beer!

A couple of alternatives, just catering for positive integers, that don't use regular expressions.

$ perl -Mstrict -Mwarnings -E '
say
   join q{,},
   reverse
   map scalar reverse,
   unpack q{(a3)*}, scalar reverse
   for qw{
      1
      12
      123
      1234
      12345
      123456
      1234567
      12345678
      123456789
      1234567890
      };'
1
12
123
1,234
12,345
123,456
1,234,567
12,345,678
123,456,789
1,234,567,890
$
[download]

$ perl -Mstrict -Mwarnings -E '               
say sub {                              
   my $v = shift;
   return $v if length $v < 4;
   my $o = 0;
   substr $v, $_, 0, q{,} for
      reverse map { $o -= 3 } 1 .. int( ( length( $v ) - 1 ) / 3 );
   return $v;
   }->( $_ ) for qw{
      1
      12
      123
      1234
      12345
      123456
      1234567
      12345678
      123456789
      1234567890
      };'
1
12
123
1,234
12,345
123,456
1,234,567
12,345,678
123,456,789
1,234,567,890
$
[download]

There are several solutions in this thread.

perldoc -q commas
[download]

If you are so concerned about performance I guess you do know exactly how much memory does Number::Format add, right? And you know how does your apparently inefficient code fare against regexp based solutions. Right? You've benchmarked, right? And you found out formatting numbers made a difference, right?

If your rates are so high I want to believe you did not waste time. I don't though.

my $sep    = ',';
my $number = '12345678.27';

print MakeThousands($number), "\n";

sub MakeThousands {
  local $_ = reverse(shift());
  s/(\d{3})(?=\d)(?!\d*\.)/$1$sep/go;
  return scalar(reverse());
}
[download]

Benchmark: timing 5000000 iterations of MakeThousands, Thousandformat.
+..
MakeThousands: -1 wallclock secs ( 0.06 usr +  0.00 sys =  0.06 CPU) @
+ 83333333.33/s (n=5000000)
Thousandformat:  1 wallclock secs ( 0.12 usr +  0.00 sys =  0.12 CPU) 
+@ 41666666.67/s (n=5000000)
[download]

This regex from Benjamin Goldberg will add commas to numbers:

s/(^[-+]?\d+?(?=(?>(?:\d{3})+)(?!\d))|\G\d{3}(?=\d))/$1,/g;
[download]

It is easier to see with comments:

s/(
   ^[-+]?            # beginning of number.
   \d+?              # first digits before first comma
   (?=               # followed by, (but not included in the match) :
      (?>(?:\d{3})+) # some positive multiple of three digits.
      (?!\d)         # an *exact* multiple, not x * 3 + 1 or whatever.
   )
   |                 # or:
   \G\d{3}           # after the last group, get three digits
   (?=\d)            # but they have to have more digits after them.
)/$1,/xg;
[download]