-
学过C,python,或者Java之类语言再来学习golang应该是无压力，看看语法就能写。语法上比较特殊的如下：
-
声明变量并赋值使用 ：=
a,b ：= 1,2 //声明变量a,b，并且赋值1,2
a = 2 //a赋值2
-
if 不需要圆括号，并且可以执行表达式.for语句类似
if x:=1; x<2 {
}
-
String()函数<同java的toString(),对象的字符串形式>中如果有对自身的"%s"操作，将导致无穷递归调用。因为"%s"会调用String(),将对象转化为字符串形式。
type MyString string
func (m MyString) String() string {
return fmt.Sprintf("MyString=%s",m) // Error: will recur forever.
return fmt.Sprintf("MyString=%s",string(m)) // OK: note conversion. }
string(m)将m转化为一个String对象，然后“%s”是作用在该String对象上，不是m本身，所以不回导致无穷递归
-
defer有点finally的味道，但是又有不同
for i := 0; i < 5; i++ {
defer fmt.Printf("%d ",i)
}
Deferred functions are executed in LIFO后进先出<栈> order,so this code will cause 4 3 2 1 0
func trace(s string) string {
fmt.Println("entering:",s)
return s
}
func un(s string) {
fmt.Println("leaving:",s)
}
func a() {
defer un(trace("a"))
fmt.Println("in a")
}
func b() {
defer un(trace("b"))
fmt.Println("in b")
a()
}
func main() {
b()
} The arguments to the deferred function (which include the receiver if the function is a method) areevaluated when the defer executes,not when the call executes.
defer语句执行时，立即计算被defer的函数所需要的所有参数，而不是等到被defer的函数执行才计算该函数的参数。结果如下
entering: b
in b
entering: a
in a
leaving: a
leaving: b
-
new and make
new(T) returns a pointer to a newly allocated zero value of type T。new适合初始化0值对象，new(File) and &File{} are equivalent。new([]int) returns a pointer to a newly allocated,zeroed slice structure,that is,a pointer to a nil slice value.
make(T,args) creates slices,maps,and channels only,and it returns an initialized (not zeroed) value of type T (not *T)
-
Arrays
Arrays are values. Assigning one array to another copies all the elements. 数组不是引用，是值，数组a赋值给b,直接拷贝成另一份b，结果是数组a,b独立，内容相同
In particular,if you pass an array to a function,it will receive a copy of the array,not a pointer to it. 数组作为参数，传递的也是整个数组的值的拷贝，而不是指针
以上两点与C语言不同，每次拷贝数组代价昂贵，如果希望类似C语言，可以传递指针。
-
Slices
Slices行为才与C的数组一致，是指针传递。Slices更常用。Slices底层是数组，只要不超过底层数组的容量，Slices地址不变。一旦添加元素导致超过底层数组的容量，就会reallocated重新分配。默认底层数组容量为cap(slice)。
-
特殊语法...(三个点的省略号)
x := []int{1,2,3}
y := []int{4,5,6}
x = append(x,y...)//去掉...报错，因为y不是int类型
fmt.Println(x)//有点类似Python对于字典**dict
-
init函数
每个源代码文件都可以有一个init函数，在该源代码文件的import语句执行完后，并且变量调用其initializers后执行init函数。一般用于检查该文件中的各种状态是否正确
-
import for side effect
有时候import一个library，并不是为了使用某个函数或者类，仅仅只是希望该library的init函数执行一次，做一下准备工作：
import _ "net/http/pprof"//during its init function,the net/http/pprof package registers HTTP handlers that provide debugging information
-
Channel
管道常用于goroutine之间的通信，同步；Go不推荐使用共享内存，互斥元等方式通信。管道用于goroutine同步例子：
c := make(chan int) // 初始化一个不带缓存的管道
go func() {
list.Sort()
c <- 1 // Send a signal; value does not matter.
}()
//新起一个goroutine，去做排序，排序完后向管道写入数据
doSomethingForAWhile()
<-c // 阻塞等待管道有数据写入，即等待上面goroutine排序完成
管道用作semaphore（信号量）,比如限流，例子：
var sem = make(chan int,100)
func Serve(queue chan *Request) {
for req := range queue {
tmp := req // Create new instance of req for every goroutine.
sem <- 1 //信号量满时写入阻塞
go func() {
process(tmp)
<-sem //处理完一个请求释放一次信号量
}()
}
} 由于管道sem分配了buffer，size为100.所以前100个请求，可以不阻塞立即得到执行。后面的请求必须排队等待前面100个请求当中，有请求处理完毕(管道中有数据被读出)，才能写入管道，得到处理。所以，这个例子，管道起到限流作用：并行处理的请求数不得超过100
-
panic recover
Go的异常处理机制,同try...except...
Because recover always returns nil unless called directly from a deferred function,deferred code can call library routines that themselves use panic and recover without failing.
func safelyDo(work *Work) {
defer func() {
if err := recover(); err != nil {
log.Println("work failed:",err)
}
}()
do(work)
} do函数里出了panic异常,执行deferred函数func,func函数里，调用recover捕获异常。
