Manual

- Overview
- Tutorials
- FAQs
- History / Changes
- License

Reference

- Language
- Functions
- Operators
- Special Variables
- Pragmas
- Utilities
- Internals
- Platform Specific

Modules

- A • B • C • D • E
- F • G • H • I • L
- M • N • O • P • S
- T • U • X

News / Blogs

- Perl Buzz
- Perl Iron Man
- Perlsphere
- Planet Perl
- TPF news
- Use Perl

See also

- CPAN
- Perl.org
- Perl.com
- Perl 5 Wiki
- Perl Jobs
- Perl Mongers
- Perl Monks

Contact

- Site designed and maintained by Jon Allen (JJ)
- http://perl.jonallen.info

- View the project page and FAQs

# sprintf

Perl 5 version 10.1 documentation
Go to top

# sprintf

Perl functions A-Z | Perl functions by category | The 'perlfunc' manpage

- sprintf FORMAT, LIST

  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.

  For example:

              # Format number with up to 8 leading zeroes        $result = sprintf("%08d", $number);        # Round number to 3 digits after decimal point        $rounded = sprintf("%.3f", $number);

  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.

  Perl's `sprintf` permits the following universally-known conversions:

         %%	a percent sign   %c	a character with the given number   %s	a string   %d	a signed integer, in decimal   %u	an unsigned integer, in decimal   %o	an unsigned integer, in octal   %x	an unsigned integer, in hexadecimal   %e	a floating-point number, in scientific notation   %f	a floating-point number, in fixed decimal notation   %g	a floating-point number, in %e or %f notation

  In addition, Perl permits the following widely-supported conversions:

         %X	like %x, but using upper-case letters   %E	like %e, but using an upper-case "E"   %G	like %g, but with an upper-case "E" (if applicable)   %b	an unsigned integer, in binary   %B	like %b, but using an upper-case "B" with the # flag   %p	a pointer (outputs the Perl value's address in hexadecimal)   %n	special: *stores* the number of characters output so far        into the next variable in the parameter list

  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.:

          printf '%2$d %1$d', 12, 34;      # prints "34 12"  printf '%3$d %d %1$d', 1, 2, 3;  # prints "3 1 1"

  - flags

    one or more of:

           space   prefix non-negative number with a space   +       prefix non-negative number with a plus sign   -       left-justify within the field   0       use zeros, not spaces, to right-justify   #       ensure the leading "0" for any octal,           prefix non-zero hexadecimal with "0x" or "0X",           prefix non-zero binary with "0b" or "0B"

    For example:

          printf '<% d>',  12;   # prints "< 12>"  printf '<%+d>',  12;   # prints "<+12>"  printf '<%6s>',  12;   # prints "<    12>"  printf '<%-6s>', 12;   # prints "<12    >"  printf '<%06s>', 12;   # prints "<000012>"  printf '<%#o>',  12;   # prints "<014>"  printf '<%#x>',  12;   # prints "<0xc>"  printf '<%#X>',  12;   # prints "<0XC>"  printf '<%#b>',  12;   # prints "<0b1100>"  printf '<%#B>',  12;   # prints "<0B1100>"

    When a space and a plus sign are given as the flags at once, a plus sign is used to prefix a positive number.

          printf '<%+ d>', 12;   # prints "<+12>"  printf '<% +d>', 12;   # prints "<+12>"

    When the # flag and a precision are given in the %o conversion, the precision is incremented if it's necessary for the leading "0".

          printf '<%#.5o>', 012;      # prints "<00012>"  printf '<%#.5o>', 012345;   # prints "<012345>"  printf '<%#.0o>', 0;        # prints "<0>"

  - vector flag

    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:

          printf "%vd", "AB\x{100}";           # prints "65.66.256"  printf "version is v%vd\n", $^V;     # Perl's version

    Put an asterisk `*` before the `v` to override the string to use to separate the numbers:

          printf "address is %*vX\n", ":", $addr;   # IPv6 address  printf "bits are %0*v8b\n", " ", $bits;   # random bitstring

    You can also explicitly specify the argument number to use for the join string using e.g. `*2$v`:

          printf '%*4$vX %*4$vX %*4$vX', @addr[1..3], ":";   # 3 IPv6 addresses

  - (minimum) width

    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$`):

          printf '<%s>', "a";       # prints "<a>"  printf '<%6s>', "a";      # prints "<     a>"  printf '<%*s>', 6, "a";   # prints "<     a>"  printf '<%*2$s>', "a", 6; # prints "<     a>"  printf '<%2s>', "long";   # prints "<long>" (does not truncate)

    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.:

          # these examples are subject to system-specific variation  printf '<%f>', 1;    # prints "<1.000000>"  printf '<%.1f>', 1;  # prints "<1.0>"  printf '<%.0f>', 1;  # prints "<1>"  printf '<%e>', 10;   # prints "<1.000000e+01>"  printf '<%.1e>', 10; # prints "<1.0e+01>"

    For 'g' and 'G', this specifies the maximum number of digits to show, including prior to the decimal point as well as after it, e.g.:

          # these examples are subject to system-specific variation  printf '<%g>', 1;        # prints "<1>"  printf '<%.10g>', 1;     # prints "<1>"  printf '<%g>', 100;      # prints "<100>"  printf '<%.1g>', 100;    # prints "<1e+02>"  printf '<%.2g>', 100.01; # prints "<1e+02>"  printf '<%.5g>', 100.01; # prints "<100.01>"  printf '<%.4g>', 100.01; # prints "<100>"

    For integer conversions, specifying a precision implies that the output of the number itself should be zero-padded to this width, where the 0 flag is ignored:

          printf '<%.6d>', 1;      # prints "<000001>"  printf '<%+.6d>', 1;     # prints "<+000001>"  printf '<%-10.6d>', 1;   # prints "<000001    >"  printf '<%10.6d>', 1;    # prints "<    000001>"  printf '<%010.6d>', 1;   # prints "<    000001>"  printf '<%+10.6d>', 1;   # prints "<   +000001>"  printf '<%.6x>', 1;      # prints "<000001>"  printf '<%#.6x>', 1;     # prints "<0x000001>"  printf '<%-10.6x>', 1;   # prints "<000001    >"  printf '<%10.6x>', 1;    # prints "<    000001>"  printf '<%010.6x>', 1;   # prints "<    000001>"  printf '<%#10.6x>', 1;   # prints "<  0x000001>"

    For string conversions, specifying a precision truncates the string to fit in the specified width:

          printf '<%.5s>', "truncated";   # prints "<trunc>"  printf '<%10.5s>', "truncated"; # prints "<     trunc>"

    You can also get the precision from the next argument using `.*`:

          printf '<%.6x>', 1;       # prints "<000001>"  printf '<%.*x>', 6, 1;    # prints "<000001>"

    If a precision obtained through `*` is negative, it has the same effect as no precision.

          printf '<%.*s>',  7, "string";   # prints "<string>"  printf '<%.*s>',  3, "string";   # prints "<str>"  printf '<%.*s>',  0, "string";   # prints "<>"  printf '<%.*s>', -1, "string";   # prints "<string>"  printf '<%.*d>',  1, 0;   # prints "<0>"  printf '<%.*d>',  0, 0;   # prints "<>"  printf '<%.*d>', -1, 0;   # prints "<0>"

    You cannot currently get the precision from a specified number, but it is intended that this will be possible in the future using e.g. `.*2$`:

          printf '<%.*2$x>', 1, 6;   # INVALID, but in future will print "<000001>"

  - size

    For numeric conversions, you can specify the size to interpret the number as using `l` , `h` , `V` , `q`, `L` , or `ll` . For integer conversions (`d u o x X b i D U O` ), 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:

           l           interpret integer as C type "long" or "unsigned long"   h           interpret integer as C type "short" or "unsigned short"   q, L or ll  interpret integer as C type "long long", "unsigned long long".               or "quads" (typically 64-bit integers)

    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:

        	use Config;	($Config{use64bitint} eq 'define' || $Config{longsize} >= 8) &&		print "quads\n";

    For floating point conversions (`e f g E F G` ), 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:

        	use Config;	$Config{d_longdbl} eq 'define' && print "long doubles\n";

    You can find out whether Perl considers 'long double' to be the default floating point size to use on your platform via Config:

                use Config;        ($Config{uselongdouble} eq 'define') &&                print "long doubles by default\n";

    It can also be the case that long doubles and doubles are the same thing:

                use Config;        ($Config{doublesize} == $Config{longdblsize}) &&                print "doubles are long doubles\n";

    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).

    So:

          printf '<%*.*s>', $a, $b, $c;

    would use `$a` for the width, `$b` for the precision and `$c` as the value to format, while:

          printf '<%*1$.*s>', $a, $b;

    would use `$a` for the width and the precision, and `$b` as the value to format.

    Here are some more examples - beware that when using an explicit index, the `$` may need to be escaped:

          printf "%2\$d %d\n",    12, 34;		# will print "34 12\n"  printf "%2\$d %d %d\n", 12, 34;		# will print "34 12 34\n"  printf "%3\$d %d %d\n", 12, 34, 56;		# will print "56 12 34\n"  printf "%2\$*3\$d %d\n", 12, 34, 3;		# will print " 34 12\n"

  If `use locale` is in effect, and POSIX::setlocale() has been called, the character used for the decimal separator in formatted floating point numbers is affected by the LC_NUMERIC locale. See perllocale and POSIX.

Recently read

Tools

- Preferences