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

巴特西

golang 小知识点记录

最新文章

热门文章