|
|
置顶随笔
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)
}
2013年12月24日
package main
import (
"fmt"
"time"
)
var ch chan int = make(chan int, 1)
func main() {
go aaa()
select {
case <-ch: //拿到锁
fmt.Println("call")
case <-time.After(5 * time.Second): //超时5s
fmt.Println("5 sec call")
}
}
func aaa() {
time.Sleep(time.Second * 3)
ch <- 1
}
2013年12月22日
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)
2013年12月19日
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
}
2013年11月20日
声明: 源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)
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) }
2013年11月19日
index := bytes.IndexByte(buf_PN, 0) rbyf_pn := buf_PN[0:index]
2013年11月15日
c := exec.Command("taskkill.exe", "/f", "/im", "test.exe") err := c.Start()
2013年11月5日
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
2013年10月10日
// (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")
对亍非缓冲通道,“从通道接收数据”的操作
一定会在
“向通道发送数据”的操作完成前发生。
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
|