类型        长度     说明 bool         1      true/false,默认false, 不能把非0值当做true(不用数字代表true/false) byte         1      uint8 别名 rune         4      int32别名。 代表一个unicode code point int/unit            一来所运行的平台，32bit/64bit int8/uint8   1     -128 ~ 127; 0 ~ 255 int16/uint16 2     -32768 ~ 32767; 0 ~ 65535 int32/uint32 4     -21亿 ~ 21亿， 0 ~ 42亿 int64/uint64 8 。

  。

float32      4     精确到7位小数,相当于c的float float64      8     精确到15位小数,相当于c的double 。

complex64    8 complex128   16 。

uintptr            足够保存指针的32位、64位整数,指针(可以存指针的整数型) array              值类型,数组 struct             值类型,结构体 string             值类型,字符串类型，常用 slice              引用类型,切片 map                引用类型,字典 channel            引用类型,通道 interface          接口类型,接口 function           函数类型,函数 。

package main import "fmt" 。

  。

func main(){     a := 0x1234     b := 1234.56     c := 256 。

    fmt.Printf("%x\n", uint8(a))     fmt.Printf("%d\n", int(b))     fmt.Printf("%f\n", float64(c)) } 。

//第一种，指定变量类型，声明后若不赋值，使用默认值 var v_name v_type v_name = value 。

  。

//第二种，根据值自行判定变量类型 var v_name = value 。

//第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误. v_name := value 。

e.g. var a int = 10 var b = 10 c : = 10 。

package main var a = 1234 var b string = "hello" var c bool 。

  。

func main(){     println(a, b, c) } 。

//类型相同多个变量, 非全局变量 var vname1, vname2, vname3 type vname1, vname2, vname3 = v1, v2, v3 。

  。

var vname1, vname2, vname3 = v1, v2, v3 //和python很像,不需要显示声明类型，自动推断 。

vname1, vname2, vname3 := v1, v2, v3 //出现在:=左侧的变量不应该是已经被声明过的，否则会导致编译错误 。

//类型不同多个变量, 全局变量, 局部变量不能使用这种方式 var (     vname1 v_type1     vname2 v_type2 ) 。

package main 。

  。

var x, y int var (  //这种只能出现在全局变量中，函数体内不支持     a int     b bool ) 。

var c, d int = 1, 2 var e, f = 123, "hello" 。

//这种不带声明格式的只能在函数体中出现 //g, h := 123, "hello" 。

func main(){     g, h := 123, "hello"     println(x, y, a, b, c, d, e, f, g, h) } 。

    i := 0     i, l[i] = 1, 2     //get i = 1， l[0] = 2 。

  。

    sc[0], sc[0] = 1, 2     //get sc[0] = 2 。

    func test()(int, string) {         return 123, "abc"     } 。

  。

    a, _ := test() 。

const constantName = value const Pi float32 = 3.1415926 。

  。

const c_name [type] = value const c_name1, c_name2 = value1, value2 const (     c_name1 = vluae1     c_name2 = value2 ) 。

=右侧，必须为常量或常量表达式，如果使用到了函数，必须为内置函数（编译期行为） 。

const i = 10000 。

A.常量必须是编译期能确定的Number(char/integer/float/complex)、String和bool 。

  。

B.在定义常量数组时，如果不提供初始化值，则表示与上行常量类型，值，完全相同 。

    const (         a = "abc"         b     )     //则 b = "abc" 。

C.常量可以用len(), cap(), unsafe.Sizeof()常量计算表达式的值.  常量表达式中，函数必须是内置函数，否则编译不过 。

    package main 。

    import "unsafe"     const (         a = "abc"         b = len(a)         c = unsafe.Sizeof(a)     ) 。

    func main(){         println(a, b, c)     } 。

结果：    abc 3 16 。

const (     a = 1     b = 2 ) 。

  。

const (     a = iota //0     b  //1     c  //2 ) 。

const (     _ = iota     a    //1     b    //2 ) 。

func main() {     const (             a = iota  //0             b   //1             c   //2             d = "ha"  //独立值，iota += 1             e    //"ha"   iota += 1             f = 100    //iota +=1             g     //100  iota +=1             h = iota  //7,恢复计数             i      //8     ) 。

  。

} 。

const (     x = iota // 0     y = iota // 1     z = iota // 2     w //省略，默认和前面一样字面值   w = iota, 即3 ) const v = iota //遇到const关键字，iota重置 。

func main() {     println(A,B,C,D,E,F) } 。

  。

//结果： 0 0 1 1 2 2   【各自增长】 。

package main 。

  。

func main(){     i := 1     i ++     println(i) 。

    b := i     println(b) 。

    //syntax error: unexpected ++, expecting semicolon or newline or }     //c := i++     //意味着, ++/--不能出现在等号右侧 } 。

package main import "fmt" 。

  。

type User struct {     Id int     Name string } func main(){     i := 100     var p *int = &i  //取地址 。

    println(*p)   //取值 。

    up := &User{1, "Jack"}     up.Id = 100  //直接取只针对想成员     fmt.Println(up) 。

    u2 := *up  //拷贝对象     u2.Name = "Tom"     fmt.Println(up, u2) } 。

import (     "fmt"     "os" ) 。

  。

const (     i = 100  //首行必须有常量表达式     pi = 3.1415 ) 。

var (  //全局变量可用，函数体内不支持     i int     pi float32 ) 。