Entrée/Sortie en Go

package main

import "fmt"

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

Le premier exemple d'introduction de ce site était de sortir une chaîne de caractères. Cette section expliquera comment effectuer des entrées/sorties en Go.

Descripteurs de fichiers

var (
   Stdin  = NewFile(uintptr(syscall.Stdin), "/dev/stdin")
   Stdout = NewFile(uintptr(syscall.Stdout), "/dev/stdout")
   Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
)

Dans le paquet os, il y a trois descripteurs de fichiers exposés, dont le type est *os.File, respectivement :

• os.Stdin - Entrée standard
• os.Stdout - Sortie standard
• os.Stderr - Erreur standard

L'entrée/sortie en Go ne peut pas se passer d'eux.

Sortie

Il existe de nombreuses méthodes de sortie en Go, voici quelques-unes des plus courantes.

stdout

Comme la sortie standard est elle-même un fichier, vous pouvez directement écrire une chaîne dans la sortie standard.

package main

import "os"

func main() {
  os.Stdout.WriteString("hello world!")
}

print

Go a deux fonctions intégrées print et println. Elles sortiront les paramètres vers la sortie d'erreur standard et sont utilisées uniquement pour le débogage. Elles ne sont généralement pas recommandées.

package main

func main() {
  print("hello world!\n")
  println("hello world")
}

fmt

L'utilisation la plus courante est d'utiliser le paquet fmt, qui fournit la fonction fmt.Println. Cette fonction sort par défaut les paramètres vers la sortie standard.

package main

import "fmt"

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

Ses paramètres prennent en charge n'importe quel type. Si le type implémente l'interface String, la méthode String sera également appelée pour obtenir sa représentation sous forme de chaîne. Par conséquent, le contenu sorti a une lisibilité élevée et convient à la plupart des situations. Cependant, en raison de l'utilisation de la réflexion en interne, il n'est pas recommandé de l'utiliser massivement dans des scénarios sensibles aux performances.

bufio

bufio fournit des méthodes de sortie avec tampon. Il écrit d'abord les données en mémoire, puis les sort vers le Writer spécifié lorsqu'un certain seuil est atteint. La taille par défaut du tampon est de 4KB. Il est recommandé d'utiliser ce paquet pour les E/S de fichiers et les E/S réseau.

func main() {
  writer := bufio.NewWriter(os.Stdout)
  defer writer.Flush()
  writer.WriteString("hello world!")
}

Vous pouvez également l'utiliser en combinaison avec le paquet fmt.

func main() {
  writer := bufio.NewWriter(os.Stdout)
  defer writer.Flush()
  fmt.Fprintln(writer, "hello world!")
}

Formatage

La fonctionnalité de sortie formatée en Go est principalement fournie par la fonction fmt.Printf. Si vous avez appris les langages de la famille C, vous trouverez cela très familier. Voici un exemple simple.

func main() {
  fmt.Printf("hello world, %s!", "jack")
}

Voici tous les verbes de formatage actuellement disponibles en Go.

0	Formatage	Description	Type accepté
1	%%	Affiche le signe de pourcentage %	N'importe quel
2	%s	Affiche la valeur string/[] byte	string,[] byte
3	%q	Formate la chaîne, la chaîne sortie a des guillemets doubles "" aux deux extrémités	string,[] byte
4	%d	Affiche la valeur entière décimale	Entier
5	%f	Affiche le nombre flottant	Flottant
6	%e	Affiche sous forme de notation scientifique, peut également être utilisé pour les nombres complexes	Flottant
7	%E	Identique à %e	Flottant
8	%g	Sélectionne automatiquement %f ou %e selon la situation, supprimera les zéros inutiles	Flottant
9	%b	Affiche la représentation binaire de l'entier	Nombre
10	%#b	Affiche la représentation binaire complète	Nombre
11	%o	Affiche la représentation octale de l'entier	Entier
12	%#o	Affiche la représentation octale complète de l'entier	Entier
13	%x	Affiche la représentation hexadécimale en minuscules de l'entier	Nombre
14	%#x	Affiche la représentation hexadécimale complète en minuscules de l'entier	Nombre
15	%X	Affiche la représentation hexadécimale en majuscules de l'entier	Nombre
16	%#X	Affiche la représentation hexadécimale complète en majuscules de l'entier	Nombre
17	%v	Affiche la valeur sous sa forme originale, souvent utilisé pour la sortie de structures de données	N'importe quel
18	%+v	Affiche le nom des champs lors de l'affichage d'une structure	N'importe quel
19	%#v	Affiche la valeur au format complet de la syntaxe Go	N'importe quel
20	%t	Affiche la valeur booléenne	Booléen
21	%T	Affiche la valeur du type Go correspondant à la valeur	N'importe quel
22	%c	Affiche le caractère correspondant au code Unicode	int32
23	%U	Affiche le code Unicode correspondant au caractère	rune,byte
24	%p	Affiche l'adresse pointée par le pointeur	Pointeur

Utilisez fmt.Sprintf ou fmt.Printf pour formater des chaînes ou afficher des chaînes formatées. Voici quelques exemples :

fmt.Printf("%%%s\n", "hello world")

fmt.Printf("%s\n", "hello world")
fmt.Printf("%q\n", "hello world")
fmt.Printf("%d\n", 2<<7-1)

fmt.Printf("%f\n", 1e2)
fmt.Printf("%e\n", 1e2)
fmt.Printf("%E\n", 1e2)
fmt.Printf("%g\n", 1e2)

fmt.Printf("%b\n", 2<<7-1)
fmt.Printf("%#b\n", 2<<7-1)
fmt.Printf("%o\n", 2<<7-1)
fmt.Printf("%#o\n", 2<<7-1)
fmt.Printf("%x\n", 2<<7-1)
fmt.Printf("%#x\n", 2<<7-1)
fmt.Printf("%X\n", 2<<7-1)
fmt.Printf("%#X\n", 2<<7-1)

type person struct {
    name    string
    age     int
    address string
}
fmt.Printf("%v\n", person{"lihua", 22, "beijing"})
fmt.Printf("%+v\n", person{"lihua", 22, "beijing"})
fmt.Printf("%#v\n", person{"lihua", 22, "beijing"})
fmt.Printf("%t\n", true)
fmt.Printf("%T\n", person{})
fmt.Printf("%c%c\n", 20050, 20051)
fmt.Printf("%U\n", '码')
fmt.Printf("%p\n", &person{})

Lors de l'utilisation d'autres bases, ajouter un espace entre % et le verbe de formatage permet d'obtenir un effet de séparateur. Par exemple :

func main() {
  str := "abcdefg"
  fmt.Printf("%x\n", str)
  fmt.Printf("% x\n", str)
}

Le résultat de cet exemple est :

61626364656667
61 62 63 64 65 66 67

Lors de l'utilisation de nombres, vous pouvez également ajouter automatiquement des zéros. Par exemple :

fmt.Printf("%09d", 1)
// 000000001

Il en va de même pour le binaire :

fmt.Printf("%09b", 1<<3)
// 000001000

Cas d'erreur

Nombre de caractères de formatage < nombre de paramètres

fmt.Printf("", "") //%!(EXTRA string=)

Nombre de caractères de formatage > nombre de paramètres

fmt.Printf("%s%s", "") //%!s(MISSING)

Type non correspondant

fmt.Printf("%s", 1) //%!s(int=1)

Verbe de formatage manquant

fmt.Printf("%", 1) // %!(NOVERB)%!(EXTRA int=1)

Entrée

Voici les méthodes d'entrée courantes.

read

Vous pouvez lire le contenu de l'entrée comme si vous lisiez directement un fichier, comme suit :

func main() {
  var buf [1024]byte
  n, _ := os.Stdin.Read(buf[:])
  os.Stdout.Write(buf[:n])
}

C'est trop compliqué à utiliser, généralement non recommandé.

fmt

Nous pouvons utiliser plusieurs fonctions fournies par le paquet fmt, similaires à C.

// Scanne le texte lu depuis os.Stdin, séparé par des espaces, les nouvelles lignes sont également traitées comme des espaces
func Scan(a ...any) (n int, err error)

// Similaire à Scan, mais s'arrête lors d'une nouvelle ligne
func Scanln(a ...any) (n int, err error)

// Scanne selon une chaîne formatée
func Scanf(format string, a ...any) (n int, err error)

Lire deux nombres :

func main() {
  var a, b int
  fmt.Scanln(&a, &b)
  fmt.Printf("%d + %d = %d\n", a, b, a+b)
}

Lire un tableau de longueur fixe :

func main() {
  n := 10
  s := make([]int, n)
  for i := range n {
    fmt.Scan(&s[i])
  }
  fmt.Println(s)
}

1 2 3 4 5 6 7 8 9 10
[1 2 3 4 5 6 7 8 9 10]

bufio

Lorsqu'il y a beaucoup d'entrées à lire, il est recommandé d'utiliser bufio.Reader pour lire le contenu.

func main() {
    reader := bufio.NewReader(os.Stdin)
    var a, b int
    fmt.Fscanln(reader, &a, &b)
    fmt.Printf("%d + %d = %d\n", a, b, a+b)
}

scanner

bufio.Scanner est similaire à bufio.Reader, mais il lit ligne par ligne.

func main() {
  scanner := bufio.NewScanner(os.Stdin)
  for scanner.Scan() {
    line := scanner.Text()
    if line == "exit" {
      break
    }
    fmt.Println("scan", line)
  }
}

Le résultat est le suivant :

first line
scan first line
second line
scan second line
third line
scan third line
exit

TIP

Pour vous entraîner en matière d'entrée/sortie, vous pouvez résoudre quelques problèmes d'algorithmes simples en mode ACM sur Luogu.