// отправляем пользователю ответ с аттачем
//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

_obj/            // старый каталог object
_test/           // старый каталог test
_testmain.go     // старый каталог gotest
test.out         // старый каталог test
build.out        // старый каталог test
*.[568ao]        // объектные файлы

DIR(.exe)        // создано go build
DIR.test(.exe)   // создано go test -c
MAINFILE(.exe)   // создано go build MAINFILE.go

BitBucket (Mercurial Git)
GitHub (git)
Google Code (Git, Mercurial, Subversion)
Launchpad (Bazaar)

привет - 2;
мир - 2;
hello - 2;
world -2;

package main

import (
    "fmt"
    "regexp"
    "strings"
)

//Создаём структуру для хранения кол-ва слов и самих слов
type Words struct {
    i int    // кол-во слов
    s string // тут само слово
}

func main() {
    str := "Привет мир, hello world, hello мир, привет world,   , "
    // приводим всё в нижний регистр для устранения проблем с различием слов 'Привет' и 'привет'
    str = strings.ToLower(str)
    // Разбиваем строку на массив строк по регулярному выражению, ищем либо ',' либо ' ' (пробел)
    arr := regexp.MustCompile("[,| ]+").Split(str, -1)
    //создаём массив структур для хранения результатов
    ret := []Words{}
    chk := false
    // проходим циклом для сранения есть ли такое слово в массиве ret или нет
    k := 0
    for i := 0; i < len(arr); i++ {
        chk = false
        for k = 0; k < len(ret); k++ {
            if arr[i] == ret[k].s {
                // если слово уже есть увеличивем счётчик и слово пропускаем
                ret[k].i += 1
                chk = true
            }
        }
        // если chk true то слово уже есть и ничего делать ненадо
        if !chk {
            // проверяем что в строке есть буквы и если они есть добавляем её в массив с результатами
            if regexp.MustCompile("[a-zа-яё]+").MatchString(arr[i]) {
                tmp := Words{i: 1, s: arr[i]}
                ret = append(ret, tmp)
            }

        }
    }
    // выводим результат
    for l := 0; l < len(ret); l++ {
        fmt.Printf("%v - %v\n", (ret[l].s), (ret[l].i))
    }

}

"Привет мир, hello world, hello мир, привет world,   , "

package main

import (
    "fmt"

    "github.com/nxadm/tail"
)

var logFile = "log.log"

func main() {
    t, err := tail.TailFile(logFile, tail.Config{Follow: true})
    if err != nil {
        panic(err)
    }

    for line := range t.Lines {
        fmt.Println(line.Text)
    }
}

package main

import (
    "os/user"
    "log"
    "fmt"
)

func main() {
    // текущий пользователь
    cur, err := user.Current()
    if  err != nil {
        log.Fatal(err)
    }
    fmt.Println("Current user:", cur)
}