This manual page is part of the POSIX Programmer's Manual. The Linux
implementation of this interface may differ (consult the corresponding Linux
manual page for details of Linux behavior), or the interface may not be
implemented on Linux.
printf — write formatted output
printf format [argument...]
utility shall write formatted operands to the standard output.
operands shall be formatted under control of the
The following operands shall be supported:
- A string describing the format to use to write the
remaining operands. See the EXTENDED DESCRIPTION section.
- The strings to be written to standard output, under the
control of format. See the EXTENDED DESCRIPTION section.
The following environment variables shall affect the execution of printf
- Provide a default value for the internationalization
variables that are unset or null. (See the Base Definitions volume of
POSIX.1‐2008, Section 8.2, Internationalization
Variables the precedence of internationalization variables used to
determine the values of locale categories.)
- If set to a non-empty string value, override the values of
all the other internationalization variables.
- Determine the locale for the interpretation of sequences of
bytes of text data as characters (for example, single-byte as opposed to
multi-byte characters in arguments).
Determine the locale that should be used to affect the format and contents
of diagnostic messages written to standard error.
Determine the locale for numeric formatting. It shall affect the format of
numbers written using the e, E, f, g, and
G conversion specifier characters (if supported).
- Determine the location of message catalogs for the
processing of LC_MESSAGES.
See the EXTENDED DESCRIPTION section.
The standard error shall be used only for diagnostic messages.
operand shall be used as the format
string described in
the Base Definitions volume of POSIX.1‐2008, Chapter 5
with the following exceptions:
- A <space> in the format string, in any context other
than a flag of a conversion specification, shall be treated as an ordinary
character that is copied to the output.
- A '' character in the format string shall be treated
as a '' character, not as a <space>.
- In addition to the escape sequences shown in the Base
Definitions volume of POSIX.1‐2008, Chapter 5, File
Format Notation ('\\', '\a', '\b', '\f',
'\n', '\r', '\t', '\v'),
"\ddd", where ddd is a one, two, or three-digit
octal number, shall be written as a byte with the numeric value specified
by the octal number.
- The implementation shall not precede or follow output from
the d or u conversion specifiers with <blank>
characters not specified by the format operand.
- The implementation shall not precede output from the
o conversion specifier with zeros not specified by the
- The a, A, e, E, f,
F, g, and G conversion specifiers need not be
- An additional conversion specifier character, b,
shall be supported as follows. The argument shall be taken to be a string
that may contain <backslash>-escape sequences. The following
<backslash>-escape sequences shall be supported:
- The escape sequences listed in the Base Definitions volume
of POSIX.1‐2008, Chapter 5, File Format Notation
('\\', '\a', '\b', '\f', '\n',
'\r', '\t', '\v'), which shall be converted to the
characters they represent
- "\0ddd", where ddd is a zero, one,
two, or three-digit octal number that shall be converted to a byte with
the numeric value specified by the octal number
- '\c', which shall not be written and shall cause
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 shall be 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 shall be taken to be infinite, so all bytes up to
the end of the converted string shall be written.
- For each conversion specification that consumes an
argument, the next argument operand shall be evaluated and converted to
the appropriate type for the conversion as specified below.
- The format operand shall be reused as often as
necessary to satisfy the argument operands. Any extra c or s
conversion specifiers shall be evaluated as if a null string argument were
supplied; other extra conversion specifications shall be evaluated as if a
zero argument were supplied. 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.
- The argument to the c conversion specifier can be a
string containing zero or more bytes. If it contains one or more bytes,
the first byte shall be written and any additional bytes shall be ignored.
If the argument is an empty string, it is unspecified whether nothing is
written or a null byte is written.
operands shall be treated as strings if the corresponding
conversion specifier is b
, or s
, and shall be
evaluated as if by the strtod
() function if the corresponding
conversion specifier is a
, or G
. Otherwise, they shall be evaluated as
unsuffixed C integer constants, as described by the ISO C standard,
with the following extensions:
- A leading <plus-sign> or minus-sign shall be
- If the leading character is a single-quote or double-quote,
the value shall be the numeric value in the underlying codeset of the
character following the single-quote or double-quote.
- Suffixed integer constants may be allowed.
If an argument operand cannot be completely converted into an internal value
appropriate to the corresponding conversion specification, a diagnostic
message shall be written to standard error and the utility shall not exit with
a zero exit status, but shall continue processing any remaining operands and
shall write the value accumulated at the time the error was detected to
It is not considered an error if an argument operand is not completely used for
The following exit values shall be returned:
- Successful completion.
- An error occurred.
The following sections are informative.
The floating-point formatting conversion specifications of printf
not required because all arithmetic in the shell is integer arithmetic. The
utility performs floating-point calculations and provides its own
function. The bc
utility can perform arbitrary-precision
floating-point arithmetic, but does not provide extensive formatting
capabilities. (This printf
utility cannot really be used to format
output; it does not support arbitrary precision.) Implementations
are encouraged to support the floating-point conversions as an extension.
Note that this printf
utility, like the printf
() function defined
in the System Interfaces volume of POSIX.1‐2008 on which it is based,
makes no special provision for dealing with multi-byte characters when using
conversion specification or when a precision is specified in a
conversion specification. Applications should be
extremely cautious using either of these features when there are multi-byte
characters in the character set.
No provision is made in this volume of POSIX.1‐2008 which allows field
widths and precisions to be specified as '*'
since the '*'
be replaced directly in the format
operand using shell variable
substitution. Implementations can also provide this feature as an extension if
they so choose.
Hexadecimal character constants as defined in the ISO C standard are not
recognized in the format
operand because there is no consistent way to
detect the end of the constant. Octal character constants are limited to, at
most, three octal digits, but hexadecimal character constants are only
terminated by a non-hex-digit character. In the ISO C standard, the
concatenation operator can be used to terminate a
constant and follow it with a hexadecimal character to be written. In the
shell, concatenation occurs before the printf
utility has a chance to
parse the end of the hexadecimal constant.
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 APPLICATION USAGE section of echo
for ways to use
as a replacement for all of the traditional versions of the
If an argument cannot be parsed correctly for the corresponding conversion
specification, the printf
utility is required to report an error. Thus,
overflow and extraneous characters at the end of an argument being used for a
numeric conversion shall be reported as errors.
To alert the user and then print and read a series of prompts:
printf "\aPlease fill in the following: \nName: "
printf "Phone number: "
To read out a list of right and wrong answers from a file, calculate the
percentage correctly, and print them out. The numbers are right-justified and
separated by a single <tab>. The percentage is written to one decimal
place of accuracy:
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
printf "%5d%4d\n" 1 21 321 4321 54321
Note that the format
operand is used three times to print all of the
given strings and that a '0'
was supplied by printf
the last %4d
utility is required to notify the user when conversion errors
are detected while producing numeric output; thus, the following results would
be expected on an implementation with 32-bit twos-complement integers when
is specified as the format
||printf: "5a" not completely converted
||printf: "9999999999" arithmetic overflow
||printf: "−9999999999" arithmetic overflow
||printf: "ABC" expected numeric value
The diagnostic message format is not specified, but these examples convey the
type of information that should be reported. Note that the value shown on
standard output is what would be expected as the return value from the
() function as defined in the System Interfaces volume of
POSIX.1‐2008. A similar correspondence exists between %u
() and %e
, and %g
implementation supports floating-point conversions) and strtod
In a locale using the ISO/IEC 646:1991 standard as the underlying
codeset, the command:
printf "%d\n" 3 +3 −3 \'3 \"+3 "'−3"
- Numeric value of constant 3
- Numeric value of constant 3
- Numeric value of constant −3
- Numeric value of the character '3' in the
ISO/IEC 646:1991 standard codeset
- Numeric value of the character '+' in the
ISO/IEC 646:1991 standard codeset
- Numeric value of the character '−' in the
ISO/IEC 646:1991 standard codeset
Note that 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 as described in the System Interfaces volume
utility was added to provide functionality that has
historically been provided by echo
. However, due to irreconcilable
differences in the various versions of echo
extant, the version has few
special features, leaving those to this new printf
utility, which is
based on one in the Ninth Edition system.
The EXTENDED DESCRIPTION section almost exactly matches the printf
function in the ISO C standard, although it is described in terms of
the file format notation in the Base Definitions volume of
POSIX.1‐2008, Chapter 5
, File Format Notation
Earlier versions of this standard specified that arguments for all conversions
other than b
, and s
were evaluated in the same way (as
C constants, but with stated exceptions). For implementations supporting the
floating-point conversions it was not clear whether integer conversions need
only accept integer constants and floating-point conversions need only accept
floating-point constants, or whether both types of conversions should accept
both types of constants. Also by not distinguishing between them, the
requirement relating to a leading single-quote or double-quote applied to
floating-point conversions even though this provided no useful functionality
to applications that was not already available through the integer
conversions. The current standard clarifies the situation by specifying that
the arguments for floating-point conversions are evaluated as if by
(), and the arguments for integer conversions are evaluated as C
integer constants, with the special treatment of leading single-quote and
double-quote applying only to integer conversions.
The Base Definitions volume of POSIX.1‐2008, Chapter 5
, Chapter 8
, Environment Variables
The System Interfaces volume of POSIX.1‐2008, fprintf()
Portions of this text are reprinted and reproduced in electronic form from IEEE
Std 1003.1, 2013 Edition, Standard for Information Technology -- Portable
Operating System Interface (POSIX), The Open Group Base Specifications Issue
7, Copyright (C) 2013 by the Institute of Electrical and Electronics
Engineers, Inc and The Open Group. (This is POSIX.1-2008 with the 2013
Technical Corrigendum 1 applied.) In the event of any discrepancy between this
version and the original IEEE and The Open Group Standard, the original IEEE
and The Open Group Standard is the referee document. The original Standard can
be obtained online at http://www.unix.org/online.html .
Any typographical or formatting errors that appear in this page are most likely
to have been introduced during the conversion of the source files to man page
format. To report such errors, see