PRINTF(1) | General Commands Manual | PRINTF(1) |
printf
— formatted
output
printf |
format [arguments ...] |
The printf
utility formats and prints its
arguments, after the first, under control of the
format. The format is a
character string which contains three types of objects: plain characters,
which are simply copied to standard output, character escape sequences which
are converted and copied to the standard output, and format specifications,
each of which causes printing of the next successive
argument.
The arguments after the first are treated as
strings if the corresponding format is either c
,
b
or s
; otherwise it is
evaluated as a C constant, with the following extensions:
The format string is reused as often as necessary to satisfy the arguments. Any extra format specifications are evaluated with zero or the null string.
Character escape sequences are in backslash notation as defined in the ANSI X3.159-1989 (“ANSI C89”), with extensions. The characters and their meanings are as follows:
\a
\b
\f
\n
\r
\t
\v
\´
\\
\
num\
num
sequences.Each format specification is introduced by the percent character (``%''). The remainder of the format specification includes, in the following order:
#
b
,
c
, d
,
s
and u
formats, this
option has no effect. For the o
formats the
precision of the number is increased to force the first character of
the output string to a zero. For the x
(X
) format, a non-zero result has the string
0x
(0X
) prepended to
it. For a
, A
,
e
, E
,
f
, F
,
g
and G
formats, the
result will always contain a decimal point, even if no digits follow
the point (normally, a decimal point only appears in the results of
those formats if a digit follows the decimal point). For
g
and G
formats,
trailing zeros are not removed from the result as they would otherwise
be;-
+
0
.
’, followed by
an optional digit string giving a
precision
which specifies the number of digits to appear after the decimal point,
for e
and f
formats, or
the maximum number of bytes to be printed from a string; if the digit
string is missing, the precision is treated as zero;diouxXfFeEgGaAcsb
). The uppercase formats differ
from their lowercase counterparts only in that the output of the former is
entirely in uppercase. The floating-point format specifiers
(fFeEgGaA
) may be prefixed by an
L
to request that additional precision be used, if
available.A field width or precision may be
‘*
’ instead of a digit string. In this
case an argument supplies the field width or
precision.
The format characters and their meanings are:
diouXx
fF
inf
’ and
‘nan
’, respectively.eE
e
‘[-d.ddd±dd]’
where there is one digit before the decimal point and the number after is
equal to the precision specification for the argument; when the precision
is missing, 6 digits are produced. The values infinity and NaN are printed
as ‘inf
’ and
‘nan
’, respectively.gG
f
(F
) or in style
e
(E
) whichever gives full
precision in minimum space.aA
p
d]’
where there is one digit before the hexadecimal point and the number after
is equal to the precision specification for the argument; when the
precision is missing, enough digits are produced to convey the argument's
exact double-precision floating-point representation. The values infinity
and NaN are printed as ‘inf
’ and
‘nan
’, respectively.c
s
b
s
, but interpret character escapes in
backslash notation in the string argument. The
permitted escape sequences are slightly different in that octal escapes
are \0
num instead of
\
num and that an additional
escape sequence \c
stops further output from this
printf
invocation.n$
%
The decimal point character is defined in the program's locale
(category LC_NUMERIC
).
In no case does a non-existent or small field width cause truncation of a field; padding takes place only if the specified field width exceeds the actual width.
Some shells may provide a builtin printf
command which is similar or identical to this utility. Consult the
builtin(1) manual page.
The printf
utility exits 0 on
success, and >0 if an error occurs.
Print the string "hello":
$ printf "%s\n" hello hello
Same as above, but notice that the format string is not quoted and hence we do not get the expected behavior:
$ printf %s\n hello hellon$
Print arguments forcing sign only for the first argument:
$ printf "%+d\n%d\n%d\n" 1 -2 13 +1 -2 13
Same as above, but the single format string will be applied to the three arguments:
$ printf "%+d\n" 1 -2 13 +1 -2 +13
Print number using only two digits after the decimal point:
$ printf "%.2f\n" 31.7456 31.75
The traditional BSD behavior of converting arguments of numeric formats not beginning with a digit to the ASCII code of the first character is not supported.
The printf
command is expected to be
compatible with the IEEE Std 1003.2
(“POSIX.2”) specification.
The printf
command appeared in
4.3BSD-Reno. It is modeled after the standard
library function, printf(3).
ANSI hexadecimal character constants were deliberately not provided.
Trying to print a dash ("-") as the first character
causes printf
to interpret the dash as a program
argument. --
must be used before
format.
If the locale contains multibyte characters (such as UTF-8), the
c
format and b
and
s
formats with a precision may not operate as
expected.
Since the floating point numbers are translated from ASCII to
floating-point and then back again, floating-point precision may be lost.
(By default, the number is translated to an IEEE-754 double-precision value
before being printed. The L
modifier may produce
additional precision, depending on the hardware platform.)
The escape sequence \000 is the string terminator. When present in
the argument for the b
format, the argument will be
truncated at the \000 character.
Multibyte characters are not recognized in format strings (this is
only a problem if ‘%
’ can appear
inside a multibyte character).
July 1, 2020 | macOS 14.6 |