Why Does the Bourne Shell printf Iterate Over a %s Argument?

When working with shell scripts, many programmers find themselves puzzled by specific behaviors of commands. One such case arises when using the Bourne shell’s printf function, especially with string arguments. If you’ve ever encountered unexpected output while trying to display a variable with printf, you’re not alone! Let’s delve into why this happens and how to solve the issue.

The Problem Breakdown

Consider the following simple shell script:

#! /bin/sh
NAME="George W. Bush"
printf "Hello, %s\n" $NAME

When you execute this script, you might assume the output would be straightforward: Hello, George W. Bush. However, to your surprise, the command line returns:

Hello, George
Hello, W.
Hello, Bush

What’s Happening Here?

The issue lies in the way shell expands the variable. When you use $NAME without quotes, the shell splits the contents of the variable NAME by spaces, treating each part as a separate argument. Hence, printf is called with three arguments: George, W., and Bush. Each of these is processed individually, leading to the unexpected behavior you see.

The Correct Approach

To avoid this problem altogether, you need to encapsulate the variable in quotes. Here’s the corrected version of your script:

#! /bin/sh
NAME="George W. Bush"
printf "Hello, %s\n" "$NAME"

Why Quotes Matter

When you wrap $NAME in quotes, you convey to the shell that the entire content — including spaces — is a single argument. This is critical for strings that contain whitespace, as it keeps them intact during variable expansion.

Alternatives: Why Not Use echo?

You may wonder why one wouldn’t simply use echo instead of printf. Here’s a comparison between the two in context using a different example:

#! /bin/sh
FILE="C:\tmp"
echo "Filename: $FILE"

Running this script yields:

Filename: C:    mp

This behavior shows the issues that can arise when using echo, particularly with backslashes and escape sequences. As per the POSIX spec for echo: “New applications are encouraged to use printf instead of echo.” This recommendation speaks to the more predictable behavior and versatility of printf in formatting output.

Conclusion

In summary, it’s essential to remember that when using printf in shell scripts, always use double quotes around variables that may contain spaces or special characters. This ensures your output behaves as expected and prevents any frustrating surprises. With this small adjustment, you can confidently utilize printf in your scripts for clean and controlled output!

By employing best practices like these, you will find yourself crafting more robust and reliable shell scripts.