Александр Павлюк

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()
}

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

package config

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

type Cfg struct {
	// Fields
}

var (
	cfg *Cfg
)

func Config() *Cfg {
	return cfg
}

func LoadConfig() error {
	f, err := os.Open("./config/config.json")
	if err != nil {
		return fmt.Errorf("can't open config file: %w", err)
	}
	defer f.Close()

	dec := json.NewDecoder(f)
	var c *Cfg
	if err := dec.Decode(c); err != nil {
		return fmt.Errorf("can't decode config file: %w", err)
	}

	if err := validate(c); err != nil {
		return fmt.Errorf("can't validate config file: %w", err)
	}
	
	cfg = c

	return nil
}

func validate(cfg *Cfg) error {
	// Logic
	return nil
}

package main

import "fmt"
import "strconv"

func main() {
  var i int64 = 65
  fmt.Println(strconv.FormatInt(i, 10))
  // или так
  fmt.Printf("%d\n", i)
}

If the paths=source_relative flag is specified, the output file is placed in the same relative directory as the input file. For example, an input file protos/buzz.proto results in an output file at protos/buzz.pb.go.

type FReader struct {
	reader io.Reader
	filter func([]byte) (int, error)
}
func NewFReader(r io.Reader) *FReader {
	return &FReader{r, func(p []byte) (int, error) { return len(p), nil }}
}
func (fr *FReader) Filter(filter func([]byte) (int, error)) *FReader {
	return &FReader{fr, filter}
}
func (fr *FReader) Read(p []byte) (n int, err error) {
	n, err = fr.reader.Read(p)
	if err == nil && fr.filter != nil {
		n, err = fr.filter(p)
	}
	return
}

chainreader := NewFReader(myreader).Filter(myfilter1).Filter(myfilter2).Filter(myfilter3)

var _ = fmt.Println
var _ = myvar