printf(1) 맨 페이지 - 윈디하나의 솔라나라

개요

섹션
맨 페이지 이름
검색(S)

printf(1)

printf(1)                        User Commands                       printf(1)



NAME
       printf - write formatted output

SYNOPSIS
   /usr/bin/printf
       printf format [argument]...

   ksh
       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(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 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(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 op‐
                              erand.


                       o      The  program  does not precede output from the o
                              conversion specification with zeros  not  speci‐
                              fied by the format operand.


                       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(7) 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. 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  unspeci‐
                   fied.


       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.


   ksh
       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.


       /usr/bin/printf  is  equivalent  to ksh'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 multibyte characters when
       using the %c conversion specification. Applications should be extremely
       cautious  using either of these features when there are multibyte char‐
       acters in the character set.


       Field widths and precisions cannot be specified as *.


       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 Examples
       Example 1 Printing a Series of Prompts



       The  following  example alerts the user, then prints and reads a series
       of prompts:


         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:


         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:



       tab()  box; cw(1.27i) cw(1.27i) cw(2.96i) lw(1.27i) lw(1.27i) lw(2.96i)
       ArgumentsStandardDiagnostic  5a5printf:  5a  not  completely  converted
       99999999992147483647printf:     9999999999:     Results    too    large
       -9999999999-2147483648printf:   -9999999999:    Results    too    large
       ABC0printf: 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:



       tab()  box; lw(0.5i) lw(5i) 3Numeric value of constant 3 3Numeric value
       of constant 3 −3Numeric value of constant −3 51T{ Numeric value of  the
       character  '3' in the ISO/IEC 646:1991 standard codeset T} 43T{ Numeric
       value of the character '+' in the ISO/IEC 646:1991 standard codeset  T}
       45T{  Numeric  value of the character '−' in the ISO/IEC 646:1991 stan‐
       dard codeset T}




       In a locale with multibyte 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.

   ksh Examples
       The  following  examples  illustrate  the  use  of the ksh93 version of
       printf.

       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 Unicode  character  for  the  euro
       currency symbol (code-point U+20AC).


         example% LC_ALL=en_US.UTF-8 printf "\u[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(7) 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(7) for descriptions of the following attributes:

   /usr/bin/printf
       tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i) ATTRIBUTE  TYPEAT‐
       TRIBUTE  VALUE  _ Availabilitytext/locale _ CSIEnabled _ Interface Sta‐
       bilityCommitted _ StandardSee standards(7).


   ksh
       tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i) ATTRIBUTE  TYPEAT‐
       TRIBUTE  VALUE _ Availabilitysystem/core-os _ Interface StabilityUncom‐
       mitted


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

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).



Oracle Solaris 11.4               11 May 2021                        printf(1)
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.
RSS ATOM XHTML 5 CSS3