sprintf

Returns a string formatted by the usual printf conventions of the C
library function sprintf. See below for more details
and see sprintf(3) or printf(3) on your system for an explanation of
the general principles.

Perl does its own sprintf formatting--it emulates the C
function sprintf, but it doesn't use it (except for floating-point
numbers, and even then only the standard modifiers are allowed). As a
result, any non-standard extensions in your local sprintf are not
available from Perl.

Unlike printf, sprintf does not do what you probably mean when you
pass it an array as your first argument. The array is given scalar context,
and instead of using the 0th element of the array as the format, Perl will
use the count of elements in the array as the format, which is almost never
useful.

Finally, for backward (and we do mean "backward") compatibility, Perl
permits these unnecessary but widely-supported conversions:

%i a synonym for %d

%D a synonym for %ld

%U a synonym for %lu

%O a synonym for %lo

%F a synonym for %f

Note that the number of exponent digits in the scientific notation produced
by %e
, %E
, %g
and %G
for numbers with the modulus of the
exponent less than 100 is system-dependent: it may be three or less
(zero-padded as necessary). In other words, 1.23 times ten to the
99th may be either "1.23e99" or "1.23e099".

Between the %
and the format letter, you may specify a number of
additional attributes controlling the interpretation of the format.
In order, these are:

format parameter index

An explicit format parameter index, such as 2$. By default sprintf
will format the next unused argument in the list, but this allows you
to take the arguments out of order, e.g.:

one or more of:
space prefix positive number with a space
+ prefix positive number with a plus sign
- left-justify within the field
0 use zeros, not spaces, to right-justify
# prefix non-zero octal with "0", non-zero hex with "0x",
non-zero binary with "0b"

This flag tells perl to interpret the supplied string as a vector of
integers, one for each character in the string. Perl applies the format to
each integer in turn, then joins the resulting strings with a separator (a
dot . by default). This can be useful for displaying ordinal values of
characters in arbitrary strings:

Arguments are usually formatted to be only as wide as required to
display the given value. You can override the width by putting
a number here, or get the width from the next argument (with *
)
or from a specified argument (with e.g. *2$):

If a field width obtained through *
is negative, it has the same
effect as the -
flag: left-justification.

precision, or maximum width

You can specify a precision (for numeric conversions) or a maximum
width (for string conversions) by specifying a . followed by a number.
For floating point formats, with the exception of 'g' and 'G', this specifies
the number of decimal places to show (the default being 6), e.g.:

For numeric conversions, you can specify the size to interpret the
number as using l
, h
, V
, q, L
, or ll
. For integer
conversions (duoxXbiDUO
), numbers are usually assumed to be
whatever the default integer size is on your platform (usually 32 or 64
bits), but you can override this to use instead one of the standard C types,
as supported by the compiler used to build Perl:

The last will produce errors if Perl does not understand "quads" in your
installation. (This requires that either the platform natively supports quads
or Perl was specifically compiled to support quads.) You can find out
whether your Perl supports quads via Config:

For floating point conversions (efgEFG
), numbers are usually assumed
to be the default floating point size on your platform (double or long double),
but you can force 'long double' with q, L
, or ll
if your
platform supports them. You can find out whether your Perl supports long
doubles via Config:

The size specifier V
has no effect for Perl code, but it is supported
for compatibility with XS code; it means 'use the standard size for
a Perl integer (or floating-point number)', which is already the
default for Perl code.

order of arguments

Normally, sprintf takes the next unused argument as the value to
format for each format specification. If the format specification
uses *
to require additional arguments, these are consumed from
the argument list in the order in which they appear in the format
specification before the value to format. Where an argument is
specified using an explicit index, this does not affect the normal
order for the arguments (even when the explicitly specified index
would have been the next argument in any case).