• 长度：1字节
    • 取值范围：true/false
    • 只能使用true/false值，不能使用数字代替布尔值

    整形 int/uint

    2. import "fmt"
    3. func main() {
    4.   // n 是一个长度为 10 的数组
    5.   var n [10]int 
    6.   var i,j int
    8.   /* 为数组 n 初始化元素 */         
    9.   for i = 0; i < 10; i++ {
    10.     n[i] = i + 100 /* 设置元素为 i + 100 */
    11.   }
    13.   /* 输出每个数组元素的值 */
    14.   for j = 0; j < 10; j++ {
    15.     fmt.Printf("Element[%d] = %d\n", j, n[j] )
    16.   }
    17. }
    • int/uint
    • 根据平台可能为32/64位

    8位整型 int8/uint8

    1. u8 := []uint8{98, 99}
    3. a := byte(255)  //11111111 这是byte的极限， 因为 a := byte(256)//越界报错， 0~255正好256个数，不能再高了
    4. b := uint8(255) //11111111 这是uint8的极限，因为 c := uint8(256)//越界报错，0~255正好256个数，不能再高了
    5. c := int8(127)  //01111111 这是int8的极限， 因为 b := int8(128)//越界报错， 0~127正好128个数，所以int8的极限只是256的一半
    6. d := int8(a)    //11111111 打印出来则是-0000001，int8(128)、int8(255)、int8(byte(255))都报错越界，因为int极限是127，但是却可以写：int8(a)，第一位拿来当符号了
    7. e := int8(c)    //01111111 打印出来还是01111111
    8. fmt.Printf("%08b %d \n", a, a)
    9. fmt.Printf("%08b %d \n", b, b)
    10. fmt.Printf("%08b %d \n", c, c)
    11. fmt.Printf("%08b %d \n", d, d)
    12. fmt.Printf("%08b %d \n", e, e)
    • int8/uint8
    • 长度：1字节
    • 取值范围：-128~127/0~255

    字节型 byte

    1. // 这里不能写成 b := []byte{"Golang"}，这里是利用类型转换。
    2. b := []byte("Golang")
    3. c := []byte("go")
    4. d := []byte("Go")
    5. println(b,c,d)
    • byte(uint8别名)

    基本处理函数

    • Contains() 返回是否包含子切片
    • Count() 子切片非重叠实例的数量
    • Map() 函数，将byte 转化为Unicode，然后进行替换
    • Repeat() 将切片复制count此，返回这个新的切片
    • Replace() 将切片中的一部分 替换为另外的一部分
    • Runes() 将 S 转化为对应的 UTF-8 编码的字节序列，并且返回对应的Unicode 切片
    • Join() 函数，将子字节切片连接到一起。

    可以参考下面列子来理解上面7个方法，例子 

    1. package main
    2. import (
    3.   "bytes"
    4.   "fmt"
    5. )
    6. func main() {
    7.   // 这里不能写成 b := []byte{"Golang"}，这里是利用类型转换。
    8.   b := []byte("Golang")
    9.   subslice1 := []byte("go")
    10.   subslice2 := []byte("Go")
    11.   // func Contains(b, subslice [] byte) bool
    12.   // 检查字节切片b ，是否包含子字节切片 subslice
    13.   fmt.Println(bytes.Contains(b, subslice1))
    14.   fmt.Println(bytes.Contains(b, subslice2))
    17.   s2 := []byte("同学们，上午好")
    18.   m := func(r rune) rune {
    19.     if r == '上' {
    20.       r = '下'
    21.     }
    22.     return r
    23.   }
    24.   fmt.Println(string(s2))
    25.   // func Map(mapping func(r rune) rune, s []byte) []byte
    26.   // Map函数: 首先将 s 转化为 UTF-8编码的字符序列，
    27.   // 然后使用 mapping 将每个Unicode字符映射为对应的字符，
    28.   // 最后将结果保存在一个新的字节切片中。
    29.   fmt.Println(string(bytes.Map(m, s2)))
    32.   s3 := []byte("google")
    33.   old := []byte("o")
    34.   //这里 new 是一个字节切片，不是关键字了
    35.   new := []byte("oo")
    36.   n := 1
    37.   // func Replace(s, old, new []byte, n int) []byte
    38.   //返回字节切片 S 的一个副本， 并且将前n个不重叠的子切片 old 替换为 new，如果n < 0 那么不限制替换的数量
    39.   fmt.Println(string(bytes.Replace(s3, old, new, n)))
    40.   fmt.Println(string(bytes.Replace(s3, old, new, -1)))
    43.   // 将字节切片 转化为对应的 UTF-8编码的字节序列，并且返回对应的 Unicode 切片。
    44.   s4 := []byte("中华人民共和国")
    45.   r1 := bytes.Runes(s4)
    46.   // func Runes(b []byte) []rune
    47.   fmt.Println(string(s4), len(s4))  // 字节切片的长度
    48.   fmt.Println(string(r1), len(r1))  // rune 切片的长度
    51.   // 字节切片 的每个元素，依旧是字节切片。
    52.   s5 := [][]byte{
    53.     []byte("你好"),
    54.     []byte("世界"),  //这里的逗号，必不可少
    55.   }
    56.   sep := []byte(",")
    57.   // func Join(s [][]byte, sep []byte) []byte
    58.   // 用字节切片 sep 吧 s中的每个字节切片连接成一个，并且返回.
    59.   fmt.Println(string(bytes.Join(s5, sep)))
    60. }

    16位整型 int16/uint16

    • int16/uint16
    • 长度：2字节
    • 取值范围：-32768~32767/0~65535

    32位整型 int32(别名rune)/uint32

    • int32(别名rune)/uint32
    • 长度：4字节
    • 取值范围：-2^32/2~2^32/2-1/0~2^32-1

    64位整型 int64/uint64

    • int64/uint64
    • 长度：8字节
    • 取值范围：-2^64/2~2^64/2-1/0~2^64-1

    浮点型 float32/float64

    1. package main
    2. import "fmt"
    3. func main() {
    4.   var x float64
    5.   x = 20.0
    6.   fmt.Println(x)
    7.   fmt.Printf("x is of type %T\n", x)
    9.   a := float64(20.0)
    10.   b := 42 
    11.   fmt.Println(a)
    12.   fmt.Println(b)
    13.   fmt.Printf("a is of type %T\n", a)
    15. }

    实例：float.go

    • float32/float64
    • 长度：4/8字节
    • 小数位：精确到 7/15 位小数

    复数 complex64/complex128

    • complex64/complex128
    • 长度：8/16

    指针整数型 uintptr

    用于指针运算，GC 不把 uintptr 当指针，uintptr 无法持有对象。uintptr 类型的目标会被回收。

    • uintptr
    • 保存指正的 32 位或者 64 位整数型
    1. // 示例：通过指针修改结构体字段
    2. package main
    3. import (
    4.   "fmt"
    5.   "unsafe"
    6. )
    8. func main() {
    9.   s := struct {
    10.     a byte
    11.     b byte
    12.     c byte
    13.     d int64
    14.   }{0, 0, 0, 0}
    16.   // 将结构体指针转换为通用指针
    17.   p := unsafe.Pointer(&s)
    18.   // 保存结构体的地址备用（偏移量为 0）
    19.   up0 := uintptr(p)
    20.   // 将通用指针转换为 byte 型指针
    21.   pb := (*byte)(p)
    22.   // 给转换后的指针赋值
    23.   *pb = 10
    24.   // 结构体内容跟着改变
    25.   fmt.Println(s)
    27.   // 偏移到第 2 个字段
    28.   up := up0 + unsafe.Offsetof(s.b)
    29.   // 将偏移后的地址转换为通用指针
    30.   p = unsafe.Pointer(up)
    31.   // 将通用指针转换为 byte 型指针
    32.   pb = (*byte)(p)
    33.   // 给转换后的指针赋值
    34.   *pb = 20
    35.   // 结构体内容跟着改变
    36.   fmt.Println(s)
    38.   // 偏移到第 3 个字段
    39.   up = up0 + unsafe.Offsetof(s.c)
    40.   // 将偏移后的地址转换为通用指针
    41.   p = unsafe.Pointer(up)
    42.   // 将通用指针转换为 byte 型指针
    43.   pb = (*byte)(p)
    44.   // 给转换后的指针赋值
    45.   *pb = 30
    46.   // 结构体内容跟着改变
    47.   fmt.Println(s)
    49.   // 偏移到第 4 个字段
    50.   up = up0 + unsafe.Offsetof(s.d)
    51.   // 将偏移后的地址转换为通用指针
    52.   p = unsafe.Pointer(up)
    53.   // 将通用指针转换为 int64 型指针
    54.   pi := (*int64)(p)
    55.   // 给转换后的指针赋值
    56.   *pi = 40
    57.   // 结构体内容跟着改变
    58.   fmt.Println(s)
    59. }

    数组声明语法

    1. var variable_name [SIZE]variable_type

    数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。下面是一个简单的对数组操作的例子

    初始化数组中 {} 中的元素个数不能大于 [] 中的数字。
    如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

    1. var array1 = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

    数组元素可以通过索引（位置）来读取。格式为数组名后加中括号，中括号中为索引的值。例如：

    1. float32 salary = array1[9]

    以上实例读取了数组array1第10个元素的值。

    多维数组，下面例子

    1. // 三行四列
    2. a = [3][4]int{  
    3.  {0, 1, 2, 3} ,   /*  第一行索引为 0 */
    4.  {4, 5, 6, 7} ,   /*  第二行索引为 1 */
    5.  {8, 9, 10, 11}   /*  第三行索引为 2 */
    6. }

    访问多维数组

    1. // 访问第2行第3列
    2. int val = a[2][3]

    结构类型 struct

    1. package main
    2. import "fmt"
    3. type Vertex struct {
    4.     X int
    5.     Y int
    6. }
    7. func main() {
    8.   fmt.Println(Vertex{1, 2})
    10.   // 结构体字段使用点号来访问。
    11.     v := Vertex{1, 2}
    12.     v.X = 4
    13.   fmt.Println(v.X)
    15.   // 结构体字段可以通过结构体指针来访问。
    16.     e := Vertex{1, 2}
    17.     p := &e
    18.     p.X = 1e9
    19.   fmt.Println(e)
    22.   var (
    23.     v1 = Vertex{1, 2}  // 类型为 Vertex
    24.     v2 = Vertex{X: 1}  // Y:0 被省略
    25.     v3 = Vertex{}      // X:0 和 Y:0
    26.     p  = &Vertex{1, 2} // 类型为 *Vertex , 特殊的前缀 & 返回一个指向结构体的指针
    27.   )
    28.   fmt.Println(v1, p, v2, v3)
    29. }

    简单的结构体

    1. type T struct {a, b int}

    结构体里的字段都有 名字，像 field1、field2 等，如果字段在代码中从来也不会被用到，那么可以命名它为 _。上面简单的结构体定义，下面调用方法：

    1. var s T
    2. s.b = 8

    数组可以看作是一种结构体类型，不过它使用下标而不是具名的字段。

    上面简单的管用语句方法t := new(T)，变量 t 是一个指向 T 的指针，此时结构体字段的值是它们所属类型的零值。

    声明 var t T 也会给 t 分配内存，并零值化内存，但是这个时候 是类型T。在这两种方式中，t 通常被称做类型 T 的一个实例（instance）或对象（object）。

    1. → go run test/structs_fields.go
    3. The int is: 10
    4. The float is: 15.500000
    5. The string is: Chris
    6. &{10 15.5 Chris}

    使用 new

    字符串类型 string

    1. var str string //声明一个字符串
    2. str = "Go lang"  //赋值
    3. ch :=str[0]    //获取第一个字符
    4. len :=len(str) //字符串的长度,len是内置函数 ,len=5

    len函数是Go中内置函数，不引入strings包即可使用。len(string)返回的是字符串的字节数。len函数所支持的入参类型如下：

    • len(Array) 数组的元素个数
    • len(*Array) 数组指针中的元素个数,如果入参为nil则返回0
    • len(Slice) 数组切片中元素个数,如果入参为nil则返回0
    • len(map) 字典中元素个数,如果入参为nil则返回0
    • len(Channel) Channel buffer队列中元素个数

    接口类型 inteface

    1. package main
    2. import (
    3.    "fmt"
    4.    "math"
    5. )
    7. /* 定义一个 interface */
    8. type shape interface {
    9.    area() float64
    10. }
    12. /* 定义一个 circle */
    13. type circle struct {
    14.    x,y,radius float64
    15. }
    17. /* 定义一个 rectangle */
    18. type rectangle struct {
    19.    width, height float64
    20. }
    22. /* 定义一个circle方法 (实现 shape.area())*/
    23. func(circle circle) area() float64 {
    24.    return math.Pi * circle.radius * circle.radius
    25. }
    27. /* 定义一个rectangle方法 (实现 shape.area())*/
    28. func(rect rectangle) area() float64 {
    29.    return rect.width * rect.height
    30. }
    32. /* 定义一个shape的方法*/
    33. func getArea(shape shape) float64 {
    34.    return shape.area()
    35. }
    37. func main() {
    38.    circle := circle{x:0,y:0,radius:5}
    39.    rectangle := rectangle {width:10, height:5}
    41.    fmt.Printf("circle area: %f\n",getArea(circle))
    42.    fmt.Printf("rectangle area: %f\n",getArea(rectangle))
    43. }

    实例：inteface.go

    函数类型 func

    1. package main
    2. import "fmt"
    3. type functinTyoe func(int, int) // 声明了一个函数类型
    4. func (f functinTyoe)Serve() {
    5.   fmt.Println("serve2")
    6. }
    7. func serve(int,int) {
    8.   fmt.Println("serve1")
    9. }
    10. func main() {
    11.   a := functinTyoe(serve)
    12.   a(1,2)
    13.   a.Serve()
    14. }

    实例：

    引用类型 func

    切片

    • slice

    Map

    是一种无序的键值对的集合。是一种集合，所以我们可以像迭代数组和 slice 那样迭代它。

    • map
    1. // 通过 make 来创建
    2. dict := make(map[string]int)
    3. // 通过字面值创建
    4. dict := map[string]string{"Red": "#da1337", "Orange": "#e95a22"}
    6. // 给 map 赋值就是指定合法类型的键，然后把值赋给键
    7. colors := map[string]string{}
    8. colors["Red"] = "#da1337"
    10. // 不初始化 map , 就会创建一个 nil map。nil map 不能用来存放键值对，否则会报运行时错误
    11. var colors map[string]string
    12. colors["Red"] = "#da1337"
    13. // Runtime Error:
    14. // panic: runtime error: assignment to entry in nil map
    16. //选择是只返回值，然后判断是否是零值来确定键是否存在。
    17. value := colors["Blue"]
    18. if value != "" {
    19.   fmt.Println(value)
    20. }

    在函数间传递 map 不是传递 map 的拷贝。所以如果我们在函数中改变了 map，那么所有引用 map 的地方都会改变

    1. func main() {
    2.   colors := map[string]string{
    3.      "AliceBlue":   "#f0f8ff",
    4.      "Coral":       "#ff7F50",
    5.      "DarkGray":    "#a9a9a9",
    6.      "ForestGreen": "#228b22",
    7.   }
    8.   for key, value := range colors {
    9.       fmt.Printf("Key: %s  Value: %s\n", key, value)
    10.   }
    11.   removeColor(colors, "Coral")
    12.   for key, value := range colors {
    13.       fmt.Printf("Key: %s  Value: %s\n", key, value)
    14.   }
    15. }
    16. func removeColor(colors map[string]string, key string) {
    17.     delete(colors, key)
    18. }
    • chan

    类型别名

    1. type (
    2.   byte int8
    3.   rune init32
    4.   文本 string
    5. )
    6. var b 文本