Type 'c' is now for character data.

Also, rather than the weird behavior where integer types return the empty string
for non-integers, just round the input to an integer.

Author: mbostock

README.md

@@ -114,16 +114,16 @@ The available *type* values are:
 
 * `e` - exponent notation.
 * `f` - fixed point notation.
-* `g` - round to significant digits, and then either decimal or exponent notation.
-* `r` - round to significant digits, and then decimal notation.
-* `s` - round to significant digits, and then decimal notation with an [SI prefix](#locale_formatPrefix).
+* `g` - either decimal or exponent notation, rounded to significant digits.
+* `r` - decimal notation, rounded to significant digits.
+* `s` - decimal notation with an [SI prefix](#locale_formatPrefix), rounded to significant digits.
 * `%` - multiply by 100, and then decimal notation with a percent sign.
 * `p` - multiply by 100, round to significant digits, and then decimal notation with a percent sign.
-* `b` - binary notation; ignores non-integers.
-* `o` - octal notation; ignores non-integers.
-* `d` - decimal notation; ignores non-integers.
-* `x` - hexadecimal notation, using lower-case letters; ignores non-integers.
-* `X` - hexadecimal notation, using upper-case letters; ignores non-integers.
+* `b` - binary notation, rounded to integer (ignores precision).
+* `o` - octal notation, rounded to integer (ignores precision).
+* `d` - decimal notation, rounded to integer (ignores precision).
+* `x` - hexadecimal notation, using lower-case letters, rounded to integer (ignores precision).
+* `X` - hexadecimal notation, using upper-case letters, rounded to integer (ignores precision).
 * `c` - converts the integer to the corresponding unicode character before printing.
 * `​` (none) - like `g`, but trim insignificant trailing zeros.
 

src/formatTypes.js

@@ -5,16 +5,16 @@ import formatRounded from "./formatRounded";
 export default {
   "": formatDefault,
   "%": function(x, p) { return (x * 100).toFixed(p); },
-  "b": function(x) { return x.toString(2); },
-  "c": function(x) { return String.fromCharCode(x); },
-  "d": function(x) { return x.toString(10); },
+  "b": function(x) { return Math.round(x).toString(2); },
+  "c": function(x) { return x + ""; },
+  "d": function(x) { return Math.round(x).toString(10); },
   "e": function(x, p) { return x.toExponential(p); },
   "f": function(x, p) { return x.toFixed(p); },
   "g": function(x, p) { return x.toPrecision(p); },
-  "o": function(x) { return x.toString(8); },
+  "o": function(x) { return Math.round(x).toString(8); },
   "p": function(x, p) { return formatRounded(x * 100, p); },
   "r": formatRounded,
   "s": formatPrefixAuto,
-  "X": function(x) { return x.toString(16).toUpperCase(); },
-  "x": function(x) { return x.toString(16); }
+  "X": function(x) { return Math.round(x).toString(16).toUpperCase(); },
+  "x": function(x) { return Math.round(x).toString(16); }
 };

src/localeFormat.js

@@ -37,7 +37,6 @@ export default function(locale) {
     // Is this an integer type?
     // Can this type generate exponential notation?
     var formatType = formatTypes[type],
-        integer = /[bcdoxX]/.test(type),
         maybeSuffix = !type || /[defgprs%]/.test(type);
 
     // Set the default precision if not specified,
@@ -49,31 +48,36 @@ export default function(locale) {
         : Math.max(0, Math.min(20, precision));
 
     return function(value) {
-      value = +value;
-
-      // Return the empty string for floats formatted as ints.
-      if (integer && (value % 1)) return "";
-
-      // Convert negative to positive, and compute the prefix.
-      // Note that -0 is not less than 0, but 1 / -0 is!
-      var valueNegative = (value < 0 || 1 / value < 0) && (value *= -1, true),
-          valuePrefix = (valueNegative ? (sign === "(" ? sign : "-") : sign === "-" || sign === "(" ? "" : sign) + prefix;
-
-      // Perform the initial formatting.
-      value = formatType(value, precision);
-
-      // Compute the suffix.
-      var valueSuffix = suffix + (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + (valueNegative && sign === "(" ? ")" : "");
-
-      // Break the formatted value into the integer “value” part that can be
-      // grouped, and fractional or exponential “suffix” part that is not.
-      if (maybeSuffix) {
-        var i = -1, n = value.length, c;
-        while (++i < n) {
-          if (c = value.charCodeAt(i), 48 > c || c > 57) {
-            valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;
-            value = value.slice(0, i);
-            break;
+      var valuePrefix = prefix,
+          valueSuffix = suffix;
+
+      if (type === "c") {
+        valueSuffix = formatType(value) + valueSuffix;
+        value = "";
+      } else {
+        value = +value;
+
+        // Convert negative to positive, and compute the prefix.
+        // Note that -0 is not less than 0, but 1 / -0 is!
+        var valueNegative = (value < 0 || 1 / value < 0) && (value *= -1, true);
+
+        // Perform the initial formatting.
+        value = formatType(value, precision);
+
+        // Compute the prefix and suffix.
+        valuePrefix = (valueNegative ? (sign === "(" ? sign : "-") : sign === "-" || sign === "(" ? "" : sign) + valuePrefix;
+        valueSuffix = valueSuffix + (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + (valueNegative && sign === "(" ? ")" : "");
+
+        // Break the formatted value into the integer “value” part that can be
+        // grouped, and fractional or exponential “suffix” part that is not.
+        if (maybeSuffix) {
+          var i = -1, n = value.length, c;
+          while (++i < n) {
+            if (c = value.charCodeAt(i), 48 > c || c > 57) {
+              valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;
+              value = value.slice(0, i);
+              break;
+            }
           }
         }
       }

test/format-type-c-test.js

@@ -2,11 +2,14 @@ var tape = require("tape"),
     format = require("../");
 
 tape("format(\"c\") unicode character", function(test) {
-  test.equal(format.format("c")(9731), "☃");
+  test.equal(format.format("c")("☃"), "☃");
+  test.equal(format.format("020c")("☃"),  "0000000000000000000☃");
+  test.equal(format.format(" ^20c")("☃"), "         ☃          ");
+  test.equal(format.format("$c")("☃"), "$☃");
   test.end();
 });
 
 tape("format(\"c\") does not localize a decimal point", function(test) {
-  test.equal(format.localeFormat({decimal: "/"}).format("c")(46), ".");
+  test.equal(format.localeFormat({decimal: "/"}).format("c")("."), ".");
   test.end();
 });