The d3-format package is part of the D3 (Data-Driven Documents) JavaScript library, which is used for producing graphical visualizations of data primarily on the web. The d3-format module provides a system for formatting numbers for human-readable display, allowing users to specify the appearance of numbers, such as the decimal precision, alignment, padding, rounding, and locale-specific formatting.

What are d3-format's main functionalities?

Number Formatting

This feature allows you to format numbers using a variety of options. The example shows formatting a number to two decimal places.

const d3 = require('d3-format');
const format = d3.format('.2f');
console.log(format(3.14159)); // Outputs: '3.14'

Locale-specific Formatting

This feature supports locale-specific formatting. The example demonstrates formatting a number as currency in a European style, using comma for decimal and period for thousands separator.

const d3 = require('d3-format');
const locale = d3.formatLocale({ decimal: ',', thousands: '.', grouping: [3], currency: ['€', ''] });
const format = locale.format('$,.2f');
console.log(format(1234567.89)); // Outputs: '€1.234.567,89'

SI Prefix Formatting

This feature allows formatting numbers with SI prefixes, useful for representing large or small numbers succinctly. The example formats the number 1500 with an SI prefix, resulting in '1.50k'.

const d3 = require('d3-format');
const format = d3.format('.3s');
console.log(format(1500)); // Outputs: '1.50k'

Other packages similar to d3-format

d3-format

Ever noticed how sometimes JavaScript doesn’t display numbers the way you expect? Like, you tried to print tenths with a simple loop:

for (var i = 0; i < 10; i++) {
  console.log(0.1 * i);
}

And you got this:

0
0.1
0.2
0.30000000000000004
0.4
0.5
0.6000000000000001
0.7000000000000001
0.8
0.9

Welcome to binary floating point! ಠ_ಠ

Yet rounding error is not the only reason to customize number formatting. A table of numbers should be formatted consistently for comparison; above, 0.0 would be better than 0. Large numbers should have grouped digits (e.g., 42,000) or be in scientific or metric notation (4.2e+4, 42k). Currencies should have fixed precision ($3.50). Reported numerical results should be rounded to significant digits (4021 becomes 4000). Number formats should appropriate to the reader’s locale (42.000,00 or 42,000.00). The list goes on.

Formatting numbers for human consumption is the purpose of d3-format, which is modeled after Python 3’s format specification mini-language (PEP 3101). Revisiting the example above:

var f = d3_format.format(".1f");
for (var i = 0; i < 10; i++) {
  console.log(f(0.1 * i));
}

Now you get this:

0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9

But d3-format is much more than an alias for number.toFixed! A few more examples:

d3_format.format(".0%")(0.123);  // rounded percentage, "12%"
d3_format.format("($.2f")(-3.5); // localized fixed-point currency, "(£3.50)"
d3_format.format("+20")(42);     // space-filled and signed, "                 +42"
d3_format.format(".^20")(42);    // dot-filled and centered, ".........42........."
d3_format.format(".2s")(42e6);   // SI-prefix with two significant digits, "42M"
d3_format.format("#x")(48879);   // prefixed lowercase hexadecimal, "0xbeef"
d3_format.format(",.2r")(4223);  // grouped thousands with two significant digits, "4,200"

See locale.format for a detailed specification, and try running formatSpecifier on the above formats to decode their meaning.

Installing

If you use NPM, npm install d3-format. Otherwise, download the latest release. The released bundle supports AMD, CommonJS, and vanilla environments. Create a custom build using Rollup or your preferred bundler. You can also load directly from d3js.org:

<script src="https://d3js.org/d3-format.v0.4.min.js"></script>

In a vanilla environment, a d3_format global is exported. Try d3-format in your browser.

API Reference

# d3_format.format(specifier)

An alias for locale.format on the U.S. English locale. See the other locales, or use locale to define a new locale.

# d3_format.formatPrefix(specifier, value)

An alias for locale.formatPrefix on the U.S. English locale. See the other locales, or use locale to define a new locale.

# locale.format(specifier)

Returns a new format function for the given string specifier. The returned function takes a number as the only argument, and returns a string representing the formatted number. The general form of a specifier is:

[[fill]align][sign][symbol][0][width][,][.precision][type]

The fill can be any character. The presence of a fill character is signaled by the align character following it, which must be one of the following:

> - Forces the field to be right-aligned within the available space. (Default behavior).
< - Forces the field to be left-aligned within the available space.
^ - Forces the field to be centered within the available space.
= - like >, but with any sign and symbol to the left of any padding.

The sign can be:

- - nothing for positive and a minus sign for negative. (Default behavior.)
+ - a plus sign for positive and a minus sign for negative.
( - nothing for positive and parentheses for negative.
(space) - a space for positive and a minus sign for negative.

The symbol can be:

$ - apply currency symbols per the locale definition.
# - for binary, octal, or hexadecimal notation, prefix by 0b, 0o, or 0x, respectively.

The zero (0) option enables zero-padding; this implicitly sets fill to 0 and align to =. The width defines the minimum field width; if not specified, then the width will be determined by the content. The comma (,) option enables the use of a group separator, such as a comma for thousands.

Depending on the type, the precision either indicates the number of digits that follow the decimal point (types f and %), or the number of significant digits (types , e, g, r, s and p). If the precision is not specified, it defaults to 6 for all types except (none), which defaults to 12. Precision is ignored for integer formats (types b, o, d, x, X and c). See precisionFixed and precisionRound for help picking an appropriate precision.

The available type values are:

e - exponent notation.
f - fixed point notation.
g - either decimal or exponent notation, rounded to significant digits.
r - decimal notation, rounded to significant digits.
s - decimal notation with an SI prefix, 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, rounded to integer.
o - octal notation, rounded to integer.
d - decimal notation, rounded to integer.
x - hexadecimal notation, using lower-case letters, rounded to integer.
X - hexadecimal notation, using upper-case letters, rounded to integer.
c - converts the integer to the corresponding unicode character before printing.
(none) - like g, but trim insignificant trailing zeros.

The type n is also supported as shorthand for ,g. For the g, n and (none) types, decimal notation is used if the resulting string would have precision or fewer digits; otherwise, exponent notation is used. For example:

d3_format.format(".2")(42);  // "42"
d3_format.format(".2")(4.2); // "4.2"
d3_format.format(".1")(42);  // "4e+1"
d3_format.format(".1")(4.2); // "4"

# locale.formatPrefix(specifier, value)

Equivalent to locale.format, except the returned function will convert values to the units of the appropriate SI prefix for the specified numeric reference value before formatting in fixed point notation. The following prefixes are supported:

y - yocto, 10⁻²⁴
z - zepto, 10⁻²¹
a - atto, 10⁻¹⁸
f - femto, 10⁻¹⁵
p - pico, 10⁻¹²
n - nano, 10⁻⁹
µ - micro, 10⁻⁶
m - milli, 10⁻³
(none) - 10⁰
k - kilo, 10³
M - mega, 10⁶
G - giga, 10⁹
T - tera, 10¹²
P - peta, 10¹⁵
E - exa, 10¹⁸
Z - zetta, 10²¹
Y - yotta, 10²⁴

Unlike locale.format with the s format type, this method returns a formatter with a consistent SI prefix, rather than computing the prefix dynamically for each number. In addition, the precision for the given specifier represents the number of digits past the decimal point (as with f fixed point notation), not the number of significant digits. For example:

var f = d3_format.formatPrefix(",.0", 1e-6);
f(0.00042); // "420µ"
f(0.0042); // "4,200µ"

This method is useful when formatting multiple numbers in the same units for easy comparison. See precisionPrefix for help picking an appropriate precision, and bl.ocks.org/9764126 for an example.

# d3_format.formatSpecifier(specifier)

Parses the specified specifier, returning an object with exposed fields that correspond to the format specification mini-language and a toString method that reconstructs the specifier. For example, formatSpecifier("s") returns:

{
  "fill": " ",
  "align": ">",
  "sign": "-",
  "symbol": "",
  "zero": false,
  "width": undefined,
  "comma": false,
  "precision": 6,
  "type": "s"
}

This method is useful for understanding how format specifiers are parsed and for deriving new specifiers. For example, you might compute an appropriate precision based on the numbers you want to format using precisionFixed and then create a new format:

var s = d3_format.formatSpecifier("f");
s.precision = precisionFixed(0.01);
var f = d3_format.format(s);
f(42); // "42.00";

# d3_format.precisionFixed(step)

Returns a suggested decimal precision for fixed point notation given the specified numeric step value. The step represents the minimum absolute difference between values that will be formatted. (This assumes that the values to be formatted are also multiples of step.) For example, given the numbers 1, 1.5, and 2, the step should be 0.5 and the suggested precision is 1:

var p = d3_format.precisionFixed(0.5),
    f = d3_format.format("." + p + "f");
f(1);   // "1.0"
f(1.5); // "1.5"
f(2);   // "2.0"

Whereas for the numbers 1, 2 and 3, the step should be 1 and the suggested precision is 0:

var p = d3_format.precisionFixed(1),
    f = d3_format.format("." + p + "f");
f(1); // "1"
f(2); // "2"
f(3); // "3"

Note: for the % format type, subtract two:

var p = Math.max(0, d3_format.precisionFixed(0.05) - 2),
    f = d3_format.format("." + p + "%");
f(0.45); // "45%"
f(0.50); // "50%"
f(0.55); // "55%"

# d3_format.precisionPrefix(step, value)

Returns a suggested decimal precision for use with locale.formatPrefix given the specified numeric step and reference value. The step represents the minimum absolute difference between values that will be formatted, and value determines which SI prefix will be used. (This assumes that the values to be formatted are also multiples of step.) For example, given the numbers 1.1e6, 1.2e6, and 1.3e6, the step should be 1e5, the value could be 1.3e6, and the suggested precision is 1:

var p = d3_format.precisionPrefix(1e5, 1.3e6),
    f = d3_format.formatPrefix("." + p, 1.3e6);
f(1.1e6); // "1.1M"
f(1.2e6); // "1.2M"
f(1.3e6); // "1.3M"

# d3_format.precisionRound(step, max)

Returns a suggested decimal precision for format types that round to significant digits given the specified numeric step and max values. The step represents the minimum absolute difference between values that will be formatted, and the max represents the largest absolute value that will be formatted. (This assumes that the values to be formatted are also multiples of step.) For example, given the numbers 0.99, 1.0, and 1.01, the step should be 0.01, the max should be 1.01, and the suggested precision is 3:

var p = d3_format.precisionRound(0.01, 1.01),
    f = d3_format.format("." + p + "r");
f(0.99); // "0.990"
f(1.0);  // "1.00"
f(1.01); // "1.01"

Whereas for the numbers 0.9, 1.0, and 1.1, the step should be 0.1, the max should be 1.1, and the suggested precision is 2:

var p = d3_format.precisionRound(0.1, 1.1),
    f = d3_format.format("." + p + "r");
f(0.9); // "0.90"
f(1.0); // "1.0"
f(1.1); // "1.1"

Note: for the e format type, subtract one:

var p = Math.max(0, d3_format.precisionRound(0.01, 1.01) - 1),
    f = d3_format.format("." + p + "e");
f(0.01); // "1.00e-2"
f(1.01); // "1.01e+0"

Locales

# d3_format.locale(definition)

Returns a locale object for the specified definition with locale.format and locale.formatPrefix methods. The definition must include the following properties:

decimal - the decimal point (e.g., ".").
thousands - the group separator (e.g., ",").
grouping - the array of group sizes (e.g., [3]), cycled as needed.
currency - the currency prefix and suffix (e.g., ["$", ""]).

Note that the thousands property is a misnomer, as the grouping definition allows groups other than thousands.

# d3_format.localeCaEs

Catalan (Spain)

# d3_format.localeCsCz

Czech (Czech Republic)

# d3_format.localeDeCh

German (Switzerland)

# d3_format.localeDeDe

German (Germany)

# d3_format.localeEnCa

English (Canada)

# d3_format.localeEnGb

English (United Kingdom)

# d3_format.localeEnUs

English (United States)

# d3_format.localeEsEs

Spanish (Spain)

# d3_format.localeFiFi

Finnish (Finland)

# d3_format.localeFrCa

French (Canada)

# d3_format.localeFrFr

French (France)

# d3_format.localeHeIl

Hebrew (Israel)

# d3_format.localeHuHu

Hungarian (Hungary)

# d3_format.localeItIt

Italian (Italy)

# d3_format.localeJaJp

Japanese (Japan)

# d3_format.localeKoKr

Korean (South Korea)

# d3_format.localeMkMk

Macedonian (Macedonia)

# d3_format.localeNlNl

Dutch (Netherlands)

# d3_format.localePlPl

Polish (Poland)

# d3_format.localePtBr

Portuguese (Brazil)

# d3_format.localeRuRu

Russian (Russia)

# d3_format.localeSvSe

Swedish (Sweden)

# d3_format.localeZhCn

Chinese (China)

Keywords

FAQs

What is d3-format?

Is d3-format popular?

Is d3-format well maintained?

Package last updated on 29 Dec 2015

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install