GO语言总结(2)——基本类型

　　上篇博文总结了Go语言的基础知识——GO语言总结(1)——基本知识  ，本篇博文介绍Go语言的基本类型。

1、整型

　　go语言有13种整形，其中有2种只是名字不一样，实质是同样的，因此，实质上go语言有11种整形。以下：

　　（1）int ：　　依赖不一样平台下的实现，能够是int32或int64

　　（2）int8 :　　　　　　　　　　  (-128　　->　　127)

　　（3）int16: 　　　　　　　　　　(-32768　　->　　32767)

　　（4）int32:　　　　　　　　　　 (-2 147 483 648　　->　　2 147 483 647)

　　（5）int64 :　　　　　　　　　　(-9 223 372 036 854 775 808　　->　　9 223 372 036 854 775 807)

 

　　（6）unit :　　　　　　　　　　 依赖不一样平台下的实现，能够是int32或int64

　　（7）unit8 (又名byte):　　　　  (0　　->　　255)

　　（8）unit16 :　　　　　　　　   (0　　->　　65535)

　　（9）unit32 (又名rune):　　　   (0　　->　　4 294 967 295)

　　（10）unit64 :　　　　　　　　 (0　　->　　18 446 744 073 709 551 615)

 

　　（11）unitptr : 　　　　　　　　刚好容纳指针值的类型，对32位平台是unit32，对64位平台是unit64

　　（PS :　值得注意的是，go语言中没有自动类型转换，这意味着，除了上篇博文分析的比较运算符以外，其余的操做符基本须要类型转换，才能进行操做。不然就是编译错误）

 

2、浮点类型

　　go语言有2种类型的浮点和两种类型的复数类型。

　　（1） float32　　　　　　　　(-3.402...×10³⁸->　　3.402...×10³⁸)

　　（2） float64　　　　　　　　(-1.797...×10³⁰⁸->　　+1.797...×10³⁰⁸)

　　（3） complex64　　　　　　( 实部、虚部都是一个float32 )

　　（4） complex128　　　　　 ( 实部、虚部都是一个float64 )

　　（PS：标准库math包中，包含了众多数学函数，其中全部函数均使用float64，

　　　　标准库math/cmplx包含众多复数相关的数学函数,其中全部函数均使用complex128）

　　（PPS : 跟数学中同样，Go语言使用后缀 i 表示复数,例如 5 + 5.1i ）

      

3、字符串

　　Go语言的字符串是用UTF-8编码的变宽字符序列，每一个字符都用一个或多个字节表示。这与Java不一样，Java是采用UTF-16来表示，每一个字符都对应2个字节。

　　（1）建立：一种是用双引号（"）括起来，它表示可解析的字符串，能够进行字符转义。另外一种是用单引号（'）括起来，它表示原生的字符串，能够包含除反引号以外的任何字符，固然也能够换行。以下：　

func test1() {
    str1 := "\"it's me!\""
    str2 := `"it's me,too"`
    fmt.Println(str1)
    fmt.Println(str2)
}

输出为：

"it's me!"
"it's me,too"

　　（2）Go语言的字符串支持 “+=”操做，能够经过[n]获取索引处的原始字节、经过[n:m]、[n:]、[:m]来获取字节对应的字符串，若字符被截段，显示乱码。如：

func test1() {
    str1 := "Go语言的字符串是用UTF-8编码的变宽字符序列，每一个字符都用一个或多个字节表示。"
    fmt.Println(str1[4:15])
    fmt.Println(str1[5:15])
    fmt.Println(str1[5])
    fmt.Println(str1[:5])
    fmt.Println(len(str1))         //字节数
    fmt.Println(len([]rune(str1))) //字符数
}

输出为 ：

�言的字�
言的字�
232
Go语
109
41

　　（3）字符串支持常规的比较运算符操做，比较运算符在内存中一个字节一个字节的比较字符串。固然了，这个比较是按照utf-8编码的顺序进行比较的。

　　（4）上例的最后一个取字符数的操做：len([]rune(str1))，在Go语言中，一个字符串能够能够用一个rune（又名int32）数组来表示，每一个rune都表示一个单一的字符。如：

func test1() {
    str1 := "Go语言的字符串是用UTF-8编码的变宽字符序列，每一个字符都用一个或多个字节表示。"
    for _, char := range []rune(str1) {
        fmt.Println(char)
    }
}

这个操做会将str1的每一个字符数字直接打印出来

 

4、指针

（1）指针的本质，用一个简单例子说明一下:

func test2() {
    a := "xyz"
    b := "opq"
    pa := &a  //pa为指向a的指针
    pp := &pa //pp为指向pa的指针
    fmt.Println(a, b, *pa, **pp)
    a += "zz" //a追加“zz”
    fmt.Println(a, b, *pa, **pp)
    *pa += "bb" //pp指向的值，追加"bb"
    fmt.Println(a, b, *pa, **pp)
    fmt.Println("打印a各类状况：", &a, a)
    fmt.Println("打印pa各类状况：", &pa, pa, *pa)
    fmt.Println("打印pp各类状况：", &pp, pp, *pp, **pp)
}

 输出以下:

xyz opq xyz xyz
xyzzz opq xyzzz xyzzz
xyzzzbb opq xyzzzbb xyzzzbb
打印a各类状况： 0xc0820001d0 xyzzzbb
打印pa各类状况： 0xc082038018 0xc0820001d0 xyzzzbb
打印pp各类状况： 0xc082038020 0xc082038018 0xc0820001d0 xyzzzbb

 可见，指针的本质就是一个存放逻辑地址的变量。

（2）有两种建立变量的语法，同时得到指向它们的指针：new(Type) 和 &Type{}, 以下：

type point struct {
    x int
    y int
}

func test3() {
    a := point{1, 2}
    b := new(point)
    c := &point{}
    d := &point{3, 4}
    fmt.Println(a, b, c, d)
}

输出为：

{1 2} &{0 0} &{0 0} &{3 4}

 Go语言打印指向结构体的指针时，会打印解引用后的结构体内容，同时会将&做为前缀，表示它是一个指针。

值得注意的是，若是Type不是一个能够用大括号初始化的类型，那就只能使用内置函数 new(Type)了。以下：

func test5() {
    //建立一个int变量，并得到它的指针
    var1 := new(int)
    //var1 := &int32{}
    fmt.Printf("%T->%v\n", var1, var1)
}

 

int不可使用大括号初始化，因此第二种会报错，注释掉后，输出：

*int->0xc082006270

 

 

参考：《Go语言程序设计》