BlogJava-咖啡伴侣-随笔分类-Golang

golang 之接口

oathleo — Sun, 22 Dec 2013 04:45:00 GMT

conn, err = ln.Accept()
go handleConnection(conn)

看到这里我曾经有个疑问，为什么不是 handleConnection(&conn) ?

下面这个例子解释这个问题

package main

import (
    "fmt"
)

type Interface interface {
    say() string
}

type Object struct {
}

func (this *Object) say() string {
    return "hello"
}

func do(i Interface) string {
    return i.say()
}

func main() {
    o := Object{}
    fmt.Println(do(&o))
    fmt.Printf("CCCCCCCCCCC:%T", o)
}

函数的参数以接口定义，编译器会自己判断参数是对象还是对象的指针
比如，say是指针上的方法，所以do只接受Object的指针做参数，do(o)是编译不过的

所以看到库里接口做参数类型定义的时候，可以简单认为，这个接口肯定是个对象指针（虽然也可以用对象，单估计没有哪个类库会用）

例如：
conn, err = ln.Accept()
go handleConnection(conn)

这里conn是个接口，不需要 go handleConnection(&conn)

oathleo 2013-12-22 12:45 发表评论

golang定时定点任务

oathleo — Thu, 19 Dec 2013 08:15:00 GMT

package main

import (
    "fmt"
    "mag/common"
    "time"
)

func main() {
    c := make(chan bool, 10)

    tt := common.GetTodayGivenTime("161300")
    dd := common.SinceNow(tt)
    time.AfterFunc(dd, func() { //非阻塞
        //后续每24小时建立目录
        ticker24h := time.NewTicker(5 * time.Second)
        for {
            select {
            case <-ticker24h.C:
                fmt.Println("print")
            }
        }
    })

    <-c
}

oathleo 2013-12-19 16:15 发表评论

golang append时slice len 和 cap

oathleo — Wed, 20 Nov 2013 10:48:00 GMT

声明:

源slice= src

添加slice = app

结果slice=tar

append时

len tar === len src + len app

1）如果len(src) + len(app) <= cap(src) cap tar = cap(src)

2）否则

a) len(src) + len(app) > 2* cap(src) cap tar = len(src) + len(app)

b) cap(src) < len(src) + len(app) <= 2* cap(src) cap tar = 2* cap(src)

data := make([]int, 10, 20)
    data[0] = 1
    data[1] = 2

    dataappend := make([]int, 12, 30)//修改这个len
    dataappend[0] = 1
    dataappend[1] = 2

    result := append(data, dataappend)

    result[0] = 99
    result[11] = 98

    fmt.Println("length:", len(data), "cap:", cap(data), ":", data)
    fmt.Println("result length:", len(result), "cap:", cap(result), ":", result)
    fmt.Println("length:", len(dataappend), "cap:", cap(dataappend), ":", dataappend)

oathleo 2013-11-20 18:48 发表评论

golang slice分割和append copy还是引用

oathleo — Wed, 20 Nov 2013 10:46:00 GMT

1.slice1:= slice[0:2]

引用，非复制，所以任何对slice1或slice的修改都会影响对方

data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}

data1 := data[0:2]

data1[0] = 99

fmt.Println(data1)

fmt.Println(data)

[99 2]

[99 2 3 4 5 6 7 8 9 0]

2.append

append 比较特殊

声明:

源slice= src

添加slice = app

结果slice=tar

1）如果len(src) + len(app) <= cap(src) src和tar 是指向同一数据引用，即修改src或tar，会影响对方

2）否则 tar 是copy的方式 src + app ，即修改src或tar，不会影响对方

无论哪种情况不会影响app，因为app都会用copy的方式进入tar

func test2() {

data := make([]int, 10, 20)

data[0] = 1

data[1] = 2

dataappend := make([]int, 10, 20)//len <=10 则 result[0] = 99 会影响源Slice

dataappend[0] = 1

dataappend[1] = 2

result := append(data, dataappend...)

result[0] = 99

result[11] = 98

fmt.Println("length:", len(data), ":", data)

fmt.Println("length:", len(result), ":", result)

fmt.Println("length:", len(dataappend), ":", dataappend)

}

oathleo 2013-11-20 18:46 发表评论

golang 之去掉定长数组里的0 []byte 转 string

oathleo — Tue, 19 Nov 2013 02:16:00 GMT

index := bytes.IndexByte(buf_PN, 0)

rbyf_pn := buf_PN[0:index]

oathleo 2013-11-19 10:16 发表评论

golang之 windows下杀进程

oathleo — Fri, 15 Nov 2013 06:07:00 GMT

c := exec.Command("taskkill.exe", "/f", "/im", "test.exe")

err := c.Start()

oathleo 2013-11-15 14:07 发表评论

golang slice Append

oathleo — Tue, 05 Nov 2013 08:39:00 GMT

s2 := append(s1, *)

切片s1上记录的切片信息复制给s2，

1.如果s1指向的底层array长度不够，append的过程会发生如下操作：内存中不仅新开辟一块区域存储append后的切片信息，而且需要新开辟一块区域存储底层array（复制原来的array至这块新array中），最后再append新数据进新array中，这样，s2指向新array。

2.如果s1指向的底层array长度够,
s2和s1指向同一个array，append的结果是内存中新开辟一个区域存储新切片信息。

开辟一块区域存储底层array 使用下面的策略：
1.如果增加的 len < s的cap 则新s的cap*2
2.如果增加的 len > s的cap 则新s的cap = 老cap + 增加数据的 len

oathleo 2013-11-05 16:39 发表评论

golang 定时

oathleo — Thu, 10 Oct 2013 07:07:00 GMT

 // (A)

time.AfterFunc(5 * time.Minute, func() {
fmt.Printf("expired")
}

// (B) create a Timer object
timer := time.NewTimer(5 * time.Minute)
<-timer.C
fmt.Printf("expired")

// (C) time.After() returns timer.C internally
<-time.After(5 * time.Minute)
fmt.Printf("expired")

oathleo 2013-10-10 15:07 发表评论

golang 非缓冲通道 recv 的操作肯定在 send 操作之前发生

oathleo — Thu, 10 Oct 2013 02:56:00 GMT

对亍非缓冲通道,“从通道接收数据”的操作
一定会在 “向通道发送数据”的操作完成前发生。

package main

import (
    "fmt"
)

var c = make(chan int)
var str string

func ready() {
    str = "abc"
    fmt.Println("ready1")
    <-c //get
    fmt.Println("ready2")
}

func main() {
    go ready()
    c <- 1 //put
    fmt.Println(str)
}

ready1
ready2
abc

oathleo 2013-10-10 10:56 发表评论

Go指针 new make

oathleo — Tue, 08 Oct 2013 02:49:00 GMT

new(T) 分配了零值填充的T

类型的内存空间,并且返回其地址,一个*T 类型的值。用Go 的术语说,它返回了一个

指针,指向新分配的类型T 的零值。有一点非常重要:

new 返回指针。

内建函数make(T, args) 与new(T) 有着不同的功能。它只能创建slice,map

和channel,并且返回一个有初始值(非零)的T 类型,而不是*T。本质来讲,导致这

三个类型有所不同的原因是指向数据结构的引用在使用前必须被初始化。

T{name:"aaa",age:11}
返回 T类型而不是*T

oathleo 2013-10-08 10:49 发表评论

go原生数据效率

oathleo — Sun, 29 Sep 2013 01:57:00 GMT

接着上回，对象序列化和反序的效率已经很高，试试原生数据的效率

先上代码

package main

import (
    "fmt"
    "math/rand"
    "opbuf"
    "time"
)

type RTValue struct {
    Time   int32
    Status int16
    Value  float32
}

func main() {

    size := 1000000
    col := make([]RTValue, size)
    for i := 0; i < size; i++ {
        col[i] = RTValue{Time: int32(i), Status: int16(i), Value: rand.Float32()}
    }

    fmt.Println("send data:", col[size-1])
    var opbuff *opbuf.OPBuffer = opbuf.NewOPBuffer()
    start := time.Now().UnixNano()
    for i := 0; i < size; i++ {
        //        opbuff.PutByte(col[i].Data)
        opbuff.PutInt32(col[i].Time)
        opbuff.PutInt16(col[i].Status)
        opbuff.PutFloat32(col[i].Value)
    }
    fmt.Println("send cost:", (time.Now().UnixNano()-start)/1000000)

    opbuff.Flush()

    start = time.Now().UnixNano()
    for i := 0; i < size; i++ {
        col[i].Time,_ = opbuff.GetInt32()
        col[i].Status,_ = opbuff.GetInt16()
        col[i].Value,_ = opbuff.GetFloat32()
    }
    fmt.Println("rev cost:", (time.Now().UnixNano()-start)/1000000)
    fmt.Println("rev data:", col[size-1])

}

123

Go原生代码性能：

total record: 1000000

send data: {999999 16959 0.69153386}

send cost: 93

rev cost: 61

rev data: {999999 16959 0.69153386}

结论：

1.不管什么语言，大批量同类型数据的传输，原生性能还是比第三方序列化效率高很多

2.C++ 使用memcpy put 原始类型，效率还是比go高很多

C++原生代码性能：

total record 1000000

time pack 11 ms

time unpack 57 ms

oathleo 2013-09-29 09:57 发表评论

go对象序列化和反序列化

oathleo — Sun, 29 Sep 2013 01:52:00 GMT

模拟测试1,000, 000条数据每条10个字节也就是10M不到的数据(高度结构化的数据)
过程
1.对象序列化为 byte
2.byte反序为对象
3.gzip压缩byte

测试语言go
测试方案： raw byte，json ,bson, msgpack （protostuff需要先做对象配置文件，比较麻烦，通常认为和msgpack性能相当）
结果：msgpack 胜出

	大小	gzip压缩后大小	对象到byte耗时	byte到对象耗时
raw	10000000	6573252（65%）	未测试	未测试
json	47515988	7919511 (17%)	3248ms	5280ms
bson	49888910	9506965 （19%）	3863ms	6235ms
msgpack	29934223	7448484	2046ms	3113ms

raw data: 1000000
raw data gzip compress: 6573252 //gzip压缩后大小

start: 1000000
Marshal cost: 3248 //json 序列化耗时
json string: 47515988
json byte: 47515988 //二进制数组大小
Unmarshal cost: 5280 //json 反序列化耗时
test data: {1 100 0.9405091}
json gzip compress: 7919511 //gzip压缩后大小

start
Marshal cost: 3863
bson byte: 49888910
Unmarshal cost: 6235
test data: {1 100 0.9405091}
bson gzip compress: 9506965

start: 1000000
Marshal cost: 2046
msgpack: 29934223
Unmarshal cost: 3113
test data: {1 100 0.9405091}
msgpack gzip compress: 7448484

oathleo 2013-09-29 09:52 发表评论

bson和json

oathleo — Mon, 23 Sep 2013 06:08:00 GMT

测试1000个数据每个数据10个字节，分别使用字节、json、bson方式存储，并用gzip压缩

结果bson比json还大一点，确实出乎意料

个人结论是BSON对比json更加适合存储，在传输上没有太大优势

　　BSON相对JSon

1.更快的遍历速度

2.操作更简易

3.增加了额外的数据类型

raw data: 10000
raw data gzip compress: 6553

json string: 44524
json byte: 44524
json gzip compress: 8125

bson byte: 46910
bson gzip compress: 9721

package main

import (
    "bytes"
    "compress/gzip"
    "fmt"
    "labix.org/v2/mgo/bson"
    "math/rand"
)

type HisCollection struct {
    RTValues []RTValue
}

type RTValue struct {
    Time   int32
    Status int16
    Value  float32
}

func main() {
    fmt.Println("start")

    size := 1000
    col := make([]RTValue, size)

    for i := 0; i < size; i++ {
        col[i] = RTValue{Time: int32(i), Status: 100, Value: rand.Float32()}
    }

    his := HisCollection{RTValues: col}
    data, err := bson.Marshal(&his)
    if err != nil {
        panic(err)
    }
    //    fmt.Println(data)
    fmt.Println("bson byte:", len(data))

    var compress_data_buf bytes.Buffer
    writer := gzip.NewWriter(&compress_data_buf)
    defer writer.Close()

    writer.Write(data)
    writer.Flush()

    fmt.Println("bson gzip compress:",len(compress_data_buf.Bytes()))

}

package main

import (
    "bytes"
    "compress/gzip"
    "fmt"
    "math/rand"
    "openplant/opnet"
)

func main() {
    var compress_data_buf bytes.Buffer
    writer := gzip.NewWriter(&compress_data_buf)
    defer writer.Close()

    size := 1000
    for i := 0; i < size; i++ {
        writer.Write(opnet.WarpInt32ToByte(int32(i)))
        writer.Write(opnet.WarpInt16ToByte(int16(100)))
        writer.Write(opnet.WarpFloat32ToByte(rand.Float32()))
    }

    writer.Flush()

    fmt.Println("raw data:", 10000)

    fmt.Println("raw data gzip compress:", len(compress_data_buf.Bytes()))

}

111

package main

import (
    "bytes"
    "compress/gzip"
    "encoding/json"
    "fmt"
    "math/rand"
)

type HisCollection struct {
    RTValues []RTValue
}

type RTValue struct {
    Time   int32
    Status int16
    Value  float32
}

func main() {
    fmt.Println("start")

    size := 1000
    col := make([]RTValue, size)

    for i := 0; i < size; i++ {
        col[i] = RTValue{Time: int32(i), Status: 100, Value: rand.Float32()}
    }

    his := HisCollection{RTValues: col}

    data, err := json.Marshal(&his)

    fmt.Println("json string:", string(data))
    fmt.Println("json string:", len(string(data)))

    if err != nil {
        panic(err)
    }
    //    fmt.Println(data)
    fmt.Println("json byte:", len(data))

    var compress_data_buf bytes.Buffer
    writer := gzip.NewWriter(&compress_data_buf)
    defer writer.Close()

    writer.Write(data)
    writer.Flush()

    fmt.Println("json gzip compress:", len(compress_data_buf.Bytes()))

}

oathleo 2013-09-23 14:08 发表评论

golang 之 bson 与 struct 转换

oathleo — Sun, 22 Sep 2013 08:08:00 GMT

bson的介绍不说了
golang下的解析包找到2个一个是mongo的http://labix.org/gobson
，另外一个比较小众https://github.com/sbunce/bson

这里用的是mongo的作为例子。
对象加上不同的注解，
可以轻松转成xml json bson 想想都兴奋

package main

import (
    "fmt"
    "labix.org/v2/mgo/bson"
)

type TestStruct struct {
    Name string
    ID   int32
}

func main() {
    fmt.Println("start")
    data, err := bson.Marshal(&TestStruct{Name: "Bob"})
    if err != nil {
        panic(err)
    }
    fmt.Println("%q", data)

    value := TestStruct{}
    err2 := bson.Unmarshal(data, &value)
    if err2 != nil {
        panic(err)
    }
    fmt.Println("value:", value)

    mmap := bson.M{}
    err3 := bson.Unmarshal(data, mmap)
    if err3 != nil {
        panic(err)
    }
    fmt.Println("mmap:", mmap)

}

oathleo 2013-09-22 16:08 发表评论

Golang 异常处理

oathleo — Sun, 22 Sep 2013 01:32:00 GMT

Panic和Recover

Go没有像Java那样的异常机制，它不能抛出异常，而是使用了panic和recover机制。一定要记住，你应当把它作为最后的手段来使用，也就是说，你的代码中应当没有，或者很少有panic的东西。这是个强大的工具，请明智地使用它。那么，我们应该如何使用它呢？

Panic

是一个内建函数，可以中断原有的控制流程，进入一个令人恐慌的流程中。当函数F调用panic，函数F的执行被中断，但是F中的延迟函数会正常执行，然后F返回到调用它的地方。在调用的地方，F的行为就像调用了panic。这一过程继续向上，直到发生panic的goroutine中所有调用的函数返回，此时程序退出。恐慌可以直接调用panic产生。也可以由运行时错误产生，例如访问越界的数组。

Recover

是一个内建的函数，可以让进入令人恐慌的流程中的goroutine恢复过来。recover仅在延迟函数中有效。在正常的执行过程中，调用recover会返回nil，并且没有其它任何效果。如果当前的goroutine陷入恐慌，调用recover可以捕获到panic的输入值，并且恢复正常的执行。

下面这个函数演示了如何在过程中使用panic

var user = os.Getenv("USER")  func init() {     if user == "" {         panic("no value for $USER")     } }

下面这个函数检查作为其参数的函数在执行时是否会产生panic：

func throwsPanic(f func()) (b bool) {     defer func() {         if x := recover(); x != nil {             b = true         }     }()     f() //执行函数f，如果f中出现了panic，那么就可以恢复回来     return }

最容易理解就是给个例子，文章里有例子：

package main  import(     "fmt"     //"os" )  var user = "" func inita() {     defer func(){         fmt.Print("defer##\n")     }()     if user == "" {         fmt.Print("@@@before panic\n")         panic("no value for user\n")         fmt.Print("!!after panic\n")     } }  func throwsPanic (f func()) (b bool){     defer func(){         if x:= recover(); x != nil{             fmt.Print(x)             b = true         }     }()     f()     fmt.Print("after the func run")     return }  func main(){     throwsPanic(inita) }

执行结果：

D:\go>go run b.go
@@@before panic
defer##
no value for user

如上面所说的：

panic在user=""时，打断了函数的执行，fmt.Print("!!after panic\n")没有执行。但函数中的延迟函数会正常执行，打印了 defer##。然后返回到调用该函数的地方，继续上面的过程。

直到执行完所有函数的defer，退出程序。Recover可以捕获到panic的值，上面的打印no value for user。并且恢复正常的执行。

oathleo 2013-09-22 09:32 发表评论

Go语言的传参和传引用

oathleo — Mon, 16 Sep 2013 01:23:00 GMT

Go语言的传参和传引用[OSC源创会主题补充1]

66人收藏此文章, 我要收藏发表于2天前(2013-09-14 22:10) , 已有1496次阅读，共12个评论

目录：[ - ]

OSC源创会主题补充系列:

Go语言规范虽然很简单, 但是深入掌握Go语言却需要很多底层知识.

本来第20期的武汉OSC源创会有Go语言的专题讲座, 谁知道说取消就取消了.

我最近也整理了一些Go语言资料, 有Go语言的历史/现状/未来发展的八卦和Go语言常见的问题和陷阱两个部分, 本来打算OSC源创会能和武汉的Gopher分享下的, 谁知道(由于不是赞助商也不是微软的大牛)主办方根本不给任何的机会.

100+人数的交流会基本都是扯淡, 还是小规模的讨论沙龙比较靠谱, 以后再也不会去OSC源创会当听众了.

现在计划将各个小问题暂时作为博客发表.

传参和传引用的问题

很多非官方的文档和教材(包括一些已经出版的图书), 对Go语言的传参和引用的讲解都有很多问题. 导致众多Go语言新手对Go的函数参数传参有很多误解.

而传参和传引用是编程语言的根本问题, 如果这个问题理解错误可能会导致很多问题.

slice不是引用!

首先, Go语言的函数调用参数全部是传值的, 包括 slice/map/chan 在内所有类型, 没有传引用的说法.

具体请看Go语言的规范:

After they are evaluated, the parameters of the call are passed by value to the function and the called function begins execution.
from: http://golang.org/ref/spec#Calls

什么叫引用?

比如有以下代码:

var a Object doSomething(a) // 修改a的值 print(a)

如果函数doSomething修改a的值, 然后print打印出来的也是修改后的值, 那么就可以认为doSomething是通过引用的方式使用了参数a.

为什么slice不是引用?

我们构造以下的代码:

func main() {     a := []int{1,2,3}     fmt.Println(a)     modifySlice(a)     fmt.Println(a) }  func modifySlice(data []int) {     data = nil }

其中modifySlice修改了切片a, 输出结果如下:

[1 2 3] [1 2 3]

说明a在调用modifySlice前后并没有任何变化, 因此a必然是传值的!

为什么很多人误以为slice是引用呢?

可能是因为很多新接触Go语言的新手, 看到Go语言的文档说Go的切片和C语言的数组类型, 而C语言的数组是传地址的(注意: 不是传引用!).

下面这个代码可能是错误的根源:

func main() {     a := []int{1,2,3}     fmt.Println(a)     modifySliceData(a)     fmt.Println(a) }  func modifySliceData(data []int) {     data[0] = 0 }

输出为:

[1 2 3] [0 2 3]

函数modifySliceData确实通过参数修改了切片的内容.

但是请注意: 修改通过函数修改参数内容的机制有很多, 其中传参数的地址就可以修改参数的值(其实是修改参数中指针指向的数据), 并不是只有引用一种方式!

传指针和传引用是等价的吗?

比如有以下代码:

func main() {     a := new(int)     fmt.Println(a)     modify(a)     fmt.Println(a) }  func modify(a *int) {     a = nil }

输出为:

0xc010000000 0xc010000000

可以看出指针a本身并没有变化. 传指针或传地址也只能修改指针指向的内存的值, 并不能改变指针本身在值.

因此, 函数参数传传指针也是传值的, 并不是传引用!

所有类型的函数参数都是传值的!

包括slice/map/chan等基础类型和自定义的类型都是传值的.

但是因为slice和map/chan底层结构的差异, 又导致了它们传值的影响并不完全等同.

重点归纳如下:

GoSpec: the parameters of the call are passed by value!
map/slice/chan 都是传值, 不是传引用
map/chan 对应指针, 和引用类似
slice 是结构体和指针的混合体
slice 含 values/count/capacity 等信息, 是按值传递
slice 中的 values 是指针, 按值传递
按值传递的 slice 只能修改values指向的数据, 其他都不能修改
以指针或结构体的角度看, 都是值传递!

那Go语言有传引用的说法吗?

Go语言其实也是有传引用的地方的, 但是不是函数的参数, 而是闭包对外部环境是通过引用访问的.

查看以下的代码:

func main() {     a := new(int)     fmt.Println(a)     func() {         a = nil     }()     fmt.Println(a) }

输出为:

0xc010000000

因为闭包是通过引用的方式使用外部环境的a变量, 因此可以直接修改a的值.

比如下面2段代码的输出是截然不同的, 原因就是第二个代码是通过闭包引用的方式输出i变量:

for i := 0; i < 5; i++ {     defer fmt.Printf("%d ", i)     // Output: 4 3 2 1 0 }  fmt.Printf("\n")     for i := 0; i < 5; i++ {     defer func(){ fmt.Printf("%d ", i) } ()     // Output: 5 5 5 5 5 }

像第二个代码就是于闭包引用导致的副作用, 回避这个副作用的办法是通过参数传值或每次闭包构造不同的临时变量:

// 方法1: 每次循环构造一个临时变量 i for i := 0; i < 5; i++ {     i := i     defer func(){ fmt.Printf("%d ", i) } ()     // Output: 4 3 2 1 0 } // 方法2: 通过函数参数传惨 for i := 0; i < 5; i++ {     defer func(i int){ fmt.Printf("%d ", i) } (i)     // Output: 4 3 2 1 0 }

总结

函数参数传值, 闭包传引用!
slice 含 values/count/capacity 等信息, 是按值传递
按值传递的 slice 只能修改values指向的数据, 其他都不能修改
slice 是结构体和指针的混合体

oathleo 2013-09-16 09:23 发表评论

数组和切片

oathleo — Thu, 12 Sep 2013 01:20:00 GMT

数组 Arrays

数组是内置(build-in)类型,是一组同类型数据的集合，它是值类型，通过从0开始的下标索引访问元素值。在初始化后长度是固定的，无法修改其长度。当作为方法的入参传入时将复制一份数组而不是引用同一指针。数组的长度也是其类型的一部分，通过内置函数len(array)获取其长度。

初始化

数组的初始化有多种形式,查看示例代码 , 在线运行示例代码

[5] int {1,2,3,4,5}
长度为5的数组，其元素值依次为：1，2，3，4，5
[5] int {1,2}
长度为5的数组，其元素值依次为：1，2，0，0，0 。在初始化时没有指定初值的元素将会赋值为其元素类型int的默认值0,string的默认值是""
[...] int {1,2,3,4,5}
长度为5的数组，其长度是根据初始化时指定的元素个数决定的
[5] int { 2:1,3:2,4:3}
长度为5的数组，key:value,其元素值依次为：0，0，1，2，3。在初始化时指定了2，3，4索引中对应的值：1，2，3
[...] int {2:1,4:3}
长度为5的数组，起元素值依次为：0，0，1，0，3。由于指定了最大索引4对应的值3，根据初始化的元素个数确定其长度为5

赋值与使用

数组通过下标访问元素，可修改其元素值

arr :=[...] int {1,2,3,4,5} arr[4]=arr[1]+len(arr)      //arr[4]=2+5

通过for遍历数组元素,查看示例代码,在线运行示例代码

arr := [5]int{5, 4, 3}  for index, value := range arr {     fmt.Printf("arr[%d]=%d \n", index, value) }  for index := 0; index < len(arr); index++ {     fmt.Printf("arr[%d]=%d \n", index, arr[index]) }

数组是值类型，将一个数组赋值给另一个数组时将复制一份新的元素,查看示例代码,在线运行示例代码

arr2 := [5]int{1, 2}  arr5 := arr2 arr5[0] = 5 arr2[4] = 2 fmt.Printf(" arr5= %d \n arr2=%d \n arr5[0]==arr2[0]= %s \n", arr5, arr2, arr5[0] == arr2[0])  OutPut:  arr5=[5 2 0 0 0]   arr2=[1 2 0 0 2]   arr5[0]==arr2[0]= false

切片 Slices

数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型Slices切片,与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。切片中有两个概念：一是len长度，二是cap容量，长度是指已经被赋过值的最大下标+1，可通过内置函数len()获得。容量是指切片目前可容纳的最多元素个数，可通过内置函数cap()获得。切片是引用类型，因此在当传递切片时将引用同一指针，修改值将会影响其他的对象。

初始化

切片可以通过数组来初始化，也可以通过内置函数make()初始化 .初始化时len=cap,在追加元素时如果容量cap不足时将按len的2倍扩容查看示例代码，在线运行示例代码

s :=[] int {1,2,3 }
直接初始化切片，[]表示是切片类型，{1,2,3}初始化值依次是1,2,3.其cap=len=3
s := arr[:]
初始化切片s,是数组arr的引用
s := arr[startIndex:endIndex]
将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片
s := arr[startIndex:]
缺省endIndex时将表示一直到arr的最后一个元素
s := arr[:endIndex]
缺省startIndex时将表示从arr的第一个元素开始
s1 := s[startIndex:endIndex]
通过切片s初始化切片s1
s :=make([]int,len,cap)
通过内置函数make()初始化切片s,[]int 标识为其元素类型为int的切片

赋值与使用

切片是引用类型，在使用时需要注意其操作。查看示例代码，在线运行示例代码切片可以通过内置函数append(slice []Type,elems ...Type)追加元素，elems可以是一排type类型的数据，也可以是slice,因为追加的一个一个的元素，因此如果将一个slice追加到另一个slice中需要带上"..."，这样才能表示是将slice中的元素依次追加到另一个slice中。另外在通过下标访问元素时下标不能超过len大小，如同数组的下标不能超出len范围一样。

s :=append(s,1,2,3,4)
s :=append(s,s1...)

转载时请注明出处！老虞http://www.cnblogs.com/howDo/

oathleo 2013-09-12 09:20 发表评论

Socket read write

oathleo — Wed, 11 Sep 2013 00:56:00 GMT

服务器端/客户端在 login的时候经常多次read write
这个时候 read 要完整，第一次没有read完，就write，第二次read 到的仍然是上次没有read完的数据

oathleo 2013-09-11 08:56 发表评论

bufio 包

oathleo — Thu, 05 Sep 2013 08:01:00 GMT

// bufio 包实现了带缓存的 I/O 操作

// 它封装一个 io.Reader 或 io.Writer 对象

// 使其具有缓存和一些文本读写功能

------------------------------------------------------------

// bufio.go

------------------------------------------------------------

// Reader 实现了带缓存的 io.Reader 对象

type Reader struct {

// 私有字段

}

// NewReaderSize 将 rd 封装成一个拥有 size 大小缓存的 bufio.Reader 对象

// 如果 rd 的基类型就是 bufio.Reader 类型，而且拥有足够的缓存

// 则直接将 rd 转换为基类型并返回

func NewReaderSize(rd io.Reader, size int) *Reader

// NewReader 相当于 NewReaderSize(rd, 4096)

func NewReader(rd io.Reader) *Reader

------------------------------------------------------------

// Peek 返回缓存的一个切片，该切片引用缓存中前 n 字节数据

// 该操作不会将数据读出，只是引用

// 引用的数据在下一次读取操作之前是有效的

// 如果引用的数据长度小于 n，则返回一个错误信息

// 如果 n 大于缓存的总大小，则返回 ErrBufferFull

// 通过 Peek 的返回值，可以修改缓存中的数据

// 但是不能修改底层 io.Reader 中的数据

func (b *Reader) Peek(n int) ([]byte, error)

func main() {

s := strings.NewReader("ABCDEFG")

br := bufio.NewReader(s)

b, _ := br.Peek(5)

fmt.Printf("%s\n", b)

// ABCDE

b[0] = 'a'

b, _ = br.Peek(5)

fmt.Printf("%s\n", b)

// aBCDE

}

------------------------------------------------------------

// Read 从 b 中读出数据到 p 中，返回读出的字节数

// 如果 p 的大小 >= 缓存的总大小，而且缓存不为空

// 则只能读出缓存中的数据，不会从底层 io.Reader 中提取数据

// 如果 p 的大小 >= 缓存的总大小，而且缓存为空

// 则直接从底层 io.Reader 向 p 中读出数据，不经过缓存

// 只有当 b 中无可读数据时，才返回 (0, io.EOF)

func (b *Reader) Read(p []byte) (n int, err error)

func main() {

s := strings.NewReader("ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890")

br := bufio.NewReader(s)

b := make([]byte, 20)

n, err := br.Read(b)

fmt.Printf("%-20s %-2v %v\n", b[:n], n, err)

// ABCDEFGHIJKLMNOPQRST 20

n, err = br.Read(b)

fmt.Printf("%-20s %-2v %v\n", b[:n], n, err)

// UVWXYZ1234567890 16

n, err = br.Read(b)

fmt.Printf("%-20s %-2v %v\n", b[:n], n, err)

// 0 EOF

}

------------------------------------------------------------

// ReadByte 从 b 中读出一个字节并返回

// 如果 b 中无可读数据，则返回一个错误

func (b *Reader) ReadByte() (c byte, err error)

// UnreadByte 撤消最后一次读出的字节

// 只有最后读出的字节可以被撤消

// 无论任何操作，只要有内容被读出，就可以用 UnreadByte 撤消一个字节

func (b *Reader) UnreadByte() error

func main() {

s := strings.NewReader("ABCDEFG")

br := bufio.NewReader(s)

c, _ := br.ReadByte()

fmt.Printf("%c\n", c)

// A

c, _ = br.ReadByte()

fmt.Printf("%c\n", c)

// B

br.UnreadByte()

c, _ = br.ReadByte()

fmt.Printf("%c\n", c)

// B

}

------------------------------------------------------------

// ReadRune 从 b 中读出一个 UTF8 编码的字符并返回

// 同时返回该字符的 UTF8 编码长度

// 如果 UTF8 序列无法解码出一个正确的 Unicode 字符

// 则只读出 b 中的一个字节，并返回 U+FFFD 字符，size 返回 1

func (b *Reader) ReadRune() (r rune, size int, err error)

// UnreadRune 撤消最后一次读出的 Unicode 字符

// 如果最后一次执行的不是 ReadRune 操作，则返回一个错误

// 因此，UnreadRune 比 UnreadByte 更严格

func (b *Reader) UnreadRune() error

func main() {

s := strings.NewReader("你好，世界！")

br := bufio.NewReader(s)

c, size, _ := br.ReadRune()

fmt.Printf("%c %v\n", c, size)

// 你 3

c, size, _ = br.ReadRune()

fmt.Printf("%c %v\n", c, size)

// 好 3

br.UnreadRune()

c, size, _ = br.ReadRune()

fmt.Printf("%c %v\n", c, size)

// 好 3

}

------------------------------------------------------------

// Buffered 返回缓存中数据的长度

func (b *Reader) Buffered() int

func main() {

s := strings.NewReader("你好，世界！")

br := bufio.NewReader(s)

fmt.Println(br.Buffered())

// 0

br.Peek(1)

fmt.Println(br.Buffered())

// 18

}

------------------------------------------------------------

// ReadSlice 在 b 中查找 delim 并返回 delim 及其之前的所有数据的切片

// 该操作会读出数据，返回的切片是已读出数据的引用

// 切片中的数据在下一次读取操作之前是有效的

// 如果 ReadSlice 在找到 delim 之前遇到错误

// 则读出缓存中的所有数据并返回，同时返回遇到的错误（通常是 io.EOF）

// 如果在整个缓存中都找不到 delim，则 err 返回 ErrBufferFull

// 如果 ReadSlice 能找到 delim，则 err 始终返回 nil

// 因为返回的切片中的数据有可能被下一次读写操作修改

// 因此大多数操作应该使用 ReadBytes 或 ReadString，它们返回的不是数据引用

func (b *Reader) ReadSlice(delim byte) (line []byte, err error)

func main() {

s := strings.NewReader("ABC DEF GHI JKL")

br := bufio.NewReader(s)

w, _ := br.ReadSlice(' ')

fmt.Printf("%q\n", w)

// "ABC "

w, _ = br.ReadSlice(' ')

fmt.Printf("%q\n", w)

// "DEF "

w, _ = br.ReadSlice(' ')

fmt.Printf("%q\n", w)

// "GHI "

}

------------------------------------------------------------

// ReadLine 是一个低级的原始的行读取操作

// 大多数情况下，应该使用 ReadBytes('\n') 或 ReadString('\n')

// 或者使用一个 Scanner

// ReadLine 通过调用 ReadSlice 方法实现，返回的也是缓存的切片

// ReadLine 尝试返回一个单行数据，不包括行尾标记（\n 或 \r\n）

// 如果在缓存中找不到行尾标记，则设置 isPrefix 为 true，表示查找未完成

// 同时读出缓存中的数据并作为切片返回

// 只有在当前缓存中找到行尾标记，才将 isPrefix 设置为 false，表示查找完成

// 可以多次调用 ReadLine 来读出一行

// 返回的数据在下一次读取操作之前是有效的

// 如果 ReadLine 无法获取任何数据，则返回一个错误信息（通常是 io.EOF）

func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)

func main() {

s := strings.NewReader("ABC\nDEF\r\nGHI\r\nJKL")

br := bufio.NewReader(s)

w, isPrefix, _ := br.ReadLine()

fmt.Printf("%q %v\n", w, isPrefix)

// "ABC" false

w, isPrefix, _ = br.ReadLine()

fmt.Printf("%q %v\n", w, isPrefix)

// "DEF" false

w, isPrefix, _ = br.ReadLine()

fmt.Printf("%q %v\n", w, isPrefix)

// "GHI" false

}

------------------------------------------------------------

// ReadBytes 在 b 中查找 delim 并读出 delim 及其之前的所有数据

// 如果 ReadBytes 在找到 delim 之前遇到错误

// 则返回遇到错误之前的所有数据，同时返回遇到的错误（通常是 io.EOF）

// 只有当 ReadBytes 找不到 delim 时，err 才不为 nil

// 对于简单的用途，使用 Scanner 可能更方便

func (b *Reader) ReadBytes(delim byte) (line []byte, err error)

func main() {

s := strings.NewReader("ABC DEF GHI JKL")

br := bufio.NewReader(s)

w, _ := br.ReadBytes(' ')

fmt.Printf("%q\n", w)

// "ABC "

w, _ = br.ReadBytes(' ')

fmt.Printf("%q\n", w)

// "DEF "

w, _ = br.ReadBytes(' ')

fmt.Printf("%q\n", w)

// "GHI "

}

------------------------------------------------------------

// ReadString 功能同 ReadBytes，只不过返回的是一个字符串

func (b *Reader) ReadString(delim byte) (line string, err error)

func main() {

s := strings.NewReader("ABC DEF GHI JKL")

br := bufio.NewReader(s)

w, _ := br.ReadString(' ')

fmt.Printf("%q\n", w)

// "ABC "

w, _ = br.ReadString(' ')

fmt.Printf("%q\n", w)

// "DEF "

w, _ = br.ReadString(' ')

fmt.Printf("%q\n", w)

// "GHI "

}

------------------------------------------------------------

// WriteTo 实现了 io.WriterTo 接口

func (b *Reader) WriteTo(w io.Writer) (n int64, err error)

func main() {

s := strings.NewReader("ABCEFG")

br := bufio.NewReader(s)

b := bytes.NewBuffer(make([]byte, 0))

br.WriteTo(b)

fmt.Printf("%s\n", b)

// ABCEFG

}

------------------------------------------------------------

// Writer 实现了带缓存的 io.Writer 对象

// 如果在向 Writer 中写入数据的过程中遇到错误

// 则 Writer 不会再接受任何数据

// 而且后续的写入操作都将返回错误信息

type Writer struct {

// 私有字段

}

// NewWriterSize 将 wr 封装成一个拥有 size 大小缓存的 bufio.Writer 对象

// 如果 wr 的基类型就是 bufio.Writer 类型，而且拥有足够的缓存

// 则直接将 wr 转换为基类型并返回

func NewWriterSize(wr io.Writer, size int) *Writer

// NewWriter 相当于 NewWriterSize(wr, 4096)

func NewWriter(wr io.Writer) *Writer

------------------------------------------------------------

// Flush 将缓存中的数据提交到底层的 io.Writer 中

func (b *Writer) Flush() error

// Available 返回缓存中的可以空间

func (b *Writer) Available() int

// Buffered 返回缓存中未提交的数据长度

func (b *Writer) Buffered() int

// Write 将 p 中的数据写入 b 中，返回写入的字节数

// 如果写入的字节数小于 p 的长度，则返回一个错误信息

func (b *Writer) Write(p []byte) (nn int, err error)

// WriteString 同 Write，只不过写入的是字符串

func (b *Writer) WriteString(s string) (int, error)

func main() {

b := bytes.NewBuffer(make([]byte, 0))

bw := bufio.NewWriter(b)

fmt.Println(bw.Available()) // 4096

fmt.Println(bw.Buffered()) // 0

bw.WriteString("ABCDEFGH")

fmt.Println(bw.Available()) // 4088

fmt.Println(bw.Buffered()) // 8

fmt.Printf("%q\n", b) // ""

bw.Flush()

fmt.Println(bw.Available()) // 4096

fmt.Println(bw.Buffered()) // 0

fmt.Printf("%q\n", b) // "ABCEFG"

}

------------------------------------------------------------

// WriteByte 向 b 中写入一个字节

func (b *Writer) WriteByte(c byte) error

// WriteRune 向 b 中写入 r 的 UTF8 编码

// 返回 r 的编码长度

func (b *Writer) WriteRune(r rune) (size int, err error)

func main() {

b := bytes.NewBuffer(make([]byte, 0))

bw := bufio.NewWriter(b)

bw.WriteByte('H')

bw.WriteByte('e')

bw.WriteByte('l')

bw.WriteByte('o')

bw.WriteByte(' ')

bw.WriteRune('世')

bw.WriteRune('界')

bw.WriteRune('！')

bw.Flush()

fmt.Println(b) // Hello 世界！

}

------------------------------------------------------------

// ReadFrom 实现了 io.ReaderFrom 接口

func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)

func main() {

b := bytes.NewBuffer(make([]byte, 0))

s := strings.NewReader("Hello 世界！")

bw := bufio.NewWriter(b)

bw.ReadFrom(s)

bw.Flush()

fmt.Println(b) // Hello 世界！

}

------------------------------------------------------------

// ReadWriter 集成了 bufio.Reader 和 bufio.Writer

// 它实现了 io.ReadWriter 接口

type ReadWriter struct {

*Reader

*Writer

}

// NewReadWriter 封装 r 和 w 为一个 bufio.ReadWriter 对象

func NewReadWriter(r *Reader, w *Writer) *ReadWriter

------------------------------------------------------------

// scan.go

------------------------------------------------------------

// Scanner 提供了一个方便的接口来读取数据，例如读取一个多行文本

// 连续调用 Scan 方法将扫描数据中的“指定部分”，跳过各个“指定部分”之间的数据

// Scanner 使用了缓存，所以“指定部分”的长度不能超出缓存的长度

// Scanner 需要一个 SplitFunc 类型的“切分函数”来确定“指定部分”的格式

// 本包中提供的“切分函数”有“行切分函数”、“字节切分函数”、“UTF8字符编码切分函数”

// 和“单词切分函数”，用户也可以自定义“切分函数”

// 默认的“切分函数”为“行切分函数”，用于获取数据中的一行数据（不包括行尾符）

// 扫描在遇到下面的情况时会停止：

// 1、数据扫描完毕，遇到 io.EOF

// 2、遇到读写错误

// 3、“指定部分”的长度超过了缓存的长度

// 如果要对数据进行更多的控制，比如的错误处理或扫描更大的“指定部分”或顺序扫描

// 则应该使用 bufio.Reader

type Scanner struct {

// 私有字段

}

// SplitFunc 用来定义“切分函数”类型

// data 是要扫描的数据

// atEOF 标记底层 io.Reader 中的数据是否已经读完

// advance 返回 data 中已处理的数据长度

// token 返回找到的“指定部分”

// err 返回错误信息

// 如果在 data 中无法找到一个完整的“指定部分”

// 则 SplitFunc 返回 (0, nil) 来告诉 Scanner

// 向缓存中填充更多数据，然后再次扫描

// 如果返回的 err 是非 nil 值，扫描将被终止，并返回错误信息

// 如果 data 为空，则“切分函数”将不被调用

// 意思是在 SplitFunc 中不必考虑 data 为空的情况

// SplitFunc 的作用很简单，从 data 中找出你感兴趣的数据，然后返回

// 并告诉调用者，data 中有多少数据你已经处理过了

type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)

// NewScanner 创建一个 Scanner 来扫描 r

// 默认切分函数为 ScanLines

func NewScanner(r io.Reader) *Scanner

// Err 返回扫描过程中遇到的非 EOF 错误

// 供用户调用，以便获取错误信息

func (s *Scanner) Err() error

------------------------------------------------------------

// Bytes 将最后一次扫描出的“指定部分”作为一个切片返回（引用传递）

// 下一次的 Scan 操作会覆盖本次返回的结果

func (s *Scanner) Bytes() []byte

// Text 将最后一次扫描出的“指定部分”作为字符串返回（值传递）

func (s *Scanner) Text() string

------------------------------------------------------------

// Scan 在 Scanner 的数据中扫描“指定部分”

// 找到后，用户可以通过 Bytes 或 Text 方法来取出“指定部分”

// 如果扫描过程中遇到错误，则终止扫描，并返回 false

func (s *Scanner) Scan() bool

func main() {

s := strings.NewReader("ABC\nDEF\r\nGHI\nJKL")

bs := bufio.NewScanner(s)

for bs.Scan() {

fmt.Printf("%s %v\n", bs.Bytes(), bs.Text())

}

// ABC ABC

// DEF DEF

// GHI GHI

// JKL JKL

}

------------------------------------------------------------

// Split 用于设置 Scanner 的“切分函数”

// 这个函数必须在调用 Scan 前执行

func (s *Scanner) Split(split SplitFunc)

func main() {

s := strings.NewReader("ABC DEF GHI JKL")

bs := bufio.NewScanner(s)

bs.Split(bufio.ScanWords)

for bs.Scan() {

fmt.Println(bs.Text())

}

// ABC

// DEF

// GHI

// JKL

}

------------------------------------------------------------

// ScanBytes 是一个“切分函数”

// 用来找出 data 中的单个字节并返回

func ScanBytes(data []byte, atEOF bool) (advance int, token []byte, err error)

func main() {

s := strings.NewReader("Hello 世界！")

bs := bufio.NewScanner(s)

bs.Split(bufio.ScanBytes)

for bs.Scan() {

fmt.Printf("%s ", bs.Text())

}

------------------------------------------------------------

// ScanRunes 是一个“切分函数”

// 用来找出 data 中的单个 UTF8 字符的编码并返回

// 如果 UTF8 解码出错，则返回的 U+FFFD 会被做为 "\xef\xbf\xbd" 返回

// 这使得用户无法区分“真正的U+FFFD字符”和“解码错误的返回值”

func ScanRunes(data []byte, atEOF bool) (advance int, token []byte, err error)

func main() {

s := strings.NewReader("Hello 世界！")

bs := bufio.NewScanner(s)

bs.Split(bufio.ScanRunes)

for bs.Scan() {

fmt.Printf("%s ", bs.Text())

} // H e l l o 世界！

}

------------------------------------------------------------

// ScanLines 是一个“切分函数”

// 用来找出 data 中的单行数据并返回（包括空行）

// 行尾标记可能是 \n 或 \r\n（返回值不包括行尾标记）

func ScanLines(data []byte, atEOF bool) (advance int, token []byte, err error)

------------------------------------------------------------

// ScanWords 是一个“切分函数”

// 用来找出 data 中的单词

// 单词以空白字符分隔，空白字符由 unicode.IsSpace 定义

func ScanWords(data []byte, atEOF bool) (advance int, token []byte, err error)

oathleo 2013-09-05 16:01 发表评论

Golang 类型转换整理

oathleo — Fri, 30 Aug 2013 03:37:00 GMT

Golang 类型转换整理

分类： Go2013-07-31 11:02 177人阅读评论(0) 收藏举报

golangString

1、整形到字符串：

[plain] view plain copy

var i int = 1
var s string

[plain] view plain copy

s = strconv.Itoa(i) 或者 s = FormatInt(int64(i), 10)

2、字符串到整形

[plain] view plain copy

var s string = "1"
var i int
i, err = strconv.Atoi(s) 或者 i, err = ParseInt(s, 10, 0)

3、字符串到float(32 / 64)

[plain] view plain copy

var s string = 1
var f float32
f, err = ParseFloat(s, 32)

float 64的时候将上面函数中的32转为64即可

4、整形到float或者float到整形
直接使用float(i) 或者 int(f) 直接进行转换即可

oathleo 2013-08-30 11:37 发表评论

golang strconv

oathleo — Fri, 30 Aug 2013 03:26:00 GMT

golang strconv

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

a:=strconv.FormatFloat(10.100,'f',-1,32)

输出:

10.1

a := strconv.FormatFloat(10.101, 'f', -1, 64)

输出:

10.101

a := strconv.FormatFloat(10.010, 'f', -1, 64)

输出：10.01

a:=strconv.FormatFloat(10.1,'f',2,64)

输出:10.10

f 参数可以时e,E,g,G

-1 代表输出的精度小数点后的位数，如果是<0的值，则返回最少的位数来表示该数，如果是大于0的则返回对应位数的值

64 为float的类型，go中float分为32和64位，因此就需要传入32或者64

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

golang strconv.ParseInt 是将字符串转换为数字的函数,功能灰常之强大,看的我口水直流.

func ParseInt(s string, base int, bitSize int) (i int64, err error)

参数1 数字的字符串形式

参数2 数字字符串的进制比如二进制八进制十进制十六进制

参数3 返回结果的bit大小也就是int8 int16 int32 int64

代码:

01package main

03import (

04 "strconv"

05)

07func main() {

08 i, err := strconv.ParseInt("123", 10, 32)

09 if err != nil {

10 panic(err)

11 }

12 println(i)

13}

oathleo 2013-08-30 11:26 发表评论

Pragma: no-cache 对性能的影响

oathleo — Tue, 27 Aug 2013 07:29:00 GMT

做了下go和java的http性能的简单比较
服务端直接输出字符串
使用JMeter
windows下

2000的并发，测试结果很出乎意料，go不会这么差吧

研究了半小时，原因如下
tomcat的servlet里加了 response.setHeader("Pragma", "no-cache");
go里没有设置该参数

设置后重新跑测试

可以了吧

oathleo 2013-08-27 15:29 发表评论

golang html 与 golang客户端上传文件转载

oathleo — Tue, 27 Aug 2013 01:10:00 GMT

golang html 与 golang客户端上传文件

May 30 , 2013 at 08:30 am - - 263点击 - 0 评论

小文件上传

var buffer bytes.Buffer

w := multipart.NewWriter(&buffer)
// Write fields and files
w.CreateFormField("input1")
w.WriteField("input1","value1")
w.CreateFormFile("file","filename.dat")

resp,err := http.Post(url,w.FormDataContentType(),&buffer)

服务器的handler:

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

if r.URL.Path=="/upload.go" {

        fn,header,err:=r.FormFile("file")

        defer fn.Close()

        f,err:=os.Create("filenametosaveas")

        defer f.Close()

        io.Copy(f,fn)

    }

}

客户端代码：
func Upload() (err error) {

    // Create buffer

    buf := new(bytes.Buffer) // caveat IMO dont use this for large files, \

    // create a tmpfile and assemble your multipart from there (not tested)

    w := multipart.NewWriter(buf)

    // Create file field

    fw, err := w.CreateFormFile("file", "helloworld.go") //这里的file很重要，必须和服务器端的FormFile一致

    if err != nil {

        fmt.Println("c")

        return err

    }

    fd, err := os.Open("helloworld.go")

    if err != nil {

        fmt.Println("d")

        return err

    }

    defer fd.Close()

    // Write file field from file to upload

    _, err = io.Copy(fw, fd)

    if err != nil {

        fmt.Println("e")

        return err

    }

    // Important if you do not close the multipart writer you will not have a

    // terminating boundry

    w.Close()

    req, err := http.NewRequest("POST","http://192.168.2.127/configure.go?portId=2", buf)

    if err != nil {

        fmt.Println("f")

        return err

    }

    req.Header.Set("Content-Type", w.FormDataContentType())

      var client http.Client

    res, err := client.Do(req)

    if err != nil {

        fmt.Println("g")

        return err

    }

    io.Copy(os.Stderr, res.Body) // Replace this with Status.Code check

    fmt.Println("h")

    return err

}

html上传，原文

package main

import (
    "fmt"
    "io"
    "net/http"
    "log"
)

// 获取大小的接口
type Sizer interface {
    Size() int64
}

// hello world, the web server
func HelloServer(w http.ResponseWriter, r *http.Request) {
    if "POST" == r.Method {
        file, _, err := r.FormFile("file")
        if err != nil {
            http.Error(w, err.Error(), 500)
            return
        }
        defer file.Close()
        f,err:=os.Create("filenametosaveas")
        defer f.Close()
        io.Copy(f,file)
        fmt.Fprintf(w, "上传文件的大小为: %d", file.(Sizer).Size())
        return
    }

    // 上传页面
    w.Header().Add("Content-Type", "text/html")
    w.WriteHeader(200)
    html := `
<form enctype="multipart/form-data" action="/hello" method="POST">
    Send this file: <input name="file" type="file" />
    <input type="submit" value="Send File" />
form>
`
    io.WriteString(w, html)
}

func main() {
    http.HandleFunc("/hello", HelloServer)
    err := http.ListenAndServe(":12345", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

大文件上传

关键的不同是io.MultiReader

package main

import (
  "fmt"
  "net/http"
  "mime/multipart"
  "bytes"
  "os"
  "io"
  )

func postFile(filename string, target_url string) (*http.Response, error) {
  body_buf := bytes.NewBufferString("")
  body_writer := multipart.NewWriter(body_buf)

  // use the body_writer to write the Part headers to the buffer
  _, err := body_writer.CreateFormFile("upfile", filename)
  if err != nil {
    fmt.Println("error writing to buffer")
    return nil, err
  }

  // the file data will be the second part of the body
  fh, err := os.Open(filename)
  if err != nil {
    fmt.Println("error opening file")
    return nil, err
  }
  defer fh.Close()
  // need to know the boundary to properly close the part myself.
  boundary := body_writer.Boundary()
  close_string := fmt.Sprintf("\r\n--%s--\r\n", boundary)
  close_buf := bytes.NewBufferString(close_string)
  // use multi-reader to defer the reading of the file data until writing to the socket buffer.
  request_reader := io.MultiReader(body_buf, fh, close_buf)
  fi, err := fh.Stat()
  if err != nil {
    fmt.Printf("Error Stating file: %s", filename)
    return nil, err
  }
  req, err := http.NewRequest("POST", target_url, request_reader)
  if err != nil {
    return nil, err
  }

  // Set headers for multipart, and Content Length
  req.Header.Add("Content-Type", "multipart/form-data; boundary=" + boundary)
  req.ContentLength = fi.Size()+int64(body_buf.Len())+int64(close_buf.Len())

  return http.DefaultClient.Do(req)
}

oathleo 2013-08-27 09:10 发表评论

golang string rune len 可能不同

oathleo — Mon, 19 Aug 2013 03:31:00 GMT

rune_str := []rune(info)
fmt.Print("rune_len:" , len(rune_str))
fmt.Print("string_len:" , len(info))

string 和对应的 rune数组的len不一定相同

如果info是有中文的，则两个length是不一样的，做string处理的时候，要注意

oathleo 2013-08-19 11:31 发表评论

golang xml 处理之生成属性必须大写

oathleo — Fri, 16 Aug 2013 07:53:00 GMT

xml对应的struct 属性必须大写，否则无法实现！
Code是必须的

package main

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

type xmldas struct {
    XMLName  xml.Name       `xml:"das"`
    DataPort string         `xml:"DataPort,attr"`
    Desc     string         `xml:"desc,attr"`
    Src      xmlsource      `xml:"source"`
    Dest     xmldestination `xml:"destination"`
}

type xmlsource struct {
    Path  string `xml:"path,attr"`
    Param string `xml:"param,attr"`
}

type xmldestination struct {
    Path  string `xml:"path,attr"`
    Param string `xml:"param,attr"`
}

func main() {
    v := xmldas{DataPort: "8250", Desc: "123"}
    v.Src = xmlsource{Path: "123", Param: "456"}
    v.Dest = xmldestination{Path: "789", Param: "000"}
    output, err := xml.MarshalIndent(v, "  ", "    ")
    if err != nil {
        fmt.Printf("error: %v\n", err)
    }
    os.Stdout.Write([]byte(xml.Header))
    os.Stdout.Write(output)
}

oathleo 2013-08-16 15:53 发表评论

golang xml 处理

oathleo — Mon, 12 Aug 2013 09:03:00 GMT

将xml文件解析成对应的struct对象是通过xml.Unmarshal来完成的，这个过程是如何实现的？可以看到我们的struct定义后面多了一些类似于xml:"serverName"这样的内容,这个是struct的一个特性，它们被称为 struct tag，它们是用来辅助反射的。

package main

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

type Servers struct {
    XMLName xml.Name `xml:"servers"`
    Version string   `xml:"version,attr"`
    Svs     []server `xml:"server"`
}

type server struct {
    ServerName string `xml:"serverName"`
    ServerIP   string `xml:"serverIP"`
}

func main() {
    v := &Servers{Version: "1"}
    v.Svs = append(v.Svs, server{"Shanghai_VPN", "127.0.0.1"})
    v.Svs = append(v.Svs, server{"Beijing_VPN", "127.0.0.2"})
    output, err := xml.MarshalIndent(v, "  ", "    ")
    if err != nil {
        fmt.Printf("error: %v\n", err)
    }
    os.Stdout.Write([]byte(xml.Header))

    os.Stdout.Write(output)
}

oathleo 2013-08-12 17:03 发表评论

exec start

oathleo — Thu, 08 Aug 2013 01:07:00 GMT

exec卡住了，阻塞调用肯定卡住了
调用Start

func (*Cmd) Run

func (c *Cmd) Run() error

Run starts the specified command and waits for it to complete.

The returned error is nil if the command runs, has no problems copying stdin, stdout, and stderr, and exits with a zero exit status.

If the command fails to run or doesn't complete successfully, the error is of type *ExitError. Other error types may be returned for I/O problems.

func (*Cmd) Start

func (c *Cmd) Start() error

Start starts the specified command but does not wait for it to complete.

oathleo 2013-08-08 09:07 发表评论

Golang语法与代码格式速记

oathleo — Fri, 02 Aug 2013 08:15:00 GMT

// Description: Golang语法与代码格式速记
// Author: cxy
// Date: 2013-04-01
// Version: 0.3
// TODO 说明


// TODO package

// Go是采用语法解析器自动在每行末尾增加分号，所以在写代码的时候可以把分号省略。
// Go编程中只有几个地方需要手工增加分号，如: for循环使用分号把初始化，条件和遍历元素分开。在一行中有多条语句时，需要增加分号。
// 不能把控制语句(if, for, switch, or select)、函数、方法 的左大括号单独放在一行， 如果你这样作了语法解析器会在大括号之前插入一个分号，导致编译错误。

// 引用包名与导入路径的最后一个目录一致
import "fmt"
import "math/rand"
fmt.Println(rand.Intn(10))    // 0到10之间的非负伪随机数

// 用圆括号组合导入包，这是“factored”导入语句
import ("fmt"; "math")
import (
    "fmt"
    "math"
)
// 导入包可以定义别名，防止同名称的包冲突
import n "net/http"
import (
    控制台 "fmt"
    m "math"
)
控制台.Println(m.Pi)

// 首字母大写的名称是被导出的, 首字母小写的名称只能在同一包内访问(同包跨文件也能访问)
var In int // In is public
var in byte // in is private
var 看不见 string // 看不见 is private
const Com bool = false // Com is public
const 还是看不见 uint8 = 1 // 还是看不见 is private
type Integer int // Integer is public
type ブーリアン *bool // ブーリアン is private
func Export() {} // Export is public
func 导入() {} // 导入 is private
func (me *Integer) valueOf(s string) int {} // valueOf is private
func (i ブーリアン) String() string {} // String is public

// Go 的基本类型：
┌──────┬─────────┬────────┬─────────┬───────────┬────────────┐
│ bool │ string  │        │         │           │            │
├──────┼─────────┼────────┼─────────┼───────────┼────────────┤
│ int  │ int8    │ int16  │ int32   │ int64     │            │
│      │         │        │ rune    │           │            │
├──────┼─────────┼────────┼─────────┼───────────┼────────────┤
│ uint │ uint8   │ uint16 │ uint32  │ uint64    │ uintptr    │
│      │ byte    │        │         │           │            │
├──────┼─────────┼────────┼─────────┼───────────┼────────────┤
│      │         │        │ float32 │ float64   │            │
├──────┼─────────┼────────┼─────────┼───────────┼────────────┤
│      │         │        │         │ complex64 │ complex128 │
└──────┴─────────┴────────┴─────────┴───────────┴────────────┘
// byte 是 uint8 的别名
// rune 是 int32 的别名，代表一个Unicode码点

// 变量声明, 使用var关键字    (Go中只能使用var声明变量，无需显式初始化值）
var i int    // i = 0
var s string    // s = ""    (Go中的string不存在nil(null)值，默认零值就是空串 "" 或 ``)
var e error    // e = nil, error是Go的内建接口类型，不是基本类型。

// var 语句声明了一个变量的列表，类型在变量名之后
var a,b,c int    // a = 0, b = 0, c = 0
var (
    a int    // a = 0
    b string    // b = ""
    c uint    // c = 0
)

// 变量定义时初始化赋值，每个变量对应一个值
var a int = 0
var a,b int = 0, 1

// 初始化使用表达式时，可以省略类型，变量从初始值中获得类型
var a = 'A'    // a int32
c := 1 + 2i    // c complex128
var a,b = 0, "B"    // a int, b string
a, b := 0, "B"    // a int, b string
c := `formatted
 string`    // c string

// := 结构不能使用在函数外，函数外的每个语法块都必须以关键字开始

// 常量可以是字符、字符串、布尔或数字类型的值，数值常量是高精度的值
const x int = 3
const (
    a byte = 'A'
    b string = "B"
    c bool = true
    d int = 4
    e float32 = 5.1
    f complex64 = 6 + 6i
)

// 未指定类型的常量由常量值决定其类型
const a = 0    // a int
const (
    b = 2.3    // b float64
    c = true    // c bool
)

// 自动枚举常量 iota
// iota的枚举值可以赋值给数值兼容类型
// 每个常量单独声明时, iota不会自动递增(无意义)
const a int = iota    // a = 0
const b int = iota    // b = 0
const c byte = iota    // c = 0
const d uint64 = iota    // d = 0

// 常量组合声明时, iota每次引用会逐步自增, 初始值为0,步进值为1
const (
    a uint8 = iota    // a = 0
    b int16 = iota    // b = 1
    c rune = iota    // c = 2
    d float64 = iota    // d = 3
    e uintptr = iota    // e = 4
)

// 枚举的常量都为同一类型时, 可以使用简单序列格式.
const (
    a = iota    // a int32 = 0
    b            // b int32 = 1
    c            // c int32 = 2
)

// 枚举序列中的未指定类型的常量会跟随序列前面最后一次出现类型定义的类型
const (
    a byte = iota    // a uint8 = 0
    b                // b uint8 = 1
    c                // c uint8 = 2
    d rune = iota    // d int32 = 3
    e                // e int32 = 4
    f                // f int32 = 5
)

// iota自增值只在一个常量定义组合中有效,跳出常量组合定义后iota值归0
const (
    a = iota    // a int32 = 0
    b            // b int32 = 1
    c            // c int32 = 2
)
const (
    e = iota    // e int32 = 0    (iota重新初始化并自增)
    f            // f int32 = 1
)

// 定制iota序列初始值与步进值 (通过数学公式实现)
const (
    a = (iota + 2) * 3    // a int32 = 0    (a=(0+2)*3) 初始值为6,步进值为3
    b                    // b int32 = 3    (b=(1+2)*3)
    c                    // c int32 = 6    (c=(2+2)*3)
    d                    // d int32 = 9    (d=(3+2)*3)
)

// 数组声明带有长度信息，数组的长度固定
var a [3]int = [3]int{0, 1, 2}    // a = [0 1 2]
var b [3]int = [3]int{}    // b = [0 0 0]
var c = [3]int{}    // c = [0 0 0]
d := [3]int{}    // d = [0 0 0]
fmt.Printf("%T\t%#v\t%d\t%d\n", d, d, len(d), cap(d))    // [3]int    [3]int{0, 0, 0}    3    3
// 使用自动计算数组初始数据的长度
var a = []int{0, 1, 2}
x := [][3]int{{0, 1, 2}, {3, 4, 5}}

// slice 指向数组的值，并且同时包含了长度信息
var a []int
fmt.Printf("%T\t%#v\t%d\t%d\n", a, a, len(a), cap(a))    // []int    []int(nil)    0    0
var a = new([]int)
fmt.Printf("%T\t%#v\t%d\t%d\n", a, a, len(*a), cap(*a))    // *[]int    &[]int(nil)    0    0
var b = make([]int, 0)
fmt.Printf("%T\t%#v\t%d\t%d\n", b, b, len(b), cap(b))    // []int    []int{}    0    0
var c = make([]int, 3, 10)
fmt.Printf("%T\t%#v\t%d\t%d\n", c, c, len(c), cap(c))    // []int    []int{}    3    10
var d []int = []int{0, 1, 2}
fmt.Printf("%T\t%#v\t%d\t%d\n", d, d, len(d), cap(d))    // []int    []int{0, 1, 2}    3    3

// slice 可以重新切片，创建一个新的 slice 值指向相同的数组
s := []int{0, 1, 2, 3, 4}
fmt.Println(s[1,3])    // [1 2]    (截取从开始索引到结束索引-1 之间的片段)
fmt.Println(s[:4])    // [0 1 2 3]
fmt.Println(s[1:])    // [1 2 3 4]
fmt.Println(s[1:1])    // []

// 向slice中添加元素
s := make([]string, 3)
s = append(s, "a")


// map 在使用之前必须用 make 来创建（不是 new）；一个值为 nil 的 map 是空的，并且不能赋值
var m map[int]int
m[0] = 0    // × runtime error: assignment to entry in nil map
fmt.Printf("type: %T\n", m)    // map[int]int
fmt.Printf("value: %#v\n", m)    // map[int]int(nil)
fmt.Printf("value: %v\n", m)    // map[]
fmt.Println("is nil: ", nil == m)    // true
fmt.Println("length: ", len(m))    // 0，if m is nil, len(m) is zero.

var m map[int]int = make(map[int]int)
m[0] = 0    // 插入或修改元素
fmt.Printf("type: %T\n", m)        // map[int]int
fmt.Printf("value: %#v\n", m)        // map[int]int(0:0)
fmt.Printf("value: %v\n", m)        // map[0:0]
fmt.Println("is nil: ", nil == m)    // false
fmt.Println("length: ", len(m))        // 1

m = map[int]int{
0:0,
1:1,    // 最后的逗号是必须的
}
m = map[string]S{
"a":S{0,1},
"b":{2,3},    // 类型名称可省略
}
a := m["a"]    // 取值
a, ok := m["a"]    // 取值, 并通过ok(bool)判断key对应的元素是否存在.
delete(m, "a")    // 删除key对应的元素.

// 结构体（struct）就是一个字段的集合， type 定义跟其字面意思相符
type S struct {
    A int
    B, c string
}
type (
    A struct {
        s *S
    }
    B struct {
        A    // 组合
    }
)
// 结构体文法表示通过结构体字段的值作为列表来新分配一个结构体。
var s S = S{0, "1", "2"}
// 使用 Name: 语法可以仅列出部分字段。（字段名的顺序无关。）
var s S = S{A: 0, B: "1"}
var s S = S{}
// 特殊的前缀 & 构造了指向结构体文法的指针。
var s *S = &S{0, "1", "2"}

// 表达式 new(T) 分配了一个零初始化的 T 值，并返回指向它的指针
var s *S = new(S)
// 有指针，但是没有指针运算，结构体字段使用点号来访问
// 结构体字段可以通过结构体指针来访问。通过指针间接的访问是透明的
fmt.Println(s.A)
fmt.Println((*s).A)

// TODO interface
type IF interface {
    a()
}

// TODO chanel

// TODO error

// if 语句 小括号 ( )是可选的，而 { } 是必须的。
if (i < 0)        // 编译错误.
    println(i)

if i < 0        // 编译错误.
    println(i)

if (i < 0) {    // 编译通过.
    println(i)
}
if i < 0 {
    println(i)
} else {
    println(i)
}

// 可以在条件之前执行一个简单的语句，由这个语句定义的变量的作用域仅在 if/else 范围之内
if (i := 0; i < 1) {    // 编译错误.
    println(i)
}

if i := 0; (i < 1) {    // 编译通过.
    println(i)
}

if i := 0; i < 0 {    // 使用gofmt格式化代码会自动移除代码中不必要的小括号( )
    println(i)
} else if i == 0 {
    println(i)
} else {
    println(i)
}

// if语句作用域范围内定义的变量会覆盖外部同名变量,(与方法函数内局部变量覆盖全局变量相同)
a, b := 0, 1
if a, b := 3, 4; a > 1 && b > 2 {
    println(a, b)    // 3 4
}
println(a, b)    // 0 1


// 只有一种循环结构，for 循环。可以让前置、后置语句为空，或者全为空
for i := 0; i < 10; i++ {}
for i := 0; i < 10; {}
for ; i < 10; i++ {}
for ; i < 10; {}
for i < 10 {}
for ; ; {}
for {}

// 小括号 ( )是可选的，而 { } 是必须的。
for (i := 0; i < 10; i++) {}    // 编译错误.
for i := 0; (i < 10); i++ {}    // 编译通过.
for (i < 10) {}    // 编译通过.

// TODO continue

// TODO for range

// TODO switch
// TODO fallthrough break
// TODO type assertion

// TODO select

// TODO goto

// 函数可以没有参数或接受多个参数
func f() {}
func f(a int) {}
func f(a int, b byte) {}
func f(a int) {}    // 可变参数
func f(a int, b bool, c string) {}
// 函数可以返回任意数量的返回值
func f() int {
    return 0
}
func f() int, string {
    return 0, "A"
}
// 函数返回结果参数，可以像变量那样命名和使用
func f() a int, b string {
    a = 1
    b = "B"
    return    // 或者 return a, b
}

// 当两个或多个连续的函数命名参数是同一类型，则除了最后一个类型之外，其他都可以省略
func f(a,b,c int) {}
func f() a,b,c int {}
func f(a,b,c int) x,y,z int {}

// 函数也是值，可以将函数赋值给变量
var f (func(i int) int) = func(i int) int {
    return i
}
fmt.Println(f(3))    // 3
var f func() int = func() int {
    return 0
}
fmt.Println(f())    // 0
var f func() = func() {}
var f = func() {}
f := func() {}

// TODO defer

// TODO 方法

// TODO 内建函数
append 
cap 
close 
complex 
copy 
delete 
imag 
len 
make 
new 
panic 
print 
println 
real 
recover

// TODO 并发
go func() {}

oathleo 2013-08-02 16:15 发表评论

Go语言文件操作

oathleo — Fri, 02 Aug 2013 02:43:00 GMT

写程序离不了文件操作，这里总结下go语言文件操作。

一、建立与打开

建立文件函数：

func Create(name string) (file *File, err Error)

func NewFile(fd int, name string) *File

具体见官网：http://golang.org/pkg/os/#Create

打开文件函数：

func Open(name string) (file *File, err Error)

func OpenFile(name string, flag int, perm uint32) (file *File, err Error)

具体见官网：http://golang.org/pkg/os/#Open

二、写文件

写文件函数：

func (file *File) Write(b []byte) (n int, err Error)

func (file *File) WriteAt(b []byte, off int64) (n int, err Error)

func (file *File) WriteString(s string) (ret int, err Error)

具体见官网：http://golang.org/pkg/os/#File.Write

写文件示例代码：

package main import (         "os"         "fmt" ) func main() {         userFile := "test.txt"         fout,err := os.Create(userFile)         defer fout.Close()         if err != nil {                 fmt.Println(userFile,err)                 return         }         for i:= 0;i<10;i++ {                 fout.WriteString("Just a test!\r\n")                 fout.Write([]byte("Just a test!\r\n"))         } }

三、读文件

读文件函数：

func (file *File) Read(b []byte) (n int, err Error)

func (file *File) ReadAt(b []byte, off int64) (n int, err Error)

具体见官网：http://golang.org/pkg/os/#File.Read

读文件示例代码：

package main import (         "os"         "fmt" ) func main() {         userFile := "test.txt"         fin,err := os.Open(userFile)         defer fin.Close()         if err != nil {                 fmt.Println(userFile,err)                 return         }         buf := make([]byte, 1024)         for{                 n, _ := fin.Read(buf)                 if 0 == n { break }                 os.Stdout.Write(buf[:n])         } }

四、删除文件

函数：

func Remove(name string) Error

oathleo 2013-08-02 10:43 发表评论

goLang 读取Int

oathleo — Fri, 02 Aug 2013 02:13:00 GMT

windows下字节序和网络的相反

func readInt32(conn net.Conn) int32 {
    num_byte := make([]byte, 4)
    conn.Read(num_byte)
    var value int32 = 0
//    //windows
//    byte2 := num_byte[2]
//    byte3 := num_byte[3]
//    num_byte[3] = num_byte[0]
//    num_byte[0] = byte3
//    num_byte[2] = num_byte[1]
//    num_byte[1] = byte2
//    //windows

    //windows
    num_byte[0],num_byte[1],num_byte[2],num_byte[3] = num_byte[3],num_byte[2],num_byte[1],num_byte[0]

    for i := 0; i < 4; i++ {
        shift := uint32((4 - 1 - i) * 8)
        value = value + (int32(num_byte[i])&0x000000FF)<    }
    return value
}

oathleo 2013-08-02 10:13 发表评论

BlogJava-咖啡伴侣-随笔分类-Golang

golang 之 接口

golang定时定点任务

golang append时slice len 和 cap

golang slice分割和append copy还是引用

golang 之 去掉定长数组里的0 []byte 转 string

golang之 windows下杀进程

golang slice Append

golang 定时

golang 非缓冲通道 recv 的操作 肯定 在 send 操作 之前发生

Go指针 new make

go原生数据效率

go对象序列化和反序列化

bson和json

golang 之 bson 与 struct 转换

Golang 异常处理

Panic和Recover

Panic

Recover

Go语言的传参和传引用

Go语言的传参和传引用[OSC源创会主题补充1]

传参和传引用的问题

slice不是引用!

什么叫引用?

为什么slice不是引用?

为什么很多人误以为slice是引用呢?

传指针和传引用是等价的吗?

所有类型的函数参数都是传值的!

那Go语言有传引用的说法吗?

总结

数组和切片

数组 Arrays

初始化

赋值与使用

切片 Slices

初始化

赋值与使用

Socket read write

bufio 包

Golang 类型转换整理

Golang 类型转换整理

golang strconv

golang strconv

Pragma: no-cache 对性能的影响

golang html 与 golang客户端 上传文件 转载

golang html 与 golang客户端 上传文件

golang string rune len 可能不同

golang xml 处理之生成 属性必须大写

golang xml 处理

exec start

exec卡住了，阻塞调用肯定卡住了调用Startfunc (*Cmd) Run

func (*Cmd) Start

Golang语法与代码格式速记

Go语言文件操作

goLang 读取Int

golang 之接口

golang 之去掉定长数组里的0 []byte 转 string

golang 非缓冲通道 recv 的操作肯定在 send 操作之前发生

golang html 与 golang客户端上传文件转载

golang html 与 golang客户端上传文件

golang xml 处理之生成属性必须大写

exec卡住了，阻塞调用肯定卡住了
调用Start

func (*Cmd) Run