This is very much a work-in-progress. I'm actively soliciting feedback. What immediately follows are points for discussion.

If you are looking for the documentation proper, skip to:

"printf: prints formatted output"

and

"Colors"

below.

This is very much a work-in-progress. I'm actively soliciting feedback.

• What useful features are available in other languages apart from Golang and C?

• behaviour of %v verb. In Golang, this is a shortcut verb to "print the default format" of the argument. It is currently implemented to format using toString in the default case and inspect if the %#v alternative format flag is used in the format directive. Alternatively, %V could be used to distinguish the two.

  inspect output is not defined, however. This may be problematic if using this code on other platforms (and expecting interoperability). To my knowledge, no suitable specification of object representation aside from JSON and toString exist. ( Aside: see "Common object formats" in the "Console Living Standard" which basically says "do whatever" )

• %j verb. This is an extension particular to this implementation. Currently not very sophisticated, it just runs JSON.stringify on the argument. Consider possible modifier flags, etc.

• < verb. This is an extension that assumes the argument is an array and will format each element according to the format (surrounded by [] and separated by comma) (< Mnemonic: pull each element out of array)

• how to deal with more newfangled JavaScript features (generic Iterables, Map and Set types, typed Arrays, ...)

• the implementation is fairly rough around the edges:

• currently contains little in the way of checking for correctness. Conceivably, there will be a 'strict' form, e.g. that ensures only Number-ish arguments are passed to %f flags.

• assembles output using string concatenation instead of utilizing buffers or other optimizations. It would be nice to have printf / sprintf / fprintf (etc) all in one.

• float formatting is handled by toString() and to toExponential along with a mess of Regexp. Would be nice to use fancy match.

• some flags that are potentially applicable ( POSIX long and unsigned modifiers are not likely useful) are missing, namely %q (print quoted), %U (unicode format)

sprintf converts and formats a variable number of arguments as is specified by a format string. In it's basic form, a format string may just be a literal. In case arguments are meant to be formatted, a directive is contained in the format string, preceded by a '%' character:

%<verb>

E.g. the verb s indicates the directive should be replaced by the string representation of the argument in the corresponding position of the argument list. E.g.:

Hello %s!

applied to the arguments "World" yields "Hello World!".

The meaning of the format string is modelled after POSIX format strings as well as well as Golang format strings. Both contain elements specific to the respective programming language that don't apply to JavaScript, so they can not be fully supported. Furthermore we implement some functionality that is specific to JS.

The following verbs are supported:

Verbs may be modified by providing them with width and precision, either or both may be omitted:

%9f    width 9, default precision
%.9f   default width, precision 9
%8.9f  width 8, precision 9
%8.f   width 9, precision 0

In general, 'width' describes the minimum length of the output, while 'precision' limits the output.

Numerical values for width and precision can be substituted for the * char, in which case the values are obtained from the next args, e.g.:

sprintf("%*.*f", 9, 8, 456.0)

is equivalent to:

sprintf("%9.8f", 456.0)

The effects of the verb may be further influenced by using flags to modify the directive:

The default format used by %v is the result of calling toString() on the relevant argument. If the # flags is used, the result of calling inspect() is interpolated. In this case, the precision, if set is passed to inspect() as the 'depth' config parameter.

Arguments do not need to be consumed in the order they are provided and may be consumed more than once. E.g.:

sprintf("%[2]s %[1]s", "World", "Hello")

returns "Hello World". The presence of a positional indicator resets the arg counter allowing args to be reused:

sprintf("dec[%d]=%d hex[%[1]d]=%x oct[%[1]d]=%#o %s", 1, 255, "Third")

returns dec[1]=255 hex[1]=0xff oct[1]=0377 Third

Width and precision my also use positionals:

"%[2]*.[1]*d", 1, 2

This follows the golang conventions and not POSIX.

The following errors are handled:

Incorrect verb:

S("%h", "") %!(BAD VERB 'h')

Too few arguments:

S("%d") %!(MISSING 'd')"

Adds functions used for displaying colored text.

import {
  bgBlue,
  bgRgb24,
  bgRgb8,
  bold,
  italic,
  red,
  rgb24,
  rgb8,
} from "https://deno.land/std@$STD_VERSION/fmt/colors.ts";

console.log(bgBlue(italic(red(bold("Hello, World!")))));

// also supports 8bit colors

console.log(rgb8("Hello, World!", 42));

console.log(bgRgb8("Hello, World!", 42));

// and 24bit rgb

console.log(rgb24("Hello, World!", {
  r: 41,
  g: 42,
  b: 43,
}));

console.log(bgRgb24("Hello, World!", {
  r: 41,
  g: 42,
  b: 43,
}));

Convert bytes to a human readable string: 1337 → 1.34 kB

A utility for displaying file sizes for humans.

Note: This module was ported from pretty-bytes.

import { prettyBytes } from "https://deno.land/std@$STD_VERSION/fmt/bytes.ts";

prettyBytes(1337);
//=> '1.34 kB'

prettyBytes(100);
//=> '100 B'

// Display with units of bits
prettyBytes(1337, { bits: true });
//=> '1.34 kbit'

// Display file size differences
prettyBytes(42, { signed: true });
//=> '+42 B'

// Localized output using German locale
prettyBytes(1337, { locale: "de" });
//=> '1,34 kB'

Get formatted time duration from milliseconds.

import { prettyDuration } from "https://deno.land/std@$STD_VERSION/fmt/duration.ts";

// "00:00:01:39:674:000:000"
prettyDuration(99674, { formatType: "time" });

// "0d 0h 1m 39s 674ms 0µs 0ns"
prettyDuration(99674);

// "1m 39s 674ms"
prettyDuration(99674, { ignoreZero: true });

// "1 minutes, 39 seconds, 674 milliseconds"
prettyDuration(99674, { formatType: "full", ignoreZero: true });