joplin-notes/joplin notion extension/Web Development/Go/Basics 2.md

Basics 2

Conditions

if/else if/else are same its just that brackets surrounding conditions are not required. switch case is similar too with extra functionality like multi case

func main() {
   day := 5

   switch day {
   case 1,3,5:
    fmt.Println("Odd weekday")
   case 2,4:
     fmt.Println("Even weekday")
   case 6,7:
    fmt.Println("Weekend")
  default:
    fmt.Println("Invalid day of day number")
  }
}

 

Loops

like in other language. for iteraing over elements of arrays,slice and map range keyword can be used too. it gives index and value respectively. index may not be used so blank identifiers can be used which is like a black hole. And even if it is used then it means those values wont be used later so it will still generate error so in that case blank identifier can be used too

   adj := [2]string{"Big", "Tasty"}
   fruits := [...]string{"Apple", "Orange"}

   for i := 0; i < len(adj); i++ {
   	for j := 0; j < len(fruits); j++ {
   		if adj[i] == "Big" {

   			fmt.Println("Big mentioned")
   		}
   		fmt.Println(adj[i], fruits[j])
   	}
   }

   for i, val := range adj {
   	for j, val2 := range fruits {
   		if val == "Big" {

   			fmt.Println("Big mentioned")
   		}
   		fmt.Println(val, val2)
   		// blank identifers
   		_, _ = i, j

   	}
   }

Extras

• go functions if needed to be used in other packages then it needed to be capitalized so using Run() instead of run().

 

random number

package main

import (
	"fmt"
	"math/rand/v2"
)

func main() {
	// Random integer between 0 and 99
	num := rand.IntN(100) 
	fmt.Println("Integer (0-99):", num)

	// Random float64 between 0.0 and 1.0
	floatNum := rand.Float64()
	fmt.Println("Float (0.0-1.0):", floatNum)
}

also

f,err := os.Open(path)

	if err!=nil{
		return  err
	}

	defer f.Close()

	scanner:= bufio.NewScanner(f)

NewScanner accepts io.Reader but os.Open outputs *os.File. due to inferfaces handled implicitly so need to 'implement interface' like in java

 

structs

type Message struct {
	Id               string `json:"id"`
	CreatedTimestamp int64  `json:"createdTimestamp"`
	Type             int    `json:"type"`
	Content          string `json:"content"`
	Reference        struct {
		MessageId string `json:"messageId"`
	} `json:"reference"`
}

or if null is expected and empty struct is not fine then simply use pointer struct

type Message struct {
	Id               string `json:"id"`
	CreatedTimestamp int64  `json:"createdTimestamp"`
	Type             int    `json:"type"`
	Content          string `json:"content"`
	Reference        *struct {
		MessageId string `json:"messageId"`
	} `json:"reference"`
	
}

optional fields in struct

type User struct {
    Name     string  `json:"name"`
    Age      *int    `json:"age,omitempty"` // Optional
    Active   *bool   `json:"active,omitempty"` // Optional
}   

for array of struct if we need to distinguish nil and empty slice before go 1.24 then

Items *[]Product `json:"items,omitempty"`   

otherwise following will be fine

Items []Product `json:"items,omitempty"`   

  parsing fields of multtiple types https://stackoverflow.com/questions/56394456/unmarshal-json-field-is-int-or-string

also https://go.dev/play/p/XnQRS8H0tKE

package main

import "fmt"

func foo(x any) {
	switch v := x.(type) {
	case int:
		fmt.Printf("math: x + 2 == %d\n", v+2)
	case string:
		fmt.Printf("string: x + def == %s\n", v+"def")
	}
}

func main() {
	var x any = 5
	foo(x)
	x = "abc"
	foo(x)
}

and maybe with reflects(not recommended)

package main

import (
    "fmt"
    "reflect"
)

func checkEquality(data any) {
    switch reflect.TypeOf(data).Kind() {
    case reflect.Int:
        if data == 1 {
            fmt.Println("It is equal to 1")
        } else {
            fmt.Println("It is not equal to 1")
        }
    case reflect.String:
        if data == "one" {
            fmt.Println("It is equal to one")
        } else {
            fmt.Println("It is not equal to one")
        }
    default:
        fmt.Println("Not a string nor an int")
    }
}

func main() {
    checkEquality("one")
    checkEquality(1)
    checkEquality(true)
    checkEquality(34)
}

 

error handling

err:= json.Unmarshal(data, &config)
if err != nil {
		fmt.Println("Error in reading json")
		os.Exit(1)
	}

short form of above

if err:= json.Unmarshal(data, &config); err!=nil{
	// code for handling error		
	}
}

also for equivalent ry catch possibility

func riskyBlock() (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered from panic: %v", r)
        }
    }()

    // --- your code here ---
    x := 10 / 0        // panics
    fmt.Println(x)     // never reached
    return nil
}

func main() {
    if err := riskyBlock(); err != nil {
        fmt.Println("Error:", err)
    }
    fmt.Println("Program continues")
}