开发中常用的Golang高级用法

前言

忙碌了两个月，这次开发终于要结束了，今天下午公司在重组集群机器，也没办法干活儿了，就写一些东西，相当于，留住一些东西，来纪念这辛苦的两个月吧。做一个纪念，也是为了方便以后自己去查看。在这次开发中，学习了不少Golang的高级特性，并且付诸于实现，也踩了不少坑，留下这篇文字，也是方便其他人能够查看，或者借鉴，如果帮到你，那么我也会很开心你。

开发常遇到的问题

Golang判断一个元素在不在切片/列表当中

在Python中，我们可以直接用 in 的方式去判断，例如

if "i" in lists

但是在Golang中，没有这种语法糖或者是关键字可以帮助我们处理这种问题，所以还是只能靠循环去处理这种问题，为此我封装了一个Golang函数，函数如下

//FindType 循环对比，匹配到返回true，不匹配返回false
func FindType(a string, typelist []string) bool {
	for _, b := range typelist {
		if b == a {
			return true
		}
	}
	return false
}

Golang获取文件的详细信息

Golang获取文件信息的方法相对来说容易一些，都已经有了对应的package，我这里只是把怎么用展示出来

//timespecToTime 转换
func timespecToTime(ts syscall.Timespec) time.Time {
	return time.Unix(int64(ts.Sec), int64(ts.Nsec))
}

//GetFileinfo 获取文件信息
func GetFileinfo(path string) {
	fileInfo, err := os.Stat(path)
	if err != nil {
		return 0
    }
    //文件大小
    filesize := fileInfo.Size()
    //文件创建时间
    stat_ts := fileInfo.Sys().(*syscall.Stat_t)
    Ctime := timespecToTime(stat_ts.Ctim).Format("2006/01/02")
    //文件修改时间
    Mtime := timespecToTime(stat_ts.Mtim).Format("2006/01/02")
    //文件访问时间
    Attim := timespecToTime(stat_ts.Atim).Format("2006/01/02")
    //获取文件所有者
    stat_ts := fileInfo.Sys().(*syscall.Stat_t)
	uid := strconv.Itoa(int(stat_ts.Uid))
    usrs, err := user.LookupId(string(uid))
    username := usrs.Username
    //获取文件名
    filename := fileInfo.Name()
}

Golang比较两个list/切片的不同之处（差集）

在开发中，我需要比较两个list，然后取出他们之中不同的部分，这里Golang也没有合适的法子，一般的方法就是转map进行处理

//difference 进行比对，输出不同的[]string
func difference(slice1, slice2 []string) []string {
	m := make(map[string]int)
	nn := make([]string, 0)
	inter := intersect(slice1, slice2)
	for _, v := range inter {
		m[v]++
	}

	for _, value := range slice1 {
		times, _ := m[value]
		if times == 0 {
			nn = append(nn, value)
		}
	}
	return nn
}

//intersect 把两个对比的列表进行map化处理
func intersect(slice1, slice2 []string) []string {
	m := make(map[string]int)
	nn := make([]string, 0)
	for _, v := range slice1 {
		m[v]++
	}

	for _, v := range slice2 {
		times, _ := m[v]
		if times == 1 {
			nn = append(nn, v)
		}
	}
	return nn
}

func main() {
    infinode := []string{"10.0.9.1","10.0.9.2"}
    syncnodes := []string{"10.0.9.1","10.0.9.2", "10.0.9.3"}
    ips := difference(infinode, syncnodes)
}

Golang格式化时间

golang 一般都可以通过Format的方法进行时间格式化，一般你可以直接调format，例如

fmt.Println(time.Now().Format("2006-01-02 15:04:05"))

有些时候是他娘的时间戳

fmt.Println(time.Unix(1389028339, 0).Format("2006-01-02 15:04:05"))

有些时候会让你搞成别的样子，比如"2006/01/02 15:04:05"

fmt.Println(time.Now().Format("2006/01/02 15:04:05"))

有些时候会让你比较个时间大小，例如

//比对时间，看看它在不在开始时间/结束时间的范围内
starttime := "2020-05-12"
endtime := "2020-05-20"
ctime := "2020-05-15"
ft, err := time.Parse("2006-01-02", ctime)
st, err := time.Parse("2006-01-02", starttime)
et, err := time.Parse("2006-01-02", endtime)
if ft.After(et) && ft.Before(st) {
    fmt.Println("在里面儿！")
} else {
     fmt.Println("不在里面儿！")
}

Golang并发循环的使用

我们处理循环的时候，在Python中，我举个例子

lists = [1, 2, 3, 4]
for i in lists:
    print i

这里打印的话是

1
2
3
4

Golang有个黑科技是并发循环，简单说，就是能一下给你把这四个都给你打印出来，不是一条条循环，也不用等上一个循环的结果返回，也可以选择略过错误。我在这里简单实现一个

直接并发循环（无需考虑错误）

这里不考虑error的情况，具体代码如下

ips := []string{"10.0.9.1","10.0.9.2"}
ch := make(chan struct{})
//并发循环ip
for _, ip := range ips {
    go func(ip string) {
        //模拟一个展示ip
        fmt.Println(ip)
        ch <- struct{}{}
    }(ip)
}
for range ips {
    <-ch
}

输出错误的并发循环(考虑错误)

ips := []string{"10.0.9.1","10.0.9.2"}
//定义一个error
errors := make(chan error)
for _, ip := range ips {
    go func(ip string) {
        _, err := test(ip)
        errors <- err
    }(ip)
}
for range ips {
    if err := <-errors; err != nil {
        return err
    }
}

Golang做一个不退出的无限循环

有些时候我们希望一个服务/脚本/函数不断运行，或者每隔一段时间来一发（运行一次），这时候我们就需要定义无限循环

func main() {
    for {
        //每隔1s打印一次start work
        time.Sleep(time.Second * 1)
		fmt.Println("Start work......")
	}
}

Golang实现一个遇到错误的重试机制

当我们最开发的时候，有些时候遇到错误，需要进行重试，这时候我们就需要进行错误捕获和函数重载

//Retry 重试逻辑
//传入函数，如果捕获到错误，则重载函数，重新来一次执行，直到没错误为止
func Retry(fn func() error) error {
	if err := fn(); err != nil {
		if s, ok := err.(stop); ok {
			return s.error
		}
		return Retry(fn)
	}
	return nil
}
//TestWork 测试函数，无意义
func TestWork() error {
    //测试函数，这里是伪代码。
    _, err := GetIpNode()
    if err != nil {
        return err
    }
    return nil
}
func main() {
    go Retry(TestWork)
}

Golang执行Linux命令

有些时候我们需要执行linux相关命令，Golang封装了相应的包，但是少部分时候我们需要控制一些很久不返回结果的命令，所以我加了一个超时时间，代码如下

var (
    //这里我写死了，你可以自己定义，更灵活一些
	Timeout = 60 * time.Second
)
//Command 执行shell
func Command(arg string) ([]byte, error) {
	ctxt, cancel := context.WithTimeout(context.Background(), Timeout)
	defer cancel()

	cmd := exec.CommandContext(ctxt, "/bin/bash", "-c", arg)

	var buf bytes.Buffer
	cmd.Stdout = &buf
	cmd.Stderr = &buf

	if err := cmd.Start(); err != nil {
		return buf.Bytes(), err
	}

	if err := cmd.Wait(); err != nil {
		return buf.Bytes(), err
	}

	return buf.Bytes(), nil
}

func main() {
    _, err := Command("ls")
    if err != nil {
        fmt.Println(err)
    }
}

Golang 简单的日志逻辑

这边贡献一个简单的日志实现代码，往文件里面写，可以自己定义格式，代码如下

import (
	"fmt"
	"os"

	"github.com/op/go-logging"
)

func Monlog() (logs *logging.Logger) {
    var log = logging.MustGetLogger("monlog")
    //定义格式 时间 go文件 行数 等级 错误信息
	var format = logging.MustStringFormatter(
		`%{time:2006-01-02T15:04:05} %{shortfile} %{shortfunc} %{level} %{message}`)
    //文件的写入位置 追加模式/没有自动创建
	logFile, err := os.OpenFile("/var/log/monlog.log", os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
	if err != nil {
		panic(fmt.Sprintf("Open faile error!"))
    }
    //头相关, 具体意思就是支持追加，然后格式化，且按照那个格式往里面写
	backend1 := logging.NewLogBackend(logFile, "", 0)
	backend2 := logging.NewLogBackend(os.Stderr, "", 0)

	backend2Formatter := logging.NewBackendFormatter(backend2, format)
	backend1Formatter := logging.NewBackendFormatter(backend1, format)
	backend1Leveled := logging.AddModuleLevel(backend1Formatter)
	backend1Leveled.SetLevel(logging.INFO, "")
	logging.SetBackend(backend1Leveled, backend2Formatter)
	return log
}

func main() {
    log := Monlog()
    log.Info("info")
 	log.Notice("notice")
 	log.Warning("warning")
}

Golang 使用 Aws-sdk 获取到指定bucket中全部的item

我前阵子写过一篇文章，是Golang 调用 s3对象存储的，使用指定的api可以获取其中的item，但是人家限定100条，估摸着怕撑爆内存，但是如果我们想要获取到所有的item，这个该怎么做呢？其实循环获取就好了，但是我还是徒手实现一下吧，大家抄抄得了。

func GetRgwItem3(buckets string) ([]*s3.Object, error) {
    var items []*s3.Object
    sess, err := session.NewSession(&aws.Config{
		Credentials:      credentials.NewStaticCredentials(ak, sk, ""),
		Endpoint:         aws.String(endpoint + ":7480"),
		Region:           aws.String("us-east-1"),
		DisableSSL:       aws.Bool(true),
		S3ForcePathStyle: aws.Bool(false), //virtual-host style方式，不要修改
	})
	if err != nil {
		return nil, err
	}
	svc := s3.New(sess)
	err := svc.ListObjectsPages(&s3.ListObjectsInput{
		Bucket: &buckets,
	}, func(p *s3.ListObjectsOutput, last bool) (shouldContinue bool) {
		for _, obj := range p.Contents {
			items = append(items, obj)
		}
		return false
	})
	if err != nil {
		return items, err
	}
	return items, nil
}

我这里没毛病啊，万一你有问题你就咨询我

后记

暂时先更这么多，这也不少了，大部分代码我都给出了具体实现，要是还不会就留言给我或者发邮件。

其实我特想对那些写几个爬虫在那里爬我博客的人说，你偷博客没所谓，复制也没所谓，不加名字说转载就很说不过去了，还TM标榜你是原创，脸呢？cnblog我会逐渐弃掉，因为我有我自己的博客了，我也在逐渐搞迁移，把我原来写的博客都迁移到我自己的博客上去，未来我的cnblog博客将逐渐少更或者停更，就算更我也会用英语/日语双更，我让你TM抄我东西不说，fuck off bitch。