Go语言学习杂记

=Start=

缘由：

到现在为止接触Go这门语言也快2个月了，但还没用过Go写过什么比较大的程序/项目（也许以后会有机会吧？）这期间也因为工作较忙的缘故，看书学习Go也是断断续续的，只是会在没事的时候去网上找找不错的Go语言代码来看、记录一些不错的小技巧什么的，时间长了，没有输出，进一步学习Go语言的热情有点减弱，所以，觉得该在博客中记录些什么，让自己保持这份热情；所以在参考其它文章的基础上，掺杂点自己的记录，就有了此文。

杂记：

#开发环境和工具

说明：在升级Go之前，必须先移除旧的版本。

开发环境配置

下载、解压、安装设置：

$ wget https://storage.googleapis.com/golang/go1.5.1.linux-amd64.tar.gz
$ sudo tar -C /usr/local -xzf go1.5.1.linux-amd64.tar.gz

$ mkdir -p $HOME/go_space #在$HOME下新建一个目录作为Go项目的工作目录
$ vim ~/.profile
++++
export GOROOT=/usr/local/go
export GOPATH=$HOME/go_space
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
++++
$ source ~/.profile

涉及到的环境变量说明：

GOROOT: go的安装目录。
GOPATH: go的工作目录，所有通过go get下载的第三方库都会位于该目录下。

一些工具

go get $url
godoc -http=:8000

go help doc
go doc regexp #查看regexp这个package的文档信息
go doc regexp/syntax #查看regexp/syntax这个package的文档信息
go doc regexp.FindString #查看regexp.FindString这个method的文档信息

godoc builtin	#查看相应的package文档
godoc net/http	#查看相应的package文档

godoc fmt Printf		#查看fmt.Printf包里面的函数
godoc -src fmt Printf	#查看fmt.Printf的代码
godoc -help				#查看 godoc 帮助

go build filename.go
go run filename.go
go test -help

go tool pprof	#性能调试工具

gofmt -w src	#格式化整个Go项目
find . -name "*.go" | xargs gofmt -w	#格式化Go代码

可以用gdb调试go程序，因为Go默认编译选项就会生成调试信息，其他基本和调试C++程序类似，更多内容见文章：Debugging Go Code with GDB

#语法小结

初始化默认零值

boolean: false
integer: 0
float: 0.0
string: “”
pointer, function, interface, slice, channel, map: nil

字符串

一个Go语言字符串是一个任意字节的常量序列。Go语言的字符串类型在本质上就与其他语言的字符串类型不同。Java的String、C++的std::string以及Python 3的str类型都只是定宽字符序列，而Go语言的字符串是一个用UTF-8编码的变宽字符序列，它的每一个字符都用一个或多个字节表示。

Go语言中的字符串字面量使用「双引号」或「反引号」来创建。

数组和切片

intSlice := []int{1, 2, 3}
intArray := [3]int{1, 2, 3}

上面的代码中，intSlice是长度和容量均为3的slice，intArray是长度为3的数组。

切片的创建方式：

make([]Type, length, capacity)
make([]Type, length)
[]Type{}
[]Type{value1, value2, ..., valueN}	#用这种语法创建切片时可以进行初始化操作

二维数组和切片的初始化

func 2d_array_slice() {
	// Initialize a 2D array
	var grid [6][3]int
	fmt.Println(grid)
	// [[0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0]]

	// Another way to initialize 2D array
	gridB := [6][3]int{}
	fmt.Println(gridB)
	// [[0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0]]

	// Initialize a slice of empty slices
	gridC := make([][]int, 6)
	fmt.Println(gridC)
	// [[] [] [] [] [] []]
	for i := 0; i < len(gridC); i++ {
		gridC[i] = make([]int, 3)
	}
	fmt.Println(gridC)
	// [[0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0]]
}

slice和append

使用append时，如果slice的容量(即对应array的长度)不够，Go会创建一个新的array(长度通常为之前的两倍)以容纳新添加的数据，所有旧的array数据都会被拷贝到新的array里。当频繁使用append时，需要考虑到其效率问题。

// 如果append之前已经知道长度，可以：
intSlice := make([]int)
for i := 0; i < length; i++ {
    intSlice = append(intSlice, i)
}

// 当然，最好是不用append:
intSlice := make([]int, 0, length)
for i := 0; i < length; i++ {
    intSlice[i] = i
}

映射

映射的创建方式：

make(map[keyType]valueType, initCapacity)
make(map[keyType]valueType)
map[keyType]valueType{}
map[keyType]valueType{key1: value1, key2: value2, ..., keyN:valueN}	#用这种语法创建映射时可以进行初始化操作

根据key取value的值：

value, found := aMap[key]

上面的代码中，value是映射中key对应的值的拷贝。如果不使用第二个参数found，如下：

value := aMap[key]

则当key不存在时，value被初始化为对应的零值。

函数和方法

函数：

func Getwd() (dir string, err error)
func Hostname() (name string, err error)

方法：

func (f *File) Read(b []byte) (n int, err error)
func (f *File) Stat() (FileInfo, error)

type File struct {
        // contains filtered or unexported fields
}

方法和函数的异同

方法是作用在自定义类型的值上的一类特殊函数，通常自定义类型的值会被传递给该函数。
该值可以以指针或者值的形式进行传递，这取决于方法是如何定义的。定义方法的语法几乎等同于定义函数，除了需要在 func 关键字和方法名之间写上接收者(放在括号中)之外。

变参函数

所谓可变参数函数就是指函数的最后一个参数可以接受任意个参数。这类函数在最后一个参数的类型前面添加有一个省略号。在函数里面这个参数实质上变成了一个对应参数类型的切片。

任意个int型参数的函数		func MinimunInt0(ints ...int) int {}
至少需要一个int型的参数	func MinimunInt1(first int, rest ...int) int {}
至少需要两个int型的参数	func MinimunInt2(first, second int, rest ...int) int {}

init() 和 main() 函数

一个package里可以有很多 init() 函数，但是一个Go程序有且只能有一个 main() 函数。

init() 和 main() 函数是自动执行的，且 init() 函数先于 main() 函数执行。

接口

在Go语言中，接口是一个自定义类型，它声明了一个或者多个方法签名。
接口是完全抽象化的，因此不能将其实例化。然而可以创建一个其类型为接口的变量，它可以被赋值为任何满足该接口类型的实际类型的值。

值传递

Go语言中函数的参数都是通过值传递的！As in all languages in the C family, everything in Go is passed by value.

引用类型

Go语言中的引用类型：映射、切片、通道、函数和方法。在发生值拷贝时，被拷贝的仅仅是指向实际数据的指针。

Go语言中的指针

Go语言提供了两种创建变量的语法，同时获得指向它们的指针。
一种方法是使用内置的 new() 函数；另一种方法是使用地址操作符 & 。new(Type) == &Type{}

Go语言不提供指针的运算操作。

使用指针的好处在于：值在传递给函数或者方法的时候会被复制一次。因此按值传递布尔变量、数值类型、字符串(Go语言中的字符串是不可变的，因此可以进行优化) 时会比较廉价。但是在传递大数组的时候代价会非常大。这个时候可以考虑切片(引用)。通过使用指针，我们可以让参数的传递成本最低并且内容可修改，而且还可以让变量的生命周期独立于作用域。指针是指保存了另一个变量内存地址的变量。（引用，也即保存指针的变量）

Go语言中的并发

Go语言中的并发是通过goroutine来实现的。

goroutine是程序中与其他goroutine完全相互独立而并发执行的函数或者方法调用。每一个程序至少包含一个goroutine，即会执行main包中的main()函数的主goroutine。所有的goroutine共享相同的地址空间，同时Go语言提供了锁原语来保证数据能够安全的跨goroutine共享。然而，Go语言推荐的并发方式是通信(通道channel)，而非共享数据。

#常见问题

赋值操作符

使用赋值操作符「:=」需要注意的地方：

左边的成员至少要有一个是未声明的变量。
已声明的变量，在同一作用域内，变量值被改写。
如果已声明的变量作用域在外层，则定义一个新的同名变量，会屏蔽外层的变量。

for…range

for k, v := range myMap {
    log.Printf("key=%v, value=%v", k, v)
}

for v := range myChannel {
    log.Printf("value=%v", v)
}

for i, v := range myArray {
    log.Printf("array value at [%d]=%v", i, v)
}

// `range` on strings iterates over Unicode code points.
// The first value is the starting byte index of the `rune` and the second the `rune` itself.
for i, c := range "go" {
    fmt.Println(i, c)
}

defer

defer语句用于延迟一个函数或者方法(或者当前所创建的匿名函数)的执行，它会在外围函数或者方法返回之前但是其返回值(如果有的话)计算之后执行。
如果一个函数或者方法中有多个defer语句，它们会以LIFO(Last in First out)的顺序执行。

package main

import "fmt"

func main() {
	defer fmt.Println("world")
	fmt.Println("hello")
}

#其它问题

#一些例子

/*
简单(并发)端口扫描器
https://golang.org/pkg/sync/#WaitGroup
https://phpinfo.me/2015/06/24/958.html
*/
package main

import (
	"fmt"
	"net"
	"os"
	"runtime"
	"sync"
)

func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())
	if len(os.Args) != 2 {
		fmt.Fprintf(os.Stderr, "Usage: %s ip/host\n", os.Args[0])
		os.Exit(1)
	}
	ip := os.Args[1]
	fmt.Println("[+]Scaning", ip)

	ports := []string{"80", "443", "8080", "8009", "3306", "21", "22", "6379", "27017", "11211", "3389", "1433"}
	wg := sync.WaitGroup{}
	wg.Add(len(ports))
	for _, port := range ports {
		go ScanPort(ip, port, &wg)
	}
	wg.Wait()
	fmt.Println("[+]Stop", ip)
}

func ScanPort(ip, port string, wg *sync.WaitGroup) {
	socket := ip + ":" + port
	_, err := net.Dial("tcp", socket)
	if err != nil {
		fmt.Println("[-]", port, "Close")
	} else {
		fmt.Println("[+]", port, "Open")
	}
	wg.Done()
}

参考链接：

=EOF=

26 11 月, 2015

admin

KnowledgeBase, Programing, Tools

Go, golang, tips