sprintf in Perl

• Introduction
• Format string
• Examples
• More examples

Introduction

Function sprintf is not often considered to be string manipulation function in most Perl textbooks. It is usually studied along with printf function in the chapter devoted to I/O operation in Perl.

But in reality it is important string manipulation function which somewhat overlaps with  substr , concatenate(dot), length and other string processing functions.

Function sprintf can also serve as analog of Unix head function for strings (see below s specifier. which can truncae strings)

It is simply indispensable when you need to assemble a string from one or several numeric values or mixture of numeric values (each using particular strict format, for example fixed length numeric field with leading zeros) and strings.

Function sprintf accepts two arguments:

FORMAT -- a string that serves as a template for the result of assembly using the classic C printf format  specification. The format tags follow this prototype:

%[flags][width][.precision][length]specifier

Important: If format string is exhausted before list of augments is exhausted, the interpretation if format string is not re-started from the very beginning.

LIST -- comma delimited list of values of variable

Typical flags were also inherited from C

• 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 numeric value
• # --ensure the leading "0" for any octal,

Format string

Format string was first introduced by Fortran and further developed in PL/1.  See printf format string - Wikipedia. It consists of several parts the most important of which are

• Flags

• Width

• Specifier

FORMAT -- a string that serves as a template for the result of assembly using the classic C printf format  specification. The format tags follow this prototype:

%[flags][width][.precision][length]specifier

Here is the basic information about format string from sprintf man page. For more information see  sprintf() man page. Perl's sprintf() permits the following classic formal elements (called  specifiers in Perl-speak):

1. c a character with the given number
2. s a substring of the string or string justified in a certain manner. For example
   • %-3s A string left-justified in a field at least 3 characters wide
   • %.3s A string, but at most 3 characters of that string are printed. This is essentially head function applied to string
3. d a signed integer, in decimal
4. u an unsigned integer, in decimal
5. o an unsigned integer, in octal
6. x an unsigned integer, in hexadecimal
7. e a floating-point number, in scientific notation
8. f a floating-point number, in fixed decimal notation
9. g a floating-point number, in e or f notation

You can put as many specifiers in the format string as you like, with the same number of following arguments as there are specifiers. An example:

	printf("%d %s %f", $decimal, $string, $float);

Perl also supports several additional useful specifiers:

1. X like x, but using upper-case letters
2. E like e, but using an upper-case "E"
3. G like g, but with an upper-case "E" (if applicable)
4. b an unsigned integer, in binary
5. B like b, but using an upper-case "B" with the # flag
6. p a pointer (outputs the Perl value's address in hexadecimal)
7. n special: *stores* the number of characters output so far

Like C Perl permits the following flags between the %  and the specifiers letter:

1. space -- prefix positive number with a space
2. + -- prefix positive number with a plus sign
3. - -- left-justify within the field
4. 0 -- use zeros, not spaces, to right-justify
5. # -- prefix non-zero octal with "0", non-zero hex with "0x"

width of the floating point numbers can be specified with number after which optionally you can specify the precision for conversion to decimal of other base.

1. number -- minimum field width
2. .number -- "precision": digits after decimal point for floating-point, max length for string, minimum length for integer
3. l -- interpret integer as C type "long" or "unsigned long"
4. h -- interpret integer as C type "short" or "unsigned short"

NOTES:

1. Where a number would appear in the flags, an asterisk ("*'') may be used instead, in which case Perl uses the next item in the parameter list as the given number (that is, as the field width or precision).

2. If a field width obtained through "*'' is negative, it has the same effect as the "-'' flag: left-justification.
    
3. There is also one Perl-specific flag v (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:

   1. printf "%vd", "AB\x{100}"; # prints "65.66.256"
   2. 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:

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

   You can also explicitly specify the argument number to use for the join string using something like *2$v; for example:

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

4. Perl also supports several macros and aliases to existing format items for backward compatibility. Among them:
   • %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

Examples

Function sprintf is extremely convenient  if you want to assemble a formatted string from several numeric variables or mixture of string and numeric variable.

One popular use for sprintf is when a number needs to be rendered with a certain number of places after the decimal point, such as when an amount of money needs to be shown as 2.50 and not 2.5 -- and certainly not as 2.49997! That's easy to accomplish with the "%.2f" format:

my $money = sprintf "%.2f", 2.49997;

Specifying integer and real values

Often you need to render the number  with a certain number of places after the decimal point. For example two in case of dollar and cents. You can accomplish this using the "%.2d" format:

my $money = sprintf("%.2d", 5.9997);

This means rounding the value to two decimal points. Unless this is the way to perform calculation specified you are better off keeping numbers in memory with all of the available accuracy, rounding off only when you need to output it as a string.

Leading Zeros

If you need to put leading zeros you need to use %0nC specified syntax, where 'n' is the field width, and C is the conversion specifier you want to use. A field width is the minimum (in this case) number of characters the value should fill. Any less than that, and the remainder is filled by prepending zeros to the value.

	sprintf("%03d", 642);		# outputs '00642'

The "%3d" specifier means a minimum width of three spaces, which, by default, will be right-justified. (Note: the alignment is not currently being displayed properly here.)

printf("%3d", 1); 
1 >

printf("%03d", 1); 
001

printf("%3d", -1); 
-1

printf("%03d", -1); 
-001

%f, are a little trickier. Floating point numbers (with %f) are always outputted with 6 places after the decimal point, unless you specify a precision with the '.' modifier (see below for a discussion of the '.' precision modifier). In other words, printing a value of '2' as %f will actually output as 2.000000. This means you have to take into account, when specifying the field width, that there are already 7 characters tacked on. To get the value of 2 to print with one leading zero, you have to use a field width of 9 (7 for the '.' and 6 zeros, 1 for the '2', and 1 for the leading zero).

All other specifiers act in this way, too. To find out how many characters are output by default for a specifier, output a value of 0 (zero) for it and count how many characters there are:

	# this outputs: '0, 0.000000, 0.000000e+00'
	printf("%d, %f, %e", 0, 0, 0);

You can also ask perl to count them for you:

	printf("There are %d characters\n", length(sprintf("%e", 0)));

Which should tell you there are 12 characters for 0 in scientific notation.

Left-justifying printf  output

String value are usually left-justified. To archive that just add a minus sign (-) after the % symbol, like this:

printf("%-12s", $name);

Here is a collection of printf examples for integer printing. Several different options are shown, including a minimum width specification, left-justified, zero-filled, and also a plus sign for positive numbers.

A more complex example

Here is more complex example:

my $timestamp = sprintf( "%4d/%02d/%02d %2d:%02d:%02d",
                         $yr,$mon,$day, $h, $m, $s);

In that example, the variable $timestamp will be initialized with the value "2012/01/19 8:00:08".

Please note that the format string used a leading zero in  format components %02d that repeats several times. The leading zero means that is number has less digits then specified width, it will be filled from the left with leading zeroes as needed to make the number into the width specified (in this example two positions). 

Formatting IP addresses and large currency values

Often for large monetary value a special "money format" is needed. This format prints an integer with each three positions before decimal point marked with comma. In other words commas are used to distinguish dollars, thousand of dollars, millions of dollars. In Perl you can generate such a format  %v flag

This flag tells Perl to interpret the supplied string as a vector of integers, one for each format item in the format string. Perl applies the format to each part of the integer one by one, 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:

1. printf "version is v%vd\n", $^V; # Perl's version

You can put an asterisk *  before the v  to override the string to use to separate the numbers:

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

You can also explicitly specify the argument number to use for the join string using something like *2$v; for example:

@addr=(10,2,5,7);
$ip=printf('%*4$vX %*4$vX %*4$vX', @addr, ":"); 

More examples

Each item below is optional (unless otherwise stated), and should be used in the order they appear here. If this is confusing, skip to the next section. It's intended as a reference, and copied from man 3 printf with some extra explanation and examples.

• % - a percent sign. This is required, of course.
• Zero or more of the following:
  • '#' (pound sign): Specifies that the value should be converted to an 'alternate form.' This has no effect on 'c', 'd', 'i', 'n', 'p', 's', and 'u' conversions. For 'o' (octal) conversions, this prepends a '0' to the beginning. For 'x' and 'X' (hexadecimal), 0x or 0X is prepended to the value. For 'e', 'E', 'f', 'g' and 'G', the value is always printed with a trailing decimal point (.), even if no numbers follow it. For 'g' and 'G', trailing zeros are not removed from the result.

    printf("%x", 10);		# prints just 'a', versus:
    printf("%#x", 10);		# prints '0xa'
    

  • '0' (zero): To specify zero-padding on a digit. The converted value is padded on the left with the specified number of zeros minus the number of digits to be printed. This is described in more detail below.

    printf("%03d", 7);		# prints '007' ;)
    printf("%03d", 153);		# prints '153'
    

  • '-' (minus): Specifies a negative field width. This indicates the value should be left-adjusted on the boundary, versus the default right-adjusted. See below for more on how to specify field widths.

    printf("%5s", 'foo');		# prints '  foo'
    printf("%-5s", 'foo');		# prints 'foo  '
    

  • ' ' (a space): To specify that a blank should be left before a positive number.

    printf("% d", 7);		# prints ' 7'
    printf("% d", -7);		# prints '-7'
    

  • '+' (plus sign): This specifies that a sign always be placed before the value. '+' overrides ' ' (space) if both are used.

    printf(*quot;%+d", 7);		# prints '+7'
    

• A decimal digit specifying the minimum field width. Using the '-' modifier (see above) will left-align the value, otherwise it is right-aligned. With the '0' modifier for numeric conversions, the value is right-padded with zeros to fill the field width.

  printf("%5s", 'foo');		# prints '  foo'
  printf("%-5s", 'foo');		# prints 'foo  '
  

• A precision value in the form of a period ('.'), followed by an optional digit string. If the digit string is omitted, a precision of zero is used. This specifies the minimum number of digits to print for 'd', 'i', 'o', 'u', 'x', and 'X' conversions. For 'e', 'E', and 'F' conversions, it is the number of digits to appear after the decimal point. For 'g' and 'G' conversions, it specifies the maximum number of signifigant digits. For the 's' (string) conversion, it is the maximum number of characters of the string to print. Use the latter to make sure long strings don't exceed their field width.

  printf("%.3d", 7);		# prints '007'
  printf("%.2f", 3.66666);	# prints '3.66'
  printf("%.3s", 'foobar');	# prints 'foo'
  

• The character 'h' here will specify to treat the decimal value as a C type 'short' or 'unsigned short'.

  printf("%hd\n", 400000);	# prints '6784'
  

• The character 'l' (ell) can be used to treat the value as a C 'long' type.
• The character 'V' will interpret an integer as Perl's standard integer type.

  printf("%Vd", 7);		# prints '7'
  

• Finally, the required conversion specifier. Valid conversions are listed in the previous section.

Padding with spaces

This is more or less the same as leading zeros, except it uses leading (or, if told, trailing) spaces to complete the field width. This is useful for lining up multiple lines of data into a report, for instance (though in that case, you may also want to specify a maximum field width to truncate long values - more on that below). The syntax is just like leading zeros, but drop the leading zero:

	printf("%6s", 'foo');		# prints '   foo'

By default, leading spaces are used, so values appear to be right-aligned in their field. To reverse this, put a '-' sign before the field width:

	printf("%-6s", 'foo');		# prints 'foo   '

For numeric values with default precision, like %f and %e, act here just like they do with leading zeros. %f, for example, won't have any padding unless you put a field width of more than 8.

Precision Modifier

The precision modifier tells printf() how many digits you want after the decimal point, if its a floating point specifier. If there are more digits than you specified, the value is rounded. If there are less, zeros are used to fill the space.

	printf("%.2f", 9.333333);		# prints '9.34'
	printf("%.2f", 9);			# prints '9.00'

For decimal values, the precision modifier has the same effect as the '0' modifier described above:

	printf("%.3f", 7);			# prints 007

For string values, it has the nice effect of specifying a maximum field width, where it will only print out the first n characters of the string. In combonation with the field width modifier described above, you can have a well-behaved-under-all-circumstances string field.

	printf("%.3s", 'foobar');		# prints 'foo'
	printf("%.10s", 'foobar');		# prints 'foobar'
	printf("%5.5s %5.5s", 'foobar', 'baz');	# prints 'fooba   baz'

Rounding Numbers with sprintf()

Ever wanted to round a floating point number to a decimal in perl? Or round it to an arbitrary decimal place? sprintf() gives you the ability to do that.

	# this sets $foo to '3'
	$foo = sprintf("%d", 3.14);

	# this sets $bar to '7.3531'
	$bar = sprintf("%.4f", 7.35309);

%d specifies to convert the given value to a decimal integer. The conversion rounds as necessary. %.4f specifies to convert the value given to a floating point number with a precision to 4 decimal places, rounding the value as needed.

Octal and Hexadecimal

You can convert your decimal based values to Hexadecimal and Octal values using printf() and sprintf(). To do so, specify the conversion as %o for octal, and %x for hexadecimal. %X is equivilant to %x, except the result is printed using capital letters.

	printf("%x", 15);	# prints 'f'
	printf("%X", 15);	# prints 'F'
	printf("%o", 15);	# prints '17'

As explained in the Format Modifiers section, using a '#' (pound sign) right after the % will convert the value to "alternate form." For %x and %X, it will prepend to the value '0x' and '0X' respectively. For %o, a single leading '0' (zero) is added. The extra characters using the # modifier are considered part of the field width.

	printf("%#x", 15);	# prints '0xf'
	printf("%#o", 15);	# prints '017'
	printf("%#4x", 15);	# prints ' 0xf'

In the last example, the field width of 4 is specified. Since the # modifier adds two extra characters to the value, it ends up taking 3 characters in total. Thus the single leading space.

Dr Nikolai Bezroukov

NEWS CONTENTS

• 20120709 : Formatting Output Using printf ( Formatting Output Using printf , Jul 09, 2012 )
• 20120709 : Using (s)printf() ( Using (s)printf(), )
• 20120709 : Formatting Data with sprintf (Learning Perl, 3rd Edition) ( Formatting Data with sprintf (Learning Perl, 3rd Edition), )

Old News ;-)

[Jul 09, 2012] Formatting Output Using printf

This quote is from David Till book

If you want to write output that looks reasonable without going to all the trouble of using write and print formats, Perl provides a built-in function, printf, that prints formatted output.

NOTE	If you are familiar with the C programming language, the behavior of printf in Perl will be familiar; the Perl printf and the C printf are basically the same

The arguments passed to the printf function are as follows:

• The string to be printed, which can contain one or more field specifiers
• One value for each field specifier appearing in the string to be printed

When printf sees a field specifier, it substitutes the corresponding value in the printf argument list. The representation of the substituted value in the string depends on the field specifier that is supplied.

Field specifiers consist of the % character followed by a single character that represents the format to use when printing. Table 11.2 lists the field-specifier formats and the field-specifier character that represents each.

Table 11.2. Field specifiers for printf.

Specifier	Description
%c	Single character
%d	Integer in decimal (base-10) format
%e	Floating-point number in scientific notation
%f	Floating-point number in "normal" (fixed-point) notation
%g	Floating-point number in compact format
%o	Integer in octal (base-8) format
%s	Character string
%u	Unsigned integer
%x	Integer in hexadecimal (base-16) format

Here is a simple example of a call to printf:

printf("The number I want to print is %d.\n", $number);

The string to be printed contains one field specifier, %d, which represents an integer. The value stored in $number is substituted for the field specifier and printed.

Field specifiers also support a variety of options, as follows:

• If you are printing an integer using the d, o, u, or x format, you can put an l character in front of the field-specifier character (as in, for example, %ld). This character specifies that the number is a decimal integer in the machine's "long integer" format (corresponding to the C type long). This is useful if your integer is large or might be.
• A positive integer following the % character indicates the minimum width of the field. For example, %20s prints a character string in a field of 20 characters. If the string is not large enough to fill the entire field, it is right justified (placed at the right end of the field) and padded with blanks. (If the integer starts with a leading 0, as in %08d, the field is padded with zeros, not blanks.)
• A negative integer following the % character indicates the width of the field and requests left justification. For example, %-15s prints a character string in a field of 15 characters, and it fills the right end of the field with blanks if the string is not large enough.
• If you are using a field specifier that prints a floating-point number (%e, %f, or %g), you can specify the number of digits that are to appear after the decimal point. To do this, specify a floating-point number after the % character. For example:
  %8.3f
• Here, the number preceding the decimal point is the field width (as before), and the number after the decimal point is the number of decimal places to print.

Warning

If a floating-point number contains more digits than the field specifier wants, the number is rounded to the number of decimal places needed. For example, if 43.499 is being printed using the field %5.2f, the number actually printed is 43.50. As with the write value field @##.##, printf might not always round up when it is handling numbers whose last decimal place is 5. This happens because some floating-point numbers cannot be stored exactly, and the nearest equivalent number that can be stored is a slightly smaller number (which rounds down, not up). For example, 43.495 when printed by %5.2f might print 43.49, depending on how 43.495 is stored.

• If you are using a field specifier that prints an integer, character, or string, supplying a floating-point number after the % character specifies the maximum length of the value to be printed. In the following example a character string is printed in a 15-character field, but the string itself can be at most 10 characters long:
  %15.10s
• This guarantees that at least five spaces will appear in the printed line.

NOTE	You can use printf to print to other files. To do this, specify the file variable corresponding to the file to which you want to print, just as you would with print or write printf MYFILE ("I am printing %d.\n", $value); This means that changing the current default file using select affects printf.

Using (s)printf()

Jun 30, 2000 | PerlMonks

printf() and sprintf() work just like in C, with a few slight differences. printf() gives you a lot of control over the formatting of your values, which is what it was intended to do.

If you've ever wanted to make a nicely behaved, field-aligned report, round to an integer or specific decimal place, get octal or hexadecimal representations of your values, or just display your values in any other form imaginable, keep reading. printf() and sprintf() give you the utility to do that, and more.

printf() versus sprintf()

printf() and sprintf() look argumentally the same. That is, whatever arguments you pass to one, you can pass to the other without change. The difference is that printf() prints to a filehandle, and sprintf() returns the string printf() would have outputted.

To use printf() on a filehandle other than STDOUT, specify the filehandle you want to use just as you would with print, like so:

printf(HANDLE $format, @values);

The result will be printed to HANDLE.

sprintf doesn't take a filehandle, but instead returns the output into a string.

my $string = sprintf($format, @values);

The Format String

The format string in printf() is a number of tokens which describe how to print the variables you supply, and whatever else you want. Each variable format specifier starts with a %, is followed by zero or more of the optional modifiers, and ends with a conversion specifier.

A typical format string could look like this:

	"foo is %d"

Printed, it may look something like: 'foo is 12'. The %d is replaced by a variable specified after the format string argument. In this case, you would say:

	printf("foo is %d", $decimal);

so that %d is replaced with the value of $decimal. You can put as many specifiers in the format string as you like, with the same number of following arguments as there are specifiers. An example:

	printf("%d %s %f", $decimal, $string, $float);

Conversion Specifiers

You put these in your Format String. Each one, except %%, is replaced by the corresponding value in the printf argument list.

• %% prints a single % (percent sign).
• %c prints a single character with the given ASCII number (66 is printed as B, for example).
• %s prints a given string
• %d a signed integer in decimal
• %u an unsigned (can't be negative) 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 same as %e or %f, whichever printf thinks is best.
• %X is the same as %x, except it uses upper-case letters
• %E like %e, but with an upper-case 'E'
• %G same as %E when scientific notation is used for the value.
• %p a pointer; it outputs Perl's value address in hexadecimal.
• %n an odd little bugger that *stores* (in the variable given for the position) the number of characters output so far.

Others that simply exist for backward compatibility:

• %i synonym for %d
• %D same as %ld (long decimal)
• %U same as %lu (long unsigned decimal)
• %O same as %lo (long octal)
• %F same as %f

Format Specifiers

Each item below is optional (unless otherwise stated), and should be used in the order they appear here. If this is confusing, skip to the next section. It's intended as a reference, and copied from man 3 printf with some extra explanation and examples.

• % - a percent sign. This is required, of course.
• Zero or more of the following:
  • '#' (pound sign): Specifies that the value should be converted to an 'alternate form.' This has no effect on 'c', 'd', 'i', 'n', 'p', 's', and 'u' conversions. For 'o' (octal) conversions, this prepends a '0' to the beginning. For 'x' and 'X' (hexadecimal), 0x or 0X is prepended to the value. For 'e', 'E', 'f', 'g' and 'G', the value is always printed with a trailing decimal point (.), even if no numbers follow it. For 'g' and 'G', trailing zeros are not removed from the result.

    printf("%x", 10);		# prints just 'a', versus:
    printf("%#x", 10);		# prints '0xa'
    

  • '0' (zero): To specify zero-padding on a digit. The converted value is padded on the left with the specified number of zeros minus the number of digits to be printed. This is described in more detail below.

    printf("%03d", 7);		# prints '007' ;)
    printf("%03d", 153);		# prints '153'
    

  • '-' (minus): Specifies a negative field width. This indicates the value should be left-adjusted on the boundary, versus the default right-adjusted. See below for more on how to specify field widths.

    printf("%5s", 'foo');		# prints '  foo'
    printf("%-5s", 'foo');		# prints 'foo  '
    

  • ' ' (a space): To specify that a blank should be left before a positive number.

    printf("% d", 7);		# prints ' 7'
    printf("% d", -7);		# prints '-7'
    

  • '+' (plus sign): This specifies that a sign always be placed before the value. '+' overrides ' ' (space) if both are used.

    printf(*quot;%+d", 7);		# prints '+7'
    

• A decimal digit specifying the minimum field width. Using the '-' modifier (see above) will left-align the value, otherwise it is right-aligned. With the '0' modifier for numeric conversions, the value is right-padded with zeros to fill the field width.

  printf("%5s", 'foo');		# prints '  foo'
  printf("%-5s", 'foo');		# prints 'foo  '
  

• A precision value in the form of a period ('.'), followed by an optional digit string. If the digit string is omitted, a precision of zero is used. This specifies the minimum number of digits to print for 'd', 'i', 'o', 'u', 'x', and 'X' conversions. For 'e', 'E', and 'F' conversions, it is the number of digits to appear after the decimal point. For 'g' and 'G' conversions, it specifies the maximum number of signifigant digits. For the 's' (string) conversion, it is the maximum number of characters of the string to print. Use the latter to make sure long strings don't exceed their field width.

  printf("%.3d", 7);		# prints '007'
  printf("%.2f", 3.66666);	# prints '3.66'
  printf("%.3s", 'foobar');	# prints 'foo'
  

• The character 'h' here will specify to treat the decimal value as a C type 'short' or 'unsigned short'.

  printf("%hd\n", 400000);	# prints '6784'
  

• The character 'l' (ell) can be used to treat the value as a C 'long' type.
• The character 'V' will interpret an integer as Perl's standard integer type.

  printf("%Vd", 7);		# prints '7'
  

• Finally, the required conversion specifier. Valid conversions are listed in the previous section.

Leading Zeros

Say you have a number, something like 642, and you want to output it as 00642 instead. The %0nC specifier syntax lets you do just that, where 'n' is the field width, and C is the conversion specifier you want to use. A field width is the minimum (in this case) number of characters the value should fill. Any less than that, and the remainder is filled by prepending zeros on your value until it fits perfectly.

	printf("%05d", 642);		# outputs '00642'

You should note that certain conversions, like %f, are a little trickier. Floating point numbers (with %f) are always outputted with 6 places after the decimal point, unless you specify a precision with the '.' modifier (see below for a discussion of the '.' precision modifier). In other words, printing a value of '2' as %f will actually output as 2.000000. This means you have to take into account, when specifying the field width, that there are already 7 characters tacked on. To get the value of 2 to print with one leading zero, you have to use a field width of 9 (7 for the '.' and 6 zeros, 1 for the '2', and 1 for the leading zero).

All other specifiers act in this way, too. To find out how many characters are output by default for a specifier, output a value of 0 (zero) for it and count how many characters there are:

	# this outputs: '0, 0.000000, 0.000000e+00'
	printf("%d, %f, %e", 0, 0, 0);

You can also ask perl to count them for you:

	printf("There are %d characters\n", length(sprintf("%e", 0)));

Which should tell you there are 12 characters for 0 in scientific notation.

Padding with spaces

This is more or less the same as leading zeros, except it uses leading (or, if told, trailing) spaces to complete the field width. This is useful for lining up multiple lines of data into a report, for instance (though in that case, you may also want to specify a maximum field width to truncate long values - more on that below). The syntax is just like leading zeros, but drop the leading zero:

	printf("%6s", 'foo');		# prints '   foo'

By default, leading spaces are used, so values appear to be right-aligned in their field. To reverse this, put a '-' sign before the field width:

	printf("%-6s", 'foo');		# prints 'foo   '

For numeric values with default precision, like %f and %e, act here just like they do with leading zeros. %f, for example, won't have any padding unless you put a field width of more than 8.

Precision Modifier

The precision modifier tells printf() how many digits you want after the decimal point, if its a floating point specifier. If there are more digits than you specified, the value is rounded. If there are less, zeros are used to fill the space.

	printf("%.2f", 9.333333);		# prints '9.34'
	printf("%.2f", 9);			# prints '9.00'

For decimal values, the precision modifier has the same effect as the '0' modifier described above:

	printf("%.3f", 7);			# prints 007

For string values, it has the nice effect of specifying a maximum field width, where it will only print out the first n characters of the string. In combonation with the field width modifier described above, you can have a well-behaved-under-all-circumstances string field.

	printf("%.3s", 'foobar');		# prints 'foo'
	printf("%.10s", 'foobar');		# prints 'foobar'
	printf("%5.5s %5.5s", 'foobar', 'baz');	# prints 'fooba   baz'

Rounding Numbers with sprintf()

Ever wanted to round a floating point number to a decimal in perl? Or round it to an arbitrary decimal place? sprintf() gives you the ability to do that.

	# this sets $foo to '3'
	$foo = sprintf("%d", 3.14);

	# this sets $bar to '7.3531'
	$bar = sprintf("%.4f", 7.35309);

%d specifies to convert the given value to a decimal integer. The conversion rounds as necessary. %.4f specifies to convert the value given to a floating point number with a precision to 4 decimal places, rounding the value as needed.

Octal and Hexadecimal

You can convert your decimal based values to Hexadecimal and Octal values using printf() and sprintf(). To do so, specify the conversion as %o for octal, and %x for hexadecimal. %X is equivilant to %x, except the result is printed using capital letters.

	printf("%x", 15);	# prints 'f'
	printf("%X", 15);	# prints 'F'
	printf("%o", 15);	# prints '17'

As explained in the Format Modifiers section, using a '#' (pound sign) right after the % will convert the value to "alternate form." For %x and %X, it will prepend to the value '0x' and '0X' respectively. For %o, a single leading '0' (zero) is added. The extra characters using the # modifier are considered part of the field width.

	printf("%#x", 15);	# prints '0xf'
	printf("%#o", 15);	# prints '017'
	printf("%#4x", 15);	# prints ' 0xf'

In the last example, the field width of 4 is specified. Since the # modifier adds two extra characters to the value, it ends up taking 3 characters in total. Thus the single leading space.

Formatting Data with sprintf (Learning Perl, 3rd Edition)

Formatting Data with sprintf

The sprintf function takes the same arguments as printf (except for the optional filehandle, of course), but it returns the requested string instead of printing it. This is handy if you want to store a formatted string into a variable for later use, or if you want more control over the result than printf alone would provide:

my $date_tag = sprintf
  "%4d/%02d/%02d %2d:%02d:%02d",
  $yr, $mo, $da, $h, $m, $s;

In that example, $date_tag gets something like "2038/01/19 3:00:08". The format string (the first argument to sprintf) used a leading zero on some of the format number, which we didn't mention when we talked about printf formats in Chapter 6, "I/O Basics". The leading zero on the format number means to use leading zeroes as needed to make the number as wide as requested. Without a leading zero in the formats, the resulting date-and-time string would have unwanted leading spaces instead of zeroes, looking like "2038/ 1/19 3: 0: 8".

15.3.1. Using sprintf with "Money Numbers"

One popular use for sprintf is when a number needs to be rendered with a certain number of places after the decimal point, such as when an amount of money needs to be shown as 2.50 and not 2.5 -- and certainly not as 2.49997! That's easy to accomplish with the "%.2f" format:

my $money = sprintf "%.2f", 2.49997;

The full implications of rounding are numerous and subtle, but in most cases you should keep numbers in memory with all of the available accuracy, rounding off only for output.

If you have a "money number" that may be large enough to need commas to show its size, you might find it handy to use a subroutine like this one.[337]

[337]Yes, we know that not everywhere in the world are commas used to separate groups of digits, not everywhere are the digits grouped by threes, and not everywhere the currency symbol appears as it does for U.S. dollars. But this is a good example anyway, so there!

sub big_money {
  my $number = sprintf "%.2f", shift @_;
  # Add one comma each time through the do-nothing loop
  1 while $number =~ s/^(-?\d+)(\d\d\d)/$1,$2/;
  # Put the dollar sign in the right place
  $number =~ s/^(-?)/$1\$/;
  $number;
}

This subroutine uses some techniques you haven't seen yet, but they logically follow from what we've shown you. The first line of the subroutine formats the first (and only) parameter to have exactly two digits after the decimal point. That is, if the parameter were the number 12345678.9, now our $number is the string "12345678.90".

The next line of code uses a while modifier. As we mentioned when we covered that modifier in Chapter 10, "More Control Structures", that can always be rewritten as a traditional while loop:

while ($number =~ s/^(-?\d+)(\d\d\d)/$1,$2/) {
  1;
}

What does that say to do? It says that, as long as the substitution returns a true value (signifying success), the loop body should run. But the loop body does nothing! That's okay with Perl, but it tells us that the purpose of that statement is to do the conditional expression (the substitution), rather than the useless loop body. The value 1 is traditionally used as this kind of a placeholder, although any other value would be equally useful.[338] This works just as well as the loop above:

[338]Which is to say, useless. By the way, in case you're wondering, Perl optimizes away the constant expression so it doesn't even take up any runtime.

'keep looping' while $number =~ s/^(-?\d+)(\d\d\d)/$1,$2/;

So, now we know that the substitution is the real purpose of the loop. But what is the substitution doing? Remember that $number will be some string like "12345678.90" at this point. The pattern will match the first part of the string, but it can't get past the decimal point. (Do you see why it can't?) Memory $1 will get "12345", and $2 will get "678", so the substitution will make $number into "12345,678.90" (remember, it couldn't match the decimal point, so the last part of the string is left untouched).

Do you see what the dash is doing near the start of that pattern? (Hint: The dash is allowed at only one place in the string.) We'll tell you at the end of this section, in case you haven't figured it out.

We're not done with that substitution statement yet. Since the substitution succeeded, the do-nothing loop goes back to try again. This time, the pattern can't match anything from the comma onward, so $number becomes "12,345,678.90". The substitution thus adds a comma to the number each time through the loop.

Speaking of the loop, it's still not done. Since the previous substitution was a success, we're back around the loop to try again. But this time, the pattern can't match at all, since it has to match at least four digits at the start of the string, so now that is the end of the loop.

Why couldn't we have simply used the /g modifier to do a "global" search-and-replace, to save the trouble and confusion of the 1 while? We couldn't use that because we're working backwards from the decimal point, rather than forward from the start of the string. Putting the commas in a number like this can't be done simply with the s///g substitution alone:

At least, it can't be done without some more-advanced regular expression techniques than we've shown you so far. Those darn Perl developers keep making it harder and harder to write Perl books that use the word "can't."

So, did you figure out the dash? It's allowing for a possible minus-sign at the start of the string. The next line of code makes the same allowance, putting the dollar-sign in the right place so that $number is something like "$12,345,678.90", or perhaps "-$12,345,678.90" if it's negative. Note that the dollar sign isn't necessarily the first character in the string, or that line would be a lot simpler. Finally, the last line of code returns our nicely formatted "money number," ready to be printed in the annual

Recommended Links

Softpanorama Recommended

Top articles

Sites

• sprintf - perldoc.perl.org
• printf format string - Wikipedia, the free encyclopedia
• Using (s)printf()
• devdaily.com
  • A printf format reference page (cheat sheet) printf reference for java perl ruby
  • Perl printf format examples (reference page) printf in perl, perl printf format devdaily.com
• sprintf in Perl description

Etc

Society

Groupthink : Two Party System as Polyarchy : Corruption of Regulators : Bureaucracies : Understanding Micromanagers and Control Freaks : Toxic Managers :   Harvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Neoliberalism  : The Iron Law of Oligarchy : Libertarian Philosophy

Quotes

War and Peace : Skeptical Finance : John Kenneth Galbraith :Talleyrand : Oscar Wilde : Otto Von Bismarck : Keynes : George Carlin : Skeptics : Propaganda  : SE quotes : Language Design and Programming Quotes : Random IT-related quotes :  Somerset Maugham : Marcus Aurelius : Kurt Vonnegut : Eric Hoffer : Winston Churchill : Napoleon Bonaparte : Ambrose Bierce :  Bernard Shaw : Mark Twain Quotes

Bulletin:

Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks The efficient markets hypothesis : Political Skeptic Bulletin, 2013 : Unemployment Bulletin, 2010 :  Vol 23, No.10 (October, 2011) An observation about corporate security departments : Slightly Skeptical Euromaydan Chronicles, June 2014 : Greenspan legacy bulletin, 2008 : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Financial Humor Bulletin, 2010 : Inequality Bulletin, 2009 : Financial Humor Bulletin, 2008 : Copyleft Problems Bulletin, 2004 : Financial Humor Bulletin, 2011 : Energy Bulletin, 2010 : Malware Protection Bulletin, 2010 : Vol 26, No.1 (January, 2013) Object-Oriented Cult : Political Skeptic Bulletin, 2011 : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method  : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law

History:

Fifty glorious years (1950-2000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds  : Larry Wall  : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOS :  Programming Languages History : PL/1 : Simula 67 : C : History of GCC development :  Scripting Languages : Perl history   : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 1987-2006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history

Classic books:

The Peter Principle : Parkinson Law : 1984 : The Mythical Man-Month :  How to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Hater’s Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite

Most popular humor pages:

Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPL-related Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perl-related Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assembler-related Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor

The Last but not Least Technology is dominated by two types of people: those who understand what they do not manage and those who manage what they do not understand ~Archibald Putt. Ph.D

The statements, views and opinions presented on this web page are those of the author (or referenced source) and are not endorsed by, nor do they necessarily reflect, the opinions of the Softpanorama society. We do not warrant the correctness of the information provided or its fitness for any purpose. The site uses AdSense so you need to be aware of Google privacy policy. You you do not want to be tracked by Google please disable Javascript for this site. This site is perfectly usable without Javascript.

Last modified: October, 17, 2020