Precision¶

The precision for a floating- or double-number can be specified by using .<DIGITS>, where <DIGITS> is the number of digits for precision. If <DIGITS> is an asterisk (*), the precision is read from the argument that precedes the number to print, like (prints 4,3000000000):

printf "%.*f\n" 10 4,3

The format .*N to specify the N'th argument for precision does not work in Bash.

For strings, the precision specifies the maximum number of characters to print (i.e., the maximum field width). For integers, it specifies the number of digits to print (zero-padding!).

Escape codes¶

These are interpreted if used anywhere in the format string, or in an argument corresponding to a %b format.

The following additional escape and extra rules apply only to arguments associated with a %b format:

• Backslashes in the escapes: \', \", and \? are not removed.
• Octal escapes beginning with \0 may contain up to four digits. (POSIX specifies up to three).

These are also respects in which %b differs from the escapes used by \$'...' style quoting.

Examples¶

Snipplets¶

• print the decimal representation of a hexadecimal number (preserve the sign)
  • printf "%d\n" 0x41
  • printf "%d\n" -0x41
  • printf "%+d\n" 0x41
• print the octal representation of a decimal number
  • printf "%o\n" 65
  • printf "%05o\n" 65 (5 characters width, padded with zeros)
• this prints a 0, since no argument is specified
  • printf "%d\n"
• print the code number of the character A
  • printf "%d\n" \'A
  • printf "%d\n" "'A"
• Generate a greeting banner and assign it to the variable GREETER
  • printf -v GREETER "Hello %s" "$LOGNAME"
• Print a text at the end of the line, using tput to get the current line width
  • printf "%*s\n" $(tput cols) "Hello world!"

Small code table¶

This small loop prints all numbers from 0 to 127 in

• decimal
• octal
• hex

for ((x=0; x <= 127; x++)); do
  printf '%3d | %04o | 0x%02x\n' "$x" "$x" "$x"
done

Ensure well-formatted MAC address¶

This code here will take a common MAC address and rewrite it into a well-known format (regarding leading zeros or upper/lowercase of the hex digits, ...):

the_mac="0:13:ce:7:7a:ad"

# lowercase hex digits
the_mac="$(printf "%02x:%02x:%02x:%02x:%02x:%02x" 0x${the_mac//:/ 0x})"

# or the uppercase-digits variant
the_mac="$(printf "%02X:%02X:%02X:%02X:%02X:%02X" 0x${the_mac//:/ 0x})"

Replacement echo¶

This code was found in Solaris manpage for echo(1).

Solaris version of /usr/bin/echo is equivalent to:

printf "%b\n" "$*"

Solaris /usr/ucb/echo is equivalent to:

if [ "X$1" = "X-n" ]
then
     shift
     printf "%s" "$*"
else
     printf "%s\n" "$*"
fi

prargs Implementation¶

Working off the replacement echo, here is a terse implementation of prargs:

printf '"%b"\n' "$0" "$@" | nl -v0 -s": "

repeating a character (for example to print a line)¶

A small trick: Combining printf and parameter expansion to draw a line

length=40
printf -v line '%*s' "$length"
echo ${line// /-}

or:

length=40
eval printf -v line '%.0s-' {1..$length}

Replacement for some calls to date(1)¶

The %(...)T format string is a direct interface to strftime(3).

$ printf 'This is week %(%U/%Y)T.\n' -1
This is week 52/2010.

Please read the manpage of strftime(3) to get more information about the supported formats.

differences from awk printf¶

Awk also derives its printf() function from C, and therefore has similar format specifiers. However, in all versions of awk the space character is used as a string concatenation operator, so it cannot be used as an argument separator. Arguments to awk printf must be separated by commas. Some versions of awk do not require printf arguments to be surrounded by parentheses, but you should use them anyway to provide portability.

In the following example, the two strings are concatenated by the intervening space so that no argument remains to fill the format.

$ echo "Foo" | awk '{ printf "%s\n" $1 }'
awk: (FILENAME=- FNR=1) fatal: not enough arguments to satisfy format string
    `%s
Foo'
     ^ ran out for this one

Simply replacing the space with a comma and adding parentheses yields correct awk syntax.

$ echo "Foo" | awk '{ printf( "%s\n", $1 ) }'
Foo

With appropriate metacharacter escaping the bash printf can be called from inside awk (as from perl and other languages that support shell callout) as long as you don't care about program efficiency or readability.

echo "Foo" | awk '{ system( "printf \"%s\\n \" \"" $1 "\""  ) }'
Foo

Differences from C, and portability considerations¶

• The a, A, e, E, f, F, g, and G conversions are supported by Bash, but not required by POSIX.

• There is no wide-character support (wprintf). For instance, if you use %c, you're actually asking for the first byte of the argument. Likewise, the maximum field width modifier (dot) in combination with %s goes by bytes, not characters. This limits some of printf's functionality to working with ascii only. ksh93's printf supports the L modifier with %s and %c (but so far not %S or %C) in order to treat precision as character width, not byte count. zsh appears to adjust itself dynamically based upon LANG and LC_CTYPE. If LC_CTYPE=C, zsh will throw "character not in range" errors, and otherwise supports wide characters automatically if a variable-width encoding is set for the current locale.

• Bash recognizes and skips over any characters present in the length modifiers specified by POSIX during format string parsing.

``` c|builtins/printf.def

define LENMODS "hjlLtz"¶

... / skip possible format modifiers / modstart = fmt; while (fmt && strchr (LENMODS, fmt)) fmt++; ```

• mksh has no built-in printf by default (usually). There is an unsupported compile-time option to include a very poor, basically unusable implementation. For the most part you must rely upon the system's /usr/bin/printf or equivalent. The mksh maintainer recommends using print. The development version (post- R40f) adds a new parameter expansion in the form of ${name@Q} which fills the role of printf %q -- expanding in a shell-escaped format.

• ksh93 optimizes builtins run from within a command substitution and which have no redirections to run in the shell's process. Therefore the printf -v functionality can be closely matched by var=$(printf ...) without a big performance hit.

# Illustrates Bash-like behavior. Redefining printf is usually unnecessary / not recommended.
function printf {
    case $1 in
        -v)
            shift
            nameref x=$1
            shift
            x=$(command printf "$@")
            ;;
        *)
            command printf "$@"
    esac
}
builtin cut
print $$
printf -v 'foo[2]' '%d\n' "$(cut -d ' ' -f 1 /proc/self/stat)"
typeset -p foo
# 22461
# typeset -a foo=([2]=22461)

• The optional Bash loadable print may be useful for ksh compatibility and to overcome some of echo's portability pitfalls. Bash, ksh93, and zsh's print have an -f option which takes a printf format string and applies it to the remaining arguments. Bash lists the synopsis as: print: print [-Rnprs] [-u unit] [-f format] [arguments]. However, only -Rrnfu are actually functional. Internally, -p is a noop (it doesn't tie in with Bash coprocs at all), and -s only sets a flag but has no effect. -Cev are unimplemented.

• Assigning to variables: The printf -v way is slightly different to the way using command-substitution. Command substitution removes trailing newlines before substituting the text, printf -v preserves all output.

See also¶

• SUS: printf utility and printf() function
• Code snip: Print a horizontal line uses some printf examples