Summary of processing that I often forget even though I write go and use it often If you remember, add them one by one
Context
https://pkg.go.dev/context
A context is a structure that manages the environment, scope, timeout, etc. in a tree format. It's a very important concept in writing go.
import (
"context"
)
ctx := context.Background()
ctx, cancel := context.WithCancel(ctx)
defer cancel()
store
package main
import "context"
import "log"
func main() {
ctx := context.Background()
ctx = context.WithValue(ctx, "silly", "work")
value := ctx.Value("silly")
// The return value is interface {}, so you need to cast the value
str, ok := value.(string)
if !ok {
log.Println("value not found")
}
log.Printf("value found: '%s'", str)
// This is the abbreviation above
str, ok = ctx.Value("silly").(string)
log.Printf("re value found: '%s'", str)
}
package main
import (
"context"
"time"
"log"
)
func main(){
ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx, time.Second * 1)
defer cancel()
go func(){
// too many time function
time.Sleep(time.Second * 10)
}()
<-ctx.Done()
log.Println("done")
}
If you have a small number of variables to refer to, you can use os.Getenv ()
normally.
import "os"
debug := os.Getenv("DEBUG")
If you want default values or required values like DB settings, it is convenient to use https://github.com/caarlos0/env/
package main
import (
"log"
"github.com/caarlos0/env/v6"
)
type DatabaseConfig struct {
UserName string `env:"DB_USER,required"`
Password string `env:"DB_PASSWORD,required"`
Host string `env:"DB_HOST" envDefault:"localhost"`
Port string `env:"DB_PORT" envDefault:"3306"`
DBName string `env:"DB_NAME"`
}
func main() {
cfg := new(DatabaseConfig)
if err := env.Parse(cfg); err != nil {
log.Printf("%+v\n", err)
}
log.Printf("%+v\n", cfg)
}
JSON
package main
import "encoding/json"
type Valiable struct {
Key string `json:"key"`
Value string `json:"value"`
}
func load(obj []byte) (*Valiable, error) {
valiable := new(Valiable)
err := json.Unmarshal(obj, valiable)
return valiable, err
}
func dump(valiable *Valiable) ([]byte, error) {
return json.Marshal(valiable)
}
func main() {
object := []byte(`{"key": "egg", "value": "spam"}`)
// to struct
valiable, _ := load(object)
// to []byte
obj, _ := dump(valiable)
_ = obj
}
io
package main
import (
"os"
"log"
"io/ioutil"
)
func main() {
file, err := os.Open("test.bin")
if err != nil {
// no such file or permission error
// If you omit this handling, there is nothing wrong with it
log.Fatal(err)
}
// Write a close defer at this timing
defer file.Close()
// Rough work to read everything with [] bytes
b, err := ioutil.ReadAll(file)
if err != nil {
log.Fatal(err)
}
log.Println(b)
/// A great guy who does the whole flow from open to Readall
content, err := ioutil.ReadFile("test.bin")
if err != nil {
log.Fatal(err)
}
log.Println(content)
}
log
https://pkg.go.dev/log https://pkg.go.dev/fmt
There are many examples of using fmt for standard output, but since it is not thread-safe, if goroutin is used a lot, the output may be mixed. It is safer to use log in actual operation
package main
import (
"errors"
"log"
)
func main() {
log.Println("spam") // 2021/01/19 18:47:35 spam
log.Println("egg", "bacon", "and spam") // 2021/01/19 18:51:04 egg bacon and spam
// Printf is the same as fmt
log.Printf("I'm a %s It's Ok", "Lumberjack") // 2021/01/19 19:53:54 I'm a Lumberjack It's Ok
log.Printf("int: %d", 253) // 2021/01/19 19:51:39 int: 253
log.Printf("hex: 0x%x", 253) // 2021/01/19 19:51:39 hex: 0xfd
log.Printf("oct: 0o%o", 253) // 2021/01/19 19:51:39 oct: 0o375
log.Printf("bin: 0b%b", 253) // 2021/01/19 19:51:39 bin: 0b11111101
s := struct {
ID int
Name string
}{123, "Graham"}
// Useful when dumping structures
log.Printf("%+v", s) // 2021/01/19 19:50:00 {ID:123 Name:Graham}
log.SetPrefix("[log] ")
log.Println ("prefix") // [log] 2021/01/19 18:50:07 Prefix
log.SetPrefix("")
log.SetFlags(log.Flags() | log.LUTC)
log.Println ("Time timezone uses default, but can be UTC by adding a flag") // 2021/01/19 09:57:09 Timetime zone uses default, but flag Can be UTC by adding
log.SetFlags(0)
log.Println ("You can turn off the time output by removing all the flags") // You can turn off the time display by setting the flag
log.SetFlags(log.Ldate | log.Lmicroseconds)
log.Println ("Notation up to microseconds") // 2021/01/19 18: 57: 09.086480 Notation up to microseconds
log.Fatal (errors.New ("some error")) // Output the error content and exit with status code 1.
}
panic
package main
import (
"log"
)
func main() {
defer func() {
e := recover()
if e != nil {
str, _ := e.(string)
log.Println("panic:", str)
}
}()
panic("example panic")
}
Recommended Posts