Allgemeines

// ein * (Stern) bedeutet immer eine Referenzierung auf etwas

Variables

var name = "asdf" // hier wird es kurzfristig definiert (z.B. wenn innerhalb einer loop definiert, dann nur in der loop verfügbar)
var name := "asdf" // hier wird die Variable langfristig erstellt
var name string // hier wird eine Variable als String deklariert

// auch:

name := "asdf" // ist die verbreiteste und modt commen Möglichkeit

Functions

// func (a *<auf das Referenzierende Objekt z.B. Struct oder Package>) <funcname>(paramname string) (<returnType> string){}
// func (hier wird definiert, ob zu welchem z.B. Stuct die Function gehört (wenn nicht gesetzt, kann man es normal aufrufen, man muss nicht direkt über des Struct))
// wenn 1. Buchstabe in Functionname gross -> Public, klein -> private (innerhalb des packages)
// ein * (Stern) bedeutet immer eine Referenzierung auf etwas
func (a *struct) funcName(paramname paramtype) (returntype){
	// do something
}

// default:

func funcName(){
	// do something
}

Return

// wenn man ein Reqest macht, der mehrere Werte zurückgibt, kann man für jeden Wert eine Variable definieren
// wenn man anstatt eine Variabel ein '_' schreibt, läuft dieser return ins leere, und kann nicht mehr benutzt werden
// Für alle Return-Werte muss eine Variable oder ein '_' angegeben werden

username, password, hasAuth := basicAuth() // admin, admin, true
username, _, _ := basicAuth() // admin, insVoid, insVoid

// falls man nicht direkt ein underscore machen kann, kann man danach die variable ins void laufen lassen (anstatt: username, _, _ := basicAuth())
username, password, hasAuth := basicAuth()
_ = password
_ = hasAuth

func basicauth() {
	username := "admin"
	password := "admin"
	hasAuth := true
	return username, password, hasAuth
}

// das gesamte Error-Handling basiert auf diesem Prinzip
result, err := callSomeFunction()
if err != nil {
  // handle error: return in this function or log error, ...
  // eg. 
  return err
}

Selektion

if 1 == 1 && 2 == 2 {
	// so something when true
} else {
	// so something when false
}

// OR

if (1 == 1 && 2 == 2) {
	// so something when true
} else {
	// so something when false
}

// most common: only use ifs without else
if 1 == 1 && 2 == 2 {
	// so something when true
} 
// so something when false

Iteration

var users []user
users = append(users, user1)
users = append(users, user2)

type user struct {
	id          string        `json:"id"`
	firstname   string        `json:"firstname"`
	lastname    string        `json:"lastname"`
	email       string        `json:"email"`
	username    string        `json:"username"`
	token       string        `json:"token"`
}

for i := 0; i < len(users); i++ {
	fmt.Println(users[i])
}

// common use:
// i: current Index; user: current user
for i, user := range users {
		users[i]
	}

Struct

// for Export the struct -> name must be uppercase: user -> User, id -> Id, ...
type user struct {
	id          string        `json:"id"`
	firstname   string        `json:"firstname"`
	lastname    string        `json:"lastname"`
	email       string        `json:"email"`
	username    string        `json:"username"`
	token       string        `json:"token"`
}

var users []user

var funcUser  = new(user) // don't name the var as same the struct, because confusing
funcUser.id = uuid.New().String()
funcUser.username = username
funcUser.firstname = firstname
funcUser.lastname = lastname
funcUser.email = email
funcUser.token = token

users = append(users, funcUser)

How to avoid annoying error "declared and not used"

JSON-to-Go