golang笔记


读取配置文件

注: Configuration 里元素(Path)必须大写开头

import (
    "encoding/json"
    "flag"
    "fmt"
    "io/ioutil"
)

type Configuration struct {
    Path string
}

const VETSION = "0.1.0"

var (
    config Configuration
)

func init() {
    var (
        conf_file string
        print_ver bool
    )
    flag.StringVar(&conf_file, "c", "etc/config.json", "config file")
    flag.BoolVar(&print_ver, "v", false, "config file")
    flag.Parse()

    raw, err := ioutil.ReadFile(conf_file)
    if err != nil {
        log.Error("config parse fail!")
        os.Exit(1)
    }
    err = json.Unmarshal(raw, &config)
    if err != nil {
        log.Error("config unmarshal fail!")
        os.Exit(1)
    }
    if print_ver {
        fmt.Println("version:", VERSION)
        os.Exit(0)
    }
}

判断文件是否存在

import (
    "os"
)
func file_is_exists(f string) bool {
    _, err := os.Stat(f)
    if os.IsNotExist(err) {
        return false
    }
    return err == nil
}

随机睡眠

import (
    "math/rand"
    "time"
)
func random_sleep(t int) {
    rand.Seed(time.Now().Unix())
    time.Sleep(time.Duration(rand.Intn(t)) * time.Microsecond)
}

字符串连接

import (
    "bytes"
)
func string_concat(s ...string) string {
    var buffer bytes.Buffer
    for _, i := range s {
        buffer.WriteString(i)
    }
    return buffer.String()
}

检查元素是否在map中

func check_in_map(f map[string]string, v string) bool {
    if _, ok := f[v]; ok {
        return true
    }
    return false
}

检查元素是否在list中

func check_in_list(f []string, v string) bool {
    for i := range f {
        if f[i] == v {
            return true
        }
    }
    return false
}

执行Linux命令

import (
    "os/exec"
)
func exec_command(command string, args ...string) (error, bool) {
    var (
        err error
    )
    cmd := exec.Command(command, args...)
    cmd.Start()
    done := make(chan error)
    go func() {
        done <- cmd.Wait()
    }()

    select {
    case <-time.After(600 * time.Second):
        if err = cmd.Process.Kill(); err != nil {
            log.Error("failed to kill: %s, error: %s", cmd.Path, err)
        }
        go func() {
            <-done // allow goroutine to exit
        }()
        log.Info("process:%s killed", cmd.Path)
        return err, true
    case err = <-done:
        return err, false
    }
}

迭代文件目录

func file_iter(path string) []string {
    // path must be abs path
    var files []string
    scripts, _ := ioutil.ReadDir(path)
    for _, script := range scripts {
        if script.IsDir() {
            return file_iter(filepath.Join(path, script.Name()))
        }
        files = append(files, filepath.Join(path, script.Name()))
    }
    return files
}

求两列表的差集

func difference(a,b []string) []string {
    // len(a) < len(b), avoid all item of a belong to b
    m := map[string]bool{}
    for _, x := range a {
        m[x] = true
    }
    diff := []string{}
    for _, x := range b {
        if _, ok := m[x]; !ok {
            diff = append(diff, x)
        }
    }
    return diff
}

删除列表中重复的数据

func RemoveDuplicates(elements []string) []string {
   keys := map[string]bool{}
   result := []string{}

   for _, element := range elements {
       if _, value := keys[element]; !value {
           keys[element] = true
           result = append(result, element)
       }
   }
   return result
}

参数校验

是否是IP

func IsValidIP(key string) bool {
    IP := net.ParseIP(key)
    if IP == nil {
        return false
    }

    return true
}

是否是EMAIL

import "regexp"

func IsValidEmail(key string) bool {
    re := regexp.MustCompile("^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$")
    if !re.MatchString(key) {
        return false
    }
    if strings.HasSuffix(key, "@upai.com") || strings.HasSuffix(key, "@huaban.com") {
        return true
    }
    return false
}