Différence entre fmt.Println() et println() en Go

Question

Comme illustré ci-dessous, les deux fmt.Println() y println() donnent le même résultat en Go : Hello world!

Mais : en quoi diffèrent-ils les uns des autres ?

L'extrait 1, qui utilise le fmt paquet ;

package main

import (
    "fmt"
)

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

L'extrait 2, sans le fmt paquet ;

package main

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

Answer 1

println est une fonction intégrée (dans le runtime) qui peut éventuellement être supprimée, tandis que la fonction fmt est dans la bibliothèque standard, ce qui persistera. Voir la spécification sur ce sujet.

Pour les développeurs de langage, il est pratique de disposer d'une println sans dépendances, mais il est préférable d'utiliser la fonction fmt ou quelque chose de similaire ( log par exemple).

Comme vous pouvez voir dans la mise en œuvre le site print(ln) ne sont pas conçues pour prendre en charge, même de loin, un mode de sortie différent et sont principalement un outil de débogage.

Answer 2

Pour construire sur la réponse de Nemo :

println est une fonction intégrée au langage. Elle se trouve dans la section Bootstrapping de l'interface utilisateur de l spec . Du lien :

Les implémentations actuelles fournissent plusieurs fonctions intégrées utiles pendant l'amorçage. Ces fonctions sont documentées pour être complètes mais ne sont pas garanties de rester dans le langage. Elles ne retournent pas un résultat.

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

Ainsi, ils sont utiles aux développeurs, car ils n'ont pas de dépendances (étant intégrés dans le compilateur), mais pas dans le code de production. Il est également important de noter que print y println rapport à stderr pas stdout .

La famille fournie par fmt sont cependant construits pour être dans le code de production. Ils rapportent de manière prévisible à stdout sauf indication contraire. Ils sont plus polyvalents ( fmt.Fprint* peut se présenter à n'importe quel io.Writer comme os.Stdout , os.Stderr ou même un net.Conn ) et ne sont pas spécifiques à une mise en œuvre.

La plupart des paquets qui sont responsables de la production ont fmt en tant que dépendance, comme log . Si votre programme est destiné à sortir quelque chose en production, fmt est très probablement le paquet que vous voulez.

Answer 3

Je peux voir la différence ici :

rangeOverIntsAndStrings(1, 5)

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

// sortie

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

vs

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

// sortie

1
5

Answer 4

Exemple intéressant :

➜  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

Il y a une différence entre println y fmt.Printf .

Answer 5

Quant à la différence, ce est un exemple.

println() imprime un pointeur sur l'adresse de la fonction test.

fmt.Println() imprime l'adresse de la fonction.