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

rows, err := conn.Queryx("SELECT id, name FROM users")
if err != nil {
      log.Fatalln(err)
}
defer rows.Close()

users := []User{}

for rows.Next() {
    if rows.StructScan(&user) != nil {
      log.Fatalln(err)
    }
    users = append(users, user)
}

ctx.HTML(http.StatusOK, "users/index.tmpl",  gin.H{"values": users})

res, err := p.Exec(js)
if err != nil {
   log.Panic(err)
}

go func(idx int) {
    ...
}(i)

package main

import (
    "sync"
)

const N = 10

func main() {
    m := make(map[int]int)
    wg := &sync.WaitGroup{}
    mu := &sync.Mutex{}
    wg.Add(N)
    for i := 0; i < N; i++ {
        k := 5
        go func(idx int) {
            defer wg.Done()
            mu.Lock()
            println(idx, k)
            m[idx] = k
            mu.Unlock()
        }(i)
    }
    wg.Wait()
    println(len(m))
    println(m[0])
}

package main

import "log"

func f() {
  defer func() {
    if r := recover(); r != nil {
      log.Printf("recover:%#v", r)
    }
  }()
  log.Println("Start first panic")
  panic(1)
  log.Println("After first panic")
  panic(2)
  log.Println("After second panic")
}

func main() {
  f()
  log.Println("After f()")
}

2020/07/20 23:14:07 Start first panic
2020/07/20 23:14:07 recover:1
2020/07/20 23:14:07 After f()

func InitEfaceType() interface{} {
  var s *S
  return s
}
...
fmt.Println(InitEfaceType() == (*S)(nil))

type Test struct {
	array []*Array
}

<link rel="stylesheet" href="/static/style.css"/>
<img src="/static/sob2.jpg" />

// добавьте эти строки
fs := http.FileServer(http.Dir("./static"))
http.Handle("/static/", http.StripPrefix("/static/", fs))
// перед этой строкой
http.HandleFunc("/", viewHandler)

server {
    listen *:80;

    server_name localhost;

    # root /тут_путь_к_вашей_папке/static;
    # для Windows будет что-то типа такого
    root D:/GoExam/static;

    location / {
        try_files $uri @process;
    }

    location @process {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_send_timeout 30;
        proxy_read_timeout 30;
    }
}

http {
  # тут идут настройки Nginx
  ....
  # тут дописываете код, что я выше написал, грубо перед закрывающей "}"
}

type Event struct {
        EventID int    `json:"eventId"`
        Type    string `json:"type"`
        ....
}

// канал создаёте вот так, т.к. вы хотите по одному событию передавать данные, а не целыми слайсами сразу
EventsCh = make(chan Event, 100)
go mailing(EventsCh)

// делаете HTTP запрос
response, responseErr := http.PostForm(...)

// создаёте decoder
decoder := json.NewDecoder(response.Body)

for {
    event := Event{}
    decoderErr := decoder.Decode(&event) // если данных нет - тут выполнение программы блокируется
    if decodeErr != nil { // тут может быть ошибка io.EOF (просто данные закончились, сервер корректно закрыл соединение)
       break
    }
    EventsCh <- event  // отправляете данные в канал, из которого их читает горутина
}

func mailing(eventsCh chan Event){									//Получает события из канала
    for{
        event, ok := <- eventsChan
        if !ok {
            // канал закрыт
            break
        }
        log.Print("Получено ", event)
    }
}

messageReturn := bytes.NewBufferString("Your message is: ")
messageReturn.Write(message)
conn.WriteMessage(websocket.TextMessage, messageReturn.Bytes())

type twoValue struct {
    x int
    y int
    expected int
}

var tests = []twoValue{
    { 1,2, 1 },
    { 2,1, 2 },
    { 2,2, 0 },
}

func TestQuestion(t *testing.T) {

  for _, value := range tests {
    res := Question(value.x, value.y)
    if res != value.expected {
      t.Errorf("при сравнении %v с %v получили, %v, а должно быть %v", value.x, value.y, res, value.expected)
    }
  }
}

import "time"

rate := time.Second / 10
throttle := time.Tick(rate)
for req := range requests {
  <-throttle  // rate limit our Service.Method RPCs
  go client.Call("Service.Method", req, ...)
}

import "time"

rate := time.Second / 10
burstLimit := 100
tick := time.NewTicker(rate)
defer tick.Stop()
throttle := make(chan time.Time, burstLimit)
go func() {
  for t := range tick.C {
    select {
      case throttle <- t:
      default:
    }
  }  // does not exit after tick.Stop()
}()
for req := range requests {
  <-throttle  // rate limit our Service.Method RPCs
  go client.Call("Service.Method", req, ...)
}

tx.Begin()
for {
   DB.Create
}
tx.Commit()

items := make([]logged, 0)
items = append(items, A{10})
print(maxLogID(items))

data, ok := <-channel
if !ok {
    return
}