Go Output Functions

« Previous Next »

Go Output Functions

In Go, output is handled using functions from the built-in fmt package. The three most commonly used functions are:

• fmt.Print()
• fmt.Println()
• fmt.Printf()

Each serves a different purpose depending on how you want to format and display output.

fmt.Print() – Basic Output

The Print() function outputs values using their default format. It does not automatically add spaces between strings or a newline at the end.

Example:

package main import "fmt" func main() { message1 := "Good" message2 := "Morning" fmt.Print(message1) fmt.Print(message2) }

GoodMorning

Adding Line Breaks with \n

To move output to a new line, use the newline escape sequence \n.

package main import "fmt" func main() { fmt.Print("Welcome\n") fmt.Print("To Go Programming\n") }

Welcome To Go Programming

Printing Multiple Values

You can pass multiple arguments to Print(). However, spacing depends on the data types.

package main import "fmt" func main() { name := "Anita" age := 22 fmt.Print("Name:", name, "\nAge:", age) }

Name:Anita Age:22

Note: When printing non-string values together, Go automatically inserts spaces.

fmt.Println() – Line-Based Output

The Println() function is similar to Print(), but with two key differences:

• Automatically inserts spaces between arguments
• Adds a newline at the end

package main import "fmt" func main() { city := "Chennai" temperature := 32 fmt.Println("City:", city, "Temperature:", temperature) }

City: Chennai Temperature: 32

fmt.Printf() – Formatted Output

The Printf() function allows you to format output using format specifiers (verbs). It gives you precise control over how values are displayed.

Common Format Verbs:

Verb	Description
%v	Value (default format)
%T	Type of the value

package main import "fmt" func main() { product := "Laptop" price := 59999.99 fmt.Printf("Product: %v (Type: %T)\n", product, product) fmt.Printf("Price: %v (Type: %T)\n", price, price) }

Product: Laptop (Type: string) Price: 59999.99 (Type: float64)

When to Use Each Function

• Use Print() for simple output without formatting
• Use Println() when you want automatic spacing and line breaks
• Use Printf() for structured and formatted output

Go Printf() Formatting Verbs

In Go, the fmt.Printf() function provides powerful formatting capabilities using formatting verbs. These verbs control how values are displayed in the output, making your programs more readable and professional.

What Are Formatting Verbs?

Formatting verbs are placeholders (starting with %) used inside a format string. They are replaced by variable values when the program runs.

package main import "fmt" func main() { language := "Go" year := 2009 fmt.Printf("%s was released in %d\n", language, year) }

Go was released in 2009

General Formatting Verbs

Verb	Description
%v	Default value format
%#v	Go-syntax representation
%T	Type of the value
%%	Prints a literal %

package main import "fmt" func main() { value := 42.75 text := "GoLang" fmt.Printf("Value: %v\n", value) fmt.Printf("Go-syntax: %#v\n", value) fmt.Printf("Type: %T\n", value) fmt.Printf("Completion: %v%%\n", 85) fmt.Printf("Text: %v | %#v | %T\n", text, text, text) }

Value: 42.75 Go-syntax: 42.75 Type: float64 Completion: 85% Text: GoLang | "GoLang" | string

Integer Formatting Verbs

These verbs are used specifically for integer values.

Verb	Description
%b	Binary (base 2)
%d	Decimal (base 10)
%+d	Decimal with sign
%o	Octal
%O	Octal with 0o prefix
%x	Hexadecimal (lowercase)
%X	Hexadecimal (uppercase)
%#x	Hex with 0x prefix
%4d	Width 4 (right-aligned)
%-4d	Width 4 (left-aligned)
%04d	Zero-padded width 4

package main import "fmt" func main() { number := 27 fmt.Printf("Binary: %b\n", number) fmt.Printf("Decimal: %d\n", number) fmt.Printf("Signed: %+d\n", number) fmt.Printf("Octal: %o\n", number) fmt.Printf("Octal (prefixed): %O\n", number) fmt.Printf("Hex (lower): %x\n", number) fmt.Printf("Hex (upper): %X\n", number) fmt.Printf("Hex (with prefix): %#x\n", number) fmt.Printf("Right padded: %4d\n", number) fmt.Printf("Left padded: %-4d\n", number) fmt.Printf("Zero padded: %04d\n", number) }

String Formatting Verbs

These verbs control how strings are displayed.

Verb	Description
%s	Plain string
%q	Double-quoted string
%8s	Right-aligned (width 8)
%-8s	Left-aligned (width 8)
%x	Hex representation
% x	Hex with spaces

package main import "fmt" func main() { word := "Code" fmt.Printf("Plain: %s\n", word) fmt.Printf("Quoted: %q\n", word) fmt.Printf("Right aligned: %8s\n", word) fmt.Printf("Left aligned: %-8s\n", word) fmt.Printf("Hex: %x\n", word) fmt.Printf("Hex (spaced): % x\n", word) }

Boolean Formatting Verb

Verb	Description
%t	Boolean value (true or false)

package main import "fmt" func main() { isLoggedIn := true isAdmin := false fmt.Printf("Logged in: %t\n", isLoggedIn) fmt.Printf("Admin: %t\n", isAdmin) }

Logged in: true Admin: false

Float Formatting Verbs

These verbs format floating-point numbers.

Verb	Description
%e	Scientific notation
%f	Decimal format
%.2f	Precision (2 decimal places)
%6.2f	Width 6, precision 2
%g	Compact format

package main import "fmt" func main() { pi := 3.14159 fmt.Printf("Scientific: %e\n", pi) fmt.Printf("Decimal: %f\n", pi) fmt.Printf("Rounded: %.2f\n", pi) fmt.Printf("Width + precision: %6.2f\n", pi) fmt.Printf("Compact: %g\n", pi) }

Scientific: 3.141590e+00 Decimal: 3.141590 Rounded: 3.14 Width + precision: 3.14 Compact: 3.14159

« Previous Next »

AI Code Explanation Go Language

Powered by Gocourse AI