package main

import (
    "log"
    "time"
)

func sleep(d time.Duration) {
    select {
    case <-time.After(d):
    }
}

func CallSleep() {
    log.Println("Do something")
    sleep(5 * time.Second)
    log.Println("Something else")
}

func sleep2(d time.Duration) time.Time {
    ticker := time.Tick(d)
    for done := range ticker {
        return done
    }
    return time.Now()
}

func sleep(d time.Duration) {
    <-time.After(d)
}

type T struct{}
var _ I = T{}       // Проверка, что T имплеменирует I.
var _ I = (*T)(nil) // Проверка, что *T имплеменирует I.

// отправляем пользователю ответ с аттачем
//reader, writer := io.Pipe()
writer := new(bytes.Buffer)
err = main.Doc.Save(writer) // метод Документа из unioffice - принимает io.Writer, сохраняет тип Document в zip.
//writer.Close() // для  Pipe
...
reader := bytes.NewReader(writer.Bytes())
...
nbytes, err := io.Copy(w, reader) //  w  это http.ResponseWriter

go func () {
            defer writer.Close()
            err = main.Doc.Save(writer) // принимает io.Writer
            ...
            }
        }()

func main() {
    // В високосном году 2096 будет 366 дней
    t1 := Date(2096, 1, 1)
    t2 := Date(2097, 1, 1)
    days := t2.Sub(t1).Hours() / 24
    fmt.Println(days) // 366
}

func Date(year, month, day int) time.Time {
    return time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)
}

map[
  /dbus-service:map[
    org.freedesktop.DBus.Introspectable:map[] 
    org.freedesktop.DBus.Peer:map[] 
    org.freedesktop.DBus.Properties:map[] 
    Basket:map[
      Fruit:"Apple"
    ]
  ]

"/dbus-service":{
    "org.freedesktop.DBus.Introspectable":{},
    "org.freedesktop.DBus.Peer":{},
    "org.freedesktop.DBus.Properties":{},
    "Basket":
    {
      "Fruit":{}
    }
  }

fmt.Printf("%v", data)

jsonData, _ := json.Marshal(data)
fmt.Printf("json data: %s", jsonData)

package main

import "fmt"

var array = []byte{104, 0, 101, 0, 108, 0, 108, 0, 111, 0, 0, 0, 0, 0, 0, 0}

func main() {
    new_array := make([]byte, 0, len(array))
    for _, b := range array {
        if b == 0 {
            continue
        }
        new_array = append(new_array, b)
    }
    // 5 - ожидаемая длинна
    fmt.Println(len(new_array))
    // строка без 0x00
    fmt.Println(string(new_array))
}

func btos(c []byte) string {
    n := 0
    for _, b := range c {
        if b == 0 {
            continue
        }
        c[n] = b
        n++
    }
    return string(c[:n])
}

package cache

import (
    "sync"
    "time"
)

type Cache struct {
    *sync.Map
    TTL time.Duration
}

func New(ttl time.Duration) *Cache {
    return &Cache{
        Map: new(sync.Map),
        TTL: ttl,
    }
}

func (c *Cache) Store(key, value interface{}) {
    c.Map.Store(key, value)
    // memory leak?
    time.AfterFunc(c.TTL, func() {
        c.Map.Delete(key)
    })
}

jsonFile, err := os.Open("referenceData/ex.json")
if err != nil {
    return err
}
defer jsonFile.Close() // первый defer
byteValue, err := ioutil.ReadAll(jsonFile)
if err != nil {
    return err
}

err = json.Unmarshal(byteValue, &exToParse)
if err != nil {
    return err
}

jsonFile, err = os.Open("referenceData/di.json") // перезапись jsonFile
if err != nil {
    return err
}
defer jsonFile.Close() // нужно ли заново объявлять defer jsonFile.Close()?
byteValue, err = ioutil.ReadAll(jsonFile)
if err != nil {
    return err
}

err = json.Unmarshal(byteValue, &diToParse)
if err != nil {
    return err
}

type T int

func (t T) Close() { fmt.Println(int(t)) }

// ...

t := T(1)
defer t.Close()

t = T(2)
defer t.Close()

// 2
// 1