Go code

package main

import (
	"fmt"

	"github.com/sourcegraph/conc/pool"
)

func main() {
	p := pool.New().WithMaxGoroutines(3)
	for i := 1; i <= 5; i++ {
		p.Go(func() {
			fmt.Println(i)
		})
	}
	p.Wait()
}

package main

import (
	"context"
	"errors"
	"fmt"

	"github.com/sourcegraph/conc/pool"
)

func main() {
	p := pool.New().
		WithMaxGoroutines(4).
		WithContext(context.Background()).
		WithCancelOnError()
	for i := 0; i < 3; i++ {
		i := i
		p.Go(func(ctx context.Context) error {
			if i == 2 {
				return errors.New("I will cancel all other tasks!")
			}
			<-ctx.Done()
			return nil
		})
	}
	err := p.Wait()
	fmt.Println(err)
	// Output:
	// I will cancel all other tasks!
}

package main

import (
	"fmt"
)

func main() {
	ch := make(chan int, 3)
	// wg := conc.NewWaitGroup()
	go func() {
		for i := 0; i < 1000; i++ {
			ch <- i
		}
		close(ch)
	}()
	// wg.Wait()

	for v := range ch {
		fmt.Println(v)
	}

}

package main

import (
	"fmt"

	"github.com/sourcegraph/conc"
)

func main() {
	ch := make(chan int)
	// ch2 := make(chan bool)

	wg := conc.NewWaitGroup()

	wg.Go(func() {
		for i := 0; i < 100; i++ {
			ch <- i
		}
		close(ch)
	})

	for sub := range ch {
		fmt.Println(sub)
	}

}

type Person struct {
	Name string
	Age  int
	Book int
}


	people := []Person{
		{"Alice", 30, 5},
		{"Bob", 25, 2},
		{"Charlie", 30, 55},
		{"David", 25, 33},
	}
	// 使用 sort.Slice 进行排序，按年龄升序排列,年龄相同则按book排序
	sort.Slice(people, func(i, j int) bool {
		if people[i].Age == people[j].Age {
			return people[i].Book < people[j].Book
		}
		return people[i].Age < people[j].Age
	})

package main

import (
	"errors"
	"fmt"

	"golang.org/x/sync/errgroup"
)

func main() {
	eg := errgroup.Group{}
	eg.Go(func() error {
		fmt.Println("go1")
		return nil
	})
	eg.Go(func() error {
		fmt.Println("go2")
		err := errors.New("go2 err")
		return err
	})
	err := eg.Wait()
	if err != nil {
		fmt.Println("err =", err)
	}
}

// 带ctx
func main1() {
	eg, ctx := errgroup.WithContext(context.Background())
	eg.Go(func() error {
		time.Sleep(1 * time.Second)
		select {
		case <-ctx.Done():
			fmt.Println("go1 cancel, err = ", ctx.Err())
		default:
			fmt.Println("go1 run")
		}
		return nil
	})
	eg.Go(func() error {
		err := errors.New("go2 err")
		return err
	})
	err := eg.Wait()
	if err != nil {
		fmt.Println("err =", err)
	}
}

// 限制并发数
func main2() {
	eg := errgroup.Group{}
	eg.SetLimit(2)
	eg.TryGo(func() error {
		fmt.Println("go1 run")
		return nil
	})
	eg.TryGo(func() error {
		err := errors.New("go2 err")
		return err
	})
	eg.TryGo(func() error {
		fmt.Println("go3 run")
		return nil
	})
	err := eg.Wait()
	if err != nil {
		fmt.Println("err =", err)
	}
}

	err = pa.WithContext(ctx).Clauses(
		clause.OnConflict{
			Columns: []clause.Column{
				{Name: user.Code.ColumnName().String()},
			},
			TargetWhere: clause.Where{
				Exprs: []clause.Expression{
					clause.Expr{
						SQL: "deleted_at = 0",
					},
				},
			},
			DoUpdates: clause.AssignmentColumns(cols),
		},
	).
		CreateInBatches(items, 30)


// 表设计优化，这样只有当deleted_at为null的时候，才会触发code的唯一性校验
// create unique index pa_code
//    on pa (code) where deleted_at is null;

func main3() {
	defer func() {
		if err2 := recover(); err2 != nil {
			fmt.Printf("Run panic error: %v", err2)
		}
	}()
	fmt.Println("xxx")
}

package main

import "fmt"

func apply(x int, y int, f func(int, int) int) int {
	return f(x, y)
}

func sum(a int, b int) int {
	return a + b
}

func main() {

	asum := apply(5, 10, sum)
	fmt.Println(asum)
}


//
func sayHello(name string) func() string {
	return func() string {
		return "Hello, " + name
	}
}
func main2() {
	hello := sayHello("Go")
	fmt.Println(hello()) // 输出: Hello, Go
}

package main

import (
	"testing"
)

func TestInit(t *testing.T) {
	t.Log("heh")

	helper := PersonHelper{}
	helper.init("pleuvoir")
	t.Log(helper.Name)
}

func TimeSince(f func()) string {
  start := time.Now() // 获取当前时间
  f()                 // 执行传入的函数
  // 获取结束的时间
  elapsed := time.Since(start)
  str := fmt.Sprintf("该函数执行完成耗时：%v", elapsed)
  return str
}

func main() {
  result := TimeSince(timeTest)
  fmt.Println(result)
}

func timeTest() {
  // 运行的函数
  sum := 0
  for i := 0; i < 1111111111; i++ {
    sum++
  }
}