Einführung in die Sprache Go anhand von Beispielen
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

126 lines
5.0 KiB

// Präsentation3hGolang4LGLRef35 project main.go
package main
import (
"bytes"
"crypto/md5"
"fmt"
"strconv"
"unicode/utf8"
)
const maximalePrüflänge int = 8
const referenzZeichenkette string = "lglRocks" // Darf nicht länger sein, als die maximale Prüflänge
var valideZeichenString string = "1234567890aäöübcdefghijklmnopqrsßtuvwxyzAÄBCDEFGHIJKLMNOÖPQRSTUÜVWXYZ_-+*!§$%&/=?#" // var statt const, damit die Funktion einen Zeiger übernehmen kann
func main() {
defer func() {
if r := recover(); r != nil {
fmt.Printf("Es gab einen Fehler: \"%v\"\n", r)
}
}()
valideZeichenStringArray := string2stringarray(&valideZeichenString)
fmt.Println(valideZeichenStringArray)
//fmt.Println(stringarray2string(&valideZeichenStringArray), len(valideZeichenStringArray), utf8.RuneCountInString(valideZeichenString))
if len(referenzZeichenkette) > maximalePrüflänge {
panic("Die Länge der Zeichenkette darf " + strconv.Itoa(maximalePrüflänge) + " nicht übersteigen")
}
/*primzahl := tcbb.FetchNextPrim()
for i := 1; i <= 10000000; i++ {
fmt.Println(primzahl())
}*/
generatedHashVorgabe := md5.Sum([]byte(referenzZeichenkette))
//fmt.Printf("%x\n", generatedHashVorgabe)
var zuPrüfendeZeichenketteIndexliste [maximalePrüflänge]int // = make([]int, 0, maximalePrüflänge) // Slice nicht notwendig, da maximalePrüflänge eine Konstante
// Damit jede mögliche Kombination einmal ausprobiert wird, baue ein Zählwerk eines Zahlensystems auf Basis der Anzahl valider Zeichen. Addiere hierzu auf den Index der niederwertigsten Ziffer 1 hinzu. Wenn diese Ziffer dann am Anschlag ist, erhöhe die nachfolgende Ziffer um 1 und stelle die aktuelle Ziffer wieder auf 0. Prüfe nun, ob dadurch die nachfolgende Ziffer auch auf 0 zurückfällt und die nächste Ziffer stattdessen erhöht werden soll.
forLoop:
for {
//fmt.Println(zuPrüfendeZeichenketteIndexliste)
zuPrüfendeZeichenkette, generatedHashVergleichswert := prüfeZeichenkette(&zuPrüfendeZeichenketteIndexliste, &valideZeichenStringArray)
if generatedHashVergleichswert == generatedHashVorgabe {
fmt.Println(zuPrüfendeZeichenkette)
fmt.Printf("%x\n", generatedHashVergleichswert)
}
for digit := 0; digit <= maximalePrüflänge; digit++ {
if digit == maximalePrüflänge {
break forLoop // Wenn eine Ziffer zuviel ausgewählt wurde, ist der Zähler einmal durch alle Kombinationen durch. Breche dann ab.
} else if zuPrüfendeZeichenketteIndexliste[digit] >= len(valideZeichenStringArray)-1 {
zuPrüfendeZeichenketteIndexliste[digit] = 0
} else {
zuPrüfendeZeichenketteIndexliste[digit]++
break // Wenn die eine Ziffer nicht am Anschlag ist, müssen die nachfolgenden nicht verändert werden
}
}
}
/*
for digit := 0; digit < len(valideZeichenStringArray); digit++ {
if zuPrüfendeZeichenkette[digit] == valideZeichenStringArray[len(valideZeichenStringArray)-1]
zuPrüfendeZeichenkette[digit] = valideZeichenStringArray[d]
fmt.Println(zuPrüfendeZeichenkette[0])
}
*/
/*
for k := maximalePrüflänge - 1; k >= 0; k-- {
for i := k - 1; i >= 0; i-- {
for j := 32; j <= 100; j = func(a int) int { // Sorge dafür, daß nur die validen Ascii-Character abgefragt werden.
switch {
case a >= 128 && a <= 159:
return 160
default:
return a + 1
}
}(j) {
zuPrüfendeZeichenkette[i] = byte(j)
fmt.Println(string(zuPrüfendeZeichenkette[:]))
//time.Sleep(10000000)
fmt.Println(string(j), j) //DEBUG
}
}
}
*/
}
// Wandele string in []string
func string2stringarray(myStr *string) (myStrArr []string) {
myStrArr = make([]string, 0, utf8.RuneCountInString(*myStr)) // Fange mit einer Länge von 0 an und rechne mit einer Kapazität der bekannten Länge und verhindere auf diese Weise Kapazitäten oberhalb des tatsächlichen Bedarfs. Teste eventuelle Kapazitätsverdopplungen mit "fmt.Println(utf8.RuneCountInString(myStr), cap(valideZeichenStringArray), len(valideZeichenStringArray))"
for _, c := range *myStr {
myStrArr = append(myStrArr, string(c))
// fmt.Println(string(c), valideZeichenStringArray[i], string(rune(myStr[i]))) // Deshalb []string statt []rune oder []byte
}
return
}
// Wandele []string in string
func stringarray2string(myStrArr *[]string) string {
var buffer bytes.Buffer
for i := 0; i < len(*myStrArr); i++ {
buffer.WriteString((*myStrArr)[i])
}
return buffer.String()
}
func prüfeZeichenkette(zuPrüfendeZeichenketteIndexliste *[maximalePrüflänge]int, valideZeichenStringArray *[]string) (string, [16]byte) {
var zuPrüfendeZeichenketteStringArray []string = make([]string, maximalePrüflänge, maximalePrüflänge) // Kapazität kann auf Länge begrenzt bleiben
for i := 0; i < maximalePrüflänge; i++ {
zuPrüfendeZeichenketteStringArray[i] = (*valideZeichenStringArray)[(*zuPrüfendeZeichenketteIndexliste)[i]]
}
zuPrüfendeZeichenketteString := stringarray2string(&zuPrüfendeZeichenketteStringArray)
return zuPrüfendeZeichenketteString, md5.Sum([]byte(zuPrüfendeZeichenketteString))
}