1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

String.prototype.reverse = function() {
  var s = "";
  for (i = this.length; i > 0; i--) { s += this.substring(i-1,i); }
  return s;
}
  
function thousands(num, decpoint, sep) {
  if (arguments.length < 3) { sep = ","; }
  if (arguments.length < 2) { decpoint = "."; }

  x = "";
  parts = num.toString().split(decpoint);
  int_part = parts[0];
  dec_part = parts[1];

  if (typeof(int_part) != "undefined") {
    x = int_part.reverse().replace(/(\d{3})/g, "$1" + sep).reverse();

    // remove extra separator?
    if (x.slice(0, sep.length) == sep) { x = x.slice(sep.length, x.length); }

    // recombine the parts
    if (typeof(dec_part) != "undefined" && dec_part.length > 0) { x += decpoint + dec_part; }
  }
  	
  return x;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//This reverse is much, much faster
String.prototype.reverse = function(){
   return this.split("").reverse().join("");
}

//This function gets even shorter if you don't bother with configurable seperators
function thousands(num, decpoint, sep){
  if (arguments.length < 3) { sep = ","; }
  if (arguments.length < 2) { decpoint = "."; }

  // this requires strong regex-fu:
  // match( an optional list of numbers up to a period, 
  //  followed by some number of groups of 1-3 numbers,
  //  followed by an option minus sign 
  var regex = new RegExp("(?:\\d*\\" + decpoint + ")?\\d{1,3}-?", "g");

  return num.toString().reverse().
    match(regex).
    join(sep).reverse();
}

1
2
3
4
5
6
7
8
9
10
11
12

function thousands(num, decpoint, sep) {
  decpoint = decpoint || ".";
  sep = sep || ",";
 
  var i = num.indexOf(decpoint);
  if (i < 0) { i = num.length; }
  do {
    i -= 3;
    num = num.substr(0, i) + sep + num.substr(i);
  } while (i > 3);
  return num;
}