Golang fmt.Fprintf Function

The fmt.Fprintf function in Golang is part of the fmt package. It allows you to format and write text to any io.Writer, such as a file, a buffer, or a network connection. This function is useful for creating dynamic and formatted output that can be sent to different destinations.

Table of Contents

1. Introduction
2. Fprintf Function Syntax
3. Examples
   • Basic Usage
   • Writing to a File
4. Real-World Use Case
5. Conclusion

Introduction

The fmt.Fprintf function is used to write formatted strings to an io.Writer. It works similarly to fmt.Sprintf, but instead of returning the formatted string, it writes the output directly to the specified writer. This is useful for writing logs, generating reports, or sending data over a network connection.

Fprintf Function Syntax

The syntax for the fmt.Fprintf function is as follows:

func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)

Parameters:

• w: An io.Writer to which the formatted output is written.
• format: A string containing format specifiers that define how the arguments should be formatted.
• a: The data to be formatted according to the format specifiers.

Returns:

• n: The number of bytes written.
• err: An error if one occurred during writing.

Examples

Basic Usage

This example demonstrates how to use the fmt.Fprintf function to write formatted text to a string buffer.

Example

package main

import (
	"bytes"
	"fmt"
)

func main() {
	var buffer bytes.Buffer

	// Use fmt.Fprintf to write formatted text to the buffer
	fmt.Fprintf(&buffer, "Name: %s, Age: %d\n", "Alice", 30)

	// Print the contents of the buffer
	fmt.Println(buffer.String())
}

Output:

Name: Alice, Age: 30

Writing to a File

You can also use fmt.Fprintf to write formatted text to a file.

Example

package main

import (
	"fmt"
	"os"
)

func main() {
	// Open a file for writing
	file, err := os.Create("info.txt")
	if err != nil {
		fmt.Println("Error creating file:", err)
		return
	}
	defer file.Close()

	// Use fmt.Fprintf to write formatted text to the file
	fmt.Fprintf(file, "Item: %s, Price: $%.2f\n", "Laptop", 1299.99)
	fmt.Fprintf(file, "Item: %s, Price: $%.2f\n", "Smartphone", 799.99)

	fmt.Println("Data written to file successfully.")
}

Output in info.txt:

Item: Laptop, Price: $1299.99
Item: Smartphone, Price: $799.99

Real-World Use Case

Sending HTTP Responses

In real-world applications, fmt.Fprintf can be used to format and send HTTP responses by writing to the response writer.

Example

package main

import (
	"fmt"
	"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
	// Use fmt.Fprintf to send a formatted response
	fmt.Fprintf(w, "Hello, %s! Welcome to our website.\n", "Visitor")
}

func main() {
	http.HandleFunc("/", handler)

	fmt.Println("Server is running on http://localhost:8080")
	http.ListenAndServe(":8080", nil)
}

Accessing http://localhost:8080 will display:

Hello, Visitor! Welcome to our website.

Conclusion

The fmt.Fprintf function is a versatile function for writing formatted data to any writer that implements the io.Writer interface. It is ideal for applications that require formatted output to files, buffers, or network connections. By using fmt.Fprintf, you can create dynamic and flexible data output in your Go programs.