| PRINTF(1) | User Commands | PRINTF(1) |
printf - write formatted output
printf format [argument]...
printf format [string...]
The printf utility writes each string operand to standard output using format to control the output format.
The following operands are supported by /usr/bin/printf:
format
Bytes from the converted string are written until the end of the string or the number of bytes indicated by the precision specification is reached. If the precision is omitted, it is taken to be infinite, so all bytes up to the end of the converted string are written. For each specification that consumes an argument, the next argument operand is evaluated and converted to the appropriate type for the conversion as specified below. The format operand is reused as often as necessary to satisfy the argument operands. Any extra c or s conversion specifications are evaluated as if a null string argument were supplied; other extra conversion specifications are evaluated as if a zero argument were supplied.
When there are more argument operands than format specifiers, and the format includes n$ position indicators, then the format is reprocessed from the beginning as above, but with the argument list starting from the next argument after the highest nth argument previously encountered.
If the format operand contains no conversion specifications and argument operands are present, the results are unspecified. If a character sequence in the format operand begins with a % character, but does not form a valid conversion specification, the behavior is unspecified.
argument
The format operands support the full range of ANSI C/C99/XPG6 formatting specifiers as well as additional specifiers:
%b
\a
\b
\c
\E
\f
\n
\t
\v
\\
\0x
%B
%H
%P
%q
%R
%T
%Z
When performing conversions of string to satisfy a numeric format specifier, if the first character of string is "or', the value is the numeric value in the underlying code set of the character following the "or'. Otherwise, string is treated like a shell arithmetic expression and evaluated.
If a string operand cannot be completely converted into a value appropriate for that format specifier, an error occurs, but remaining string operands continue to be processed.
In addition to the format specifier extensions, the following extensions of ANSI C/C99/XPG6 are permitted in format specifiers:
If there are more string operands than format specifiers, the format string is reprocessed from the beginning. If there are fewer string operands than format specifiers, then string specifiers are treated as if empty strings were supplied, numeric conversions are treated as if 0 was supplied, and time conversions are treated as if now was supplied.
When there are more argument operands than format specifiers, and the format includes n$ position indicators, then the format is reprocessed from the beginning as above, but with the argument list starting from the next argument after the highest nth argument previously encountered.
/usr/bin/printf is equivalent to ksh93's printf built-in and print -f, which allows additional options to be specified.
The printf utility, like the printf(3C) function on which it is based, makes no special provision for dealing with multi-byte characters when using the %c conversion specification. Applications should be extremely cautious using either of these features when there are multi-byte characters in the character set.
The %b conversion specification is not part of the ISO C standard; it has been added here as a portable way to process backslash escapes expanded in string operands as provided by the echo utility. See also the USAGE section of the echo(1) manual page for ways to use printf as a replacement for all of the traditional versions of the echo utility.
If an argument cannot be parsed correctly for the corresponding conversion specification, the printf utility reports an error. Thus, overflow and extraneous characters at the end of an argument being used for a numeric conversion are to be reported as errors.
It is not considered an error if an argument operand is not completely used for a c or s conversion or if a string operand's first or second character is used to get the numeric value of a character.
Example 1 Printing a Series of Prompts
The following example alerts the user, then prints and reads a series of prompts:
example% printf "\aPlease fill in the following: \nName: " read name printf "Phone number: " read phone
Example 2 Printing a Table of Calculations
The following example prints a table of calculations. It reads out a list of right and wrong answers from a file, calculates the percentage correctly, and prints them out. The numbers are right-justified and separated by a single tab character. The percentage is written to one decimal place of accuracy:
example% while read right wrong ; do
percent=$(echo "scale=1;($right*100)/($right+$wrong)" | bc)
printf "%2d right\t%2d wrong\t(%s%%)\n" \ $right $wrong $percent done < database_file
Example 3 Printing number strings
The command:
example% printf "%5d%4d\n" 1 21 321 4321 54321
produces:
1 21
3214321 54321 0
The format operand is used three times to print all of the given strings and that a 0 was supplied by printf to satisfy the last %4d conversion specification.
Example 4 Tabulating Conversion Errors
The following example tabulates conversion errors.
The printf utility tells the user when conversion errors are detected while producing numeric output. These results would be expected on an implementation with 32-bit twos-complement integers when %d is specified as the format operand:
| Arguments | Standard | Diagnostic |
| 5a | 5 | printf: 5a not completely converted |
| 9999999999 | 2147483647 | printf: 9999999999: Results too large |
| -9999999999 | -2147483648 | printf: -9999999999: Results too large |
| ABC | 0 | printf: ABC expected numeric value |
The value shown on standard output is what would be expected as the return value from the function strtol(3C). A similar correspondence exists between %u and strtoul(3C), and %e, %f and %g and strtod(3C).
Example 5 Printing Output for a Specific Locale
The following example prints output for a specific locale. In a locale using the ISO/IEC 646:1991 standard as the underlying codeset, the command:
example% printf "%d\n" 3 +3 -3 \'3 \"+3 "'-3"
produces:
| 3 | Numeric value of constant 3 |
| 3 | Numeric value of constant 3 |
| −3 | Numeric value of constant −3 |
| 51 | Numeric value of the character `3' in the ISO/IEC 646:1991 standard codeset |
| 43 | Numeric value of the character `+' in the ISO/IEC 646:1991 standard codeset |
| 45 | Numeric value of the character `−' in the SO/IEC 646:1991 standard codeset |
In a locale with multi-byte characters, the value of a character is intended to be the value of the equivalent of the wchar_t representation of the character.
If an argument operand cannot be completely converted into an internal value appropriate to the corresponding conversion specification, a diagnostic message is written to standard error and the utility does exit with a zero exit status, but continues processing any remaining operands and writes the value accumulated at the time the error was detected to standard output.
Example 6 Alternative floating point representation 1
The printf utility supports an alternative floating point representation (see printf(3C) entry for the "%a"/"%A"), which allows the output of floating-point values in a format that avoids the usual base16 to base10 rounding errors.
example% printf "%a\n" 2 3.1 NaN
produces:
0x1.0000000000000000000000000000p+01 0x1.8ccccccccccccccccccccccccccdp+01 nan
Example 7 Alternative floating point representation 2
The following example shows two different representations of the same floating-point value.
example% x=2 ; printf "%f == %a\n" x x
produces:
2.000000 == 0x1.0000000000000000000000000000p+01
Example 8 Output of unicode values
The following command will print the EURO unicode symbol (code-point 0x20ac).
example% LC_ALL=en_US.UTF-8 printf "[20ac]\n"
produces:
<euro>
where "<euro>" represents the EURO currency symbol character.
Example 9 Convert unicode character to unicode code-point value
The following command will print the hexadecimal value of a given character.
example% export LC_ALL=en_US.UTF-8 example% printf "%x\n" "'<euro>"
where "<euro>" represents the EURO currency symbol character (code-point 0x20ac).
produces:
20ac
Example 10 Print the numeric value of an ASCII character
example% printf "%d\n" "'A"
produces:
65
Example 11 Print the language-independent date and time format
To print the language-independent date and time format, the following statement could be used:
example% printf "format" weekday month day hour min
For example,
$ printf format "Sunday" "July" 3 10 2
For American usage, format could be the string:
"%s, %s %d, %d:%.2d\n"
producing the message:
Sunday, July 3, 10:02
Whereas for EU usage, format could be the string:
"%1$s, %3$d. %2$s, %4$d:%5$.2d\n"
Note that the '$' characters must be properly escaped, such as
"%1\$s, %3\$d. %2\$s, %4\$d:%5\$.2d\n" in this case
producing the message:
Sunday, 3. July, 10:02
See environ(7) for descriptions of the following environment variables that affect the execution of printf: LANG, LC_ALL, LC_CTYPE, LC_MESSAGES, LC_NUMERIC, and NLSPATH.
The following exit values are returned:
0
>0
See attributes(7) for descriptions of the following attributes:
| ATTRIBUTE TYPE | ATTRIBUTE VALUE |
| CSI | Enabled |
| Interface Stability | Committed |
| Standard | See standards(7). |
| ATTRIBUTE TYPE | ATTRIBUTE VALUE |
| Interface Stability | Uncommitted |
awk(1), bc(1), date(1), echo(1), ksh93(1), printf(3C), strtod(3C), strtol(3C), strtoul(3C), attributes(7), environ(7), formats(7), standards(7)
Using format specifiers (characters following '%') which are not listed in the printf(3C) or this manual page will result in undefined behavior.
Using escape sequences (the character following a backslash ('\')) which are not listed in the printf(3C) or this manual page will result in undefined behavior.
Floating-point values follow C99, XPG6 and IEEE 754 standard behavior and can handle values the same way as the platform's |long double| datatype.
Floating-point values handle the sign separately which allows signs for values like NaN (for example, -nan), Infinite (for example, -inf) and zero (for example, -0.0).
| May 11, 2014 | OmniOS |