Difference between fmt.Println() and println() in Go

Question

As illustrated below, both fmt.Println() and println() give same output in Go: Hello world!

But: how do they differ from each other?

Snippet 1, using the fmt package;

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Hello world!")
}

Snippet 2, without the fmt package;

package main

func main() {
    println("Hello world!")
}

Wongawonga

Answer 1

println is an built-in function (into the runtime) which may eventually be removed, while the fmt package is in the standard library, which will persist. See the spec on that topic.

For language developers it is handy to have a println without dependencies, but the way to go is to use the fmt package or something similar (log for example).

As you can see in the implementation the print(ln) functions are not designed to even remotely support a different output mode and are mainly a debug tool.

Dosage

Answer 2

To build upon nemo's answer:

println is a function built into the language. It is in the Bootstrapping section of the spec. From the link:

Current implementations provide several built-in functions useful during bootstrapping. These functions are documented for completeness but are not guaranteed to stay in the language. They do not return a result.

Function   Behavior

print      prints all arguments; formatting of arguments is implementation-specific
println    like print but prints spaces between arguments and a newline at the end

Thus, they are useful to developers, because they lack dependencies (being built into the compiler), but not in production code. It also important to note that print and println report to stderr, not stdout.

The family provided by fmt, however, are built to be in production code. They report predictably to stdout, unless otherwise specified. They are more versatile (fmt.Fprint* can report to any io.Writer, such as os.Stdout, os.Stderr, or even a net.Conn type.) and are not implementation specific.

Most packages that are responsible for output have fmt as a dependency, such as log. If your program is going to be outputting anything in production, fmt is most likely the package that you want.

Tutu

"but not in production code" what does this mean? When I run go build, the output binary still has the text from println. – Uzial

It just means that it should not be used in "important" code. Production code is code that is used for some sort of larger project or product that a company or gov't agency uses. In other words, it's fine for a homework assignment, but not for a software engineer who gets paid to do her job. – Quartern

Answer 3

I can see difference here:

rangeOverIntsAndStrings(1, 5)

func rangeOverIntsAndStrings(args ...interface{}) {
    for _, v := range args {
        println(v)
    }
}

// output

(0x108f060,0x10c5358)
(0x108f060,0x10c5360)

vs

func rangeOverIntsAndStrings(args ...interface{}) {
    for _, v := range args {
        fmt.Println(v)
    }
}

// output

1
5

Scheer

Answer 4

Interesting Example:

➜  netpoll git:(develop) ✗ cat test.go
package main

import "fmt"

func main() {
        a := new(struct{})
        b := new(struct{})
        println(a, b, a == b)

        c := new(struct{})
        d := new(struct{})
        fmt.Printf("%v %v %v\n", c, d, c == d)
}
➜  netpoll git:(develop) ✗ go run test.go       
0xc000074f47 0xc000074f47 false
&{} &{} true
➜  netpoll git:(develop) ✗ go run -gcflags="-m" test.go
# command-line-arguments
./test.go:12:12: inlining call to fmt.Printf
./test.go:6:10: new(struct {}) does not escape
./test.go:7:10: new(struct {}) does not escape
./test.go:10:10: new(struct {}) escapes to heap
./test.go:11:10: new(struct {}) escapes to heap
./test.go:12:35: c == d escapes to heap
./test.go:12:12: []interface {} literal does not escape
<autogenerated>:1: .this does not escape
0xc000074f47 0xc000074f47 false
&{} &{} true

It is something difference between println and fmt.Printf.

Wetmore

Why you did not compare with println vs fmt.Println instead? – Knotty