Евгений Мамонов

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup

    num := make(chan int, 1000) // 1000 - размер буффера канала

    wg.Add(1)
    go func() {
        for i := 0; i < 1000; i++ {
            num <- i
            fmt.Printf("write to channel: %d\n", i)
            // задержка нужна только на время теста
            time.Sleep(100 * time.Microsecond)
        }
        close(num)
        wg.Done()
    }()

    wg.Add(1)
    go func() {
        for {
            val, ok := <-num
            if !ok {
                break
            }
            fmt.Printf("goroutine 1 got: %d\n", val)
        }
        wg.Done()
    }()

    wg.Add(1)
    go func() {
        for {
            val, ok := <-num
            if !ok {
                break
            }
            fmt.Printf("goroutine 2 got: %d\n", val)
        }
        wg.Done()
    }()

    wg.Wait()
}

func GetProducts(c *gin.Context) {
  var products []models.Product
  database.DB.Find(&products)
  c.JSON(http.StatusOK, products)
}

jsonDataBytes, err := ioutil.ReadAll(c.Request.Body)

package main

import (
    "fmt"
    "log"
    "os"
    "strconv"
)

func main() {

    var what string
    var input string

    fmt.Print("Выберите действие (+, -)")
    fmt.Fscan(os.Stdin, &what)
    if what != `+` && what != `-` {
        log.Fatalf("действие указанно не корректно\n")
    }

    fmt.Print("Введите первое значение: ")
    fmt.Fscan(os.Stdin, &input)
    a, err := strconv.ParseFloat(input, 64)
    if err != nil {
        log.Fatalf("число указано не корректно: %v\n", err)
    }

    fmt.Print("Введите второе значение: ")
    fmt.Fscan(os.Stdin, &input)
    b, err := strconv.ParseFloat(input, 64)
    if err != nil {
        log.Fatalf("число указано не корректно: %v\n", err)
    }

    var c float64
    if what == "+" {
        c = a + b
    } else if what == "-" {
        c = a - b
    }

    fmt.Printf("Результат: %v\n", c)
}

https://domain.com/products/chairs?height=200&width=100

r.HandleFunc("/products/{category_handle}", h.ShowProducts).Methods("GET")

// из извлекаем из URL категорию
vars := mux.Vars(r)
categoryHandle := vars["categoryHandle"]

// получаем параметры
height, _ := strconv.Atoi(r.URL.Query().Get("height"))
width, _ := strconv.Atoi(r.URL.Query().Get("width"))

server {
    listen *:80;
    server_name yourdomain1.com; # домен, который вам нужно
    ...
    location / {
        proxy_pass http://127.0.0.1:9000; # IP адрес и порт, на котором слушает сервис Go lang.
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

server {
    listen *:80;
    server_name yourdomain2.com; # домен, который вам нужно
    ...
    location / {
        proxy_pass http://127.0.0.1:9001; # IP адрес и порт, на котором слушает сервис Go lang.
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

func SortBytes(arr []byte) {
    sort.Slice(arr, func(i, j int) bool {
        return arr[i] < arr[j]
    })
}
// потом использовать вот так
arr := []byte{4, 3, 2, 1, 6, 3, 77, 8,3}
sortBytes(arr)
fmt.Println(arr)

sort.Slice(arr, func(i, j int) bool {
  return arr[i] < arr[j]
})
fmt.Println(arr)

package main

import "fmt"

type User struct {
  UserName string
  Category string
  Age      int
}

func main() {

  users := []User{
    User{UserName: "Bryan", Category: "Human", Age: 33},
    User{UserName: "Jane", Category: "Rocker", Age: 25},
    User{UserName: "Nancy", Category: "Mother", Age: 40},
    User{UserName: "Chris", Category: "Dude", Age: 19},
    User{UserName: "Martha", Category: "Cook", Age: 52},
  }

  // подключаетесь к базе
  db, _ := sql.Open(...)
  defer db.Close()

  for _, user := range users {
      fmt.Println(user)
      // делаете запрос в базу
      db.Exec("INSERT INTO users (name, category, age) VALUES ($1, $2, $3)", user.UserName, user.Category, user.Age)
  }
}

tx, _ := db.Begin()  // начинаете транзакцию
for _, user := range users {
    fmt.Println(user)
    // делаете запрос в базу (тут уже не db, а tx.Exec)
    tx.Exec("INSERT INTO users (name, category, age) VALUES ($1, $2, $3)", user.UserName, user.Category, user.Age)
}
tx.Commit() // завершаете транзакцию, данные сохраняются в базе

package main

import (
  "fmt"
  "time"
)

var c = make(chan int, 3)
var data = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

func main() {
  fmt.Println("Hello, playground")
  go save()
  go read()
  time.Sleep(3 * time.Second)
}

func save() {
  for _, val := range data {
    c <- val
  }
}

func read() {
  for {
    val := <-c
    fmt.Println("read:", val)
  }
}

package main

import (
	"fmt"
	"time"
)

var c = make(chan *int)
var data = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

func main() {
	fmt.Println("Hello, playground")
	go save()
	go read()
	time.Sleep(3 * time.Second)
}

func save() {
	for _, val := range data {
	        v := val
		c <- &v
	}
}

func read() {
	for {
		val := <-c
		fmt.Println("read:", *val)
	}
}

package main

import (
	"fmt"
	"time"


var c = make(chan *int, 5)
var data = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

func main() {
	fmt.Println("Hello, playground")
	go save()
	go read()
	time.Sleep(3 * time.Second)
}

func save() {
	for i := range data {
		c <- &data[i]
	}
}

func read() {
	for {
		val := <-c
		fmt.Println("read:", *val)
	}
}

package main

import (
	"fmt"
	"time"
)

var c = make(chan *int, 5)
var data = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

func main() {
	fmt.Println("Hello, playground")
	go save()
	go read()
	time.Sleep(3 * time.Second)
}

func save() {
	for _, val := range data {
		c <- &val
		fmt.Printf("write: %v\n", &val)
	}
}

func read() {
	for {
		val := <-c
		fmt.Println("read:", *val)
	}
}

Hello, playground
write: 0xc000094000
write: 0xc000094000
write: 0xc000094000
write: 0xc000094000
write: 0xc000094000
write: 0xc000094000
...

func save() {
	for _, val := range data {
		v := val
		c <- &v
		fmt.Printf("write: %v\n", &v)
	}
}

Hello, playground
write: 0xc000094000
write: 0xc000094010
write: 0xc000094018
write: 0xc000094020
write: 0xc000094028
write: 0xc000094030

func Process(device test123.Command) {
    device.Open()
    device.Close()
}

dev1 := a123.A123struct{параметры...}
Process(dev1)

dev2 := b123.B123struct{параметры...}
Process(dev2)

// или с перечислением
devices := []test123.Command{dev1, dev2}
for _, device := range devices {
    Process(device)
}

package main

import (
    "fmt"
    "os"
)

// Logger интерфейс логгера.
type Logger interface {
    Error(msg string)
}

// StdoutLogger реализация интерфейса Logger для вывода сообщений в консоль.
type StdoutLogger struct{}

// NewStdoutLogger конструктор (возвращаем структуру, не интерфейс)
func NewStdoutLogger() *StdoutLogger {
    return &StdoutLogger{}
}

// Error добавляет в лог сообщение с уровнем error
func (l *StdoutLogger) Error(msg string) {
    fmt.Printf("ERROR: %s\n", msg)
}

// FileLogger реализация интерфейса Logger для вывода сообщений в файл.
type FileLogger struct {
    FileName string
    Fh       *os.File
}

// NewFileLogger конструктор.
func NewFileLogger(fileName string) *FileLogger {
    logger := &FileLogger{
        FileName: fileName,
    }
    fh, err := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE, 0664)
    if err != nil {
        panic(fmt.Sprintf("FileLogger: can't open log file: %s: %s\n", fileName, err))
    }
    logger.Fh = fh

    return logger
}

// Error добавляет в лог сообщение с уровнем error.
func (l *FileLogger) Error(msg string) {
    l.Fh.WriteString(fmt.Sprintf("ERROR: %s\n", msg))
}

// ProcessData какая то функция, которая использует логгер и которую не должна беспокоить реализация логгера.
// Тут тип параметра должен быть интерфейс.
func ProcessData(logger Logger) {
    logger.Error("Data process some error happened")
}

func main() {
    var logger Logger

    // если лог файл не указан - используем StdoutLogger, если указан - используем FileLogger
    logFile := os.Getenv("LOG_FILE")
    if logFile != `` {
        logger = NewFileLogger(logFile)
    } else {
        logger = NewStdoutLogger()
    }

    ProcessData(logger)
}

export LOG_FILE=test.log
go run main.go

db.SetConnMaxIdleTime(0)
db.SetConnMaxLifetime(0)
db.SetMaxIdleConns(10)
db.SetMaxOpenConns(10)

psql -h 127.0.0.1 -p 5432 -U user_name  database_name

mysql -h 127.0.0.1 -P 3307 -u user_name -p database_name

update_answer_id_start, err33 := db.Query(fmt.Sprintf("UPDATE `ucp` SET `closed` = '1' WHERE `id` = '%d'", res_trim_int))
defer update_answer_id_start.Close()

update_answer_id_start, err33 := db.Exec("UPDATE `ucp` SET `closed` = '1' WHERE `id` = ?", res_trim_int)

for res_select_list.Next(){
    err18 := res_select_list.Scan(&ucp.Id, &ucp.Text)
    if err18 != nil {
        panic(err18)
    }
    str.WriteString("LIST QUESTION:\r\nID- " + strconv.Itoa(ucp.Id) + " TEXT- " + ucp.Text)
}

str.WriteString("LIST QUESTION:\r\n")
for res_select_list.Next(){
    err18 := res_select_list.Scan(&ucp.Id, &ucp.Text)
    if err18 != nil {
        panic(err18)
    }
    str.WriteString("ID- " + strconv.Itoa(ucp.Id) + " TEXT- " + ucp.Text + "\r\n")
}

// makeslicecopy allocates a slice of "tolen" elements of type "et",
// then copies "fromlen" elements of type "et" into that new allocation from "from".

// makeslicecopy allocates a slice of "tolen" elements of type "et",
// then copies "fromlen" elements of type "et" into that new allocation from "from".
func makeslicecopy(et *_type, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer {
	var tomem, copymem uintptr
	if uintptr(tolen) > uintptr(fromlen) {
		var overflow bool
		tomem, overflow = math.MulUintptr(et.size, uintptr(tolen))
		if overflow || tomem > maxAlloc || tolen < 0 {
			panicmakeslicelen()
		}
		copymem = et.size * uintptr(fromlen)
	} else {
		// fromlen is a known good length providing and equal or greater than tolen,
		// thereby making tolen a good slice length too as from and to slices have the
		// same element width.
		tomem = et.size * uintptr(tolen)
		copymem = tomem
	}

	var to unsafe.Pointer
	if et.ptrdata == 0 {
		to = mallocgc(tomem, nil, false)
		if copymem < tomem {
			memclrNoHeapPointers(add(to, copymem), tomem-copymem)
		}
	} else {
		// Note: can't use rawmem (which avoids zeroing of memory), because then GC can scan uninitialized memory.
		to = mallocgc(tomem, et, true)
		if copymem > 0 && writeBarrier.enabled {
			// Only shade the pointers in old.array since we know the destination slice to
			// only contains nil pointers because it has been cleared during alloc.
			bulkBarrierPreWriteSrcOnly(uintptr(to), uintptr(from), copymem)
		}
	}

	if raceenabled {
		callerpc := getcallerpc()
		pc := funcPC(makeslicecopy)
		racereadrangepc(from, copymem, callerpc, pc)
	}
	if msanenabled {
		msanread(from, copymem)
	}

	memmove(to, from, copymem)

	return to
}

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

type TemplateCategory struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

type Template struct {
    Name         string            `json:"name"`
    CategoryInfo *TemplateCategory `json:"category_info"`
}

func (t *Template) UnmarshalJSON(b []byte) error {
    var result map[string]interface{}
    if err := json.Unmarshal(b, &result); err != nil {
        return err
    }

    if t == nil {
        t = &Template{}
    }
    t.Name, _ = result[`name`].(string)

    categoryInfo, isMap := result[`category_info`].(map[string]interface{})
    if isMap {
        t.CategoryInfo = &TemplateCategory{}
        t.CategoryInfo.ID, _ = categoryInfo[`id`].(int)
        t.CategoryInfo.Name, _ = categoryInfo[`name`].(string)
    }

    return nil
}

func main() {
    json1 := []byte(`{
        "name": "Мой шаблон",
        "category_info": {
            "id": 109,
            "name": "Тест"
        }
    }`)

    json2 := []byte(`{
        "name": "Мой шаблон",
        "category_info": []
    }`)

    var data1 Template
    err := json.Unmarshal(json1, &data1)
    if err != nil {
        log.Fatalf(`json1: %s`, err)
    }

    var data2 Template
    err = json.Unmarshal(json2, &data2)
    if err != nil {
        log.Fatalf(`json2: %s`, err)
    }

    fmt.Printf("data1: %+v\n", data1)
    fmt.Printf("data1.CategoryInfo: %+v\n\n", data1.CategoryInfo)

    fmt.Printf("\n\ndata2: %+v\n", data2)
    fmt.Printf("data2.CategoryInfo: %+v\n\n", data2.CategoryInfo)
}

lp.MessageNew(func(_ context.Context, obj events.MessageNewObject) {
    // тут приходит новый запрос
    if obj.Message.Text == "/dump" {
       var str strings.Builder
       // читаете данные из базы
       res, err := db.Query("SELECT `report_id`, `content_type` FROM `xf_report` WHERE `report_state` = 'open'")
       // по одном их обрабатываете и записываете в strings.Builder
       for res.Next(){
        err := res.Scan(&report.Report_id, &report.Content_type)
        str.WriteString(...)
      }
      // тут у вас все данные собраны в str
      // отправляете данные в ответ
      send, err2 := vk.MessagesSend(api.Params{
          "peer_id": 2000000001,
          "random_id": 0,
          "message": str.String(),
        })
    }