Hello again! In this lesson, we're revisiting Printf, an essential Go function for data printing. We'll explore it thoroughly to understand its critical role in formatting output. Let's get started!

Do you remember the fmt package function, Printf? It serves as Go's tool for print formatting, akin to crafting a telling narrative with full control over the structure and direction. Allow me to provide a brief recap of Printf:

Go
Copy
1package main
2import "fmt"
3func main() {
4    name := "John Doe"
5    fmt.Printf("Hello, %s!\n", name)  // Hello, John Doe
6}

In this Go code, %s acts as a string placeholder. Upon execution, Go replaces %s with the string stored in name.

Let's delve into Printf. Central to Printf are a format string and values. In essence, it is analogous to compiling words into a meaningful sentence.

Go
Copy
1x := 10
2y := 20
3fmt.Printf("x is %d and y is %d\n", x, y)  // x is 10 and y is 20

This example utilizes %d as a placeholder for an integer value. In the formatted print line, x and y replace %d correspondingly. Notice \n in the end of the string. It is a special character that creates a new line. Unlike fmt.Println, fmt.Printf function doesn't include a newline automatically. We will cover more details about special characters like this one in the following units.

Format specifiers in Printf orchestrate the display of various data types. Here's a summary:

• %v: default format representation
• %T: Go-syntax data type
• %d: integer
• %f: floating-point number
• %s: string
• %t: boolean

Let's see these specifiers in action:

Go
Copy
1x := 10
2fmt.Printf("Type: %T, Value: %v\n", x, x) // Type: int, Value: 10
3
4y := 20.5
5fmt.Printf("Type: %T, Value: %f\n", y, y) // Type: float64, Value: 20.500000
6
7name := "John Doe"
8fmt.Printf("Type: %T, Value: %s\n", name, name) // Type: string, Value: John Doe

Choosing the appropriate specifier can render your code more efficient and precise, and less prone to errors.

Now, let's demonstrate usage of Printf with different data types and precision control:

Go
Copy
1// Integer
2fmt.Printf("Integer: %d\n", 10)  // Integer: 10
3
4// Float
5fmt.Printf("Float: %.2f\n", 12.3456)  // Float: 12.35
6
7// String
8fmt.Printf("String: %s\n", "Hello, world!")  // String: Hello, world!
9
10// Boolean
11fmt.Printf("Boolean: %t\n", true)  // Boolean: true

%.2f in a float denotes a floating-point number with precision up to 2 decimal places.

Great job! We revisited Printf today, focusing on its syntax, format specifiers, and how they're utilized to format output for various data types. The vital takeaway here is that Printf provides the tools for precision in output formatting.

It's now time to hone your Printf skills with our custom practice exercises. Happy coding!