golang 小知识点记录

获取url中的参数及输出到页面的几种方式

func SayHello(w http.ResponseWriter, req *http.Request) {
    req.Method                              //获取url的方法 GET or POST
    request := req.URL.Query()              //获取url中的所有参数（get或post）
    io.WriteString(w, req.FormValue("id"))  //获取url的id参数（常用）
    w.Write([]byte(request["wang"][]))     //发送到HTTP客户端
    io.WriteString(w, "hello, world!\n")    //发送到HTTP客户端
    fmt.Fprintf(w, "%s", "hello, world!\n") //发送到HTTP客户端

}

获取当前路径  

 os.Getwd() //执行用户当前所在路径
 file, _ := exec.LookPath(os.Args[])//执行程序所在的绝对路径

变量类型转换

floatTOint
      int(float)

intTOfloat
      var a int =
      var b float64 = float64(a)
stringTOfloat( / )
      f, err := strconv.ParseFloat(s, )
      f, err := strconv.ParseFloat(s, )
intTOstring
      var i int =
      str1 := strconv.Itoa(i)   // 通过Itoa方法转换
      str2 := fmt.Sprintf("%v", i) // 通过Sprintf方法转换  万能
stringTOint
      var s string = ""
      var i int
      i, err = strconv.Atoi(s)
stringToint
      strconv.ParseInt()
strToBool
      i, err =strconv.ParseBool("")
intToint32
      var a int
      b = int32(a)
interface TO string
        var a interface{}
        var b string
        a = "asdasdasdasd"
        b = a.(string)
interface TO float32
        var a interface{}
        var b float32
        a = 126.982577
        b = a.(float32)
 interface TO int32
        var a interface{}
        var b int32
        a =
        b = a.(int32)
强制类型转换
            type MyInt32 int32
            func main() {
                var uid int32 =
                var gid MyInt32 = MyInt32(uid)
                fmt.Printf("uid=%d, gid=%d\n", uid, gid)
            }
强制类型转换
        unsafe.Pointer  

string  byte互转

aa:="hello world"
      bb:=[]byte(aa)
      cc:=string(bb)

时间篇

 当前时间戳
    fmt.Println(time.Now().Unix())
    # 

时间戳到具体显示的转化
        fmt.Println(time.Unix(t, ).String())

 带纳秒的时间戳
     t = time.Now().UnixNano()
基本格式化的时间表示
         fmt.Println(time.Now().String())
格式化时间
        fmt.Println(time.Now().Format("2006-01-02 15:04:05")) # 记忆方法:-----
        # -- ::

时间戳转str格式化时间
        str_time := time.Unix(, ).Format("2006-01-02 15:04:05")
        fmt.Println(str_time) # -- ::

str格式化时间转时间戳
       the_time := time.Date(, , , , , , , time.Local)
       unix_time := the_time.Unix()
       fmt.Println(unix_time) # 

还有一种方法,使用time.Parse
              the_time, err := time.Parse("2006-01-02 15:04:05", "2014-01-08 09:04:41")
                if err == nil {
                        unix_time := the_time.Unix()
                    fmt.Println(unix_time)
                }
                # 

sleep

   time.Sleep(time.Millisecond * 1000)  #sleep 1000毫秒
   time.Sleep(time.Second * 1) #sleep 1秒

fmt

    万能格式:%v
    字符串： %s
    十进制： %d
    浮点数： %f  保留2位小数 %0.2f
    二进制： %b
    Boolen:  %t

        fmt.Fprintf(os.Stdout, "%08b\n", 32) //
        fmt.Printf("%v", "hello world")              // hello world  直接格式化打印
        fmt.Print(fmt.Sprintf("%v", "hello world"))  // hello world  Sprintf 返回格式化后的变量
        fmt.Print(fmt.Errorf("%08b\n", 32))  //
        fmt.Fprint(os.Stdout, "A")
        fmt.Fprintln(os.Stdout, "A") // A
        fmt.Println("B")             // B
        fmt.Print(fmt.Sprintln("C")) // C  

函数不定参数 

func sum (nums ...int) {
    fmt.Print(nums, " ")  //输出如 [1, 2, 3] 之类的数组
    total := 0
    for _, num := range nums { //要的是值而不是下标
        total += num
    }
    fmt.Println (total)
}
a:=[]int{1,2,3,4,5} //可传slice …
sum(a…)

执行命令行

import "os/exec"
         func main () {
            //cmd := exec.Command("ps", "-aux")
                cmd := exec.Command ("ls", "/root")
                out, err := cmd.Output ()
                if err!=nil {
                    println ("Command Error!", err.Error ())
                    return
                }
                fmt.Println (string (out))
            }
            或者（正规一点）
            func main () {
                cmd := exec.Command ("tr", "a-z", "A-Z")
                cmd.Stdin = strings.NewReader ("some input")
                var out bytes.Buffer
                cmd.Stdout = &out
                err := cmd.Run ()
                if err != nil {
                    log.Fatal (err)
                }
                fmt.Printf("in all caps: %q\n", out.String ())
            }

            输出:in all caps: "SOME INPUT"

命令行参数 （可用flag包）

func main () {
            args := os.Args
            fmt.Println (args) //带执行文件的
 }
$go run args.go aaa bbb ccc ddd

生成随机数

 r := rand.New(rand.NewSource(time.Now().UnixNano())) //使用时间作为种子

结构体的初始化方法

        rect1 := new(Rect)
        rect2 := &Rect{}
        rect3 := &Rect{0, 0, 100, 200}
        rect4 := &Rect{width:100, height:200}
        var rect5 *Rect=new(Rect)
        注意这几个变量全部为指向Rect结构的指针(指针变量)，因为使用了new()函数和&操作符
        a := Rect{}

        则表示这个是一个Rect{}类型

md5

import (
    "crypto/md5"
    "encoding/hex"
)

func GetMd5String(s string) string {
    h := md5.New()
    h.Write([]byte(s))
    return hex.EncodeToString(h.Sum(nil))
}

urlencode

import "net/url"
url.QueryEscape("strings")

log 记日志

logfile, _ := os.OpenFile("./pro.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0777)
defer logfile.Close()

logger := log.New(logfile, "", 0)
logger.Printf("%v%v", err, ret)

判断文件是否存在

func main() {
    f, err := os.Open("dotcoo.com.txt")
    defer f.Close()
    if err != nil && os.IsNotExist(err) {
        fmt.Printf("file not exist!\n")
        return
    }
    fmt.Printf("file exist!\n")
   }

string如果里面有"或换行，可以使用`来进行包含

jsonString := `
     {
    "development":{
        "connector":[
             {"id":"connector-server-1", "host":"127.0.0.1", "port":4050, "wsPort":3050}
                     ],
        "gate":[
          {"id": "gate-server-1", "host": "127.0.0.1", "wsPort": 3014}
     ]
    }
    }`

path.Clean

path.Clean用于对路径 ../../等进行过滤，在创建修改文件的时候需要使用到，否则会有漏洞

import包命名

import的包可以给它命名import l4g "code.google.com/p/log4go"

判断当前用户是否是root用户

os.Geteuid() != 0

break 退出指定的循环体  如果在某个条件下，你需要从 for-select 中退出，就需要使用标签

    sum := 0
MyForLable:
    for {
        for i := 0; i < 10; i++ {
            if sum > 200 {
                break MyForLable //将退出循环体for{}
            }
            sum += i
        }
    }
    fmt.Println(sum)

golang 通过go-sql-driver/mysql 调取存储过程报错

Error 1312: PROCEDURE mydb.GetAllNotes can't return a result set in the given context
       to line 209 in packets.go
       under function writeAuthPacket
       adding

       clientMultiStatements |
       clientMultiResults |

调用方式 db.Query("call proc_xxx();")

golang 中的 类型判断

var a interface{}
   a=12
   newA,ok:=a.(string)
   如果ok 是 true 则说明 变量a 是字符串类型,而newA就是string类型的变量，a的实际值
    a.(type) 返回的是 a的 类型, 注意他返回的不是一个 字符串表示 string int 这样表示a的类型
        a.(type)是和switch 搭配使用的
        switch vtype:=v.(type){
            case string:

            case int:

            case  []interface{}:

            default:
        }

json 简单的 encode decode 

import  "encoding/json"

   type MyData struct {
    Name   string    `json:"item"`
    Other  float32   `json:"amount"`
   }
    detail:=&MyData{"Name":"hello","Other":2}
    userinfo, _ := json.Marshal(detail)
    fmt.Println(string(userinfo))
   //`json:"item"` 就是Name字段在从结构体实例编码到JSON数据格式的时候，使用item作为名字。算是一种重命名的方式。
   //输出：{"item":"hello","amount":2}

   userinfo,_:=json.Marshal(detail)
   ObjUser := make(map[string]interface{})
   json.Unmarshal([]byte(userinfo), &ObjUser)

panic和恢复recover用法 

defer func() {

    if re := recover(); re != nil {

        fmt.Printf("%v", re)

    }

}()

从文件中json解析 

尽量使用os.OpenFile直接获取reader，然后再从reader中使用Decoder来解析json

package main

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

func main() {
    pathToFile := "jsondata.txt"

    file, err := os.OpenFile(pathToFile, os.O_RDONLY, 0644)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }

    configs := make(map[string]map[string][]Service, 0)
    err = json.NewDecoder(file).Decode(&configs)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }}

lock 并发小例

import (
    "fmt"
    "sync"
    "time"
)

var l sync.Mutex

func main() {
    l.Lock()
    defer l.Unlock()
    m := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    ch := make(chan int)
    defer close(ch)
    for i := 0; i < 30; i++ {
        time.Sleep(time.Second)
        go func(x int) {
            for {
                if len(m) == 0 {
                    break
                } else {
                    l.Unlock()
                    fmt.Println(x, m[0:1])
                    m = m[1:len(m)]
                    l.Lock()
                }
                time.Sleep(time.Second)

            }
            ch <- x

        }(i)
    }
    for i := 0; i < 30; i++ {
        fmt.Println(<-ch)
    }

}

future 小例

package main

import (
    "fmt"
)

//一个查询结构体
type query struct {
    //参数Channel
    sql chan string
    //结果Channel
    result chan string
}

//执行Query
func execQuery(q query) {
    //启动协程
    go func() {
        //获取输入
        sql := <-q.sql
        //访问数据库，输出结果通道
        q.result <- "get " + sql
    }()

}

func main() {
    //初始化Query
    q :=
        query{make(chan string, 1), make(chan string, 1)}
    //执行Query，注意执行的时候无需准备参数
    execQuery(q)

    //准备参数
    q.sql <- "select * from table"
    //获取结果
    fmt.Println(<-q.result)
}

反射小例

package main

import (
    "errors"
    "fmt"
    "reflect"
)

func foo() {
    fmt.Println("hello")

}
func bar(a, b, c int) {
    fmt.Println(a, b, c)
}

func Call(m map[string]interface{}, name string, params ...interface{}) (result []reflect.Value, err error) {
    f := reflect.ValueOf(m[name])
    if len(params) != f.Type().NumIn() {
        err = errors.New("The number of params is not adapted.")
        return
    }
    in := make([]reflect.Value, len(params))
    for k, param := range params {
        in[k] = reflect.ValueOf(param)
    }
    result = f.Call(in)
    return
}

func main() {
    funcs := map[string]interface{}{"foo": foo, "bar": bar}
    Call(funcs, "foo")
    Call(funcs, "bar", 1, 2, 3)
}

快速搭建服务器

func main(){
    http.HandleFunc( "/",Handler)
    http.HandleFunc( "/valueget",valueget)
    s := &http.Server{
        Addr:           ":80",
        ReadTimeout:    30 * time.Second,
        WriteTimeout:   30 * time.Second,
        MaxHeaderBytes: 1 << 20,
    }
    log.Fatal(s.ListenAndServe())
}

func valueget(w http.ResponseWriter, r *http.Request) {

    params := r.URL.Query()

    user := params.Get("user")

    fmt.Fprintf(w, "you are get user %s", user)

}

go “静态目录服务” http.FileServer

//对目录提供静态映射服务
http.Handle("/", http.FileServer(http.Dir("/tmp")))

http.HandleFunc("/static/", func(w http.ResponseWriter, r *http.Request) {

        http.ServeFile(w, r, r.URL.Path[1:])

})

go语言中导入另外一个库结果调用时出错：cannot refer to unexported name

解决方法
go，模块中要导出的函数，必须首字母大写。

 goto

func main() {
    defer fmt.Println("cc")
    goto L
    defer fmt.Println("dd")
    fmt.Println("aa")
L:
    fmt.Println("bb")
}

输出
bb
cc

git 安装redis

  cd $GOPATH/src
  git clone git://github.com/alphazero/Go-Redis.git redis
  cd redis
  go install

 hook

package main

import (
    "fmt"
)

var hooks []hookfunc //hook function slice to store the hookfunc

type hookfunc func() error //hook function to run

func initOne() error {
    fmt.Println("hello world 1")
    return nil
}
func initTwo() error {
    fmt.Println("hello world 2")
    return nil
}
func AddHook(hf hookfunc) {
    hooks = append(hooks, hf)
}

func main() {
    AddHook(initOne)
    AddHook(initTwo)

    // do hooks function
    for _, hk := range hooks {
        err := hk()
        if err != nil {
            panic(err)
        }
    }
}

signalpackage main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    go signalHandle()
    time.Sleep(time.Second * )
}

func signalHandle() {
    for {
        ch := make(chan os.Signal)
        signal.Notify(ch, syscall.SIGINT, syscall.SIGUSR1, syscall.SIGUSR2, syscall.SIGHUP)
        sig := <-ch
        switch sig {
        default:
            fmt.Println("default")
        case syscall.SIGHUP:
            fmt.Println("SIGHUP")
        case syscall.SIGINT:
            fmt.Println("SIGINT")
        case syscall.SIGUSR1:
            fmt.Println("SIGUSR1")
        case syscall.SIGUSR2:
            fmt.Println("SIGUSR2")

        }
    }
}

闭包

package main

import "fmt"

func adder() func(int) int {
     sum :=
     return func(x int) int {
          sum += x
          return sum
     }
}

func main() {
     pos, neg := adder(), adder()
     for i := ; i < ; i++ {
          fmt.Println(
               pos(i),
               neg(-*i),
          )
     }
}

json 解析标签

//tag中的第一个参数是用来指定别名
//比如Name 指定别名为 username `json:"username"`
//如果不想指定别名但是想指定其他参数用逗号来分隔
//omitempty 指定到一个field时 如果该字段为nil或0值（数字0,字符串"",空数组[]等），则打包的JSON结果不会有这个字段//- 指定到一个field时 无论有没有值将Person序列化成json时都会忽略该字段
//string 指定到一个field时
//比如Person中的Count为int类型 如果没有任何指定在序列化
//到json之后也是int 比如这个样子 "Count":0
//但是如果指定了string之后序列化之后也是string类型的
//那么就是这个样子"Count":"0"
type Person struct {
    Name        string `json:"username"`
    Age         int
    Gender      bool `json:",omitempty"`
    Profile     string
    OmitContent string `json:"-"`
    Count       int    `json:",string"`
}

命令

格式化（美化）文件代码
>go fmt -x test  或者
>gofmt -l -w E:\projects\go\src\test\main.go