最近又打算玩玩golang，打算把工作中的爬虫从脚本语言迁移到golang，读了两本golang的书，对语法做了一个简单的整理。
编程语言的选择
0 业务的要求
1 性能
2 表达能力
3 是否容易上手
4 坑和维护
变量
变量的声明
var xx type 或者 var (xx type xxx type)
初始化
var v1 i = 10; var v2 = 10; v3 := 10
交换值
i,j = j,i
多个值
_,a = 11,34
常量
const pi float32 = 1.2
const zero = 11
const( a1 int32 = 11; a2 = 11;)
const a2 = 1 << 2
预定义常量
const( c0=iota;c1=iota;c2=iota;)//iota 值自动增加
const (a = 1 << iota; b ; c;)
枚举
const( day1=iota;day2;day3;day4;)
类型
bool
var b1 bool = true; b2 := (1 == 2);
int8,byte int16 int unit unitptr int32 unit32 int64 unit64 int unit
整型是不同的，数值运算，比较运算，位运算
float32 float64
var f1 float32 = 11.1;
不能直接比较大小，可以计算减法比较
complex64 complex128
com1 := 3+12i; 实部real(com1); 虚部imag(com1)
string
str1 := "hi"; len(str1);str1[0];
字符串的运算
加 x+y
长度 len(s)
取字符 s[i]
字符串的遍历
for k,v := range str{
fmt.Println(k,v);
}
rune字符类型
byte,uint8的别名，一个是rune 代表unicode字符
unicode/utf8包提供utf-8和unicode的转换
指针 pointer
数组 array
[32]int;[2*N]struct{x,y int32};[3][5]int
长度 alen := len(arr)
遍历 下标遍历，range遍历，
数组是值类型，传递是拷贝
切片 slice
创建切片 arr[a:b]; make([]int,len,cap);
遍历 小标遍历，range遍历
常用函数 len长度 cap容量
可以基于切片创建切片
新增元素 slice=append(slice,11)
内容复制 copy(slice1,slice2);
字典 map
创建字典 make(map[string]int,len)
赋值 map1[key] = val1
查找字典 p,ok := map1[key1]
删除 delete(map1,"k1")
通道 chan
结构体 struct
接口 interface
error
流程语句
选择
if,else 和else if
if xxx{
}else{
}
switch
switch xx{
case 1:
fallthrough
case 2:
default:
}
select
循环
for
for{}
for a;b;c;{}
break 跳出循环
continue 继续
range 循环
跳转
HERE:
goto HERE
init()函数main前调用
函数
func (t *R) funcname(a type,b type)(ret type, err error){
return a,nil
}
函数返回nil比较多
调用 a:= funcname(a,b); a:= FTT.funcname(a,b);
不定参数 func funcname2(arg ...int){
funcname3(arg...)
}
任意参数 func funcname3(args ...interface{})
匿名函数
func(x,y int)int{
return x+y
}
//调用匿名函数
func(x,y int)int{
print(x,y)
}(1,2)
闭包：
j :=3;
func()(func()){
var i int = 1;
return fun(){
fmt.Printf("i,j:%d,%d\n",i,j);
}
}()
获取数据的类型
xxx.(type)
nil
代表空
defer和panic 错误处理
error的定义
type error interface{
Error() string
}
defer 延后处理
例如defer func(){}()
panic() 和recover()
panic()释放错误
defer func(){
if r:= recover();r!=nil{
log.Printf("xxx");
}
}()
import
相对路径 import "./xx"
绝对路径 import "xx/xx"
点导入 import . "math" 可以直接 sqrt()
别名 import f fmt 可以f.printf(xxx)
_操作 _"github.com/xxx" 引用包不是直接调用函数，而是使用了包里面的init方法
go的类型系统
基础类型 byte int bool float
符合类型 数组，结构体，指针
任意类型 interface{}
值和引用语义
面向对象
接口
go 里面有引用语义的
切片，map，channel，接口
结构
type A struct{
stat int
}
func ( a A) add(a1 int,b1 int ) int{
return a1+b1
}
初始化
a1 := new(A)
a2 := &A{}
a3 := &A{1}
a4 := &A{stat:1}
自建构造函数
func NewA(stat int){
return &A{stat}
}
匿名组合
type B struct{
A
}
type B struct{
*A
}
可见性
通过大小写控制
接口
type Read interface{
Reader(buf []byte)(n int,err error)
}
type FileReader struct{
int xx;
}
实现接口
func (fr *FileReader)Reader(buf []byte)(n int,err error){
return 1,nil
}
接口的赋值
对象赋值给接口通过引用
file_reader := new(FileReader);
var b Read = file_reader
将接口赋值给接口
只需要一个是另外一个的子集即可，反过来不成立
IA > IB IA = IB
接口查询
检查是否实现了接口
if xx,ok := file_reader.(Read);ok{
}
接口组合
type interface1 interface{
read()(n int,err error)
}
type interface2 interface{
write()(n int,err error)
}
type interface3 interface{
interface1
interface2
}
任意类型
interface{}
类型查询
switch v:= v1.(type){
case xx1:
case xx2:
case xx3:
}
并发
通过go实现
main方法调用go的方式
1 主线程睡眠 2 使用管道等待 3 for或者select死循环
管道的声明
ch := make(chan int)
管道写入数据
ch <- value
管道数据写入变量
value := <-ch
select
go在语言级别支持select
select{
case <-chan1://chan1读取数据执行下面
case chan2 <- 1: chan2读取成功
default:默认流程
}
缓冲机制-自带线程池
c :=make(chan int,1023)
for i:= range c{
printf("receiverd: ",i);
}
超时机制
1 定义一个chan运行，到时间写即可，可以使用select来实现
2 也可以 使用 time.After(5.time.Second)
传递性
可以通过chan传递数据
type PipeData struct {
value int
handler func(int) int
next chan int
}
func handle(queue chan *PipeData) {
for data := range queue {
data.next <- data.handler(data.value)
}
}
单向管道
读写 var ch1 chan int
写 var ch2 chan<- float32
读 var ch2 <-chan int
关闭管道
close(ch)
多核化
cpu个数的管道
Gosched让出时间片
同步
sync.Mutex
sync.RWMutex
全局唯一操作
var once sync.Once
once.Do(xxx)
go并发相关函数：
Goexit 退出去
Gosched 让出执行权限
NumCPU cpu核数量
NumGoroutine 执行和排队的携程数
GOMAXPROCES 核心数
反射
t := reflect.TypeOf(i) //得到类型的元数据,通过t我们能获取类型定义里面的所有元素
v := reflect.ValueOf(i) //得到实际的值,通过v我们获取存储在里面的值,还可以去改变值
转化为reflect对象之后我们就可以进行一些操作了,也就是将reflect对象转化成相应的值,例如
tag := t.Elem().Field(0).Tag //获取定义在struct里面的标签
name := v.Elem().Field(0).String() //获取存储在第一个字段里面的值
访问mysql数据库
package main
import (
_ "github.com/Go-SQL-Driver/MySQL" "database/sql"
"fmt"
//"time"
)
func main() {
db, err := sql.Open("mysql", "astaxie:astaxie@/test?charset=utf8") checkErr(err)
//插入数据
stmt, err := db.Prepare("INSERT userinfo SET username=?,departname=?,created=?") checkErr(err)
res, err := stmt.Exec("astaxie", "研发部门", "2012-12-09") checkErr(err)
}
使用redis
package main
import (
"github.com/astaxie/goredis" "fmt"
)
func main() {
var client goredis.Client
client.Set("a", []byte("hello")) val, _ := client.Get("a") fmt.Println(string(val)) client.Del("a")
//list操作
var client goredis.Client
vals := []string{"a", "b", "c", "d", "e"}
for _, v := range vals {
client.Rpush("l", []byte(v))
}
dbvals,_ := client.Lrange("l", 0, 4)
for i, v := range dbvals {
println(i,":",string(v)) }
client.Del("l")
}
操作xml
package main
import (
"encoding/xml"
"fmt"
"io/ioutil"
"os"
)
type Recurlyservers struct {
XMLName xml.Name `xml:"servers"`
Version string `xml:"version,attr"`
Svs []server `xml:"server"`
Description string `xml:",innerxml"`
}
type server struct {
XMLName xml.Name `xml:"server"`
ServerName string `xml:"serverName"`
ServerIP string `xml:"serverIP"`
}
func main() {
file, err := os.Open("servers.xml") // For read access.
if err != nil {
fmt.Printf("error: %v", err)
return
}
defer file.Close()
data, err := ioutil.ReadAll(file)
if err != nil {
fmt.Printf("error: %v", err) return
}
v := Recurlyservers{}
err = xml.Unmarshal(data, &v) if err != nil {
fmt.Printf("error: %v", err)
return
}
fmt.Println(v)
}
正则表达式
func Match(pattern string, b []byte) (matched bool, error error)
func MatchReader(pattern string, r io.RuneReader) (matched bool, error error)
func MatchString(pattern string, s string) (matched bool, error error)
解析正则
func Compile(expr string) (*Regexp, error)
func CompilePOSIX(expr string) (*Regexp, error)
func MustCompile(str string) *Regexp
func MustCompilePOSIX(str string) *Regexp
查找
func (re *Regexp) Find(b []byte) []byte
func (re *Regexp) FindAll(b []byte, n int) [][]byte
func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int
func (re *Regexp) FindIndex(b []byte) (loc []int)
func (re *Regexp) FindSubmatch(b []byte) [][]byte
func (re *Regexp) FindSubmatchIndex(b []byte) []int
模板处理
html/template"
文件处理
目录
文件操作的大多数函数都是在os包里面,下面列举了几个目录操作的:
func Mkdir(name string, perm FileMode) error
创建名称为name的目录,权限设置是perm,例如0777
func MkdirAll(path string, perm FileMode) error
根据path创建多级子目录,例如astaxie/test1/test2。
func Remove(name string) error
删除名称为name的目录,当目录下有文件或者其他目录是会出错
func RemoveAll(path string) error
根据path删除多级子目录,如果path是单个名称,那么该目录不删除。
文件
func Create(name string) (file *File, err Error)
根据提供的文件名创建新的文件,返回一个文件对象,默认权限是0666的文件,返回的文件对象是可读写
func NewFile(fd uintptr, name string) *File
根据文件描述符创建相应的文件,返回一个文件对象
打开
func Open(name string) (file *File, err Error)
该方法打开一个名称为name的文件,但是是只读方式,内部实现其实调用了OpenFile。
func OpenFile(name string, flag int, perm uint32) (file *File, err Error)
名字，方式，权限
写
func (file *File) Write(b []byte) (n int, err Error)
写入byte类型的信息到文件
func (file *File) WriteAt(b []byte, off int64) (n int, err Error)
在指定位置开始写入byte类型的信息
func (file *File) WriteString(s string) (ret int, err Error)
写入string信息到文件
读
func (file *File) Read(b []byte) (n int, err Error)
func (file *File) ReadAt(b []byte, off int64) (n int, err Error)
字符串处理
字符串操作
func Contains(s, substr string) bool
func Join(a []string, sep string) string
func Index(s, sep string) int
func Replace(s, old, new string, n int) string
func Repeat(s string, count int) string
func Split(s, sep string) []string
func Trim(s string, cutset string) string
func Fields(s string) []string
字符串转换
str := make([]byte, 0, 100)
str = strconv.AppendInt(str, 4567, 10)
str = strconv.AppendBool(str, false)
str = strconv.AppendQuote(str, "abcdefg")
str = strconv.AppendQuoteRune(str, '单')
a := strconv.FormatBool(false)
b := strconv.FormatFloat(123.23, 'g', 12, 64)
c := strconv.FormatInt(1234, 10)
d := strconv.FormatUint(12345, 10)
e := strconv.Itoa(1023)
a, err := strconv.ParseBool("false")
if err != nil {fmt.Println(err) }
b, err := strconv.ParseFloat("123.23", 64)
if err != nil {
fmt.Println(err) }
c, err := strconv.ParseInt("1234", 10, 64)
if err != nil {
fmt.Println(err)
}
d, err := strconv.ParseUint("12345", 10, 64)
if err != nil {
fmt.Println(err)
}
e, err := strconv.Itoa("1023")
if err != nil {
fmt.Println(err)
}
fmt.Println(a, b, c, d, e) }
websocket
"code.google.com/p/go.net/websocket" 服务
gdb调试
日志系统
seelog
部署
daemon
性能监控
net/http/pprof
runtime/pprof
常用的库
net包
socket 库
Dial(net,addr string)(Conn,error)
conn,err := net.Dial("tcp","127.0.0.1:8888")
conn,err := net.Dial("udp","127.0.0.1:8888")
conn,err := net.Dial("ip4:icmp","www.baidu.com")
conn,err := net.Dial("ip4:1","10.113.1.103")
目前支持的协议：
tcp tcp4 tcp6 udp upd4 udp6 ip ip4 ip6
dial实际上是对函数的封装
func DialTCP(net string, laddr, raddr *TCPAddr) (c *TCPConn, err error)
func DialUDP(net string, laddr, raddr *UDPAddr) (c *UDPConn, err error)
func DialIP(netProto string, laddr, raddr *IPAddr) (*IPConn, error)
func DialUnix(net string, laddr, raddr *UnixAddr) (c *UnixConn, err error)
http库，net/http包
func (c *Client) Get(url string) (r *Response, err error)
func (c *Client) Post(url string, bodyType string, body io.Reader) (r *Response, err error)
func (c *Client) PostForm(url string, data url.Values) (r *Response, err error)
func (c *Client) Head(url string) (r *Response, err error)
func (c *Client) Do(req *Request) (resp *Response, err error)
http服务端编程
http.Handle("/foo", fooHandler)
http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
}
)
log.Fatal(http.ListenAndServe(":8080", nil))
或者是
s := &http.Server{
Addr:":8080",
Handler:myHandler,
ReadTimeout:10 * time.Second,
ReadTimeout:10 * time.Second,
MaxHeaderBytes: 1 << 20,
}
log.Fatal(s.ListenAndServe())
https有点不同
log.Fatal(http.ListenAndServeTLS(":10443", "cert.pem", "key.pem", nil))
RPC
net/rpc直接支持
服务端
arith := new(Arith)
rpc.Register(arith) rpc.HandleHTTP()
l, e := net.Listen("tcp", ":1234") if e != nil {
log.Fatal("listen error:", e)
}
go http.Serve(l, nil)
客户端
client, err := rpc.DialHTTP("tcp",
serverAddress + ":1234") if err != nil {
log.Fatal("dialing:", err)
}
args := &server.Args{7,8}
var reply int
err = client.Call("Arith.Multiply", args, &reply)
if err != nil {
log.Fatal("arith error:", err)
}
fmt.Printf("Arith: %d*%d=%d", args.A, args.B, reply)
Gob
Gob 是 Go 的一个序列化数据结构的编码解码工具
json处理
压缩一个数据，放到另外一个数据里面
func Marshal(v interface{}) ([]byte, error)
func Unmarshal(data []byte, v interface{}) error