PRINTF(1) User Commands PRINTF(1)
NAME
printf - write formatted output
SYNOPSIS
/usr/bin/printf printf format [
argument]...
ksh93 printf format [
string...]
DESCRIPTION
/usr/bin/printf The
printf utility writes each string operand to standard output using
format to control the output format.
OPERANDS
/usr/bin/printf The following operands are supported by
/usr/bin/printf:
format A string describing the format to use to write the remaining
operands. The
format operand is used as the
format string
described on the
formats(7) manual page, with the following
exceptions:
o A
SPACE character in the format string, in any
context other than a flag of a conversion
specification, is treated as an ordinary character
that is copied to the output.
o A character in the format string is treated as a
character, not as a
SPACE character.
o In addition to the escape sequences described on
the
formats(7) manual page (
\\,
\a,
\b,
\f,
\n,
\r,
\t,
\v),
\ddd, where
ddd is a one-, two- or
three-digit octal number, is written as a byte
with the numeric value specified by the octal
number.
o The program does not precede or follow output from
the
d or
u conversion specifications with blank
characters not specified by the
format operand.
o The program does not precede output from the
o conversion specification with zeros not specified
by the
format operand.
o The argument used for the conversion character (or
width or precision parameters, see below) may be
taken from the
nnth argument instead of the next
unused argument, by specifying
n$ immediately
following the
% character, or the
* character (for
width or precision arguments). If
n$ appears in
any conversions in the format string, then it must
be used for all conversions, including any
variable width or precision specifiers.
o The special character
* may be used instead of a
string of decimal digits to indicate a minimum
field width or a precision. In this case the next
available argument is used (or the
nth if the form
n$ is used), treating its value as a decimal
string.
o An additional conversion character,
b, is
supported as follows. The argument is taken to be
a string that can contain backslash-escape
sequences. The following backslash-escape
sequences are supported:
o the escape sequences listed on the
formats(7) manual page (
\\,
\a,
\b,
\f,
\n,
\r,
\t,
\v),
which are converted to the characters they
represent
o
\0ddd, where
ddd is a zero-, one-, two- or
three-digit octal number that is converted to
a byte with the numeric value specified by the
octal number
o
\c, which is written and causes
printf to
ignore any remaining characters in the string
operand containing it, any remaining string
operands and any additional characters in the
format operand.
The interpretation of a backslash followed by any other
sequence of characters is unspecified.
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 strings to be written to standard output, under the
control of
format. The
argument operands are treated as
strings if the corresponding conversion character is
b,
c or
s. Otherwise, it is evaluated as a C constant, as described
by the ISO C standard, with the following extensions:
o A leading plus or minus sign is allowed.
o If the leading character is a single- or double-
quote, the value is the numeric value in the
underlying codeset of the character following the
single- or double-quote.
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 not 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.
ksh93 The
format operands support the full range of ANSI C/C99/XPG6 formatting
specifiers as well as additional specifiers:
%b Each character in the string operand is processed specially, as
follows:
\a Alert character.
\b Backspace character.
\c Terminate output without appending NEWLINE. The remaining
string operands are ignored.
\E Escape character (
ASCII octal
033).
\f FORM FEED character.
\n NEWLINE character.
\t TAB character.
\v Vertical tab character.
\\ Backslash character.
\0x The 8-bit character whose
ASCII code is the
1-,
2-, or
3-digit octal number
x.
%B Treat the argument as a variable name and output the value without
converting it to a string. This is most useful for variables of
type
-b.
%H Output string with characters
<,
&,
>,
", and non-printable
characters, properly escaped for use in HTML and XML documents.
%P Treat
string as an extended regular expression and convert it to a
shell pattern.
%q Output
string quoted in a manner that it can be read in by the
shell to get back the same string. However, empty strings resulting
from missing string operands are not quoted.
%R Treat
string as an shell pattern expression and convert it to an
extended regular expression.
%T Treat
string as a date/time string and format it. The
T can be
preceded by (
dformat), where
dformat is a date format as defined by
the
date(1) command.
%Z Output a byte whose value is
0.
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:
o The escape sequences
\E and
\e expand to the escape character
which is octal 033 in ASCII.
o The escape sequence
\cx expands to CTRL-x.
o The escape sequence
\C[.name.] expands to the collating
element
name.
o The escape sequence
\x{hex} expands to the character
corresponding to the hexadecimal value
hex.
o The format modifier flag = can be used to center a field to a
specified width. When the output is a terminal, the character
width is used rather than the number of bytes.
o Each of the integral format specifiers can have a third
modifier after width and precision that specifies the base of
the conversion from 2 to 64. In this case, the
# modifier
causes
base# to be prepended to the value.
o The
# modifier can be used with the
d specifier when no base
is specified to cause the output to be written in units of
1000 with a suffix of one of
k M G T P E.
o The
# modifier can be used with the
i specifier to cause the
output to be written in units of
1024 with a suffix of one of
Ki Mi Gi Ti Pi Ei.
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.
USAGE
/usr/bin/printf 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.
EXAMPLES
/usr/bin/printf 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
ENVIRONMENT VARIABLES
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.
EXIT STATUS
The following exit values are returned:
0 Successful completion.
>0 An error occurred.
ATTRIBUTES
See
attributes(7) for descriptions of the following attributes:
/usr/bin/printf +--------------------+-------------------+
| ATTRIBUTE TYPE | ATTRIBUTE VALUE |
+--------------------+-------------------+
|CSI | Enabled |
+--------------------+-------------------+
|Interface Stability | Committed |
+--------------------+-------------------+
|Standard | See
standards(7). |
+--------------------+-------------------+
ksh93 +--------------------+-----------------+
| ATTRIBUTE TYPE | ATTRIBUTE VALUE |
+--------------------+-----------------+
|Interface Stability | Uncommitted |
+--------------------+-----------------+
SEE ALSO
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)NOTES
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
PRINTF(1)