Carsten

Heute habe ich mir eine Kata vorgenommen, und zwar FizzBuzz. Ich schreibe mein Golang immer noch extrem kurz und unleserlich. Solche Dinge wie r[v] = list[v] lösen ein schlechtes Gewissen bei mir aus, aber trotzdem bekommt ihr hier den Sourcecode ohne irgendwelche Verschönerungen. Wie bei einer Kata üblich kommt erst der Test, dann der Code:

fizzbuzz_test.go

package fizzbuzz

import (
    "testing"
)

func TestAnswer(t *testing.T) {
    actual := Answer([]int{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,60})
    expected := []interface{}{1,2,"fizz",4,"buzz","fizz",7,8,"fizz", "buzz",11,"fizz",13,14,"fizzbuzz","fizzbuzz"}
    for a := range(actual) {
        if actual[a] != expected[a] {
            error(t, "Wrong", expected[a], actual[a])
        }
    }
}
func error(t *testing.T, message string, expected interface{}, actual interface{}) {
    t.Errorf("%s: '%s' != '%s'", message, expected, actual)
}

fizzbuzz.go

package fizzbuzz

func Answer(list []int) []interface{} {
    r := make([]interface{}, len(list))
    for v := range(list) {
        switch {
            case list[v] % 3 == 0 && list[v] % 5 == 0:
                r[v] = "fizzbuzz"
            case list[v] % 3 == 0:
                r[v] = "fizz"
            case list[v] % 5 == 0:
                r[v] = "buzz"
            default:
                r[v] = list[v]
        }
    }
    return r
}

Es mag offensichtlich sein, aber ich will es hier doch noch festhalten: Um ein Element an eine map anzuhängen, genügt eine Zuweisung.

package main

import (
    "fmt"
)

func main() {
    var m = map[string]string{"1":"eins"}
    m["2"] = "zwei"
    fmt.Println(m)
}

Diese kleine Programm gibt folgende Ausgabe:

map[1:eins 2:zwei]

Daraufhin habe ich diese kleine Testanwendung geschrieben, die eine map[string]string nimmt, ein Argument hinzufügt und anschliessend einen String ausgibt, in dem alle Inhalte der map sortiert enthalten sind.

package main

import (
    "fmt"
    "strings"
    "sort"
)

func gq(m map[string]string) string {
    ma := make([]string, len(m))
    i := 0
    for key,value := range(m) {
        ma[i] = key + "=" + value
        i++
    }
    sort.SortStrings(ma)
    query := strings.Join(ma, "&")
    return query
}

func main() {
    var m = map[string]string{"1":"eins", "acht":"8"}
    m["2"] = "zwei"
    query := gq(m)
    fmt.Printf("result: ?%s\n", query)
}

Und ja, brauche ich so für meine erste kleine Anwendung von golang.

Weiter geht’s. Diesmal mit der Erstellung einer MD5-Hashsumme. Diese Funktion brauchte ich für die Validierung einer API-Anfrage. Dort sollte neben der Argumentliste auch eine Hashsumme der Argumente plus einem geheimen Schlüssel übermittelt werden. Nach ein paar erfolglosen Versuchen, aus der Package Documentation schlau zu werden, half mir (wieder einmal) Stackoverflow weiter.

Das ist übrigens auch der schwierigste Teil von Golang bis jetzt: Herausfinden, welche Funktion man aus einem Package gerade benötigt und vor allem wie man sie aufruft.

package main

import (
    "fmt"
    "crypto/md5"
    "hash"
)

func main() {
    original := "my string comes here"
    var h hash.Hash = md5.New()
    h.Write([]byte(original))
    fmt.Printf("%s: %x\n", original, h.Sum())
}

Gestern habe ich weiter an meiner ersten Applikation in golang gearbeitet und dabei stellte sich mir die Frage, wie man eine map[string]string sortiert. Stackoverflow hat (wie immer) weiter geholfen, nachdem ich ein paar Versuche selbst unternommen hatte.

Ich denke, die folgende Lösung ist nicht das schickste. Sicherlich gibt es eine nette Möglichkeit, eine map auch mit Channels zu sortieren. Ein BubbleSort sollte damit schnell erstellt sein. Das werde ich beim nächsten Mal ausprobieren.

package main

import (
    "fmt"
    "sort"
)

func main() {
    m := map[string]string{"b":"15", "z":"123123", "x":"sdf", "a":"12"}
    mk := make([]string, len(m))
    i := 0
    for k, _ := range m {
        mk[i] = k
        i++
    }
    sort.SortStrings(mk)
    fmt.Println(mk)
}