Input/Output Go

package main

import "fmt"

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

Il primo caso di入门 di questo sito è l'output di una stringa. In questa sezione verrà spiegato come eseguire input e output in Go.

Descrittori di file

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

Nel pacchetto os ci sono tre descrittori di file esposti, i cui tipi sono *os.File, rispettivamente:

• os.Stdin - Input standard
• os.Stdout - Output standard
• os.Stderr - Errore standard

L'input e l'output in Go non possono prescindere da essi.

Output

In Go ci sono molti metodi di output, di seguito alcuni dei più comuni

stdout

Poiché l'output standard è esso stesso un file, puoi scrivere direttamente una stringa nell'output standard

package main

import "os"

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

print

Go ha due funzioni incorporate print e println, che stamperanno i parametri nell'errore standard, solo per debug, generalmente non si consiglia l'uso.

package main

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

fmt

L'uso più comune è utilizzare il pacchetto fmt, che fornisce la funzione fmt.Println, che per impostazione predefinita stamperà i parametri nell'output standard.

package main

import "fmt"

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

I suoi parametri supportano qualsiasi tipo. Se il tipo implementa l'interfaccia String, verrà chiamato anche il metodo String per ottenere la sua rappresentazione come stringa, quindi il contenuto output ha una leggibilità relativamente alta, adatto alla maggior parte delle situazioni. Tuttavia, poiché internamente utilizza la riflessione, non si consiglia un uso massiccio in scenari sensibili alle prestazioni.

bufio

bufio fornisce metodi di output bufferizzati. Scriverà prima i dati in memoria e, una volta accumulata una certa soglia, li outputerà al Writer specificato. La dimensione predefinita del buffer è 4KB. Si consiglia di utilizzare questo pacchetto durante l'I/O di file e l'I/O di rete.

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

Puoi anche combinarlo con il pacchetto fmt

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

Formattazione

La funzionalità di output formattato in Go è fornita principalmente dalla funzione fmt.Printf. Se hai imparato linguaggi della famiglia C, ti sembrerà familiare. Di seguito è riportato un esempio semplice.

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

Di seguito sono riportati tutti i verbi di formattazione attualmente disponibili in Go.

0	Formattazione	Descrizione	Tipo ricevuto
1	%%	Stampa il simbolo di percentuale %	Qualsiasi
2	%s	Stampa il valore string/[] byte	string,[] byte
3	%q	Formatta la stringa, la stringa output ha virgolette doppie "" alle estremità	string,[] byte
4	%d	Stampa il valore intero decimale	Intero
5	%f	Stampa il numero floating-point	Floating-point
6	%e	Stampa in notazione scientifica, può essere utilizzato anche per numeri complessi	Floating-point
7	%E	Uguale a %e	Floating-point
8	%g	Determina se outputare %f o %e in base alla situazione, rimuoverà gli 0 superflui	Floating-point
9	%b	Stampa la rappresentazione binaria dell'intero	Numero
10	%#b	Stampa la rappresentazione completa in binario	Numero
11	%o	Stampa la rappresentazione ottale dell'intero	Intero
12	%#o	Stampa la rappresentazione ottale completa dell'intero	Intero
13	%x	Stampa la rappresentazione esadecimale minuscola dell'intero	Numero
14	%#x	Stampa la rappresentazione esadecimale minuscola completa dell'intero	Numero
15	%X	Stampa la rappresentazione esadecimale maiuscola dell'intero	Numero
16	%#X	Stampa la rappresentazione esadecimale maiuscola completa dell'intero	Numero
17	%v	Stampa il valore nel suo formato originale, utilizzato principalmente per l'output di strutture dati	Qualsiasi
18	%+v	Stampa il nome del campo quando si outputa una struttura	Qualsiasi
19	%#v	Stampa il valore nel formato completo della sintassi Go	Qualsiasi
20	%t	Stampa il valore booleano	Booleano
21	%T	Stampa il valore del tipo Go corrispondente al valore	Qualsiasi
22	%c	Stampa il carattere corrispondente al codice Unicode	int32
23	%U	Stampa il codice Unicode corrispondente al carattere	rune,byte
24	%p	Stampa l'indirizzo puntato dal puntatore	Puntatore

Utilizza fmt.Sprintf o fmt.Printf per formattare stringhe o output di stringhe formattate. Guarda alcuni esempi

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{})

Quando si utilizzano altre basi, aggiungendo uno spazio tra % e il verbo di formattazione si può ottenere l'effetto di un separatore, ad esempio

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

Il risultato output di questo esempio è

61626364656667
61 62 63 64 65 66 67

Quando si utilizzano numeri, è anche possibile aggiungere automaticamente zeri. Ad esempio

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

Lo stesso vale per il binario

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

Situazioni di errore

Numero di caratteri di formattazione < Numero di parametri

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

Numero di caratteri di formattazione > Numero di parametri

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

Tipo non corrispondente

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

Verbo di formattazione mancante

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

Input

Di seguito sono introdotti i metodi di input comuni

read

Puoi leggere il contenuto dell'input proprio come leggi direttamente un file, come segue

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

È troppo fastidioso da usare, generalmente non si consiglia l'uso.

fmt

Possiamo utilizzare alcune funzioni fornite dal pacchetto fmt, l'uso è simile a C.

// Scansiona il testo letto da os.Stdin, separato da spazi, anche il ritorno a capo è considerato uno spazio
func Scan(a ...any) (n int, err error)

// Simile a Scan, ma si interrompe la scansione quando si incontra un ritorno a capo
func Scanln(a ...any) (n int, err error)

// Scansiona in base a una stringa formattata
func Scanf(format string, a ...any) (n int, err error)

Leggere due numeri

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

Leggere un array di lunghezza fissa

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

Quando c'è una grande quantità di input da leggere, si consiglia di utilizzare bufio.Reader per leggere il contenuto

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 è simile a bufio.Reader, ma legge per righe.

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

Il risultato è il seguente

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

TIP

Per quanto riguarda l'input e l'output, se vuoi fare pratica, puoi risolvere alcuni semplici problemi algoritmici in modalità ACM su Luogu per familiarizzare.