darjun / go-daily-lib Goto Github PK

package main

import (
	"fmt"
	"github.com/guonaihong/clop"
)

type add struct {
	All      bool     `clop:"-A; --all" usage:"add changes from all tracked and untracked files"`
	Force    bool     `clop:"-f; --force" usage:"allow adding otherwise ignored files"`
	Pathspec []string `clop:"args=pathspec"`
}

type mv struct {
	Force bool `clop:"-f; --force" usage:"allow adding otherwise ignored files"`
}

type git struct {
	Add add `clop:"subcommand=add" usage:"Add file contents to the index"`
	Mv  mv  `clop:"subcommand=mv" usage:"Move or rename a file, a directory, or a symlink"`
}

func main() {
	g := git{}
	clop.Bind(&g)
	fmt.Printf("git:%#v\n", g)
	fmt.Printf("git:set mv(%t) or set add(%t)\n", clop.IsSetSubcommand("mv"), clop.IsSetSubcommand("add"))
}
// run:
// ./git add -f

// output:
// git:main.git{Add:main.add{All:false, Force:true, Pathspec:[]string(nil)}, Mv:main.mv{Force:false}}
// git:set mv(false) or set add(true)

package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"time"

	"github.com/Pallinder/go-randomdata"
	"github.com/ahmetb/go-linq"
	"github.com/reactivex/rxgo/v2"
)

// ParallelCase1 并发获取不同类型字段信息
func ParallelCase1(ctx context.Context) {
	type Student struct {
		ID      int64
		Name    string
		Age     int64
		Teacher string
	}

	student := Student{ID: 1}
	getNameByID := func() (interface{}, error) {
		time.Sleep(1 * time.Second)
		fmt.Println("getNameByID Success")
		return func() { student.Name = "kangkang" }, nil
	}
	getAgeByID := func() (interface{}, error) {
		time.Sleep(3 * time.Second)
		fmt.Println("getAgeByID Success")
		return func() { student.Age = 13 }, nil
	}
	getTeacherByID := func() (interface{}, error) {
		time.Sleep(2 * time.Second)
		fmt.Println("getTeacherByID failed")
		return nil, errors.New("ERROR!")
	}

	for item := range rxgo.Just(getNameByID, getAgeByID, getTeacherByID)().Map(
		// 执行并发任务
		func(ctx context.Context, item interface{}) (interface{}, error) {
			f := item.(func() (interface{}, error))
			return f()
		},
		// 配置并发策略
		rxgo.WithPool(3),
		rxgo.WithErrorStrategy(rxgo.StopOnError),
		rxgo.WithContext(ctx),
	).Observe() {
		if item.E != nil {
			log.Fatal(item.E)
		}
		// 获取并发任务执行结果
		f := item.V.(func())
		f()
	}

	fmt.Printf("student: %+v", student)
}

// ParallelCase2 并发处理同类型字段信息
func ParallelCase2(ctx context.Context) {
	idList, _ := rxgo.Range(1, 100).ToSlice(100)
	var nameList []string

	itemList, err := rxgo.Just(idList)().Map(
		func(ctx context.Context, item interface{}) (interface{}, error) {
			randNum := randomdata.Number(0, 3)
			time.Sleep(time.Duration(randNum) * time.Second)
			if randNum == 1 {
				return nil, errors.New("[RANDOM ERROR]")
			}
			randName := randomdata.SillyName()
			fmt.Printf("randNum: %d, randName: %s\n", randNum, randName)
			return randName, nil
		},
		rxgo.WithPool(20),                            // 最大并发数
		rxgo.WithBufferedChannel(20),                 // 带缓存接收
		rxgo.WithContext(ctx),                        // 传递context进行链路追踪
		rxgo.WithErrorStrategy(rxgo.ContinueOnError), // 错误处理策略
	).ToSlice(len(idList))
	if err != nil {
		log.Fatalf("[RXGO ERROR]: %+v", err)
	}

	linq.From(itemList).SelectT(
		func(item string) string { return item },
	).ToSlice(&nameList)

	fmt.Printf("nameList: %+v", nameList)
}

func main() {
	ctx := context.Background()
	ParallelCase1(ctx)
	ParallelCase2(ctx)
}