In Go programs, output needs to be printed and reported. We have the "fmt
" package, and many helpful funcs like Printf
and Println
.
In Go we can use Printf
with a special format code. This determines how a string
or integer is formatted. Println
does not require a format string
.
Printf
, V formatTo start, with Printf
many format codes are available. But to make programs simpler, we can just use the "%v" format code to insert values.
Printf
calls easier to write and read.package main
import "fmt"
func main() {
result := true
name := "Spark"
size := 2000
// Print line with v format codes.
fmt.Printf("Result = %v, Name = %v, Size = %v",
result, name, size)
}Result = true, Name = Spark, Size = 2000
We can pass various format strings to Printf
. Codes like "%s" and "%d" indicate insertion points for values. Those values are also passed as arguments.
package main
import "fmt"
func main() {
name := "Mittens"
weight := 12
// Use %s to mean string.
// ... Use an explicit newline.
fmt.Printf("The cat is named %s.\n", name)
// Use %d to mean integer.
fmt.Printf("Its weight is %d.\n", weight)
}The cat is named Mittens.
Its weight is 12.
Println
To continue, we examine the Println
method. This method is one of the easiest and simplest ones in fmt
. We first must use an import statement with the argument "fmt
."
Println
, on the fmt
package. Println
is versatile and can accept many arguments.package main
import "fmt"
func main() {
// The Println method can handle one or more arguments.
fmt.Println("cat")
fmt.Println("cat", 900)
// Use Println on a slice.
items := []int{10, 20, 30}
fmt.Println(items)
}cat
cat 900
[10 20 30]
for
-loopThe Println
always inserts a newline after we use it. But Print does not: it just writes the data to the console with no trailing newline.
package main import "fmt" func main() { elements := []int{999, 99, 9} // Loop over the int slice and Print its elements. // ... No newline is inserted after Print. for i := 0; i < len(elements); i++ { fmt.Print(elements[i] + 1) fmt.Print(" ") } fmt.Println("... DONE!") }1000 100 10 ... DONE!
println
Print and println
are universal functions. We can call these without referencing the "fmt
" package. But their functionality is not identical to the fmt
methods.
fmt.Println
not just println
. The fmt
package is thus preferred.package main
func main() {
value := 10
// Use println.
println(value)
// Use print.
// ... Use println with no arguments to write a newline.
print(value)
println()
// Done.
println("DONE")
}10
10
DONE
Println
differencesThe println
universal function has different output than the fmt.Println
method. They are not the interchangeable.
Fmt.Println
displays the elements, but "println
" displays a reference value.package main
import "fmt"
func main() {
items := []int{10, 20}
// These two println methods have different output.
fmt.Println(items)
println(items)
}[10 20]
[2/2]0xc08200a250
This method is a string
-based form of Printf
. The "S" stands for "string
." So we use Printf
and it returns a string
—the value is not written to the console.
string
. We then print its length, and its contents with fmt.Println
.Printf
in a string
(for later use or processing) then Sprintf is ideal.import "fmt"
func main() {
value1 := "a tree";
value2 := "the park";
// Use format string to generate string.
result := fmt.Sprintf("I saw %v at %v.\n", value1, value2)
// Write length of string, and string itself.
fmt.Println("Length:", len(result))
fmt.Println(result)
}Length: 26
I saw a tree at the park.
This func
takes any number or arguments—it works the same way as fmt.Println
, but returns a string
. It does not support format codes.
package main
import "fmt"
func main() {
// Use Sprintln, no format strings are supported.
// ... A newline is added.
// A string is returned.
result := fmt.Sprintln("Hey friend", 100)
fmt.Print("[" + result + "]")
}[Hey friend 100
]
Fprint
, Fprintf
These methods are just like fmt.Print
but target a file in the first argument. They write to files—nothing is written to the console.
Sscan
, Sscanf
We can parse in space-separated values with fmt.Sscan
. And with Sscanf
we use a format string
to parse in values. Sometimes this is easier than using split()
or fields()
.
We can apply padding with fmt.Printf
to ensure strings are a certain number of characters long. Spaces are added before or after the value.
With methods prefixed by s, we can output the results to a string
. We can write those strings to a file, or use them in any way we can use a string
.