亚洲高清中文字幕综合网,怡红院亚洲红怡院在线观看,亚洲人成网站18禁止一区

golang �?接口

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

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

看到�q�里我曾�l�有个疑问，��Z��么不�?nbsp; handleConnection(&conn) ?

下面�q�个例子解释�q�个问题

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)
}

函数的参��C��接口定义�Q�编译器会自己判断参数是对象�q�是对象的指�?br /> 比如�Q�say是指针上的方法，所以do只接�?span style="background-color: #eeeeee;">Object的指针做参数�Q�do(o)是编译不�q�的

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

例如�Q?br /> conn, err = ln.Accept()
go handleConnection(conn)

�q�里conn是个接口�Q�不需�?nbsp;go handleConnection(&conn)

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

golang定时定点��d��

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() { //非阻�?br />        //后箋�?4��时建立目录
        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

��d��slice = app

�l�果slice=tar

append�?/div>

len tar === len src + len app

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

2�Q�否�?nbsp;

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)//修改�q�个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�q�是引用

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

1.slice1:= slice[0:2]

引用�Q�非复制�Q�所以�Q何对slice1或slice的修攚w��会媄响对�?/div>

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

��d��slice = app

�l�果slice=tar

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

2�Q�否�?tar 是copy的方�?nbsp;src + app �Q?span style="color: #ff0000; ">即修改src或tar�Q�不会媄响对�?/span>

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

func test2() {

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

data[0] = 1

data[1] = 2

dataappend := make([]int, 10, 20)//len <=10 �?nbsp; 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 �? ��L��定长数组里的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下杀�q�程

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上记录的切片信息复制�l�s2�Q?br />
1.如果s1指向的底层array长度不够�Q�append的过�E�会发生如下操作�Q�内存中不仅新开辟一块区域存储append后的切片信息�Q�而且需要新开辟一块区域存储底层array�Q�复制原来的array臌��块新array中）�Q�最后再append新数据进新array中，�q�样�Q�s2指向新array�?br />
2.如果s1指向的底层array长度�?
s2和s1指向同一个array�Q�append的结果是内存中新开辟一个区域存储新切片信息�?br />
开辟一块区域存储底层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

对亍非缓冲通道,“从通道接收数据”的操�?br /> 一定会�? “向通道发送数�?#8221;的操作完成前发生�?br />

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

�c�d��的内存空�?�q�且�q�回其地址,一�?T �c�d��的倹{��用Go 的术语说,它返回了一�?/div>

指针,指向新分配的�c�d��T 的零倹{��有一炚w��帔R��?

new �q�回指针�?br />

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

和channel,�q�且�q�回一个有初始�?非零)的T �c�d��,而不�?T�?/span>本质来讲,��D��q?/div>

三个�c�d��有所不同的原因是指向数据�l�构的引用在使用前必��被初始化�?br />

T{name:"aaa",age:11}
�q�回 T�c�d�� 而不�?T

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

go原生数据效率

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

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

先上代码

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原生代码性能�Q?/div>

total record: 1000000

send data: {999999 16959 0.69153386}

send cost: 93

rev cost: 61

rev data: {999999 16959 0.69153386}

�l�论�Q?/div>

1.不管什么语�a��Q?span style="color: #ff0000">大批量同�c�d��数据的传�?/span>�Q�原生性能�q�是比第三方序列�? 效率高很�?

2.C++ 使用memcpy put 原始�c�d��Q�效率还是比go高很�?br />

C++原生代码性能�Q?/div>

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个字�?nbsp; 也就�?0M不到�?数据(高度�l�构化的数据)
�q�程
1.对象序列化�ؓ byte
2.byte反序为对�?br />3.gzip压羃byte

��试语言go
��试�Ҏ��Q? raw byte�Q�json ,bson, msgpack �Q�protostuff需要先做对象配�|�文�Ӟ��比较�ȝ��Q�通常认�ؓ和msgpack性能相当 �Q?br />�l�果�Q�msgpack 胜出

	大小	gzip压羃后大��?br />	对象到byte耗时	byte到对象耗时
raw	10000000	6573252�Q?5%�Q?/td>	未测�?br />	未测�?/td>
json	47515988	7919511 (17%)	3248ms	5280ms
bson	49888910	9506965 �Q?9%�Q?br />	3863ms	6235ms
msgpack	29934223	7448484	2046ms	3113ms

raw data: 1000000
raw data gzip compress: 6573252 //gzip压羃后大��?br />
start: 1000000
Marshal cost: 3248 //json 序列化耗时
json string: 47515988
json byte: 47515988 //二进制数�l�大��?br />Unmarshal cost: 5280 //json 反序列化耗时
test data: {1 100 0.9405091}
json gzip compress: 7919511 //gzip压羃后大��?br />
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方式存储�Q��ƈ用gzip压羃

�l�果bson比json�q�大一点，��实��Z��意料

个�h�l�论是BSON�Ҏ��json更加适合存储�Q�在传输上没有太大优�?br />

　　BSON相对JSon

1.更快的遍历速度

2.操作更简�?/div>

3.增加了额外的数据�c�d��

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的介�l�不说了
golang下的解析包找�?�?一个是mongo�?a >http://labix.org/gobson
�Q�另外一个比较小�?a >https://github.com/sbunce/bson

�q�里用的是mongo的作��Z��子�?br />对象加上不同的注解，
可以��L��转成xml json bson ��x��都兴�?nbsp;

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那样的异常机�Ӟ��它不能抛出异常，而是使用�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">panic�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">recover机制。一定要��C��Q�你应当把它作�ؓ最后的手段来��用，也就是说�Q�你的代码中应当没有�Q�或者很��有panic的东�ѝ��这是个强大的工��P��h��智地使用它。那么，我们应该如何使用它呢�Q?/p>

Panic

是一个内建函敎ͼ�可以中断原有的控制流�E�，�q�入一个��o人恐慌的��程中。当函数F调用panic�Q�函�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">F的执行被中断�Q�但�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">F中的延迟函数会正常执行，然后F�q�回到调用它的地斏V��在调用的地方，F的行为就像调用了panic。这一�q�程�l�箋向上�Q�直到发�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">panic�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">goroutine中所有调用的函数�q�回�Q�此时程序退出。恐慌可以直接调�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">panic产生。也可以��p��行时错误产生�Q�例如访问越界的数组�?/p>

Recover

是一个内建的函数�Q�可以让�q�入令�h恐慌的流�E�中�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">goroutine恢复�q�来�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">recover仅在延迟函数中有效。在正常的执行过�E�中�Q�调�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">recover会返�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">nil�Q��ƈ且没有其它�Q何效果。如果当前的goroutine陷入恐慌�Q�调�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">recover可以捕获�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">panic的输入��|��q�且恢复正常的执行�?/p>

下面�q�个函数演示了如何在�q�程中��?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">panic

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

下面�q�个函数��查作为其参数的函数在执行时是否会产生panic�Q?/strong>

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

最�Ҏ��理解��是�l�个例子�Q�文章里有例子：

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) }

执行�l�果�Q?/p>

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

如上面所说的�Q?/p>

panic�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">user=""�Ӟ��打断了函数的执行�Q?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">fmt.Print("!!after panic\n")没有执行�?但函��C��的�g�q�函��C��正常执行�Q�打��C�� defer##。然后返回到调用该函数的地方�Q��l�上面的�q�程�?/p>

直到执行完所有函数的defer�Q�退出程序�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">Recover可以捕获�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">panic的��|��上面的打�?code style="margin: 0px 2px; padding: 0px 5px; white-space: nowrap; border: 1px solid #eaeaea; background-color: #f8f8f8; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; font-family: consolas, courier; font-size: 13px; line-height: 20px;">no value for user。�ƈ且恢复正常的执行�?/p>

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

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

Go语言的传参和传引用[OSC源创会主题补�?]
66人收藏此文章, 我要收藏发表�?天前(2013-09-14 22:10) , 已有1496�ơ阅�?�Q�共12个评�?/div>
目录�Q�[ - ]
传参和传引用的问�?/a>
slice不是引用!
什么叫引用?
��Z��么slice不是引用?
��Z��么很多�h误以为slice是引用呢?
传指针和传引用是�{��h的吗?
所有类型的函数参数都是传值的!
那Go语言有传引用的说法吗?
�ȝ��
OSC源创会主题补充系�?
Go语言的传参和传引�?/a>
Go语言的类型�{换和�c�d��断言
Go语言规范虽然很简�? 但是深入掌握Go语言却需要很多底层知�?
本来�W?0期的武汉OSC源创�?/a>有Go语言的专题讲�? 谁知道说取消��取消了.
我最�q�也整理了一些Go语言资料, 有Go语言的历�?现状/未来发展的八卦和Go语言常见的问题和陷阱两个部分, 本来打算OSC源创会能和武汉的Gopher分��n 下的, 谁知�?�׃��不是赞助商也不是微��Y的大�?��d��Ҏ��本不�l��Q何的��Z��.
100+人数的交��会基本都是扯��E, �q�是��规模的讨论沙龙比较靠谱, 以后再也不会去OSC源创会当听众�?
现在计划��各个小问题暂时作�ؓ博客发表.
传参和传引用的问�?/h2>
很多非官方的文��和教�?包括一些已�l�出版的图书), 对Go语言的传参和引用的讲�?都有很多问题. ��D��众多Go语言新手对Go的函数参��C��参有很多误解.
而传参和传引用是�~�程语言的根本问�? 如果�q�个问题理解错误可能会导致很多问�?
slice不是引用!
首先, Go语言的函数调用参数全部是传值的, 包括 slice/map/chan 在内所有类�? 没有传引用的说法.
具体��L��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打印出来的也是修改后的�? 那么��可以认�?code style="padding: 2px 5px; margin: 0px 2px; border: 1px solid #dddddd; background-color: #f6f6f6; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; word-break: break-all;">doSomething是通过引用的方式��用了参数a.
��Z��么slice不是引用?
我们构造以下的代码:
func main() { a := []int{1,2,3} fmt.Println(a) modifySlice(a) fmt.Println(a) } func modifySlice(data []int) { data = nil }
其中modifySlice修改了切�?code style="padding: 2px 5px; margin: 0px 2px; border: 1px solid #dddddd; background-color: #f6f6f6; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; word-break: break-all;">a, 输出�l�果如下:
[1 2 3] [1 2 3]
说明a在调�?code style="padding: 2px 5px; margin: 0px 2px; border: 1px solid #dddddd; background-color: #f6f6f6; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; word-break: break-all;">modifySlice前后�q�没有�Q何变�? 因此a必然是传值的!
��Z��么很多�h误以为slice是引用呢?
可能�?因�ؓ很多新接触Go语言的新�? 看到Go语言的文��说Go的切片和C语言的数�l�类�? 而C语言的数�l�是传地址�?注意: 不是传引�?).
下面�q�个代码可能是错误的�Ҏ��:
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��实通过参数修改了切片的内容.
但是��h��? 修改通过函数修改参数内容的机制有很多, 其中传参数的地址��可以修改参数的�?其实是修改参��C��指针指向的数�?, �q�不是只有引用一�U�方�?
传指针和传引用是�{��h的吗?
比如有以下代�?
func main() { a := new(int) fmt.Println(a) modify(a) fmt.Println(a) } func modify(a *int) { a = nil }
输出�?
0xc010000000 0xc010000000
可以看出指针a本��n�q�没有变�? 传指针或传地址也只能修�Ҏ��针指向的内存的�? �q�不能改变指针本�w�在�?
因此, 函数参数传传指针也是传值的, �q�不是传引用!
所有类型的函数参数都是传值的!
包括slice/map/chan�{�基��c�d��和自定义的类型都是传值的.
但是因�ؓslice�?code style="padding: 2px 5px; margin: 0px 2px; border: 1px solid #dddddd; background-color: #f6f6f6; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; word-break: break-all;">map/chan底层�l�构的差�? 又导致了它们传值的影响�q�不完全�{�同.
重点归纳如下:
GoSpec: the parameters of the call are passed by value!
map/slice/chan 都是传�? 不是传引�?/li>
map/chan 对应指针, 和引用类�?/li>
slice 是结构体和指针的混合�?/p>
slice �?values/count/capacity �{�信�? 是按��g��?/p>
slice 中的 values 是指�? 按��g��?/li>
按��g��递的 slice 只能修改values指向的数�? 其他都不能修�?/p>
以指针或�l�构体的角度�? 都是��g��?
那Go语言有传引用的说法吗?
Go语言其实也是有传引用的地方的, 但是不是函数的参�? 而是闭包对外部环境是通过引用讉K��?
查看以下的代�?
func main() { a := new(int) fmt.Println(a) func() { a = nil }() fmt.Println(a) }
输出�?
0xc010000000
因�ؓ闭包是通过引用的方式��用外部环境的a变量, 因此可以直接修改a的�?
比如下面2�D�代码的输出是截然不同的, 原因��是�W�二个代码是通过闭包引用的方式输�?code style="padding: 2px 5px; margin: 0px 2px; border: 1px solid #dddddd; background-color: #f6f6f6; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; word-break: break-all;">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 }
像第二个代码��是于闭包引用导致的副作�? 回避�q�个副作用的办法是通过参数传值或每次闭包构造不同的临时变量:
// �Ҏ��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 �{�信�? 是按��g��?/li>
按��g��递的 slice 只能修改values指向的数�? 其他都不能修�?/li>
slice 是结构体和指针的混合�?/li>

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

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

数组 Arrays
数组是内�|?build-in)�c�d��,是一�l�同�c�d��数据的集合，它是值类型，通过�?开始的下标索引讉K��元素倹{��在初始化后长度是固定的�Q�无法修改其长度。当作�ؓ�Ҏ��的入参传入时��复制一份数�l�而不是引用同一指针。数�l�的长度也是其类型的一部分�Q�通过内置函数len(array)获取光��度�?/p>
初始�?/h4>
数组的初始化有多�U��Ş�?查看�C�Z��代码 , 在线�q�行�C�Z��代码
[5] int {1,2,3,4,5}
长度�?的数�l�，其元素��g��ơ�ؓ�Q?�Q?�Q?�Q?�Q?
[5] int {1,2}
长度�?的数�l�，其元素��g��ơ�ؓ�Q?�Q?�Q?�Q?�Q? 。在初始化时没有指定初值的元素��会赋��gؓ其元素类型int的默认�?,string的默认值是""
[...] int {1,2,3,4,5}
长度�?的数�l�，光��度是�Ҏ��初始化时指定的元素个数决定的
[5] int { 2:1,3:2,4:3}
长度�?的数�l�，key:value,其元素��g��ơ�ؓ�Q?�Q?�Q?�Q?�Q?。在初始化时指定�?�Q?�Q?索引中对应的��|��1�Q?�Q?
[...] int {2:1,4:3}
长度�?的数�l�，起元素��g��ơ�ؓ�Q?�Q?�Q?�Q?�Q?。由于指定了最大烦�?对应的�?�Q�根据初始化的元素个数确定其长度�?
赋��g��使用
数组通过下标讉K��元素�Q�可修改其元素�?/p>
arr :=[...] int {1,2,3,4,5} arr[4]=arr[1]+len(arr) //arr[4]=2+5
通过for遍历数组元素,查看�C�Z��代码,在线�q�行�C�Z��代码
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]) }
数组是值类型，��一个数�l�赋值给另一个数�l�时��复制一份新的元�?查看�C�Z��代码,在线�q�行�C�Z��代码
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

数组的长度不可改变，在特定场景中�q�样的集合就不太适用�Q�Go中提供了一�U�灵�z�，功能强悍的内�|�类�?strong>Slices切片,与数�l�相比切片的长度是不固定的，可以�q�加元素�Q�在�q�加时可能��切片的容量增大。切片中有两个概念：一�?strong>len长度�Q�二�?strong>cap定w��Q�长度是指已�l�被赋过值的最大下�?1�Q�可通过内置函数len()获得。容量是指切片目前可容纳的最多元素个敎ͼ�可通过内置函数cap()获得。切片是引用�c�d��Q�因此在当传递切片时��引用同一指针�Q�修改值将会媄响其他的对象�?/p>

初始�?/h4>
切片可以通过数组来初始化�Q�也可以通过内置函数make()初始�?.初始化时len=cap,在追加元素时如果定w��cap不��时将按len�?strong>2倍扩�?nbsp;查看�C�Z��代码�Q?a style="color: #770000; text-decoration: none;">在线�q�行�C�Z��代码
`s :=[] int {1,2,3 }`
直接初始化切片，[]表示是切片类型，{1,2,3}初始化��g��ơ是1,2,3.其cap=len=3
`s := arr[:]`
初始化切片s,是数�l�arr的引�?/li>
`s := arr[startIndex:endIndex]`
��arr中从下标startIndex到endIndex-1 下的元素创徏��Z��个新的切�?/li>
`s := arr[startIndex:]`
�~�省endIndex时将表示一直到arr的最后一个元�?/li>
`s := arr[:endIndex]`
�~�省startIndex时将表示从arr的第一个元素开�?/li>
`s1 := s[startIndex:endIndex]`
通过切片s初始化切片s1
`s :=make([]int,len,cap)`
通过内置函数make()初始化切片s,[]int 标识为其元素�c�d��为int的切�?/li>

赋��g��使用

切片是引用类型，在��用时需要注意其操作�?a style="color: #770000; text-decoration: none;">查看�C�Z��代码 �Q?a style="color: #770000; text-decoration: none;">在线�q�行�C�Z��代码切片可以通过内置函数append(slice []Type,elems ...Type)�q�加元素�Q�elems可以是一排type�c�d��的数据，也可以是slice,因�ؓ�q�加的一个一个的元素�Q�因此如果将一个slice�q�加到另一个slice中需要带�?..."�Q�这��h��能表�C�是��slice中的元素依次�q�加到另一个slice中。另外在通过下标讉K��元素时下标不能超�q�len大小�Q�如同数�l�的下标不能��出len范围一栗��?/p>

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

转蝲时请注明出处�Q�老虞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
�q�个时�?read 要完��_��W�一�ơ没有read完，��write�Q�第二次read 到的仍然是上�ơ没有read完的数据

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

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

// bufio 包实��C��带缓存的 I/O 操作

// 它封装一�?io.Reader �?io.Writer 对象

// 使其��h��~�存和一些文本读写功�?/div>

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

// bufio.go

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

// Reader 实现了带�~�存�?io.Reader 对象

type Reader struct {

// �U�有字段

}

// NewReaderSize ��?rd ��装成一个拥�?size 大小�~�存�?bufio.Reader 对象

// 如果 rd 的基�c�d��是 bufio.Reader �c�d��Q�而且拥有��_��的缓�?/div>

// 则直接将 rd 转换为基�c�d��q�返�?/div>

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

// NewReader 相当�?NewReaderSize(rd, 4096)

func NewReader(rd io.Reader) *Reader

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

// Peek �q�回�~�存的一个切片，该切片引用缓存中�?n 字节数据

// 该操作不会将数据��d��Q�只是引�?/div>

// 引用的数据在下一�ơ读取操作之前是有效�?/div>

// 如果引用的数据长度小�?n�Q�则�q�回一个错误信�?/div>

// 如果 n 大于�~�存的��d��，则返�?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 中，�q�回��d��的字节数

// 如果 p 的大��?>= �~�存的��d��，而且�~�存不�ؓ�I?/div>

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

// 如果 p 的大��?>= �~�存的��d��，而且�~�存为空

// 则直接从底层 io.Reader �?p 中读出数据，不经�q�缓�?/div>

// 只有�?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 中读��Z��个字节�ƈ�q�回

// 如果 b 中无可读数据�Q�则�q�回一个错�?/div>

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

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

// 只有最后读出的字节可以被撤�?/div>

// 无论��M��操作�Q�只要有内容被读出，��可以用 UnreadByte 撤消一个字�?/div>

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 中读��Z��?UTF8 �~�码的字�W��ƈ�q�回

// 同时�q�回该字�W�的 UTF8 �~�码长度

// 如果 UTF8 序列无法解码��Z��个正��的 Unicode 字符

// 则只��d�� b 中的一个字节，�q�返�?U+FFFD 字符�Q�size �q�回 1

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

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

// 如果最后一�ơ执行的不是 ReadRune 操作�Q�则�q�回一个错�?/div>

// 因此�Q�UnreadRune �?UnreadByte 更严�?/div>

func (b *Reader) UnreadRune() error

func main() {

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

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 �q�回�~�存中数据的长度

func (b *Reader) Buffered() int

func main() {

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

br := bufio.NewReader(s)

fmt.Println(br.Buffered())

// 0

br.Peek(1)

fmt.Println(br.Buffered())

// 18

}

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

// ReadSlice �?b 中查�?delim �q�返�?delim 及其之前的所有数据的切片

// 该操作会��d��数据�Q�返回的切片是已��d��数据的引�?/div>

// 切片中的数据在下一�ơ读取操作之前是有效�?/div>

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

// 则读出缓存中的所有数据�ƈ�q�回�Q�同时返回遇到的错误�Q�通常�?io.EOF�Q?/div>

// 如果在整个缓存中都找不到 delim�Q�则 err �q�回 ErrBufferFull

// 如果 ReadSlice 能找�?delim�Q�则 err 始终�q�回 nil

// 因�ؓ�q�回的切片中的数据有可能被下一�ơ读写操作修�?/div>

// 因此大多数操作应该��?ReadBytes �?ReadString�Q�它们返回的不是数据引用

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 是一个低�U�的原始的行��d��操作

// 大多数情况下�Q�应该��?ReadBytes('\n') �?ReadString('\n')

// 或者��用一�?Scanner

// ReadLine 通过调用 ReadSlice �Ҏ��实现�Q�返回的也是�~�存的切�?/div>

// ReadLine ��试�q�回一个单行数据，不包括行��标讎ͼ�\n �?\r\n�Q?/div>

// 如果在缓存中找不到行��标讎ͼ�则设�|?isPrefix �?true�Q�表�C�查找未完成

// 同时��d��~�存中的数据�q�作为切片返�?/div>

// 只有在当前缓存中扑ֈ�行尾标记�Q�才��?isPrefix 讄��?false�Q�表�C�查扑֮��?/div>

// 可以多次调用 ReadLine 来读��Z��?/div>

// �q�回的数据在下一�ơ读取操作之前是有效�?/div>

// 如果 ReadLine 无法获取��M��数据�Q�则�q�回一个错误信息（通常�?io.EOF�Q?/div>

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 �q�读�?delim 及其之前的所有数�?/div>

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

// 则返回遇到错误之前的所有数据，同时�q�回遇到的错误（通常�?io.EOF�Q?/div>

// 只有�?ReadBytes 找不�?delim �Ӟ��err 才不�?nil

// 对于��单的用途，使用 Scanner 可能更方�?/div>

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�Q�只不过�q�回的是一个字�W�串

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 中写入数据的�q�程中遇到错�?/div>

// �?Writer 不会再接受�Q何数�?/div>

// 而且后箋的写入操作都��返回错误信�?/div>

type Writer struct {

// �U�有字段

}

// NewWriterSize ��?wr ��装成一个拥�?size 大小�~�存�?bufio.Writer 对象

// 如果 wr 的基�c�d��是 bufio.Writer �c�d��Q�而且拥有��_��的缓�?/div>

// 则直接将 wr 转换为基�c�d��q�返�?/div>

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

// NewWriter 相当�?NewWriterSize(wr, 4096)

func NewWriter(wr io.Writer) *Writer

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

// Flush ��缓存中的数据提交到底层�?io.Writer �?/div>

func (b *Writer) Flush() error

// Available �q�回�~�存中的可以�I�间

func (b *Writer) Available() int

// Buffered �q�回�~�存中未提交的数据长�?/div>

func (b *Writer) Buffered() int

// Write ��?p 中的数据写入 b 中，�q�回写入的字节数

// 如果写入的字节数��于 p 的长度，则返回一个错误信�?/div>

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

// WriteString �?Write�Q�只不过写入的是字符�?/div>

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 中写入一个字�?/div>

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

// WriteRune �?b 中写�?r �?UTF8 �~�码

// �q�回 r 的编码长�?/div>

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('�Q?)

bw.Flush()

fmt.Println(b) // Hello 世界�Q?/div>

}

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

// 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 世界�Q?)

bw := bufio.NewWriter(b)

bw.ReadFrom(s)

bw.Flush()

fmt.Println(b) // Hello 世界�Q?/div>

}

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

// ReadWriter 集成�?bufio.Reader �?bufio.Writer

// 它实��C�� io.ReadWriter 接口

type ReadWriter struct {

*Reader

*Writer

}

// NewReadWriter ��装 r �?w ��Z��?bufio.ReadWriter 对象

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

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

// scan.go

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

// Scanner 提供了一个方便的接口来读取数据，例如��d��一个多行文�?/div>

// �q�箋调用 Scan �Ҏ��扫描数据中�?#8220;指定部分”�Q�蟩�q�各�?#8220;指定部分”之间的数�?/div>

// Scanner 使用了缓存，所�?#8220;指定部分”的长度不能超出缓存的长度

// Scanner 需要一�?SplitFunc �c�d��?#8220;切分函数”来确�?#8220;指定部分”的格�?/div>

// 本包中提供的“切分函数”�?#8220;行切分函�?#8221;�?#8220;字节切分函数”�?#8220;UTF8字符�~�码切分函数”

// �?#8220;单词切分函数”�Q�用户也可以自定�?#8220;切分函数”

// 默认�?#8220;切分函数”�?#8220;行切分函�?#8221;�Q�用于获取数据中的一行数据（不包括行��Q?/div>

// 扫描在遇��C��面的情况时会停止�Q?/div>

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

// 2、遇到读写错�?/div>

// 3�?#8220;指定部分”的长度超�q�了�~�存的长�?/div>

// 如果要对数据�q�行更多的控�Ӟ��比如的错误处理或扫描更大�?#8220;指定部分”或顺序扫�?/div>

// 则应该��?bufio.Reader

type Scanner struct {

// �U�有字段

}

// SplitFunc 用来定义“切分函数”�c�d��

// data 是要扫描的数�?/div>

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

// advance �q�回 data 中已处理的数据长�?/div>

// token �q�回扑ֈ��?#8220;指定部分”

// err �q�回错误信息

// 如果�?data 中无法找��C��个完整的“指定部分”

// �?SplitFunc �q�回 (0, nil) 来告�?Scanner

// 向缓存中填充更多数据�Q�然后再�ơ扫�?/div>

// 如果�q�回�?err 是非 nil ��|��扫描��被�l�止�Q��ƈ�q�回错误信息

// 如果 data 为空�Q�则“切分函数”��不被调�?/div>

// 意思是�?SplitFunc 中不必考虑 data 为空的情�?/div>

// SplitFunc 的作用很��单，�?data 中找��Z��感兴��的数据�Q�然后返�?/div>

// �q�告诉调用者，data 中有多少数据你已�l�处理过�?/div>

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

// NewScanner 创徏一�?Scanner 来扫�?r

// 默认切分函数�?ScanLines

func NewScanner(r io.Reader) *Scanner

// Err �q�回扫描�q�程中遇到的�?EOF 错误

// 供用戯��用，以便获取错误信息

func (s *Scanner) Err() error

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

// Bytes ��最后一�ơ扫描出�?#8220;指定部分”作�ؓ一个切片返回（引用传递）

// 下一�ơ的 Scan 操作会覆盖本�ơ返回的�l�果

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

// Text ��最后一�ơ扫描出�?#8220;指定部分”作�ؓ字符串返回（��g��递）

func (s *Scanner) Text() string

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

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

// 扑ֈ�后，用户可以通过 Bytes �?Text �Ҏ��来取�?#8220;指定部分”

// 如果扫描�q�程中遇到错误，则终止扫描，�q�返�?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 �?#8220;切分函数”

// �q�个函数必须在调�?Scan 前执�?/div>

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 是一�?#8220;切分函数”

// 用来扑և� data 中的单个字节�q�返�?/div>

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

func main() {

s := strings.NewReader("Hello 世界�Q?)

bs := bufio.NewScanner(s)

bs.Split(bufio.ScanBytes)

for bs.Scan() {

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

}

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

// ScanRunes 是一�?#8220;切分函数”

// 用来扑և� data 中的单个 UTF8 字符的编码�ƈ�q�回

// 如果 UTF8 解码出错�Q�则�q�回�?U+FFFD 会被做�ؓ "\xef\xbf\xbd" �q�回

// �q��得用��h��法区�?#8220;真正的U+FFFD字符”�?#8220;解码错误的返回�?#8221;

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

func main() {

s := strings.NewReader("Hello 世界�Q?)

bs := bufio.NewScanner(s)

bs.Split(bufio.ScanRunes)

for bs.Scan() {

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

} // H e l l o �?�?�Q?/div>

}

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

// ScanLines 是一�?#8220;切分函数”

// 用来扑և� data 中的单行数据�q�返回（包括�I��Q?/div>

// 行尾标记可能�?\n �?\r\n�Q�返回��g��包括行尾标记�Q?/div>

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

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

// ScanWords 是一�?#8220;切分函数”

// 用来扑և� data 中的单词

// 单词以空白字�W�分隔，�I�白字符�?unicode.IsSpace 定义

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

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

Golang �c�d��转换整理

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

Golang �c�d��转换整理

分类�Q?nbsp;Go2013-07-31 11:02 177人阅�?/span> 评论(0) 收藏举报

golangString

1、整形到字符�Ԍ��

[plain] view plain copy

var i int = 1
var s string

[plain] view plain copy

s = strconv.Itoa(i) 或�?nbsp;s = FormatInt(int64(i), 10)

2、字�W�串到整�?br />

[plain] view plain copy

var s string = "1"
var i int
i, err = strconv.Atoi(s) 或�?nbsp;i, err = ParseInt(s, 10, 0)

3、字�W�串到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到整�?br /> 直接使用float(i) 或�?int(f) 直接�q�行转换卛_��

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)

输出�Q?0.01

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

输出:10.10

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

-1 代表输出的精度小数点后的位数�Q�如果是<0的��|��则返回最��的位数来表�C��敎ͼ�如果是大�?的则�q�回对应位数的�?/p>

64 为float的类型，go中float分�ؓ32�?4位，因此��需要传�?2或�?4

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

golang strconv.ParseInt 是将字符串�{换�ؓ数字的函�?功能灰常之强�?看的我口水直��?

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

参数1 数字的字�W�串形式

参数2 数字字符串的�q�制比如二进�?nbsp;八进�?nbsp;十进�?nbsp;十六�q�制

参数3 �q�回�l�果的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 发表评论

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

做了下go和java的http性能的简单比�?br />服务端直接输出字�W�串
使用JMeter
windows�?br />

2000的�ƈ发，��试�l�果很出乎意料，go不会�q�么差吧

研究了半��时�Q�原因如�?br />tomcat的servlet里加�?span style="background-color: #eeeeee; font-size: 13px;"> response.setHeader("Pragma", "no-cache");
go里没有设�|�该参数

讄��后重新跑��试

可以了吧

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

golang html �?golang客户�?上传文�g 转蝲

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

golang html �?golang客户�?上传文�g

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

��文件上�?/span>

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") //�q�里的file很重要，必须和服务器端的FormFile一�?/span>

    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上传�Q?a style="color: #1570a6; text-decoration: none;">原文

package main

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

// 获取大小的接�?/span>
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, "上传文�g的大��ؓ: %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)
    }
}

大文件上�?/span>

关键的不同是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不一定相�?/div>
如果info是有中文的，则两个length是不一��L��Q�做string处理的时候，要注�?br />

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

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

xml对应的struct 属性必��d��写，否则无法实现�Q?br /> 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文�g解析成对应的struct对象是通过xml.Unmarshal来完成的�Q�这个过�E�是如何实现的？可以看到我们的struct定义后面多了一些类��g��xml:"serverName"�q�样的内�?�q�个是struct的一个特性，它们被称�?struct tag�Q�它们是用来辅助反射的�?br />

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卡住了，��d��调用肯定卡住�?br />调用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是采用语法解析器自动在每行末���֢�加分��P��所以在写代码的时候可以把分号省略�?br />// Go�~�程中只有几个地斚w��要手工增加分��P���? for循环使用分号把初始化�Q�条件和遍历元素分开。在一行中有多条语句时�Q�需要增加分受��?br />// 不能把控制语�?if, for, switch, or select)、函数、方�?nbsp;的左大括号单独放在一行， 如果你这样作了语法解析器会在大括号之前插入一个分��P����D���~�译错误�?br />
// 引用包名与导入�\径的最后一个目录一�?/span>
import "fmt"
import "math/rand"
fmt.Println(rand.Intn(10))    // 0�?0之间的非负伪随机�?br />
// 用圆括号�l�合导入包，�q�是“factored”导入语句
import ("fmt"; "math")
import (
    "fmt"
    "math"
)
// 导入包可以定义别名，防止同名�U�的包冲�H?/span>
import n "net/http"
import (
    控制�?nbsp;"fmt"
    m "math"
)
控制�?Println(m.Pi)

// 首字母大写的名称是被导出�? 首字母小写的名称只能在同一包内讉K��(同包跨文件也能访�?
var In int // In is public
var in byte // in is private
var 看不�?nbsp;string // 看不�?nbsp;is private
const Com bool = false // Com is public
const �q�是看不�?nbsp;uint8 = 1 // �q�是看不�?nbsp;is private
type Integer int // Integer is public
type ブーリア�?nbsp;*bool // ブーリア�?nbsp;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 �?nbsp;uint8 的别�?br />// rune �?nbsp;int32 的别名，代表一个Unicode码点

// 变量声明, 使用var关键�?nbsp;   (Go中只能��用var声明变量�Q�无需昑ּ�初始化��|��
var i int    // i = 0
var s string    // s = ""    (Go中的string不存在nil(null)��|��默认零值就是空�?nbsp;"" �?nbsp;``)
var e error    // e = nil, error是Go的内建接口类型，不是基本�c�d���?br />
// var 语句声明了一个变量的列表�Q�类型在变量名之�?/span>
var a,b,c int    // a = 0, b = 0, c = 0
var (
    a int    // a = 0
    b string    // b = ""
    c uint    // c = 0
)

// 变量定义时初始化赋��|��每个变量对应一个�?/span>
var a int = 0
var a,b int = 0, 1

// 初始化��用表辑ּ��Ӟ��可以省略�c�d���Q�变量从初始��g��获得�c�d��
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

// := �l�构不能使用在函数外�Q�函数外的每个语法块都必���M��关键字开�?br />
// 帔R��可以是字�W�、字�W�串、布���或数字�c�d��的��|��数值常量是高精度的�?/span>
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
)

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

// 自动枚�D帔R�� iota
// iota的枚丑ր�可以赋值给数值兼容类�?br />// 每个帔R��单独声明�? 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

// 帔R���l�合声明�? iota每次引用会逐步自增, 初始��gؓ0,步进��gؓ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
)

// 枚�D的常量都为同一�c�d���? 可以使用���单序列格�?
const (
    a = iota    // a int32 = 0
    b            // b int32 = 1
    c            // c int32 = 2
)

// 枚�D序列中的未指定类型的帔R��会跟随序列前面最后一�ơ出现类型定义的�c�d��
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自增值只在一个常量定义组合中有效,跛_��帔R���l�合定义后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序列初始��g��步进�?nbsp;(通过数学公式实现)
const (
    a = (iota + 2) * 3    // a int32 = 0    (a=(0+2)*3) 初始��gؓ6,步进��gؓ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)
)

// 数组声明带有长度信息�Q�数�l�的长度固定
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
// 使用自动计算数组初始数据的长�?/span>
var a = []int{0, 1, 2}
x := [][3]int{{0, 1, 2}, {3, 4, 5}}

// slice 指向数组的��|���q�且同时包含了长度信�?/span>
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 可以重新切片�Q�创��Z��个新�?nbsp;slice 值指向相同的数组
s := []int{0, 1, 2, 3, 4}
fmt.Println(s[1,3])    // [1 2]    (截取从开始烦引到�l�束索引-1 之间的片�D?
fmt.Println(s[:4])    // [0 1 2 3]
fmt.Println(s[1:])    // [1 2 3 4]
fmt.Println(s[1:1])    // []

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


// map 在��用之前必��ȝ�� make 来创建（不是 new�Q�；一个��gؓ nil �?nbsp;map 是空的，�q�且不能赋�?/span>
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�Q�if m is nil, len(m) is zero.

var m map[int]int = make(map[int]int)
m[0] = 0    // 插入或修改元�?/span>
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},    // �c�d��名称可省�?/span>
}
a := m["a"]    // 取�?/span>
a, ok := m["a"]    // 取�? �q����过ok(bool)判断key对应的元素是否存�?
delete(m, "a")    // 删除key对应的元�?

// �l�构体（struct�Q�就是一个字�D늚�集合�Q?nbsp;type 定义跟其字面意思相�W?/span>
type S struct {
    A int
    B, c string
}
type (
    A struct {
        s *S
    }
    B struct {
        A    // �l�合
    }
)
// �l�构体文法表�C�通过�l�构体字�D늚���g��为列表来新分配一个结构体�?/span>
var s S = S{0, "1", "2"}
// 使用 Name: 语法可以仅列出部分字�D�c��（字段名的��序无关。）
var s S = S{A: 0, B: "1"}
var s S = S{}
// �Ҏ��的前�~� & 构造了指向�l�构体文法的指针�?/span>
var s *S = &S{0, "1", "2"}

// 表达�?nbsp;new(T) 分配了一个零初始化的 T ��|���q�返回指向它的指�?/span>
var s *S = new(S)
// 有指针，但是没有指针�q�算�Q�结构体字段使用点号来访�?br />// �l�构体字�D�可以通过�l�构体指针来讉K��。通过指针间接的访问是透明�?/span>
fmt.Println(s.A)
fmt.Println((*s).A)

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

// TODO chanel

// TODO error

// if 语句 ���括�?nbsp;( )是可选的�Q��?nbsp;{ } 是必��ȝ���?/span>
if (i < 0)        // �~�译错误.
    println(i)

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

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

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

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

if i := 0; i < 0 {    // 使用gofmt格式化代码会自动�U�除代码中不必要的小括号( )
    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


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

// ���括�?nbsp;( )是可选的�Q��?nbsp;{ } 是必��ȝ���?/span>
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

// 函数可以没有参数或接受多个参�?/span>
func f() {}
func f(a int) {}
func f(a int, b byte) {}
func f(a int) {}    // 可变参数
func f(a int, b bool, c string) {}
// 函数可以�q�回��L��数量的返回�?/span>
func f() int {
    return 0
}
func f() int, string {
    return 0, "A"
}
// 函数�q�回�l�果参数�Q�可以像变量那样命名和���?/span>
func f() a int, b string {
    a = 1
    b = "B"
    return    // 或�?nbsp;return a, b
}

// 当两个或多个�q�箋的函数命名参数是同一�c�d���Q�则除了最后一个类型之外，其他都可以省�?/span>
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 �q�发
go func() {}

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

Go语言文�g操作

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

写程序离不了文�g操作�Q?/span>�q�里�ȝ��?/span>go语言文�g操作�?/span>

一、徏立与打开

建立文�g函数�Q?/p>

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

func NewFile(fd int, name string) *File

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

打开文�g函数�Q?/p>

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

二、写文�g

写文件函敎ͼ�

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"))         } }

三、读文�g

��L��件函敎ͼ�

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

��L��件示例代码：

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])         } }

四、删除文�?/span>

函数�Q?/span>

func Remove(name string) Error

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

goLang ��d��Int

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

windows下字节序和网�l�的相反

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 发表评论

亚洲高清中文字幕综合网,怡红院亚洲红怡院在线观看,亚洲人成网站18禁止一区

golang �?接口

golang定时定点��d��

golang append时slice len �?cap

golang slice分割和append copy�q�是引用

golang �? ��L��定长数组里的0 []byte �?string

golang�?windows下杀�q�程

golang slice Append

golang 定时

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

Go指针 new make

go原生数据效率

go对象序列化和反序列化

bson和json

golang �? bson �?struct 转换

Golang 异常处理

Panic和Recover

Panic

Recover

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

slice不是引用!

什么叫引用?

��Z��么slice不是引用?

��Z��么很多�h误以为slice是引用呢?

传指针和传引用是�{��h的吗?

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

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

�ȝ��

数组 Arrays

赋��g��使用

切片 Slices

赋��g��使用

Socket read write

Golang �c�d��转换整理

Golang �c�d��转换整理

golang strconv

golang strconv

golang html �?golang客户�?上传文�g 转蝲

golang html �?golang客户�?上传文�g

golang string rune len 可能不同

golang xml 处理

exec start

exec卡住了，��d��调用肯定卡住�?br />调用Startfunc (*Cmd) Run

func (*Cmd) Start

Golang语法与代码格式速记

Go语言文�g操作

goLang ��d��Int

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

exec卡住了，��d��调用肯定卡住�?br />调用Start

func (*Cmd) Run