Output formatting basics in Go - Step-by-Step Execution

Concept Flow - Output formatting basics

Start program

↓

Call fmt.Printf

↓

Process format string

↓

Replace verbs with values

↓

Print formatted output

↓

End program

The program starts, calls fmt.Printf with a format string and values, processes the format string by replacing verbs with values, prints the formatted output, then ends.

Execution Sample

Go

package main
import "fmt"
func main() {
 fmt.Printf("Hello, %s! You have %d new messages.\n", "Alice", 5)
}

This Go program prints a formatted greeting with a name and number of messages.

Execution Table

Step	Action	Format String	Values	Output Produced
1	Start program
2	Call fmt.Printf	Hello, %s! You have %d new messages.\n	["Alice", 5]
3	Process format string	Hello, %s! You have %d new messages.\n	["Alice", 5]
4	Replace %s with "Alice"	Hello, Alice! You have %d new messages.\n	[5]	Hello, Alice! You have %d new messages.\n
5	Replace %d with 5	Hello, Alice! You have 5 new messages.\n	[]	Hello, Alice! You have 5 new messages.\n
6	Print formatted output			Hello, Alice! You have 5 new messages.\n
7	End program

💡 Program ends after printing the formatted output.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
formatString		Hello, %s! You have %d new messages.\n	Hello, Alice! You have %d new messages.\n	Hello, Alice! You have 5 new messages.\n
values		["Alice", 5]	[5]	[]
output			Hello, Alice! You have %d new messages.\n	Hello, Alice! You have 5 new messages.\n	Hello, Alice! You have 5 new messages.\n

Key Moments - 2 Insights

Why does the output replace %s and %d with values?

Because fmt.Printf reads the format string and replaces each verb (%s, %d) with the corresponding value from the values list, as shown in steps 4 and 5 of the execution table.

What happens if the number of verbs and values don't match?

fmt.Printf will print the values for the verbs it can match and may print extra values or leave verbs unchanged if there is a mismatch, causing unexpected output. This is why matching counts is important.

Visual Quiz - 3 Questions

Look at the execution table, what is the output after step 5?

A Hello, Alice! You have 5 new messages.\n

B Hello, %s! You have %d new messages.\n

C Hello, Alice! You have %d new messages.\n

D Hello, %s! You have 5 new messages.\n

💡 Hint

Check the 'Output Produced' column at step 5 in the execution table.

At which step does the program actually print the final output?

A Step 3

B Step 6

C Step 4

D Step 7

💡 Hint

Look for the step labeled 'Print formatted output' in the execution table.

If we change the format string to "Hi %s!\n", how does the output change at step 6?

A Hi %s!\n

B Hello, Alice! You have 5 new messages.\n

C Hi Alice!\n

D Error because of missing %d

💡 Hint

Think about how the format string controls the printed output in the execution table.

Concept Snapshot

Go output formatting uses fmt.Printf with a format string and values.
Format verbs like %s and %d are placeholders.
Each verb is replaced by the corresponding value in order.
The final string is printed to the console.
Mismatch in verbs and values can cause unexpected output.

Full Transcript

This visual execution trace shows how Go's fmt.Printf function formats output. The program starts and calls fmt.Printf with a format string containing verbs like %s and %d, and values such as "Alice" and 5. The format string is processed step-by-step, replacing each verb with the matching value. After all replacements, the formatted string is printed to the console. The program then ends. Key points include how verbs correspond to values and the importance of matching their counts. The execution table and variable tracker show the state changes clearly at each step.

Practice

1. What does the %d format specifier do in fmt.Printf in Go?

easy

A. Prints an integer value

B. Prints a floating-point number

C. Prints a string

D. Prints a boolean value

Solution

1. Step 1: Understand format specifiers in Go

   The %d specifier is used to print decimal integers in Go's fmt.Printf.

2. Step 2: Match specifier to data type

   Since %d prints integers, it matches integer values, not floats, strings, or booleans.

3. Final Answer:

   Prints an integer value -> Option A

4. Quick Check:

   %d = integer [OK]

Hint: Remember %d is for decimal integers in printf [OK]

Common Mistakes:

• Confusing %d with %f for floats
• Using %d for strings
• Thinking %d prints booleans

2. Which of the following is the correct syntax to print a string variable name using fmt.Printf in Go?

easy

A. fmt.Printf("%d", name)

B. fmt.Printf("%f", name)

C. fmt.Printf("%s", name)

D. fmt.Printf(name)

Solution

1. Step 1: Identify the correct format specifier for strings

   The format specifier for strings in Go's fmt.Printf is %s.

2. Step 2: Check the syntax correctness

   fmt.Printf("%s", name) uses fmt.Printf("%s", name), which correctly prints the string variable name.

3. Final Answer:

   fmt.Printf("%s", name) -> Option C

4. Quick Check:

   %s prints strings [OK]

Hint: Use %s for strings in fmt.Printf [OK]

Common Mistakes:

• Using %d or %f for strings
• Omitting quotes around format string
• Passing variable without format specifier

3. What is the output of the following Go code?

package main
import "fmt"
func main() {
    x := 7
    y := 3.14
    fmt.Printf("x = %d, y = %.1f\n", x, y)
}

medium

A. x = 7, y = 3.1

B. x = 7, y = 3.14

C. x = 7, y = 3.0

D. x = 7, y = 3

Solution

1. Step 1: Understand the format specifiers used

   %d prints integer x as 7. %.1f prints floating-point y rounded to 1 decimal place.

2. Step 2: Apply rounding to y

   3.14 rounded to 1 decimal place is 3.1, so output is "x = 7, y = 3.1".

3. Final Answer:

   x = 7, y = 3.1 -> Option A

4. Quick Check:

   %.1f rounds float to 1 decimal [OK]

Hint: %.1f rounds float to 1 decimal place [OK]

Common Mistakes:

• Expecting full float without rounding
• Confusing %d with %f
• Ignoring newline character

4. Identify the error in this Go code snippet:

package main
import "fmt"
func main() {
    name := "Alice"
    age := 30
    fmt.Printf("Name: %s, Age: %f\n", name, age)
}

medium

A. Missing newline character in format string

B. Missing import statement

C. Incorrect variable declaration

D. Using %f to print an integer variable

Solution

1. Step 1: Check format specifiers against variable types

   name is a string, printed with %s correctly. age is an integer but printed with %f, which expects a float.

2. Step 2: Identify the mismatch causing error

   Using %f for an integer causes a runtime error or incorrect output.

3. Final Answer:

   Using %f to print an integer variable -> Option D

4. Quick Check:

   Match %f with float, not int [OK]

Hint: Match %f only with float variables [OK]

Common Mistakes:

• Using %f for integers
• Ignoring type mismatch warnings
• Assuming %f works for all numbers

5. You want to print a table of product names and prices aligned in columns using fmt.Printf. Which format string correctly aligns the name left in 10 spaces and price right in 6 spaces with 2 decimals?

fmt.Printf("...", name, price)

hard

A. "%10s %-6.2f\n"

B. "%-10s %6.2f\n"

C. "%10s %6.2f\n"

D. "%-10s %-6.2f\n"

Solution

1. Step 1: Understand alignment flags in format strings

   In Go, %-10s means left-align string in 10 spaces; %6.2f means right-align float in 6 spaces with 2 decimals.

2. Step 2: Match alignment to requirements

   We want product name left-aligned in 10 spaces and price right-aligned in 6 spaces with 2 decimals, so "%-10s %6.2f\n" fits.

3. Final Answer:

   "%-10s %6.2f\n" -> Option B

4. Quick Check:

   Left-align string with %-10s, right-align float with %6.2f [OK]

Hint: Use - for left-align strings, no - for right-align numbers [OK]

Common Mistakes:

• Swapping alignment flags
• Using wrong width or precision
• Forgetting to specify decimal places for floats