printf man page on SmartOS

Man page or keyword search:  
man Server   16655 pages
apropos Keyword Search (all sections)
Output format
SmartOS logo
[printable version]

PRINTF(1)							     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  remain‐
		   ing	operands.  The	format	operand	 is used as the format
		   string described on the formats(5) manual  page,  with  the
		   following exceptions:

		       o      A	 SPACE	character in the format string, in any
			      context other than a flag of a conversion speci‐
			      fication,	 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(5) 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 op‐
			      erand.

		       o      The  program  does not precede output from the o
			      conversion specification with zeros  not	speci‐
			      fied 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$ imme‐
			      diately  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  conver‐
			      sions, 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 sup‐
			      ported 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 for‐
				  mats(5) manual page (\\, \a, \b, \f, \n, \r,
				  \t,  \v), which are converted to the charac‐
				  ters 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  charac‐
				  ters 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 pre‐
		   cision specification is reached. If the precision is	 omit‐
		   ted, 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  conver‐
		   sion	 specifications	 are  evaluated	 as if a zero argument
		   were supplied.

		   When there are more argument operands  than	format	speci‐
		   fiers, 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 unspeci‐
		   fied. 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	exten‐
		   sions:

		       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 conver‐
		   sion 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	 oper‐
		   ands 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  format‐
       ting 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	 with‐
	     out  converting it to a string. This is most useful for variables
	     of type -b.

       %H
	     Output string with characters <, &, >, ", and non-printable char‐
	     acters, 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 result‐
	     ing 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 spec‐
       ifier, 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 appro‐
       priate for that format specifier, an error occurs, but remaining string
       operands continue to be processed.

       In  addition  to	 the format specifier extensions, the following exten‐
       sions of ANSI C/C99/XPG6 are permitted in format specifiers:

	   o	  The escape sequences \E and \e expand to the escape  charac‐
		  ter 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 ele‐
		  ment name.

	   o	  The escape sequence \x{hex} expands to the character	corre‐
		  sponding 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 char‐
		  acter width is used rather than the number of bytes.

	   o	  Each of the integral format specifiers can have a third mod‐
		  ifier 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 op‐
       erands 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 encoun‐
       tered.

       /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 char‐
       acters 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 conver‐
       sion 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 speci‐
       fied 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 com‐
       mand:

	 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 charac‐ │
       │     ter   `3'	 in  the  ISO/IEC │
       │     646:1991 standard codeset	  │
       │43   Numeric value of the charac‐ │
       │     ter   `+'	 in  the  ISO/IEC │
       │     646:1991 standard codeset	  │
       │45   Numeric value of the charac‐ │
       │     ter   `−'	 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 representa‐
       tion 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 representa‐
       tion (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 char‐
       acter.

	 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(5) for descriptions of the following environment variables
       that affect the execution of printf: LANG,  LC_ALL,  LC_CTYPE,  LC_MES‐
       SAGES, LC_NUMERIC, and NLSPATH.

EXIT STATUS
       The following exit values are returned:

       0
	     Successful completion.

       >0
	     An error occurred.

ATTRIBUTES
       See attributes(5) for descriptions of the following attributes:

   /usr/bin/printf
       ┌────────────────────┬───────────────────┐
       │  ATTRIBUTE TYPE    │  ATTRIBUTE VALUE	│
       ├────────────────────┼───────────────────┤
       │CSI		    │ Enabled		│
       ├────────────────────┼───────────────────┤
       │Interface Stability │ Committed		│
       ├────────────────────┼───────────────────┤
       │Standard	    │ See standards(5). │
       └────────────────────┴───────────────────┘

   ksh93
       ┌────────────────────┬─────────────────┐
       │  ATTRIBUTE TYPE    │ ATTRIBUTE VALUE │
       ├────────────────────┼─────────────────┤
       │Interface Stability │ Uncommitted     │
       └────────────────────┴─────────────────┘

SEE ALSO
       awk(1), bc(1), date(1), echo(1), ksh93(1), printf(3C), strtod(3C), str‐
       tol(3C),	 strtoul(3C),  attributes(5),  environ(5),  formats(5),	 stan‐
       dards(5)

NOTES
       Using format specifiers (characters following '%') which are not listed
       in the printf(3C) or this manual page will result in  undefined	behav‐
       ior.

       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)
[top]

List of man pages available for SmartOS

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net