够粉丝读书笔记

1：定义string字符串，返回的是指针

例子:

s := "hello"
if s[1] != 'e' { os.Exit(1) }
s = "good bye"
var p *string = &s
*p = "ciao"

下面的语句就是非法的.

s[0] = 'x'
(*p)[1] = 'y'

注意：

    1:string返回的是指针，但是这个值不能被修改。就像const char*

2：string和slice

package main

import (
         "fmt"
         "reflect"
)


func test(srcData []byte){
        fmt.Println(len(srcData))
        for i:=0;i<len(srcData);i++{
                srcData[i] = srcData[i] + 1;
        }
}


func main(){
        a := [10]byte{0x30,0x31,0x32}
        fmt.Println(a)
        test(a[0:]) // ok,数组转换成切片，传递的是引用
         //test(&a) // error,数组到底是啥类型
         var b interface{}
        b = a
        dd := reflect.ValueOf(b)
        fmt.Println(dd.Kind()) //结果是：array 。表明是一个数组
         b = &a
        gg := reflect.ValueOf(b)
        fmt.Println(gg.Kind())//结果是：ptr 。表明是一个指针。但是注意，是指向[10]byte的指针。不是我们理解的[]byte
        fmt.Println(a)
        

        var e1 […]int{1,1,2,3} //这个是一个数组，编译器会自动计算长度

        var e2 [10]int{1,2,2,3} //这个是数组 

        var e3 []int{1,2,3,4} //这个是一个切片

        var e4 [10]int{1,2,3,4}[0:]
}

注意：1：数组传参数给函数，一般使用切片。

      2：标准定义切片方法。s := make([]int, 3, 10);     //一个slice，有三个参数 类型、slice长度、slice底层的array长度，即slice的最大容量。

 3：数组一般用于切片里面真正存储数据的容器。传递一个数组的参数，是指传递。数组的尺寸是数组类型的一部分。[10]int [20]int 他们的类型完全不一样

 4:切片传递是引用类型。所以在go里面，尽量传递切片。

3：定义变量

import "fmt"

type student struct {
        a int
        b int
}


func sum(a *student){
        fmt.Println(a.a + a.b)
}

func main(){


        //定义一个变量
        var a student
        a.a = 123
        a.b = 333
        sum(&a)

        //定义一个变量，并且初始化
        d := student{a:123,b:3333}
        sum(&d)


        //new一个变量，返回的是指针
        b := new(student)
        b.a = 1
        b.b = 2
        sum(b)
}

 

4：常用风格以及易混淆点

a：golang里面不需要分号。只有在for和两行语句写在一行。但是地道的程序分号只会在for里面出现

b：golang里面if,for不需要()。但是需要{}。可以将多行语句写在if后，用分号分开.

c：不要把{}，左{单独写成一行

d：go里面循环语句只有for。但是for有不同的表现形式。

                    1)for init; condition; post { } //类似 C 的 for

                    2)for condition { } //类似 C 的 while

                    3)for { }   // 类似 C 的 for(;;)

 

5:.(type) 操作，通过一定的机制，可以知道这个变量的类型是多少。只能在switch里面使用。

package main
import "fmt"

func main(){
        var a int = 1000

        //switch b:a.(type){  //错误
        var d interface{} = a
        switch b:=d.(type){
                case int:
                        fmt.Println("type is int %T",b)
                case *int:
                        fmt.Println("type is *int,%T",b)
                default :
                        fmt.Println("type is unkown,%T",b)
        }
}

http://www.jmcneil.net/  这里有说明

更多通过变量得到这个数据类型，看reflect包.