• Go-Beispiele

> vi Hallo_Welt.go

Hallo_Welt.go

//Hallo Welt
package main
 
import "fmt"
 
func main()
{
        var welt string = "Welt"
        fmt.Printf("Hallo %v!\n", welt)
}

> go build Hallo_Welt.go
> ./Hallo_Welt
Hallo Welt!

> vi Funktionstest.go

Funktionstest.go

// Funktionstest
package main
 
import "fmt"
 
func Hallo(name string) {
        begruessung := "Hallo %v!\n"
        fmt.Printf(begruessung, name)
}
 
func Tschuess(name string) {
        verabschiedung := "Tschüß, %v!\n"
        fmt.Printf(verabschiedung, name)
}
 
func main() {
        var Welt string = "verbesserte Welt"
 
        Hallo(Welt)
 
        Tschuess(Welt)
}

> go build Funktionstest.go
> ./Funktionstest
Hallo verbesserte Welt!
Tschüß, verbesserte Welt!

> vi verzweigung_1.go

verzweigung_1.go

// Verzweigung mit switch
package main
 
import "fmt"
 
func Hallo(gender int, name string) {
        var addr string
 
        switch gender {
        default:
                addr = ""
        case 1:
                addr = "Frau "
        case 2:
                addr = "Herr "
        }
 
        fmt.Printf("Hallo, %v%v!\n", addr, name)
}
 
func main() {
        Hallo(1, "Fritz")
        Hallo(2, "Fratz")
        Hallo(3, "Fummel")
}

> go build verzweigung_1.go
> ./verzweigung_1
Hallo, Frau Fritz!
Hallo, Herr Fratz!
Hallo, Fummel!

> vi verzweigung_2.go

verzweigung_2.go

// Verzweigung mit if
package main
 
import "fmt"
 
func Hallo(gender int, name string) {
        var addr string
 
        if gender == 1 {
                addr = "Frau "
        } else {
                if gender == 2 {
                        addr = "Herr "
                } else {
                        addr = ""
                }
        }
 
        fmt.Printf("Hallo, %v%v!\n", addr, name)
}
 
func main() {
        Hallo(1, "Fritz")
        Hallo(2, "Fratz")
        Hallo(3, "Fummel")
}

> go build verzweigung_2.go
> ./verzweigung_2
Hallo, Frau Fritz!
Hallo, Herr Fratz!
Hallo, Fummel!

> vi zaehlschleife.go

zaehlschleife.go

// Zählschleife
package main
 
import "fmt"
 
func main() {
        // initializiere i nit 0
        // kontrolliere jedes mal ob i kleiner als 5 ist
        // i bei jedem Durchlauf um 1 vergrößern
        for i := 0; i <= 5; i++ {
                fmt.Println("Der Wert von 'i' ist jetzt:", i)
        }
}

> go build zaehlschleife.go
> ./zaehlschleife
Der Wert von 'i' ist jetzt: 0
Der Wert von 'i' ist jetzt: 1
Der Wert von 'i' ist jetzt: 2
Der Wert von 'i' ist jetzt: 3
Der Wert von 'i' ist jetzt: 4
Der Wert von 'i' ist jetzt: 5

> vi kanal_10.go

kanal_10.go

// nebenläufige Abarbeitung (parallele Programmierung) von Daten aus einem Kanal
package main
 
import "fmt"
 
func zehnMal(kanal chan string) {
        // Argument empfangen
        sag := <-kanal
 
        // Zehn mal zurückschreiben
        for i := 0; i < 10; i++ {
                kanal <- sag
        }
 
        // Kanal schließen
        close(kanal)
}
 
func main() {
        // synchronen Kanal öffnen
        //kanal := make(chan string)
        kanal := make(chan string, 0)
 
        // Starten der parallelen Go-Routine „zehnMal()“
        go zehnMal(kanal)
 
        // Senden eines Strings
        kanal <- "Hallo"
 
        // Empfangen der Strings, bis der Channel geschlossen wird
        for s := range kanal {
                fmt.Println(s)
        }
 
        fmt.Println("Fertig!")
}

> go build kanal_10.go
> ./kanal_10
Hallo
Hallo
Hallo
Hallo
Hallo
Hallo
Hallo
Hallo
Hallo
Hallo
Fertig!

> vi for-schleife_1.go

for-schleife_1.go

// einfache iterierende for-Schleife
package main
 
import (
        "fmt"
)
 
var timeZone = []string{
    "UTC:  0*60*60",
    "EST: -5*60*60",
    "CST: -6*60*60",
    "MST: -7*60*60",
    "PST: -8*60*60",
}
 
func main() {
        for _, j := range timeZone {
                fmt.Printf("%v\n",j)
        }   
}

> go build for-schleife_1.go
> ./for-schleife_1

> vi for-schleife_2.go

for-schleife_2.go

// iterierende for-Schleife mit Index
package main
 
import (
        "fmt"
)
 
var Zeitspannen = map[string]int{
    "Tag"    : 1*60*60*24,
    "Stunde" : 1*60*60,
    "Minute" : 1*60,
    "Sekunde": 1,
}
 
func main() {
        for i, j := range Zeitspannen {
                fmt.Printf("%v %v\n",i,j)
        }   
}

> go build for-schleife_2.go
> ./for-schleife_2

> vi parameter.go

parameter.go

// Parameter-Übergabe
package main
 
import (
        "fmt"
        "flag"
        )
 
func main() {
        // definiere das Flag "-par1" mit Voreinstellung und Hilfetext
        par1p := flag.Int("par1", 12, "dieser Parameter kann nur Integer-Werte annehmen")
        //
        // definiere das Flag "-par2" mit Voreinstellung und Hilfetext
        par2p := flag.String("par2", "gute Sache", "dieser Parameter kann nur Zeichenketten annehmen")
 
        // Ausgabe des Vorgabewertes vom Parameter
        fmt.Println("'par1' hat den folgenden Vorgabewert:", *par1p)
        fmt.Println("'par2' hat den folgenden Vorgabewert:", *par2p)
 
        // Parse
        flag.Parse()
 
        // Ausgabe des übergebenen Wertes vom Parameter
        fmt.Println()
        fmt.Println("'par1' wurde der Wert", *par1p ,"übergeben.")
        fmt.Println("'par2' wurde der Wert '"+*par2p+"' übergeben.")
}

> go build parameter.go
> ./parameter
'par1' hat den folgenden Vorgabewert: 12
'par2' hat den folgenden Vorgabewert: gute Sache

'par1' wurde der Wert 12 übergeben.
'par2' wurde der Wert gute Sache übergeben.

> ./parameter -par1=20 -par2="alles klar"
'par1' hat den folgenden Vorgabewert: 12
'par2' hat den folgenden Vorgabewert: gute Sache

'par1' wurde der Wert 20 übergeben.
'par2' wurde der Wert alles klar übergeben.

> ./parameter -par1=20 -par2=12
'par1' hat den folgenden Vorgabewert: 12
'par2' hat den folgenden Vorgabewert: gute Sache

'par1' wurde der Wert 20 übergeben.
'par2' wurde der Wert 12 übergeben.

> ./parameter -par1="alles super" -par2=1
'par1' hat den folgenden Vorgabewert: 12
'par2' hat den folgenden Vorgabewert: gute Sache
invalid value "alles super" for flag -par1: strconv.ParseInt: parsing "alles super": invalid syntax
Usage of ./parameter:
  -par1=12: dieser Parameter kann nur Integer-Werte annehmen
  -par2="gute Sache": dieser Parameter kann nur Zeichenketten annehmen

> vi Argumente.go

Argumente.go

// Argumenten-Übergabe
package main
 
import "os"
import "fmt"
 
func main() {
        for i := range os.Args[1:] {
                i += 1
                arg := os.Args[i]
                fmt.Printf("Das %v. Argument ist %v.\n", i, arg)
        }
}

> go build Argumente.go
> ./Argumente A B C D E F G H I J K L M
Das 1. Argument ist A.
Das 2. Argument ist B.
Das 3. Argument ist C.
Das 4. Argument ist D.
Das 5. Argument ist E.
Das 6. Argument ist F.
Das 7. Argument ist G.
Das 8. Argument ist H.
Das 9. Argument ist I.
Das 10. Argument ist J.
Das 11. Argument ist K.
Das 12. Argument ist L.
Das 13. Argument ist M.

dateiinhalt_in_variable_einlesen.go

// Dateiinhalt in eine Variable einlesen
 
package main
 
import (
        "fmt"
        "os"
        "io/ioutil"
        //"strings"
)
 
func main() {
        var (
                file string
                err error
        )
 
        file = os.Args[1]
        datei, err := ioutil.ReadFile(file)
        if err != nil {
                panic(err)
        }
        inhalt := string(datei)
 
        fmt.Println(inhalt)
        //fmt.Println(strings.Replace(inhalt, "\n", "|", -1))
 
        // Zeilenumbrüche gegen "|" austauschen
        //zeile := (strings.Replace(inhalt, "\n", "|", -1))
 
        // dort, wo vorher Leerzeilen waren, sind jetzt "||"
        // "||" werden hier wieder durch Zeilenumbrüche ersetzt
        //daten := (strings.Replace(zeile, "||", "\n", -1))
 
        //fmt.Println(daten)
}

dateiinhalt_in_array_einlesen.go

// Dateiinhalt zeilenweise in ein Array einlesen
 
package main
 
import (
        "os"
        "fmt"
        "bufio"
        "bytes"
        "io"
        //"io/ioutil"
        //"strings"
)
 
func readLines(path string) (lines []string, err error) {
        var (
                file *os.File
                part []byte
                prefix bool
        )
        if file, err = os.Open(path); err != nil {
                return
        }
        defer file.Close()
 
        reader := bufio.NewReader(file)
        buffer := bytes.NewBuffer(make([]byte, 0))
        for {
                if part, prefix, err = reader.ReadLine(); err != nil {
                        break
                }
                buffer.Write(part)
                if !prefix {
                        lines = append(lines, buffer.String())
                        buffer.Reset()
                }
        }
        if err == io.EOF {
                err = nil
        }
        return
}
 
 
func main() {
        dateiinhalt_alle_zeilen, _ := readLines(os.Args[1])
        fmt.Println(dateiinhalt_alle_zeilen)
 
        // alle Zeilen aus dem Array "dateiinhalt_alle_zeilen"
        // werden, durch "|" getrennt, aneinander gereiht
        //dateiinhalt_alles_in_einer_zeile := strings.Join(dateiinhalt_alle_zeilen, "|")
        //fmt.Println(dateiinhalt_alles_in_einer_zeile)
 
        //fmt.Println(strings.Replace(dateiinhalt_alles_in_einer_zeile, `\n`, "|", -1))
}

> vi datei_ueberschreiben.go

datei_ueberschreiben

// vorhandene Datei überschreiben bzw. Datei neu anlegen
package main
 
import (
        "fmt"
        "os"
        "log"
)
 
func main() {
        var datei string
        var text string
 
        datei = "/tmp/go-test.txt"
        text = "Hallo Welt!\n"
 
        // die Datei wird neu angelegt, dabei geht der alte Inhalt verloren
        os.Create(datei)
        // wenn die Datei existiert, dann wird sie überschrieben
        f, err1 := os.OpenFile(datei, os.O_RDWR, 0644)
        //  
        // hier wird überprüft, ob es beim öffnen der Datei, einen Fehler gegeben hat 
        if err1 != nil {
                log.Fatal(err1)
        }   
 
        // hier wird die Datei-Kennzeichnung, der geöffneten Datei, ausgegeben
//      fmt.Printf("file descriptor: %v\n", f)
 
        // hier wird in die Datei geschrieben
        g, err2 := f.WriteString(text)
        fmt.Printf("%v Zeichen wurden geschrieben: %v", g, text)
 
        // hier wird überprüft, ob es beim Schreibvorgang in die Datei, einen Fehler gegeben hat 
        if err2 != nil {
                log.Fatal(err2)
        }   
}

> go build datei_ueberschreiben.go
> ./datei_ueberschreiben

> vi datei_schreiben.go

datei_schreiben

// Datei von Beginn an überschreiben (auch unvollständig)
package main
 
import (
        "fmt"
        "os"
        "log"
)
 
func main() {
        var datei string
        var text string
 
        datei = "/tmp/go-test.txt"
        text = "Hallo Welt!\n"
 
        // wenn die Datei noch nicht existiert, dann wird sie angelegt
        // wenn die Datei bereits vorhanden ist, dann werden die neuen Daten vom
        // Beginn der Datei an geschrieben; werden weniger Daten geschrieben, als
        // sich bereits in der Datei befanden, dann bleibt der Rest weiterhin bestehen
        f, err1 := os.OpenFile(datei, os.O_RDWR|os.O_CREATE, 0644)
        //
        // hier wird überprüft, ob es beim öffnen der Datei, einen Fehler gegeben hat
        if err1 != nil {
                log.Fatal(err1)
        }
 
        // hier wird die Datei-Kennzeichnung, der geöffneten Datei, ausgegeben
//      fmt.Printf("file descriptor: %v\n", f)
 
        // hier wird in die Datei geschrieben
        g, err2 := f.WriteString(text)
        fmt.Printf("%v Zeichen wurden geschrieben: %v", g, text)
 
        // hier wird überprüft, ob es beim Schreibvorgang in die Datei, einen Fehler gegeben hat
        if err2 != nil {
                log.Fatal(err2)
        }
}

> go build datei_schreiben.go
> ./datei_schreiben

> vi datei_anhaengen.go

datei_anhaengen

// an Datei anhängen
package main
 
import (
        "fmt"
        "os"
        "log"
)
 
func main() {
        var datei string
        var text string
 
        datei = "/tmp/go-test.txt"
        text = "Hallo Welt!\n"
 
        // wenn die Datei noch nicht existiert, dann wird sie angelegt
        // wenn die Datei bereits vorhanden ist, dann werden die neuen Daten vom
        // Beginn der Datei an geschrieben; werden weniger Daten geschrieben, als
        // sich bereits in der Datei befanden, dann bleibt der Rest weiterhin bestehen
        f, err1 := os.OpenFile(datei, os.O_RDWR|os.O_CREATE, 0644)
        //
        // gehe ans Ende
        f.Seek(0, 2)
        //
        // hier wird überprüft, ob es beim öffnen der Datei, einen Fehler gegeben hat
        if err1 != nil {
                log.Fatal(err1)
        }
 
        // hier wird die Datei-Kennzeichnung, der geöffneten Datei, ausgegeben
//      fmt.Printf("file descriptor: %v\n", f)
 
        // hier wird in die Datei geschrieben
        g, err2 := f.WriteString(text)
        fmt.Printf("%v Zeichen wurden geschrieben: %v", g, text)
 
        // hier wird überprüft, ob es beim Schreibvorgang in die Datei, einen Fehler gegeben hat
        if err2 != nil {
                log.Fatal(err2)
        }
}

> go build datei_anhaengen.go
> ./datei_anhaengen

• http://rosettacode.org/wiki/Read_a_file_line_by_line#Go

> vi date_zeilenweise_lesen.go

date_zeilenweise_lesen

// Datei zeilenweise auslesen
package main
 
import (
        "bufio"
        "fmt"
        "io"
        "log"
        "os"
)
 
func main() {
        var datei string
        datei = "/tmp/go-test.txt"
 
        // Datei öffnen
        f, err := os.Open(datei)
        // kontrollieren, ob beim öffnen der Datei alles gut gegangen ist 
        if err != nil {
                log.Fatal(err)
        }   
 
        // Dateiinhalt aus der Datei in einen Puffer lesen
        bf := bufio.NewReader(f)
 
        // Endlosschleife starten
        // die geht Zeile für Zeile durch die Datei
        for {
                // den Puffer zeilenweise auslesen
                line, isPrefix, err := bf.ReadLine()
 
                // kontrollieren, ob das Dateiende erreicht wurde
                if err == io.EOF {
                        break
                }   
 
                // kontrollieren, ob beim lesen aus dem Puffer alles gut gegangen ist
                if err != nil {
                        log.Fatal(err)
                }   
 
                // nach weiteren Fehler sehen;
                // Bufio ist normalerweise 4K groß, ist eine Zeile größer als 4K
                // gibt es hier eine Fehlermeldung;
                // sollte es einen Fehler geben obwohl die Zeile kleiner als 4K ist,
                // dann kann die Datei kaputt sein oder es wir die falsche Datei
                // gelesen
                if isPrefix {
                        log.Fatal("Error: Unexpected long line reading", f.Name())
                }   
 
                // Fertig 
                // aber beachte, dass die Daten hier als Byte-Stück (byte slice)
                // und nicht als "string" vorliegen...
                // Bist Du damit zufrieden, dann kannst Du das hier einsetzen.
                fmt.Println(string(line))
        }   
}

> go build date_zeilenweise_lesen.go
> ./date_zeilenweise_lesen

hiermit wird eine Webseite aufgerufen und dessen Quellkode ausgegeben

go_web.go

// Web-Aufruf
 
//
// Beispiele für Aufrufe:
// ./go_web -HOST=www.heise.de -PFAD=/index.html
// ./go_web -HOST www.heise.de -PFAD /
//
 
package main
 
import (
        "fmt"
        "io/ioutil"
        "log"
        "net/http"
        "crypto/tls"
        "strings"
        "os"
        "flag"
)
 
func GetWebsite(HOST , PFAD string) string {
        NoCertVerify := &http.Transport{
                TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        }
 
        NoCertVerifyHttp := &http.Client{Transport: NoCertVerify}
 
        JoinStrings := []string{"https://", HOST, PFAD}
        Response, Error := NoCertVerifyHttp.Get(strings.Join(JoinStrings, ""))
        if Error != nil {
                log.Fatal(Error)
        }
 
        Output, Error := ioutil.ReadAll(Response.Body)
        Response.Body.Close()
        if Error != nil {
                log.Fatal(Error)
        }
 
        return string(Output)
}
 
func main() {
        HOSTPtr := flag.String("HOST", "NoHOST", "HOST to check")
        PFADPtr := flag.String("PFAD", "NoPFAD", "PFAD to check")
 
        flag.Parse()
 
        if *HOSTPtr != "NoHOST" && *PFADPtr != "NoPFAD" {
 
        } else {
                fmt.Println("Es wurden nicht alle Schalter benutzt!")
                os.Exit(2)
        }
 
        WebsiteContent := GetWebsite(*HOSTPtr, *PFADPtr)
 
        if WebsiteContent != "" {
                fmt.Println(WebsiteContent)
                os.Exit(0)
 
        } else {
                fmt.Println("Fehler!")
                os.Exit(1)
        }
}

> go build go_web.go
> ./go_web -IP=www.heise.de -PFAD=/index.html
> ./go_web -IP www.heise.de -PFAD /

hiermit wird überprüft, ob eine bestimmte Zeichenfolge im Quellkode einer Webseite enthalten ist:

web_check.go

// Web-Check
 
//
// Beispiele für Aufrufe:
// go build web_check.go
// ./web_check -HOST=www.heise.de -PFAD=/index.html -STRING='Newsticker'
// ./web_check -HOST www.heise.de -PFAD / -STRING 'Newsticker'
//
 
package main
 
import (
        "fmt"
        "io/ioutil"
        "log"
        "net/http"
        "crypto/tls"
        "strings"
        "os"
        "flag"
)
 
func GetWebsite(HOST , PFAD string) string {
 
        NoCertVerify := &http.Transport{
                TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        }
 
        NoCertVerifyHttp := &http.Client{Transport: NoCertVerify}
 
        JoinStrings := []string{"https://", HOST, PFAD}
        Response, Error := NoCertVerifyHttp.Get(strings.Join(JoinStrings, ""))
        if Error != nil {
                log.Fatal(Error)
        }
 
        Output, Error := ioutil.ReadAll(Response.Body)
        Response.Body.Close()
        if Error != nil {
                log.Fatal(Error)
        }
 
        return string(Output)
}
 
func StringContains(WebsiteString, StringToCompare string) bool {
 
        if strings.Contains(WebsiteString, StringToCompare) {
                return true
        } else {
                return false
        }
}
 
func main() {
 
        HOSTPtr := flag.String("HOST", "NoHOST", "HOST to check")
        PFADPtr := flag.String("PFAD", "NoPFAD", "PFAD to check")
        STRINGPtr := flag.String("STRING", "NosTRING", "STRING to check")
 
        flag.Parse()
 
        if *HOSTPtr != "NoHOST" && *PFADPtr != "NoPFAD" && *STRINGPtr != "NoSTRING" {
 
 
        } else {
                fmt.Println("Es wurden nicht alle Schalter benutzt!")
                os.Exit(2)
        }
 
        WebsiteContent := GetWebsite(*HOSTPtr, *PFADPtr)
        Status := StringContains(WebsiteContent, *STRINGPtr)
 
        if Status {
                //fmt.Println("Läuft!")
                os.Exit(0)
 
        } else {
                //fmt.Println("Läuft nicht!")
                os.Exit(1)
        }
}

> go build web_check.go
> ./web_check -HOST www.heise.de -PFAD / -STRING 'Newsticker' && echo OK || echo KO
OK

> ./web_check -HOST www.heise.de -PFAD / -STRING '§' && echo OK || echo KO
KO

https://thedeveloperblog.com/go/os-exec-go

programmaufruf.go

package main
 
import (
        "fmt"
        "log"
        "os"
        "os/exec"
)
 
func main() {
        //var psize string
        //psize = "9223372036G"
        var psize string = "9223372036G"
        var film = os.Args[1]
 
        prog := "ffprobe"
        cmd := exec.Command(prog, "-v", "error", "-probesize", psize, "-analyzeduration", psize, "-i", film, "-show_streams")
 
        out, err := cmd.Output()
        if err != nil {
                log.Fatal(err)
        }
        fmt.Printf("%s\n", out)
}

> go build programmstart.go
./programmstart title_t01.mpg
[STREAM]
index=0
codec_name=mpeg2video
codec_long_name=MPEG-2 video
profile=Main
codec_type=video
codec_tag_string=[0][0][0][0]
codec_tag=0x0000
width=720
height=576
...

In der Praxis wird man eine solche Aufgabe nicht so lösen, sondern dafür eine entsprechende Bibliothek einsetzen.

go-ffprobe

FFprobeTest.go

package main
 
import (
	"context"
	"fmt"
	"log"
	"os"
	"regexp"
	"strconv"
	"time"
 
	"gopkg.in/vansante/go-ffprobe.v2"
)
 
func string2int(s string) int {
	i, err := strconv.Atoi(s)
	if err != nil {
		i = 0
	}
	return i
}
 
func main() {
	var film = os.Args[1]
 
	ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Minute)
	defer cancelFn()
 
	data, err := ffprobe.ProbeURL(ctx, film)
	if err != nil {
		log.Panicf("Error getting data: %v", err)
	}
 
	//fmt.Printf("%s\n", data.Streams[0].CodecType)
	//fmt.Printf("%s\n", data.FirstSubtitleStream())
 
	for i, s := range data.Streams {
		codectype := s.CodecType
		sprache, _ := s.TagList.GetString("language")
		fmt.Printf("Spur: %v, Typ: %v, Sprache: %v\n", i, codectype, sprache)
 
		if "video" == s.CodecType {
			fmt.Printf("Spur: %v, Typ: %v, Width: %v\n", i, codectype, data.Streams[i].Width)
			fmt.Printf("Spur: %v, Typ: %v, Height: %v\n", i, codectype, data.Streams[i].Height)
			fmt.Printf("Spur: %v, Typ: %v, PAR: %v\n", i, codectype, data.Streams[i].SampleAspectRatio)
			fmt.Printf("Spur: %v, Typ: %v, DAR: %v\n", i, codectype, data.Streams[i].DisplayAspectRatio)
			fmt.Printf("Spur: %v, Typ: %v, Level: %v\n", i, codectype, data.Streams[i].Level)
			fmt.Printf("Spur: %v, Typ: %v, FieldOrder: %v\n", i, codectype, data.Streams[i].FieldOrder)
			fmt.Printf("Spur: %v, Typ: %v, FPS: %v\n", i, codectype, data.Streams[i].RFrameRate)
			fmt.Printf("Spur: %v, Typ: %v, avg FSP: %v\n", i, codectype, data.Streams[i].AvgFrameRate)
 
			drehung := 0
			rotation, _ := s.TagList.GetString("Rotate")
			drehlength := len([]rune(rotation))
			if drehlength > 0 {
				drehung = string2int(rotation)
			}
			fmt.Printf("Spur: %v, Typ: %v, Drehung: %v Grad\n", i, codectype, drehung)
 
			spieldauer := 0
			duration, _ := s.TagList.GetString("DURATION")
			durlength := len([]rune(duration))
			if durlength > 0 {
				var hms [3]int
				rsplit := regexp.MustCompile("[:.]")
				for g, h := range rsplit.Split(duration, -1)[:3] {
					hms[g] = string2int(h)
				}
 
				// hms -> H:M:S -> Stunde:Minute:Sekunde
				spieldauer = hms[0]*3600 + hms[1]*60 + hms[2]
			}
 
			fmt.Printf("Spur: %v, Typ: %v, Spieldauer: %v Sekunden\n", i, codectype, spieldauer)
 
			// Alle TAGs aus dem Container anzeigen
			//for n, t := range s.TagList {
			//	fmt.Printf("        %v, %v\n", n, t)
			//}
		}
	}
}

> go build FFprobeTest.go
> ./FFprobeTest titlet01.mkv
Spur: 0, Typ: video, Sprache: eng
Spur: 0, Typ: video, Width: 720
Spur: 0, Typ: video, Height: 576
Spur: 0, Typ: video, PAR: 16:15
Spur: 0, Typ: video, DAR: 4:3
Spur: 0, Typ: video, Level: 8
Spur: 0, Typ: video, FieldOrder: tt
Spur: 0, Typ: video, FPS: 25/1
Spur: 0, Typ: video, avg FSP: 25/1
Spur: 0, Typ: video, Drehung: 0 Grad
Spur: 0, Typ: video, Spieldauer: 122 Sekunden
Spur: 1, Typ: audio, Sprache: eng
Spur: 2, Typ: subtitle, Sprache: eng
Spur: 3, Typ: subtitle, Sprache: ger