Go-Ein- und Ausgabe

In Go ist die Ein- und Ausgabe stark von der io-Schnittstelle abhängig. Die fmt-Paket bietet formatierte Ein- und Ausgabefunktionen.

fmt-Paket

Das fmt-Paket bietet Funktionen für formatierte Ein- und Ausgabe. Die häufigsten Funktionen sind Print, Printf, Println, Sprint, Sprintf, Sprintln, Fprint, Fprintf, Fprintln.

Print-Familie

Die Print-Familie gibt Werte auf dem Standardausgabegerät aus.

func Print(a ...any) (n int, err error)
func Printf(format string, a ...any) (n int, err error)
func Println(a ...any) (n int, err error)

• Print: Gibt Werte ohne Formatierung aus, getrennt durch Leerzeichen
• Printf: Gibt formatierte Werte aus
• Println: Gibt Werte mit Zeilenumbruch aus

Beispiel:

func main() {
   name := "Jack"
   age := 18
   fmt.Print("Name:", name, "Alter:", age)
   fmt.Println()
   fmt.Printf("Name:%s Alter:%d\n", name, age)
   fmt.Println("Name:", name, "Alter:", age)
}

Ausgabe:

Name:Jack Alter:18
Name:Jack Alter:18
Name: Jack Alter: 18

Sprint-Familie

Die Sprint-Familie formatiert Werte und gibt sie als String zurück.

func Sprint(a ...any) string
func Sprintf(format string, a ...any) string
func Sprintln(a ...any) string

Beispiel:

func main() {
   name := "Jack"
   age := 18
   s1 := fmt.Sprint("Name:", name, "Alter:", age)
   s2 := fmt.Sprintf("Name:%s Alter:%d", name, age)
   s3 := fmt.Sprintln("Name:", name, "Alter:", age)
   fmt.Println(s1)
   fmt.Println(s2)
   fmt.Println(s3)
}

Ausgabe:

Name:Jack Alter:18
Name:Jack Alter:18
Name: Jack Alter: 18

Fprint-Familie

Die Fprint-Familie schreibt formatierte Werte in einen io.Writer.

func Fprint(w io.Writer, a ...any) (n int, err error)
func Fprintf(w io.Writer, format string, a ...any) (n int, err error)
func Fprintln(w io.Writer, a ...any) (n int, err error)

Beispiel:

func main() {
   name := "Jack"
   age := 18
   fmt.Fprint(os.Stdout, "Name:", name, "Alter:", age)
   fmt.Println()
   fmt.Fprintf(os.Stdout, "Name:%s Alter:%d\n", name, age)
   fmt.Fprintln(os.Stdout, "Name:", name, "Alter:", age)
}

Ausgabe:

Name:Jack Alter:18
Name:Jack Alter:18
Name: Jack Alter: 18

Format-Verb

Das fmt-Paket unterstützt verschiedene Format-Verben für die Ausgabe.

Verb	Beschreibung
%v	Wert in Standardformat
%+v	Bei Strukturen Feldnamen hinzufügen
%#v	Go-Syntax-Darstellung des Werts
%T	Typ des Werts in Go-Syntax
%%	Literal-Prozentzeichen

Ganzzahlen

Verb	Beschreibung
%b	Basis 2
%c	Zeichen (Unicode-Codepoint)
%d	Basis 10
%o	Basis 8
%q	Einfach oder doppelt angeführtes Zeichen
%x	Basis 16, Kleinbuchstaben a-f
%X	Basis 16, Großbuchstaben A-F

Beispiel:

func main() {
   n := 255
   fmt.Printf("%b\n", n)
   fmt.Printf("%c\n", n)
   fmt.Printf("%d\n", n)
   fmt.Printf("%o\n", n)
   fmt.Printf("%q\n", n)
   fmt.Printf("%x\n", n)
   fmt.Printf("%X\n", n)
}

Ausgabe:

11111111
ÿ
255
377
'ÿ'
ff
FF

Gleitkommazahlen

Verb	Beschreibung
%b	wissenschaftliche Notation mit Basis 2
%e	wissenschaftliche Notation, z.B. -1234.567e+78
%E	wissenschaftliche Notation, z.B. -1234.567E+78
%f	Dezimalpunkt, keine Exponenten, z.B. 123.456
%F	Synonym für %f
%g	%e für große Exponenten, %f sonst
%G	%E für große Exponenten, %F sonst
%x	Hexadezimal, z.B. -0x1.23456p+78
%X	Hexadezimal, z.B. -0X1.23456P+78

Beispiel:

func main() {
   f := 3.14159
   fmt.Printf("%b\n", f)
   fmt.Printf("%e\n", f)
   fmt.Printf("%E\n", f)
   fmt.Printf("%f\n", f)
   fmt.Printf("%F\n", f)
   fmt.Printf("%g\n", f)
   fmt.Printf("%G\n", f)
   fmt.Printf("%x\n", f)
   fmt.Printf("%X\n", f)
}

Ausgabe:

7074237752028440p-50
3.141590e+00
3.141590E+00
3.141590
3.141590
3.14159
3.14159
+0x1.921fb54442d18p+1
+0X1.921FB54442D18P+1

Strings und Bytes

Verb	Beschreibung
%s	String
%q	Doppelt angeführter String
%x	Hexadezimal, Kleinbuchstaben
%X	Hexadezimal, Großbuchstaben

Beispiel:

func main() {
   s := "hello"
   fmt.Printf("%s\n", s)
   fmt.Printf("%q\n", s)
   fmt.Printf("%x\n", s)
   fmt.Printf("%X\n", s)
}

Ausgabe:

hello
"hello"
68656c6c6f
68656C6C6F

Zeiger

Verb	Beschreibung
%p	Basis 16, vorangestellt mit 0x

Beispiel:

func main() {
   n := 42
   p := &n
   fmt.Printf("%p\n", p)
   fmt.Printf("%p\n", &p)
}

Ausgabe:

0xc000016088
0xc000016090

io-Paket

Das io-Paket bietet grundlegende Schnittstellen für Ein- und Ausgabeoperationen.

Reader

Der Reader ist eine Schnittstelle zum Lesen von Daten.

type Reader interface {
   Read(p []byte) (n int, err error)
}

Writer

Der Writer ist eine Schnittstelle zum Schreiben von Daten.

type Writer interface {
   Write(p []byte) (n int, err error)
}

Closer

Der Closer ist eine Schnittstelle zum Schließen von Ressourcen.

type Closer interface {
   Close() error
}

ReadWriter

Der ReadWriter kombiniert Reader und Writer.

type ReadWriter interface {
   Reader
   Writer
}

ReadCloser

Der ReadCloser kombiniert Reader und Closer.

type ReadCloser interface {
   Reader
   Closer
}

WriteCloser

Der WriteCloser kombiniert Writer und Closer.

type WriteCloser interface {
   Writer
   Closer
}

ReadWriteCloser

Der ReadWriteCloser kombiniert Reader, Writer und Closer.

type ReadWriteCloser interface {
   Reader
   Writer
   Closer
}

os-Paket

Das os-Paket bietet plattformunabhängige Funktionen für Betriebssystemoperationen.

Stdin, Stdout, Stderr

var Stdin *File
var Stdout *File
var Stderr *File

• Stdin: Standardeingabe
• Stdout: Standardausgabe
• Stderr: Standardfehlerausgabe

Beispiel:

func main() {
   fmt.Fprint(os.Stdin, "Eingabe")
   fmt.Fprint(os.Stdout, "Ausgabe")
   fmt.Fprint(os.Stderr, "Fehler")
}

Dateioperationen

func Open(name string) (*File, error)
func Create(name string) (*File, error)
func OpenFile(name string, flag int, perm FileMode) (*File, error)

Beispiel:

func main() {
   file, err := os.Open("datei.txt")
   if err != nil {
      fmt.Println(err)
      return
   }
   defer file.Close()
   
   data := make([]byte, 100)
   n, err := file.Read(data)
   if err != nil {
      fmt.Println(err)
      return
   }
   fmt.Println(string(data[:n]))
}