Go 语言保姆级教程（2021版下）

上篇文章给大家分享了 Go 语言保姆级教程（2021版上）

很多读者表示太赞了，希望尽快出下篇，今天就给大家安排上。

这篇文章可以说又是一本书了，排版，码字耗费了很长的时间，10W+字 Go 语言入门保姆级教程2021年版，觉得有价值记得一键四连支持。

切片

• 无论是C语言中的数组还是Go语言中的数组,数组的长度一旦确定就不能改变, 但在实际开发中我们可能事先不能确定数组的长度, 为了解决这类问题Go语言中推出了一种新的数据类型切片

• 切片可以简单的理解为长度可以变化的数组, 但是Go语言中的切片本质上是一个结构体

  type slice struct{
    array unsafe.Pointer // 指向底层数组指针
    len int // 切片长度(保存了多少个元素)
    cap int // 切片容量(可以保存多少个元素)
  }
  

• 切片源码

• 切片创建的三种方式

• 方式一: 通过数组创建切片array[startIndex:endIndex]

  package main
  import "fmt"
  func main() {
    var arr = [5]int{1, 3, 5, 7, 9}
    // 从数组0下标开始取,一直取到2下标前面一个索引
    var sce = arr[0:2]
    fmt.Println(sce) // [1 3]
    // 切片len = 结束位置 - 开始位置
    fmt.Println(len(sce)) // 2 - 0 = 2
    fmt.Println(cap(sce)) // 5 - 0 = 5
    // 数组地址就是数组首元素的地址
    fmt.Printf("%p\n", &arr) // 0xc04200a330
    fmt.Printf("%p\n", &arr[0]) // 0xc04200a330
    // 切片地址就是数组中指定的开始元素的地址
    //  arr[0:2]开始地址为0, 所以就是arr[0]的地址
    fmt.Printf("%p\n", sce) // 0xc04200a330
  }
  

  

  package main
  import "fmt"
  func main() {
  var arr = [5]int{1, 3, 5, 7, 9}
  // 根据数组的索引片段创建切片
  var sce = arr[2:4]
  fmt.Println(sce) // [5 7]
  fmt.Println(len(sce)) // 4 - 2 = 2
  fmt.Println(cap(sce)) // 5 - 2 = 3
  fmt.Printf("%p\n", &arr[2]) // 0xc042076070
  fmt.Printf("%p\n", sce) // 0xc042076070
  }
  

  

• 指定起始位置时有三种方式可以指定

• 开始位置和结束位置都指定
• 只指定开始位置或结束位置
• 开始位置和结束位置都不指定

  package main
  import "fmt"
  func main() {
 var arr = [5]int{1, 3, 5, 7, 9}
 // 同时指定开始位置和结束位置
 var sce1 = arr[0:2]
 fmt.Println(sce1) // [1 3]

 // 只指定结束位置
 var sce3 = arr[:2]
 fmt.Println(sce3) // [1 3]

 // 只指定开始位置
 var sce2 = arr[0:]
 fmt.Println(sce2) // [1 3 5 7 9]

 // 都不指定
 var sce4 = arr[:]
 fmt.Println(sce4) // [1 3 5 7 9]
  }

• 方式二: 通过make函数创建make(类型, 长度, 容量)
• 内部会先创建一个数组, 然后让切片指向数组
• 如果没有指定容量,那么容量和长度一样

 package main
 import "fmt"
 func main() {
 // 第一个参数: 指定切片数据类型
 // 第二个参数: 指定切片的长度
 // 第三个参数: 指定切片的容量
 var sce = make([]int, 3, 5)
 fmt.Println(sce) // [0 0 0]
 fmt.Println(len(sce)) // 3
 fmt.Println(cap(sce)) // 5
 /*
 内部实现原理
 var arr = [5]int{0, 0, 0}
 var sce = arr[0:3]
 */
 }

• 方式三:通过Go提供的语法糖快速创建
• 和创建数组一模一样, 但是不能指定长度
• 通过该方式创建时, 切片的长度和容量相等

 package main
 import "fmt"
 func main() {
 var sce = []int{1, 3, 5}
 fmt.Println(sce) // [1 3 5]
 fmt.Println(len(sce)) // 3
 fmt.Println(cap(sce)) // 3
 }

• 切片的使用

   package main
   import "fmt"
   func main() {
    var sce = []int{1, 3, 5}
    // 使用切片, 往切片中存放数据
    sce[1] = 666
    // 访问切片, 从切片中获取数据
    fmt.Println(sce) // [1 666 5]
   }
  

   package main
   import "fmt"
   func main() {
    var sce = []int{1, 3, 5}
    // 编译报错, 越界
    sce[3] = 666
   }
  

   package main
   import "fmt"
   func main() {
  var sce = []int{1, 3, 5}
  fmt.Println("追加数据前:", sce) // [1 3 5]
  fmt.Println("追加数据前:", len(sce)) // 3
  fmt.Println("追加数据前:", cap(sce)) // 3
  fmt.Printf("追加数据前: %p\n", sce) // 0xc0420600a0
  // 第一个参数: 需要把数据追加到哪个切片中
  // 第二个参数: 需要追加的数据, 可以是一个或多个
  sce = append(sce, 666)
  fmt.Println("追加数据后:", sce) // [1 3 5 666]
  fmt.Println("追加数据后:", len(sce)) // 4
  fmt.Println("追加数据后:", cap(sce)) // 6
  fmt.Printf("追加数据前: %p\n", sce) // 0xc042076b60
   }
  

     package main
     import "fmt"
     func main() {
  var sce1 = []int{1, 3, 5}
  var sce2 = make([]int, 5)
  fmt.Printf("赋值前:%p\n", sce1) // 0xc0420600a0
  fmt.Printf("赋值前:%p\n", sce2) // 0xc042076060
  // 将sce2的指向修改为sce1, 此时sce1和sce2底层指向同一个数组
  sce2 = sce1
  fmt.Printf("赋值后:%p\n", sce1) // 0xc0420600a0
  fmt.Printf("赋值后:%p\n", sce2) // 0xc0420600a0
  //copy(sce2, sce1)
  fmt.Println(sce1) // [1 3 5]
  fmt.Println(sce2) // [1 3 5]
  sce2[1] = 666
  fmt.Println(sce1) // [1 666 5]
  fmt.Println(sce2) // [1 666 5]
     }
  

     package main
     import "fmt"
     func main() {
  var sce1 = []int{1, 3, 5}
  var sce2 = make([]int, 5)
  fmt.Printf("赋值前:%p\n", sce1) // 0xc0420600a0
  fmt.Printf("赋值前:%p\n", sce2) // 0xc042076060
  // 将sce1中的数据拷贝到sce2中,, 此时sce1和sce2底层指向不同数组
  copy(sce2, sce1)
  fmt.Printf("赋值后:%p\n", sce1) // 0xc0420600a0
  fmt.Printf("赋值后:%p\n", sce2) // 0xc042076060
  //copy(sce2, sce1)
  fmt.Println(sce1) // [1 3 5]
  fmt.Println(sce2) // [1 3 5 0 0]
  sce2[1] = 666
  fmt.Println(sce1) // [1 3 5]
  fmt.Println(sce2) // [1 666 5 0 0]
     }
  

     package main
     import "fmt"
     func main() {
  // 容量为3
  var sce1 = []int{1, 3, 5}
  // 容量为5
  var sce2 = make([]int, 5)
  fmt.Println("拷贝前:", sce2) // [0 0 0 0 0]
  // sce2容量足够, 会将sce1所有内容拷贝到sce2
  copy(sce2, sce1)
  fmt.Println("拷贝后:", sce2) // [1 3 5 0 0]
     }
  

     package main
     import "fmt"
     func main() {
  // 容量为3
  var sce1 = []int{1, 3, 5}
  // 容量为2
  var sce2 = make([]int, 2)
  fmt.Println("拷贝前:", sce2) // [0 0]
  // sce2容量不够, 会将sce1前2个元素拷贝到sce2中
  copy(sce2, sce1)
  fmt.Println("拷贝后:", sce2) // [1 3]
     }
  

• copy函数在拷贝数据时永远以小容量为准
• 格式: copy(目标切片, 源切片), 会将源切片中数据拷贝到目标切片中
• 除了append函数外,Go语言还提供了一个copy函数, 用于两个切片之间数据的快速拷贝
• append函数会在切片末尾添加一个元素, 并返回一个追加数据之后的切片
• 利用append函数追加数据时,如果追加之后没有超出切片的容量,那么返回原来的切片, 如果追加之后超出了切片的容量,那么返回一个新的切片
• append函数每次给切片扩容都会按照原有切片容量*2的方式扩容
• 如果希望切片自动扩容,那么添加数据时必须使用append方法
• 和数组一样, 如果通过切片名称[索引]方式操作切片, 不能越界
• 切片的基本使用方式和数组一样, 可以通过切片名称[索引]方式操作切片

• 切片的注意点

    package main
    import "fmt"
    func main() {
        arr := [5]int{1, 3, 5, 7, 9}
        sce1 := arr[0:4]
        sce2 := sce1[0:3]
        fmt.Println(sce1) // [1 3 5 7]
        fmt.Println(sce2) // [1 3 5]
        // 由于底层指向同一数组, 所以修改sce2会影响sce1
        sce2[1] = 666
        fmt.Println(sce1) // [1 666 5 7]
        fmt.Println(sce2) // [1 666 5]
     }
  

  package main
  import "fmt"
  func main() {
      var arr1 [3]int = [3]int{1, 3, 5}
      var arr2 [3]int = [3]int{1, 3, 5}
      var arr3 [3]int = [3]int{2, 4, 6}
      // 首先会判断`数据类型`是否相同,如果相同会依次取出数组中`对应索引的元素`进行比较, 
      // 如果所有元素都相同返回true,否则返回false
      fmt.Println(arr1 == arr2) // true
      fmt.Println(arr1 == arr3) // false
  
      sce1 := []int{1, 3, 5}
      sce2 := []int{1, 3, 5}
      //fmt.Println(sce1 == sce2) // 编译报错
      fmt.Println(sce1 != nil) // true
      fmt.Println(sce2 == nil) // false
   }
  

  package main
  import "fmt"
  func main() {
  // 数组声明后就可以直接使用, 声明时就会开辟存储空间
  var arr [3]int
  arr[0] = 2
  arr[1] = 4
  arr[2] = 6
  fmt.Println(arr) // [2 4 6]
  
  // 切片声明后不能直接使用, 只有通过make或语法糖创建之后才会开辟空间,才能使用
  var sce []int
  sce[0] = 2 // 编译报错
  sce[1] = 4
  sce[2] = 6
  fmt.Println(sce)
   }
  

  package main
  import "fmt"
  func main() {
  str := "abcdefg"
  // 通过字符串生成切片
  sce1 := str[3:]
  fmt.Println(sce1) // defg
  
  sce2 := make([]byte, 10)
  // 第二个参数只能是slice或者是数组
  // 将字符串拷贝到切片中
  copy(sce2, str)
  fmt.Println(sce2) //[97 98 99 100 101 102 103 0 0 0]
   }
  

• 字符串的底层是[]byte数组, 所以字符也支持切片相关操作
• 只声明当没有被创建的切片是不能使用的
• 和数组不同, 切片只支持判断是否为nil, 不支持==、!=判断
• 可以通过切片再次生成新的切片, 两个切片底层指向同一数组

map(字典、映射)

• map翻译过来就是字典或者映射, 可以把map看做是切片的升级版
• 只要是可以做==、!=判断的数据类型都可以作为key(数值类型、字符串、数组、指针、结构体、接口)
• map的key的数据类型不能是:slice、map、function
• map和切片一样容量都不是固定的, 当容量不足时底层会自动扩容
• 切片是用来存储一组相同类型的数据的, map也是用来存储一组相同类型的数据的
• 在切片中我们可以通过索引获取对应的元素, 在map中我们可以通过key获取对应的元素
• 切片的索引是系统自动生成的,从0开始递增. map中的key需要我们自己指定
• map格式:var dic map[key数据类型]value数据类型

package main
import "fmt"
func main() {
 var dic map[int]int = map[int]int{0:1, 1:3, 2:5}
 fmt.Println(dic) // map[0:1 1:3 2:5]

 // 获取map中某个key对应的值
 fmt.Println(dic[0]) // 1
 
 // 修改map中某个key对应的值
 dic[1] = 666
 fmt.Println(dic) // map[0:1 1:666 2:5]
}

package main
import "fmt"
func main() {
 var dict map[string]string = map[string]string{"name":"lnj", "age":"33", "gender":"male"}
 fmt.Println(dict)// map[name:lnj age:33 gender:male]
}

• 创建map的三种方式
• 方式一: 通过Go提供的语法糖快速创建

package main
import "fmt"
func main() {
 dict  := map[string]string{"name":"lnj", "age":"33", "gender":"male"}
 fmt.Println(dict)// map[name:lnj age:33 gender:male]
}

• 方式二:通过make函数创建make(类型, 容量)

package main
import "fmt"
func main() {
 var dict = make(map[string]string, 3)
 dict["name"] = "lnj"
 dict["age"] = "33"
 dict["gender"] = "male"
 fmt.Println(dict)// map[age:33 gender:male name:lnj]
}

• 方式二:通过make函数创建make(类型)

package main
import "fmt"
func main() {
 var dict = make(map[string]string)
 dict["name"] = "lnj"
 dict["age"] = "33"
 dict["gender"] = "male"
 fmt.Println(dict)// map[age:33 gender:male name:lnj]
}

• 和切片一样,没有被创建的map是不能使用的

package main
import "fmt"
func main() {
 // map声明后不能直接使用, 只有通过make或语法糖创建之后才会开辟空间,才能使用
 var dict map[string]string
 dict["name"] = "lnj" // 编译报错
 dict["age"] = "33"
 dict["gender"] = "male"
 fmt.Println(dict)
}

• map的增删改查
• 增加: 当map中没有指定的key时就会自动增加

package main
import "fmt"
func main() {
 var dict = make(map[string]string)
 fmt.Println("增加前:", dict) // map[]
 dict["name"] = "lnj"
 fmt.Println("增加后:", dict) // map[name:lnj]
}

• 修改: 当map中有指定的key时就会自动修改

package main
import "fmt"
func main() {
 var dict = map[string]string{"name":"lnj", "age":"33", "gender":"male"}
 fmt.Println("修改前:", dict) // map[name:lnj age:33 gender:male]
 dict["name"] = "zs"
 fmt.Println("修改后:", dict) // map[age:33 gender:male name:zs]
}

• 删除: 可以通过Go语言内置delete函数删除指定元素

package main
import "fmt"
func main() {
 var dict = map[string]string{"name":"lnj", "age":"33", "gender":"male"}
 fmt.Println("删除前:", dict) // map[name:lnj age:33 gender:male]
 // 第一个参数: 被操作的字典
 // 第二个参数: 需要删除元素对应的key
 delete(dict, "name")
 fmt.Println("删除后:", dict) // map[age:33 gender:male]
}

• 查询: 通过ok-idiom模式判断指定键值对是否存储

package main
import "fmt"
func main() {
 var dict = map[string]string{"name":"lnj", "age":"33", "gender":"male"}
 //value, ok := dict["age"]
 //if(ok){
 // fmt.Println("有age这个key,值为", value)
 //}else{
 // fmt.Println("没有age这个key,值为", value)
 //}
 if value, ok := dict["age"]; ok{
  fmt.Println("有age这个key,值为", value)
 }
}
```go
- ***map遍历***
  + 注意: map和数组以及切片不同,map中存储的数据是无序的, 所以多次打印输出的顺序可能不同
```go
 var dict = map[string]string{"name":"lnj", "age":"33", "gender":"male"}
 for key, value := range dict{
  fmt.Println(key, value)
 }

结构体

• Go语言中的结构体和C语言中结构体一样, 都是用来保存一组不同类型的数据
• Go语言中的结构体和C语言中结构体一样, 都需要先定义结构体类型再利用结构体类型定义结构体变量
• 定义结构体类型

type 类型名称 struct{
  属性名称 属性类型
  属性名称 属性类型
  ... ...
}

type Studentstruct {
 name string
 age int
}

• 创建结构体变量的两种方式

  package main
  import "fmt"
  func main() {
  type Student struct {
   name string
   age int
  } 
  
  // 完全初始化
  var stu1= Student{"lnj", 33}
  fmt.Println(stu1)
  // 部分初始化
  // 部分初始化必须通过 属性名称: 方式指定要初始化的属性
  var stu2 = Student{name:"lnj"}
  fmt.Println(stu2)
  }
  

  package main
  import "fmt"
  func main() {
  // 注意: 这里不用写type和结构体类型名称
  var stu2 = struct {
   name string
   age int
  }{
   name: "lnj",
   age: 33,
  }
  fmt.Println(stu2)
  }
  

• 和C语言中的结构体一样, 如果结构体类型只需要使用一次, 那么建议定义类型同时定义变量
• 方式二: 定义结构体类型同时定义结构体变量(匿名结构体)
• 和C语言中的结构体一样, 如果结构体类型需要多次使用, 那么建议先定义类型再定义变量
• 方式一: 先定义结构体类型, 再定义结构体变量

• 结构体类型操作

  package main
  import "fmt"
  type Student struct {
   name string
   age int
  }
  func main() {
 var stu= Student{"lnj", 33}
 // 获取结构体中某个属性对应的值
 fmt.Println(stu.name)

 // 修改结构体中某个属性对应的值
 stu.name = "zs"
 fmt.Println(stu)
  }

• 和slice、map不同的是, 只要定义了结构体变量就可以使用结构体变量
• 默认情况下结构体中的所有属性都是属性对应类型的默认值

  package main
  import "fmt"
  type Student struct {
   name string
   age int
  }
  func main() {
 var stu Student // 相当于 var stu = Student{}
 fmt.Println(stu) // { 0}
 stu.name = "lnj" // 不会报错
 stu.age = 33
 fmt.Println(stu) // {lnj 33}
  }

• 复杂结构体成员

  package main
  import "fmt"
  type Student struct {
    name string
    age int
  }
  func main() {
  type Demo struct {
   age int // 基本类型作为属性
   arr [3]int // 数组类型作为属性
   sce []int // 切片类型作为属性
   mp map[string]string // 字典类型作为属性
   stu Student // 结构体类型作为属性
  }
  
  var d Demo = Demo{
   33,
   [3]int{1, 3, 5},
   []int{2, 4, 6},
   map[string]string{"class":"one"},
   Student{
    "lnj",
    33,
   },
  }
  fmt.Println(d) // {33 [1 3 5] [2 4 6] map[class:one] {lnj 33}}
  }
  

  package main
  import "fmt"
  type Student struct {
    name string
    age int
  }
  func main() {
  type Demo struct {
   age int // 基本类型作为属性
   arr [3]int // 数组类型作为属性
   sce []int // 切片类型作为属性
   mp map[string]string // 字典类型作为属性
   stu Student // 结构体类型作为属性
  }
  
  // 定义结构体变量
  var d Demo
  // 可以直接使用基本类型属性
  d.age = 33
  // 可以直接使用数组类型属性
  d.arr[0] = 666
  // 不可以直接使用切片类型属性
  //d.sce[0] = 888 // 编译报错
  d.sce = make([]int, 5) // 先创建
  d.sce[0] = 888 // 后使用
  // 不可以直接使用字典类型属性
  //d.mp["class"] = "one" // 编译报错
  d.mp = make(map[string]string)// 先创建
  d.mp["class"] = "one"// 后使用
  // 可以直接使用结构体类型属性
  d.stu.name = "lnj"
  fmt.Println(d) // {33 [666 0 0] [888 0 0 0 0] map[class:one] {lnj 0}}
  }
  

• slice、map类型属性默认值是nil,不能直接使用
• 创建时可以按照属性单独存在时初始化方式初始化

• 结构体类型转换
• 属性名、属性类型、属性个数、排列顺序都是类型组成部分
• 只有属性名、属性类型、属性个数、排列顺序都相同的结构体类型才能转换

  package main
  import "fmt"
  func main() {
 type Person1 struct {
  name string
  age int
 }
 type Person2 struct {
  name string
  age int
 }
 type Person3 struct {
  age int
  name string
 }
 type Person4 struct {
  nm string
  age int
 }
 type Person5 struct {
  name string
  age string
 }
 type Person6 struct {
  age int
  name string
  gender string
 }

 var p1 Person1 = Person1{"lnj", 33}
 var p2 Person2
 // 类型名称不一样不能直接赋值(Person1、Person2)
 //p2 = p1

 // 虽然类型名称不一样, 但是两个类型中的`属性名称`、`属性类型`、`属性个数`、`排列顺序`都一样,所以可以强制转换
 p2 = Person2(p1)
 fmt.Println(p2)
 // 两个结构体类型中的`属性名称`、`属性类型`、`属性个数`都一样,但是`排列顺序`不一样,所以不能强制转换
 //var p3 Person3
 //p3 = Person3(p1)
 //fmt.Println(p3)

 // 两个结构体类型中的`属性类型`、`属性个数`、`排列顺序`都一样,但是`属性名称`不一样,所以不能强制转换
 //var p4 Person4
 //p4 = Person4(p1)
 //fmt.Println(p4)

 // 两个结构体类型中的`属性名称`、`属性个数`、`排列顺序`都一样,但是`属性类型`不一样,所以不能强制转换
 //var p5 Person5
 //p5 = Person5(p1)
 //fmt.Println(p5)

 // 两个结构体类型中的`属性名称`、`属性类型`、`排列顺序`都一样,但是`属性个数`不一样,所以不能强制转换
 //var p6 Person6
 //p6 = Person6(p1)
 //fmt.Println(p6)
  }

• 匿名属性

  package main
  import "fmt"
  func main() {
  type Person struct {
   int
   float32
   bool
   string
  }
  // 不指定名称初始化
  per1 := Person{3, 3.14, false, "lnj"}
  fmt.Println(per1)
  
  // 可以把数据类型作为名字显示初始化
  per2 := Person{
   int: 3,
   float32: 3.14,
   bool: true,
   string: "lnj",
  }
  fmt.Println(per2)
  
  // 可以把数据类型当做属性名称操作结构体
  per2.int = 666
  fmt.Println(per2.int) // 666
  }
  

  package main
  import "fmt"
  func main() {
  type Person struct {
   name string
   age int
  }
  type Student struct {
   Person // 匿名属性
   class string
  }
  
  stu := Student{
   Person{"lnj", 33},
   "学前一班",
  }
  fmt.Println(stu) // {{lnj 33} 学前一班}
  }
  

  package main
  import "fmt"
  func main() {
  type Person struct {
   name string
   age int
  }
  type Student struct {
   Person // 匿名属性
   class string
  }
  
  stu := Student{
   Person{"lnj", 33},
   "学前一班",
  }
  fmt.Println(stu) // {{lnj 33} 学前一班}
  
  // 方式一: 先找到匿名属性,再访问匿名属性中的属性
  stu.Person.name = "zs"
  fmt.Println(stu) // {{zs 33} 学前一班}
  // 方式二: 直接访问匿名属性中的属性
  // 系统会先查找当前结构体有没有名称叫做name的属性
  // 如果没有会继续查找匿名属性中有没有名称叫做name的属性
  stu.name = "ww"
  fmt.Println(stu) // {{ww 33} 学前一班}
  }
  

  package main
  import "fmt"
  func main() {
  type Person struct {
   name string
   age int
  }
  type Class struct {
   name string
   time string
  }
  type Student struct {
   Person // 匿名属性
   Class // 匿名属性
  }
  stu := Student{
   Person{"lnj", 33},
   Class{"学前一班", "2020-12-12"},
  }
  fmt.Println(stu) // {{lnj 33} {学前一班 2020-12-12}}
  // 编译报错, 系统搞不清楚要找哪个name
  //stu.name = "zs"
  
  stu.Person.name = "zs"
  stu.Class.name = "小学一年级"
  fmt.Println(stu) // {{zs 33} {小学一年级 2020-12-12}}
  }
  

  package main
  import "fmt"
  func main() {
  type Person struct {
   name string
  }
  type Student struct {
   per Person
   age int
  }
  
  var stu Student = Student{Person{"lnj"}, 18}
  //fmt.Println(stu.name) // 报错
  fmt.Println(stu.per.name) // 必须通过属性进一步查找
  fmt.Println(stu.age)
  }
  

  package main
  import "fmt"
  func main() {
  type Person struct {
   Person // 错误
   name string
  }
  type Student struct {
   *Student  // 正确, 链表
   age int
  }
  }
  

• 注意点: 如果匿名属性是一个结构体类型, 那么这个结构体类型不能是自己
• 注意点: 只有匿名结构体才支持向上查找
• 注意点: 如果多个匿名属性的属性名称相同,那么不能通过方式二操作,只能通过方式一
• 如果结构体作为匿名属性, 想访问匿名属性的属性有两种方式
• Go语言中最常见的匿名属性是用结构体类型作为匿名属性
• 没有指定属性名称,只有属性的类型, 我们称之为匿名属性
• 任何有命名的数据类型都可以作为匿名属性(int、float、bool、string、struct等)

普通指针

• 和C语言一样, 允许用一个变量来存放其它变量的地址, 这种专门用于存储其它变量地址的变量, 我们称之为指针变量
• 和C语言一样, Go语言中的指针无论是什么类型占用内存都一样(32位4个字节, 64位8个字节)

package main

import (
 "fmt"
 "unsafe"
)

func main() {

 var p1 *int;
 var p2 *float64;
 var p3 *bool;
 fmt.Println(unsafe.Sizeof(p1)) // 8
 fmt.Println(unsafe.Sizeof(p2)) // 8
 fmt.Println(unsafe.Sizeof(p3)) // 8
}

• 和C语言一样, 只要一个指针变量保存了另一个变量对应的内存地址, 那么就可以通过*来访问指针变量指向的存储空间

package main

import (
 "fmt"
)

func main() {

 // 1.定义一个普通变量
 var num int = 666
 // 2.定义一个指针变量
 var p *int = &num
 fmt.Printf("%p\n", &num) // 0xc042064080
 fmt.Printf("%p\n", p) // 0xc042064080
 fmt.Printf("%T\n", p) // *int
 // 3.通过指针变量操作指向的存储空间
 *p = 888
 // 4.指针变量操作的就是指向变量的存储空间
 fmt.Println(num) // 888
 fmt.Println(*p) // 888
}

指向数组指针

• 在C语言中, 数组名,&数组名,&数组首元素保存的都是同一个地址

#include <stdio.h>

int main(){
     int arr[3] = {1, 3, 5};
     printf("%p\n", arr); // 0060FEA4
     printf("%p\n", &arr); // 0060FEA4
     printf("%p\n", &arr[0]); // 0060FEA4
}

• 在Go语言中通过数组名无法直接获取数组的内存地址

package main
import "fmt"

func main() {
 var arr [3]int = [3]int{1, 3, 5}
 fmt.Printf("%p\n", arr) // 乱七八糟东西
 fmt.Printf("%p\n", &arr) // 0xc0420620a0
 fmt.Printf("%p\n", &arr[0]) // 0xc0420620a0
}

• 在C语言中, 无论我们将数组名,&数组名,&数组首元素赋值给指针变量, 都代表指针变量指向了这个数组

#include <stdio.h>

int main(){
     int arr[3] = {1, 3, 5};
     int *p1 = arr;
     p1[1] = 6;
     printf("%d\n", arr[1]);

     int *p2 = &arr;
     p2[1] = 7;
     printf("%d\n", arr[1]);

     int *p3 = &arr[0];
     p3[1] = 8;
     printf("%d\n", arr[1]);
}

• 在Go语言中, 因为只有数据类型一模一样才能赋值, 所以只能通过&数组名赋值给指针变量, 才代表指针变量指向了这个数组

package main

import "fmt"

func main() {
 // 1.错误, 在Go语言中必须类型一模一样才能赋值
 // arr类型是[3]int, p1的类型是*[3]int
 var p1 *[3]int
 fmt.Printf("%T\n", arr)
 fmt.Printf("%T\n", p1)
 p1 = arr // 报错
 p1[1] = 6
 fmt.Println(arr[1])

 // 2.正确, &arr的类型是*[3]int, p2的类型也是*[3]int
 var p2 *[3]int
 fmt.Printf("%T\n", &arr)
 fmt.Printf("%T\n", p2)
 p2 = &arr
 p2[1] = 6
 fmt.Println(arr[1])

 // 3.错误, &arr[0]的类型是*int, p3的类型也是*[3]int
 var p3 *[3]int
 fmt.Printf("%T\n", &arr[0])
 fmt.Printf("%T\n", p3)
 p3 = &arr[0] // 报错
 p3[1] = 6
 fmt.Println(arr[1])
}

• 注意点:
• Go语言中的指针, 不支持C语言中的+1 -1和++ -- 操作

package main

import "fmt"

func main() {


 var arr [3]int = [3]int{1, 3, 5}
 var p *[3]int
 p = &arr
 fmt.Printf("%p\n", &arr) // 0xc0420620a0
 fmt.Printf("%p\n", p) // 0xc0420620a0
 fmt.Println(&arr) // &[1 3 5]
 fmt.Println(p) // &[1 3 5]
 // 指针指向数组之后操作数组的几种方式
 // 1.直接通过数组名操作
 arr[1] = 6
 fmt.Println(arr[1])
 // 2.通过指针间接操作
 (*p)[1] = 7
 fmt.Println((*p)[1])
 fmt.Println(arr[1])
 // 3.通过指针间接操作
 p[1] = 8
 fmt.Println(p[1])
 fmt.Println(arr[1])

 // 注意点: Go语言中的指针, 不支持+1 -1和++ --操作
 *(p + 1) = 9 // 报错
 fmt.Println(*p++) // 报错
 fmt.Println(arr[1])
}

指向切片的指针

• 值得注意点的是切片的本质就是一个指针指向数组, 所以指向切片的指针是一个二级指针

package main

import "fmt"

func main() {
 // 1.定义一个切片
 var sce[]int = []int{1, 3, 5}
 // 2.打印切片的地址
 // 切片变量中保存的地址, 也就是指向的那个数组的地址 sce = 0xc0420620a0
 fmt.Printf("sce = %p\n",sce )
 fmt.Println(sce) // [1 3 5]
 // 切片变量自己的地址, &sce = 0xc04205e3e0
 fmt.Printf("&sce = %p\n",&sce )
 fmt.Println(&sce) // &[1 3 5]
 // 3.定义一个指向切片的指针
 var p *[]int
 // 因为必须类型一致才能赋值, 所以将切片变量自己的地址给了指针
 p = &sce
 // 4.打印指针保存的地址
 // 直接打印p打印出来的是保存的切片变量的地址 p = 0xc04205e3e0
 fmt.Printf("p = %p\n", p)
 fmt.Println(p) // &[1 3 5]
 // 打印*p打印出来的是切片变量保存的地址, 也就是数组的地址 *p = 0xc0420620a0
 fmt.Printf("*p = %p\n", *p)
 fmt.Println(*p) // [1 3 5]
 
 // 5.修改切片的值
 // 通过*p找到切片变量指向的存储空间(数组), 然后修改数组中保存的数据
 (*p)[1] = 666
 fmt.Println(sce[1])
}

指向字典指针

• 与普通指针并无差异

package main
import "fmt"
func main() {

 var dict map[string]string = map[string]string{"name":"lnj", "age":"33"}
 var p *map[string]string = &dict
 (*p)["name"] = "zs"
 fmt.Println(dict)
}

指向结构体指针

• Go语言中指向结构体的指针和C语言一样

• 结构体和指针

  package main
  import "fmt"
  type Student struct {
    name string
    age int
  }
  func main() {
  // 创建时利用取地址符号获取结构体变量地址
  var p1 = &Student{"lnj", 33}
  fmt.Println(p1) // &{lnj 33}
  
  // 通过new内置函数传入数据类型创建
  // 内部会创建一个空的结构体变量, 然后返回这个结构体变量的地址
  var p2 = new(Student)
  fmt.Println(p2) // &{ 0}
  }
  

  package main
  import "fmt"
  type Student struct {
    name string
    age int
  }
  func main() {
  var p = &Student{}
  // 方式一: 传统方式操作
  // 修改结构体中某个属性对应的值
  // 注意: 由于.运算符优先级比*高, 所以一定要加上()
  (*p).name = "lnj"
  // 获取结构体中某个属性对应的值
  fmt.Println((*p).name) // lnj
  
  // 方式二: 通过Go语法糖操作
  // Go语言作者为了程序员使用起来更加方便, 在操作指向结构体的指针时可以像操作接头体变量一样通过.来操作
  // 编译时底层会自动转发为(*p).age方式
  p.age = 33
  fmt.Println(p.age) // 33
  }
  

• 利用结构体指针操作结构体属性
• 创建结构体指针变量有两种方式

指针作为函数参数和返回值

• 如果指针类型作为函数参数, 修改形参会影响实参
• 不能将函数内的指向局部变量的指针作为返回值, 函数结束指向空间会被释放
• 可以将函数内的局部变量作为返回值, 本质是拷贝一份

方法

• Go语言中的方法其实就是一个特殊函数, 只不过这个函数是和某种属性类型绑定在一起的而已

• Go语言中的方法一般用于将函数和结构体绑定在一起, 让结构体除了能够保存数据外还能具备某些行为

• 将函数和数据类型绑定的格式

• 只需要在函数名称前面加上(接收者 数据类型), 即可将函数和某种数据类型绑定在一起

func (接收者 数据类型)方法名称(形参列表)(返回值列表){
  方法体
}

• 示例: 给结构体添加一个方法,此时结构体除了可以保存数据,还具备说出自己名字和年龄的行为

package main
import "fmt"
// 1.定义一个结构体
type Person struct {
 name string
 age int
}
// 2.定义一个函数, 并将这个函数和Person结构体绑定在一起
func (p Person)say()  {
 fmt.Println("my name is", p.name, "my age is", p.age)
}
func main() {
 // 3.创建一个结构体变量
 per := Person{"lnj", 33}
 // 4.利用结构体变量调用和结构体绑定的方法
 // 调用时会自动将调用者(per)传递给方法的接收者(p)
 // 所以可以在方法内部通过p方法结构体变量的属性
 per.say()
}

• 方法和函数异同

  package main
  import "fmt"
  type Person struct {
  name string
  age int
  }
  // 定义一个方法
  func (p Person)say()  {
  fmt.Println("say方法")
  }
  // 定义一个函数
  func say()  {
  fmt.Println("say函数")
  }
  func main() {
  p := Person{"lnj", 33}
  fmt.Printf("%T\n", p.say) // func()
  fmt.Printf("%T\n", say) // func()
  
  // 定义一个保存没有形参没有返回值的函数类型变量
  var fn func()
  // 利用函数类型变量保存一个方法
  fn = p.say
  // 利用函数类型变量调用一个方法
  fn()
  
  // 利用函数类型变量保存一个函数
  fn = say
  // 利用函数类型变量调用一个函数
  fn()
  }
  

  package main
  import "fmt"
  type Person struct {
   name string
   age int
  }
  // 定义一个方法
  func (p Person)say()  {
     fmt.Println("my name is", p.name, "my age is", p.age)
  }
  // 定义一个函数
  func test()  {
   fmt.Println("test")
  }
  func main() {
   per := Person{"lnj", 33}
   per.say() // 方法只能通过绑定类型的变量调用
   //say() // 编译报错, 不能直接调用
   test() // 编译通过, 可以直接调用
  }
  

  package main
  import "fmt"
  type Person struct {
   name string
   age int
  }
  // 定义一个方法
  func (p Person)say()  {
     fmt.Println("my name is", p.name, "my age is", p.age)
  }
  // 定义一个函数
  func test(p Person)  {
   fmt.Println("my name is", p.name, "my age is", p.age)
  }
  func main() {
   per := Person{"lnj", 33}
   per.say() // my name is lnj my age is 33
   test(per) // my name is lnj my age is 33
  }
  

  package main
  import "fmt"
  type Person struct {
   name string
   age int
  }
  // 接收者是一个变量
  func (p Person)setName(name string)  {
   p.name = name
  }
  // 接收者是一个指针
  func (p *Person)setAge(age int)  {
   p.age = age
  }
  func main() {
   per := Person{"lnj", 33}
   fmt.Println(per) // {lnj 33}
   // 值传递, 方法内部修改不会影响方法外部
   per.setName("zs")
   fmt.Println(per) // {lnj 33}
   p := &per
   // 地址传递, 方法内部修改会影响方法外部
   (*p).setAge(18)
   fmt.Println(per) // {lnj 18}
  }
  

  package main
  import "fmt"
  type Person struct {
   name string
   age int
  }
  // 接收者是一个变量
  func (p Person)setName(name string)  {
   p.name = name
  }
  // 接收者是一个指针
  func (p *Person)setAge(age int)  {
   p.age = age
  }
  func main() {
   per := Person{"lnj", 33}
   // 方式一: 先拿到指针,然后再通过指针调用
   p := &per
   (*p).setAge(18)
   fmt.Println(per) // {lnj 18}
   // 方式二: 直接利用变量调用, 底层会自动获取变量地址传递给接收者
   per.setAge(66)
   fmt.Println(per) // {lnj 66}
  }
  

• 地址传递的几种调用方式
• 既然可以看做形参, 那么自然也具备形参的特点(值传递和地址传递)
• 方法的接收者可以看做就是函数的一个形参
• 方法只能通过绑定类型的变量调用, 函数可以直接调用
• 方法的数据类型也是函数类型, 所以也可以定义变量保存(作为参数返回值等)

接口

• Go语言中的接口和现实生活中的USB插槽很像, 它定义某种标准, 但不关心具体实现
• 无论你到哪个商店里面去购买USB线,只要你告诉商家你需要一根USB线, 买回家之后就一定能插到电脑上使用. 之所以能用,原因就是电脑厂商在指定了USB插槽的标准(尺寸、排线等等), 生产厂家只需要按照标准生产即可
• 同样在Go语言中我们可以通过接口来定义某种标准(函数声明),但不用不关心具体实现(函数实现), 只要将来有人按照标准实现了接口,我们就可以使用
• 定义接口格式

type 接口名称 interface{
  函数声明
}

• 示例: 定义一个通用的USB接口

package main
import "fmt"
// 1.定义一个接口
type usber interface {
 start()
 stop()
}
type Computer struct {
 name string
 model string
}
// 2.实现接口中的所有方法
func (cm Computer)start() {
 fmt.Println("启动电脑")
}
func (cm Computer)stop() {
 fmt.Println("关闭电脑")
}

type Phone struct {
 name string
 model string
}
// 2.实现接口中的所有方法
func (p Phone)start()  {
 fmt.Println("启动手机")
}
func (p Phone)stop()  {
 fmt.Println("关闭手机")
}

// 3.使用接口定义的方法
func working(u usber)  {
 u.start()
 u.stop()
}
func main() {
 cm := Computer{"戴尔", "F1234"}
 working(cm) // 启动电脑 关闭电脑

 p := Phone{"华为", "M10"}
 working(p)  // 启动手机 关闭手机
}

• 接口注意点

  type usber interface {
    func start(){ // 错误
     fmt.Println("启动")
    }
    func stop()  { // 错误
     fmt.Println("停止")
    }
  }
  

  type usber interface {
    name string // 错误
    start()
    stop()
  }
  

  package main
  import "fmt"
  // 1.定义一个接口
  type usber interface {
    start()
    stop()
  }
  type Computer struct {
    name string
    model string
  }
  // 2.实现接口中的所有方法
  func (cm Computer)start() {
    fmt.Println("启动电脑")
  }
  func (cm Computer)stop() {
    fmt.Println("关闭电脑")
  }
  // 2.只实现了接口中部分方法
  type Phone struct {
    name string
    model string
  }
  func (p Phone)start()  {
    fmt.Println("启动手机")
  }
  func main() {
    // 1.定义一个usber接口类型变量
    var i usber
    // 2.用usber接口类型变量接收Computer类型结构体
    i = Computer{"戴尔", "F1234"} // 实现了所有方法, 不会报错
    // 3.用usber接口类型变量接收Phone类型结构体
    //i = Phone{"华为", "M10"} // 只实现了部分方法, 会报错
    fmt.Println(i)
  }
  

  package main
  import "fmt"
  type A interface {
    fna()
  }
  type B interface {
    fnb()
  }
  type C interface {
    A // 嵌入A接口
    B // 嵌入B接口
    fnc()
  }
  type Person struct {}
  func (p Person)fna()  {
    fmt.Println("实现A接口中的方法")
  }
  func (p Person)fnb()  {
    fmt.Println("实现B接口中的方法")
  }
  func (p Person)fnc()  {
    fmt.Println("实现C接口中的方法")
  }
  func main() {
    p := Person{}
    p.fna() // 实现A接口中的方法
    p.fnb() // 实现B接口中的方法
    p.fnc() // 实现C接口中的方法
  }
  

  type A interface {
    A // 报错, 不能自己搞自己
  }
  

  type A interface {
    fn()
  }
  type B interface {
    fn()
  }
  type C interface {
    A 
    B // 报错, A接口和B接口都有名称叫做fn的方法
    fnc()
  }
  

  package main
  import "fmt"
  type aer interface {
    fna()
  }
  type ber interface {
    aer
    fnb()
  }
  // Person实现了超集接口所有方法
  type Person struct {}
  func (p Person)fna()  {
    fmt.Println("实现A接口中的方法")
  }
  func (p Person)fnb()  {
    fmt.Println("实现B接口中的方法")
  }
  // Student实现了子集接口所有方法
  type Student struct { }
  func (p Student)fna()  {
  fmt.Println("实现A接口中的方法")
  }
  func main() {
    var i ber
    // 子集接口变量不能转换为超集接口变量
    //i = Student{}
    fmt.Println(i)
    var j aer
    // 超集接口变量可以自动转换成子集接口变量,
    j = Person{}
    fmt.Println(j)
  }
  

  package main
  import "fmt"
  func main() {
    // 1.定义一个空接口类型变量
    var i interface{}
    // 2.用接口类型保存任意类型数据
    i = 123
    fmt.Println(i) // 123
    i = 3.14
    fmt.Println(i) // 3.14
    i = "lnj"
    fmt.Println(i) // lnj
    i = [3]int{1, 3, 5}
    fmt.Println(i) // [1 3 5]
    i = []int{2, 4, 6}
    fmt.Println(i) // [2 4 6]
    i = map[string]string{"name": "lnj"}
    fmt.Println(i) // map[name:lnj]
    i = Computer{"戴尔", "F1234"}
    fmt.Println(i) // {戴尔 F1234}
  }
  

  package main
  import "fmt"
  // 1.定义一个接口
  type usber interface {
    start()
    stop()
  }
  // 2.自定义int类型
  type integer int
  // 2.实现接口中的所有方法
  func (i integer)start()  {
    fmt.Println("int类型实现接口")
  }
  func (i integer)stop()  {
    fmt.Println("int类型实现接口")
  }
  func main() {
    var i integer = 666
    i.start() // int类型实现接口
    i.stop() // int类型实现接口
  }
  

• 只要是自定义类型就可以实现接口
• 空接口类型可以接收任意类型数据
• 超集接口变量可以自动转换成子集接口变量, 子集接口变量不能转换为超集接口变量(本质就是没有实现所有方法)
• 接口中嵌入接口时不能出现相同的方法名称
• 和结构体一样,接口中嵌入接口时不能嵌入自己
• 和结构体一样,接口中也可以嵌入接口
• 只有实现了接口中所有的方法, 才算实现了接口, 才能用该接口类型接收
• 接口中只能有方法什么不能有字段
• 接口中只能有方法的声明不能有方法的实现

• 接口类型转换

  package main
  import "fmt"
  type studier interface {
    read()
  }
  type Person struct {
    name string
    age int
  }
  func (p Person)read()  {
    fmt.Println(p.name, "正在学习")
  }
  func main() {
    // 1.定义一个接口类型变量
    var s studier
    // 2.用接口类型变量接收实现了接口的结构体
    s = Person{"lnj", 33}
    s.name = "zs" // 报错, 由于s是接口类型, 所以不能访问属性
    fmt.Println(s)
  }
  

  package main
  import "fmt"
  type studier interface {
    read()
  }
  type Person struct {
    name string
    age int
  }
  func (p Person)read()  {
    fmt.Println(p.name, "正在学习")
  }
  func main() {
    var s studier
    s = Person{"lnj", 33}
    s.name = "zs" // 报错, 由于s是接口类型, 所以不能访问属性
    // 2.定义一个结构体类型变量
    //var p Person
    // 不能用强制类型转换方式将接口类型转换为原始类型
    //p = Person(s) // 报错
  
    // 2.利用ok-idiom模式将接口类型还原为原始类型
    // s.(Person)这种格式我们称之为: 类型断言
    if p, ok := s.(Person); ok {
     p.name = "zs"
     fmt.Println(p)
    }
  
    // 2.通过 type switch将接口类型还原为原始类型
   // 注意: type switch不支持fallthrought
    switch p := s.(type) {
     case Person:
      p.name = "zs"
      fmt.Println(p) // {zs 33}
     default:
      fmt.Println("不是Person类型")
    }
  }
  

  package main
  import "fmt"
  type studier interface {
    read()
  }
  type Person struct {
    name string
    age int
  }
  func (p Person)read()  {
    fmt.Println(p.name, "正在学习")
  }
  func main() {
    // 1.定义一个抽象接口类型
    var i interface{}
    i = Person{"lnj", 33}
    // 不能调用read方法, 因为抽象接口中没有这个方法
    //i.read()
    // 2.利用ok-idiom模式将抽象接口转换为具体接口
    if s, ok := i.(studier); ok{
     // 可以调用read方法,因为studier中声明了这个方法,并且结构体中实现了这个方法
     s.read() // lnj 正在学习
    }
    }
  

• 除了可以将接口类型转换为原始类型以外, 企业开发中有时候可能我们还需要将抽象接口类型转换为具体接口类型
• 想要访问变量中的属性, 必须将接口类型还原为原始类型
• 接口类型变量可以接收实现了该接口类型的变量, 但是只能调用该变量中的方法, 不能访问该变量的属性

面向对象基本概念

面向对象思想

• 面向对象(Object Oriented,OO)是软件开发方法
• 面向对象是一种对现实世界抽象的理解，是计算机编程技术发展到一定阶段后的产物
• Object Oriented Programming-OOP ——面向对象编程

面向对象和面向过程区别

• 面向对象是相对面向过程而言

• 面向对象和面向过程都是一种思想

• 面向过程

• 强调的是功能行为
• 关注的是解决问题需要哪些步骤

• 回想下前面我们完成一个需求的步骤：

• 首先搞清楚我们要做什么
• 然后分析怎么做
• 最后我用代码体现
• 一步一步去实现，而具体的每一步都需要我们去实现和操作

• 在上面每一个具体步骤中我们都是参与者， 并且需要面对具体的每一个步骤和过程， 这就是面向过程最直接的体现

• 面向对象
• 将功能封装进对象，强调具备了功能的对象
• 关注的是解决问题需要哪些对象
• 当需求单一， 或者简单时， 我们一步一步去操作没问题， 并且效率也挺高。可随着需求的更改， 功能的增加， 发现需要面对每一个步骤非常麻烦， 这时就开始思索， 能不能把这些步骤和功能再进行封装， 封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰多了， 用的时候， 找到对应的类就可以了， 这就是面向对象思想

• 示例
• 买电脑
• 找班长
• 描述需求
• 班长把电脑买回来 *
• 了解电脑
• 了解自己的需求
• 对比参数
• 去电脑城
• 砍价，付钱
• 买回电脑
• 被坑

• 面向过程

• 面向对象

• 吃饭
• 去饭店
• 点菜
• 吃
• 去超市卖菜
• 摘菜
• 洗菜
• 切菜
• 炒菜
• 盛菜
• 吃

• 面向过程

• 面向对象

• 洗衣服
• 买电脑/吃饭/洗衣服
• 找个对象
• 脱衣服
• 打开洗衣机
• 丢进去
• 一键洗衣烘干
• 脱衣服
• 放进盆里
• 放洗衣液
• 加水
• 放衣服
• 搓一搓
• 清一清
• 拧一拧
• 晒起来
• 面向过程
• 面向对象
• 终极面向对象
• 现实生活中我们是如何应用面相对象思想的
• 包工头
• 汽车坏了
• 面试

面向对象的特点

• 是一种符合人们思考习惯的思想
• 可以将复杂的事情简单化
• 将程序员从执行者转换成了指挥者
• 完成需求时：
• 先要去找具有所需的功能的对象来用
• 如果该对象不存在，那么创建一个具有所需功能的对象
• 这样简化开发并提高复用

类与对象的关系

• 面向对象的核心就是对象,那怎么创建对象?

• 现实生活中可以根据模板创建对象,编程语言也一样,也必须先有一个模板,在这个模板中说清楚将来创建出来的对象有哪些属性和行为

• Go语言中的类相当于图纸，用来描述一类事物。也就是说要想创建对象必须先有类

• Go语言利用类来创建对象，对象是类的具体存在, 因此面向对象解决问题应该是先考虑需要设计哪些类，再利用类创建多少个对象

如何设计一个类

• 生活中描述事物无非就是描述事物的属性和行为。
• 如：人有身高，体重等属性，有说话，打架等行为。

事物名称(类名):人(Person)
属性:身高(height)、年龄(age)
行为(功能):跑(run)、打架(fight)

• Go语言中用类来描述事物也是如此
• 属性：对应类中的成员变量。
• 行为：对应类中的成员方法。
• 定义类其实在定义类中的成员(成员变量和成员方法)
• 拥有相同或者类似属性（状态特征）和行为（能干什么事）的对象都可以抽像成为一个类

如何分析一个类

• 一般名词都是类(名词提炼法)
• 飞机发射两颗炮弹摧毁了8辆装甲车

飞机
炮弹
装甲车

• 隔壁老王在公车上牵着一条叼着热狗的草泥马

老王
热狗
草泥马

如何定义一个类

• 类是用于描述事物的的属性和行为的, 而Go语言中的结构体正好可以用于描述事物的属性和行为
• 所以在Go语言中我们使用结构体来定义一个类型

type Person struct {
    name string // 人的属性
    age int // 人的属性
}
// 人的行为
func (p Person)Say()  {
    fmt.Println("my name is", p.name, "my age is", p.age)
}

如何通过类创建一个对象

• 不过就是创建结构体的时候, 根据每个对象的特征赋值不同的属性罢了

// 3.创建一个结构体变量
    p1 := Person{"lnj", 33}
    per.say()

    p2 := Person{"zs", 18}
    per.Say()

不同包中变量、函数、方法、类型公私有问题

• 在Go语言中通过首字母大小写来控制变量、函数、方法、类型的公私有
• 如果首字母小写, 那么代表私有, 仅在当前包中可以使用
• 如果首字母大写, 那么代表共有, 其它包中也可以使用

package demo

import "fmt"

var num1 int = 123 // 当前包可用
var Num1 int = 123 // 其它包也可用

type person struct { // 当前包可用
 name string // 当前包可用
 age int // 当前包可用
}

type Student struct { // 其它包也可用
 Name string // 其它包也可用
 Age int // 其它包也可用
}

func test1()  { // 当前包可用
 fmt.Println("test1")
}
func Test2()  { // 其它包也可用
 fmt.Println("Test2")
}

func (p person)say()  { // 当前包可用
 fmt.Println(p.name, p.age)
}
func (s Student)Say()  { // 其它包也可用
 fmt.Println(s.Name, s.Age)
}

面向对象三大特性

• 封装性
• 封装性就是隐藏实现细节，仅对外公开接口
• 类是数据与功能的封装，数据就是成员变量，功能就是方法
• 为什么要封装?
• 不封装的缺点：当一个类把自己的成员变量暴露给外部的时候,那么该类就失去对该成员变量的管理权，别人可以任意的修改你的成员变量
• 封装就是将数据隐藏起来,只能用此类的方法才可以读取或者设置数据,不可被外部任意修改是面向对象设计本质(将变化隔离)。这样降低了数据被误用的可能 (提高安全性和灵活性)

package model
import "fmt"
type Person struct { // 其它包也可用
 name string // 当前包可用
 age int // 当前包可用
}
func (p *person)SetAge(age int)  {
 // 安全校验
 if age < 0 {
  fmt.Println("年龄不能为负数")
 }
 p.age = age
}

package main
import (
 "fmt"
 "main/model"
)
func main()  {
 // 报错, 因为name和age不是公开的
 //p := model.Person{"lnj", 18}

 // 方式一
 //p := model.Person{}
 //p.SetAge(18)
 //fmt.Println(p)

 // 方式二
 //p := new(model.Person)
 //p.SetAge(18)
 //fmt.Println(p)
}

• 封装原则
• 将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共的方法对其访问

• 继承性

• Go语言认为虽然继承能够提升代码的复用性, 但是会让代码腐烂, 并增加代码的复杂度.
• 所以go语言坚持了〃组合优于继承〃的原则, Go语言中所谓的继承其实是利用组合实现的(匿名结构体属性)

• 普通继承(组合)

package main

import "fmt"

type Person struct {
 name string
 age int
}
type Student struct {
 Person // 学生继承了人的特性
 score int
}
type Teacher struct {
 Person // 老师继承了人的特性
 Title string
}
func main()  {
 s := Student{Person{"lnj", 18}, 99}
 //fmt.Println(s.Person.name)
 fmt.Println(s.name) // 两种方式都能访问
 //fmt.Println(s.Person.age)
 fmt.Println(s.age) // 两种方式都能访问
 fmt.Println(s.score)
}

• 继承结构中出现重名情况, 采用就近原则

package main

import "fmt"

type Person struct {
 name string // 属性重名
 age int
}
type Student struct {
 Person
 name string // 属性重名
 score int
}
func main()  {
 s := Student{Person{"zs", 18}, "ls", 99}

 fmt.Println(s.Person.name) // zs
 fmt.Println(s.name) // ls
 //fmt.Println(s.Person.age)
 fmt.Println(s.age) // 两种方式都能访问
 fmt.Println(s.score)
}

• 多重继承

package main

import "fmt"

type Object struct {
 life int
}
type Person struct {
 Object
 name string
 age int
}
type Student struct {
 Person
 score int
}
func main()  {
 s := Student{Person{Object{77}, "zs", 33}, 99}
 //fmt.Println(s.Person.Object.life)
 //fmt.Println(s.Person.life)
 fmt.Println(s.life) // 三种方式都可以
 //fmt.Println(s.Person.name)
 fmt.Println(s.name) // 两种方式都能访问
 //fmt.Println(s.Person.age)
 fmt.Println(s.age) // 两种方式都能访问
 fmt.Println(s.score)
}

package main

import "fmt"

type Object struct {
 life int
}
type Person struct {
 name string
 age int
}
type Student struct {
 Object
 Person
 score int
}
func main()  {
 s := Student{Object{77}, Person{"zs", 33}, 99}
 //fmt.Println(s.Person.life)
 fmt.Println(s.life) // 两种方式都可以
 //fmt.Println(s.Person.name)
 fmt.Println(s.name) // 两种方式都能访问
 //fmt.Println(s.Person.age)
 fmt.Println(s.age) // 两种方式都能访问
 fmt.Println(s.score)

• 方法继承
• 在Go语言中子类不仅仅能够继承父类的属性, 还能够继承父类的方法

package main

import "fmt"
type Person struct {
 name string
 age int
}
// 父类方法
func (p Person)say()  {
 fmt.Println("name is ", p.name, "age is ", p.age)
}

type Student struct {
 Person
 score float32
} 

func main() {
 stu := Student{Person{"zs", 18}, 59.9}
 stu.say()
}

• 继承中的方法重写
• 如果子类有和父类同名的方法, 那么我们称之为方法重写

package main

import "fmt"
type Person struct {
 name string
 age int
}
// 父类方法
func (p Person)say()  {
 fmt.Println("name is ", p.name, "age is ", p.age)
}

type Student struct {
 Person
 score float32
}
// 子类方法
func (s Student)say()  {
 fmt.Println("name is ", s.name, "age is ", s.age, "score is ", s.score)
}
func main() {
 stu := Student{Person{"zs", 18}, 59.9}
 // 和属性一样, 访问时采用就近原则
 stu.say() 
 // 和属性一样, 方法同名时可以通过指定父类名称的方式, 访问父类方法
 stu.Person.say()
}

• 注意点:
• 无论是属性继承还是方法继承, 都只能子类访问父类, 不能父类访问子类

• 多态性
• 多态就是某一类事物的多种形态

猫: 猫-->动物
狗: 狗-->动物
男人 : 男人 -->人 -->高级动物
女人 : 女人 -->人 -->高级动物

• Go语言中的多态是采用接口来实现的

package main

import "fmt"
// 1.定义接口
type Animal interface { 
 Eat()
}
type Dog struct {
 name string
 age int
}
// 2.实现接口方法
func (d Dog)Eat()  {
 fmt.Println(d.name, "正在吃东西")
}

type Cat struct {
 name string
 age int
}
// 2.实现接口方法
func (c Cat)Eat()  {
 fmt.Println(c.name, "正在吃东西")
}
// 3.对象特有方法
func (c Cat)Special()  {
 fmt.Println(c.name, "特有方法")
}

func main()  {
 // 1.利用接口类型保存实现了所有接口方法的对象
 var a Animal
 a = Dog{"旺财", 18}
 // 2.利用接口类型调用对象中实现的方法
 a.Eat()
 a = Cat{"喵喵", 18}
 a.Eat()
 // 3.利用接口类型调用对象特有的方法
 //a.Special() // 接口类型只能调用接口中声明的方法, 不能调用对象特有方法
 if cat, ok := a.(Cat); ok{
  cat.Special() // 只有对象本身才能调用对象的特有方法
 }
}

• 多态优点
• 多态的主要好处就是简化了编程接口。它允许在类和类之间重用一些习惯性的命名,而不用为每一个新的方法命名一个新名字。这样,编程接口就是一些抽象的行为的集合,从而和实现接口的类的区分开来
• 多态也使得代码可以分散在不同的对象中而不用试图在一个方法中考虑到所有可能的对象。这样使得您的代码扩展性和复用性更好一些。当一个新的情景出现时,您无须对现有的代码进行改动,而只需要增加一个新的类和新的同名方法

异常处理

• 程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常
• golang中提供了两种处理异常的方式
• 一种是程序发生异常时, 将异常信息反馈给使用者
• 一种是程序发生异常时, 立刻退出终止程序继续运行

打印异常信息

• Go语言中提供了两种创建异常信息的方式
• 方式一: 通过fmt包中的Errorf函数创建错误信息, 然后打印

package main
import "fmt"
func main() {
 // 1.创建错误信息
 var err error = fmt.Errorf("这里是错误信息")
 // 2.打印错误信息
 fmt.Println(err) // 这里是错误信息
}

• 方式二: 通过errors包中的New函数创建错误信息,然后打印

package main
import "fmt"
func main() {
 // 1.创建错误信息
 var err error = errors.New("这里是错误信息")
 // 2.打印错误信息
 fmt.Println(err) // 这里是错误信息
}

• 两种创建异常信息实现原理解析
• Go语言中创建异常信息其实都是通过一个error接口实现的
• Go语言再builtin包中定义了一个名称叫做error的接口. 源码如下

package builtin
// 定义了一个名称叫做error的接口
// 接口中声明了一个叫做Error() 的方法
type error interface {
 Error() string
}

• 在errors包中定义了一个名称叫做做errorString的结构体, 利用这个结构体实现了error接口中指定的方法
• 并且在errors 包中还提供了一个New方法, 用于创建实现了error接口的结构体对象, 并且在创建时就会把指定的字符串传递给这个结构体

// 指定包名为errors
package errors 
// 定义了一个名称叫做errorString的结构体, 里面有一个字符串类型属性s
type errorString struct {
 s string
}
// 实现了error接口中的Error方法
// 内部直接将结构体中保存的字符串返回
func (e *errorString) Error() string {
 return e.s
}
// 定义了一个New函数, 用于创建异常信息
// 注意: New函数的返回值是一个接口类型
func New(text string) error {
        // 返回一个创建好的errorString结构体地址
 return &errorString{text}
}

• fmt包中Errorf底层的实现原理其实就是在内部自动调用了errors包中的New函数

func Errorf(format string, a ...interface{}) error {
 return errors.New(Sprintf(format, a...))
}

• 应用场景

package main
import "fmt"
func div(a, b int) (res int, err error) {
 if(b == 0){
  // 一旦传入的除数为0, 就会返回error信息
  err = errors.New("除数不能为0")
 }else{
  res = a / b
 }
 return
}
func main() {
 //res, err := div(10, 5)
 res, err := div(10, 0)
 if(err != nil){
  fmt.Println(err) // 除数不能为0
 }else{
  fmt.Println(res) // 2
 }
}

中断程序

• Go语言中提供了一个叫做panic函数, 用于发生异常时终止程序继续运行

package main
import "fmt"
func div(a, b int) (res int) {
 if(b == 0){
  //一旦传入的除数为0, 程序就会终止
  panic("除数不能为0")
 }else{
  res = a / b
 }
 return
}
func main() {
 res := div(10, 0)
 fmt.Println(res)
}

• Go语言中有两种方式可以触发panic终止程序
• 我们自己手动调用panic函数
• 程序内部出现问题自动触发panic函数

package main
import "fmt"
func main() {
 // 例如:数组角标越界, 就会自动触发panic
 var arr = [3]int{1, 3, 5}
 arr[5] = 666 // 报错
 fmt.Println(arr)

 // 例如:除数为0, 就会自动触发panic
 var res = 10 / 0
 fmt.Println(res)
}

• 除非是不可恢复性、导致系统无法正常工作的错误, 否则不建议使用panic

恢复程序

• 程序和人一样都需要具备一定的容错能力, 学会知错就改. 所以如果不是不可恢复性、导致系统无法正常工作的错误, 如果发生了panic我们需要恢复程序, 让程序继续执行,并且需要记录到底犯了什么错误
• 在Go语言中我们可以通过defer和recover来实现panic异常的捕获, 让程序继续执行

package main
import "fmt"
func div(a, b int) (res int) {
 // 定义一个延迟调用的函数, 用于捕获panic异常
 // 注意: 一定要在panic之前定义
 defer func() {
  if err := recover(); err != nil{
   res = -1
   fmt.Println(err) // 除数不能为0
  }
 }()
 if(b == 0){
  //err = errors.New("除数不能为0")
  panic("除数不能为0")
 }else{
  res = a / b
 }
 return
}

func setValue(arr []int, index int ,value int)  {
 arr[index] = value
}
func main() {
 res := div(10, 0)
 fmt.Println(res) // -1
}

• panic注意点
• panic异常会沿着调用堆栈向外传递, 所以也可以在外层捕获

package main
import "fmt"
func div(a, b int) (res int) {
 if(b == 0){
  //err = errors.New("除数不能为0")
  panic("除数不能为0")
 }else{
  res = a / b
 }
 return
}
func main() {
 // panic异常会沿着调用堆栈向外传递, 所以也可以在外层捕获
 defer func() {
  if err := recover(); err != nil{
   fmt.Println(err) // 除数不能为0
  }
 }()
 div(10, 0)
}

• 多个异常,只有第一个会被捕获

package main
import "fmt"
func test1()  {
 // 多个异常,只有第一个会被捕获
 defer func() {
  if err := recover(); err != nil{
   fmt.Println(err) // 异常A
  }
 }()
 panic("异常A") // 相当于return, 后面代码不会继续执行
 panic("异常B")
}
func main() {
 test1(10, 0)
}

• 如果有异常写在defer中, 那么只有defer中的异常会被捕获

package main
import "fmt"
func test2()  {
 // 如果有异常写在defer中, 并且其它异常写在defer后面, 那么只有defer中的异常会被捕获
 defer func() {
  if err := recover(); err != nil{
   fmt.Println(err) // 异常A
  }
 }()
 
 defer func() { 
  panic("异常B")
 }()
 panic("异常A")
}
func main() {
 test1(10, 0)
}

字符串相关方法

• 获取字符串长度
• 注意: Go语言编码方式是UTF-8,在UTF-8中一个汉字占3个字节

package main
import "fmt"
func main() {
 str1 := "lnj"
 fmt.Println(len(str1)) // 3
 str2 := "公号：代码情缘"
 fmt.Println(len(str2)) // 12
}

• 如果字符串中包含中文, 又想精确的计算字符串中字符的个数而不是占用的字节, 那么必须先将字符串转换为rune类型数组
• Go语言中byte用于保存字符, rune用于保存汉字

package main
import "fmt"
func main() {
 str := "公号：代码情缘"
 // 注意byte占1个字节, 只能保存字符不能保存汉字,因为一个汉字占用3个字节
 arr1 := []byte(str) // 12
 fmt.Println(len(arr1))
 for _, v := range arr1{
  fmt.Printf("%c", v) // lnj李南江
 }

 // Go语言中rune类型就是专门用于保存汉字的
 arr2 := []rune(str)
 fmt.Println(len(arr2)) // 6
 for _, v := range arr2{
  fmt.Printf("%c", v) // lnj李南江
 }
}

• 查找子串在字符串中出现的位置
• func Index(s, sep string) int
• func IndexByte(s string, c byte) int
• func IndexRune(s string, r rune) int
• func IndexAny(s, chars string) int
• func IndexFunc(s string, f func(rune) bool) int
• func LastIndex(s, sep string) int
• func LastIndexByte(s string, c byte) int
• func LastIndexAny(s, chars string) int
• func LastIndexFunc(s string, f func(rune) bool) int

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 查找`字符`在字符串中第一次出现的位置, 找不到返回-1
 res := strings.IndexByte("hello 李南江", 'l')
 fmt.Println(res) // 2

 // 查找`汉字`OR`字符`在字符串中第一次出现的位置, 找不到返回-1
 res = strings.IndexRune("hello 李南江", '李')
 fmt.Println(res) // 6
 res = strings.IndexRune("hello 李南江", 'l')
 fmt.Println(res) // 2

 // 查找`汉字`OR`字符`中任意一个在字符串中第一次出现的位置, 找不到返回-1
 res = strings.IndexAny("hello 李南江", "wml")
 fmt.Println(res) // 2
 // 会把wmhl拆开逐个查找, w、m、h、l只要任意一个被找到, 立刻停止查找
 res = strings.IndexAny("hello 李南江", "wmhl")
 fmt.Println(res) // 0
 // 查找`子串`在字符串第一次出现的位置, 找不到返回-1
 res = strings.Index("hello 李南江", "llo")
 fmt.Println(res) // 2
 // 会把lle当做一个整体去查找, 而不是拆开
 res = strings.Index("hello 李南江", "lle")
 fmt.Println(res) // -1
 // 可以查找字符也可以查找汉字
 res = strings.Index("hello 李南江", "李")
 fmt.Println(res) // 6

 // 会将字符串先转换为[]rune, 然后遍历rune切片逐个取出传给自定义函数
 // 只要函数返回true,代表符合我们的需求, 既立即停止查找
 res = strings.IndexFunc("hello 李南江", custom)
 fmt.Println(res) // 6

 // 倒序查找`子串`在字符串第一次出现的位置, 找不到返回-1
 res := strings.LastIndex("hello 李南江", "l")
 fmt.Println(res) // 3
}
func custom(r rune) bool {
 fmt.Printf("被调用了, 当前传入的是%c\n", r)
 if r == 'o' {
  return true
 }
 return false
}

• 判断字符串中是否包含子串
• func Contains(s, substr string) bool
• func ContainsRune(s string, r rune) bool
• func ContainsAny(s, chars string) bool
• func HasPrefix(s, prefix string) bool
• func HasSuffix(s, suffix string) bool

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 查找`子串`在字符串中是否存在, 存在返回true, 不存在返回false
 // 底层实现就是调用strings.Index函数
 res := strings.Contains( "hello 代码情缘", "llo")
 fmt.Println(res) // true

 // 查找`汉字`OR`字符`在字符串中是否存在, 存在返回true, 不存在返回false
 // 底层实现就是调用strings.IndexRune函数
 res = strings.ContainsRune( "hello 代码情缘", 'l')
 fmt.Println(res) // true
 res = strings.ContainsRune( "hello 代码情缘", '李')
 fmt.Println(res) // true

 // 查找`汉字`OR`字符`中任意一个在字符串中是否存在, 存在返回true, 不存在返回false
 // 底层实现就是调用strings.IndexAny函数
 res = strings.ContainsAny( "hello 代码情缘", "wmhl")
 fmt.Println(res) // true

 // 判断字符串是否已某个字符串开头
 res = strings.HasPrefix("lnj-book.avi", "lnj")
 fmt.Println(res) // true

 // 判断字符串是否已某个字符串结尾
 res = strings.HasSuffix("lnj-book.avi", ".avi")
 fmt.Println(res) // true
}

• 字符串比较
• func Compare(a, b string) int
• func EqualFold(s, t string) bool

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 比较两个字符串大小, 会逐个字符地进行比较ASCII值
 // 第一个参数 >  第二个参数 返回 1
 // 第一个参数 <  第二个参数 返回 -1
 // 第一个参数 == 第二个参数 返回 0
 res := strings.Compare("bcd", "abc")
 fmt.Println(res) // 1
 res = strings.Compare("bcd", "bdc")
 fmt.Println(res) // -1
 res = strings.Compare("bcd", "bcd")
 fmt.Println(res) // 0

 // 判断两个字符串是否相等, 可以判断字符和中文
 // 判断时会忽略大小写进行判断
 res2 := strings.EqualFold("abc", "def")
 fmt.Println(res2) // false
 res2 = strings.EqualFold("abc", "abc")
 fmt.Println(res2) // true
 res2 = strings.EqualFold("abc", "ABC")
 fmt.Println(res2) // true
 res2 = strings.EqualFold("代码情缘", "代码情缘")
 fmt.Println(res2) // true
}

• 字符串转换
• func ToUpper(s string) string
• func ToLower(s string) string
• func ToTitle(s string) string
• func ToUpperSpecial(_case unicode.SpecialCase, s string) string
• func ToLowerSpecial(_case unicode.SpecialCase, s string) string
• func ToTitleSpecial(_case unicode.SpecialCase, s string) string
• func Title(s string) string

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 将字符串转换为小写
 res := strings.ToLower("ABC")
 fmt.Println(res) // abc
 
 // 将字符串转换为大写
 res = strings.ToUpper("abc")
 fmt.Println(res) // ABC

 // 将字符串转换为标题格式, 大部分`字符`标题格式就是大写
 res = strings.ToTitle("hello world")
 fmt.Println(res) // HELLO WORLD
 res = strings.ToTitle("HELLO WORLD")
 fmt.Println(res) // HELLO WORLD

 // 将单词首字母变为大写, 其它字符不变
 // 单词之间用空格OR特殊字符隔开
 res = strings.Title("hello world")
 fmt.Println(res) // Hello World
}

• 字符串拆合
• func Split(s, sep string) []string
• func SplitN(s, sep string, n int) []string
• func SplitAfter(s, sep string) []string
• func SplitAfterN(s, sep string, n int) []string
• func Fields(s string) []string
• func FieldsFunc(s string, f func(rune) bool) []string
• func Join(a []string, sep string) string
• func Repeat(s string, count int) string
• func Replace(s, old, new string, n int) string

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 按照指定字符串切割原字符串
 // 用,切割字符串
 arr1 := strings.Split("a,b,c", ",")
 fmt.Println(arr1) // [a b c]
 arr2 := strings.Split("ambmc", "m")
 fmt.Println(arr2) // [a b c]

 // 按照指定字符串切割原字符串, 并且指定切割为几份
 // 如果最后一个参数为0, 那么会范围一个空数组
 arr3 := strings.SplitN("a,b,c", ",", 2)
 fmt.Println(arr3) // [a b,c]
 arr4 := strings.SplitN("a,b,c", ",", 0)
 fmt.Println(arr4) // []

 // 按照指定字符串切割原字符串, 切割时包含指定字符串
 arr5 := strings.SplitAfter("a,b,c", ",")
 fmt.Println(arr5) // [a, b, c]

 // 按照指定字符串切割原字符串, 切割时包含指定字符串, 并且指定切割为几份
 arr6 := strings.SplitAfterN("a,b,c", ",", 2)
 fmt.Println(arr6) // [a, b,c]

 // 按照空格切割字符串, 多个空格会合并为一个空格处理
 arr7 := strings.Fields("a  b c    d")
 fmt.Println(arr7) // [a b c d]

 // 将字符串转换成切片传递给函数之后由函数决定如何切割
 // 类似于IndexFunc
 arr8 := strings.FieldsFunc("a,b,c", custom)
 fmt.Println(arr8) // [a b c]

 // 将字符串切片按照指定连接符号转换为字符串
 sce := []string{"aa", "bb", "cc"}
 str1 := strings.Join(sce, "-")
 fmt.Println(str1) // aa-bb-cc


 // 返回count个s串联的指定字符串
 str2 := strings.Repeat("abc", 2)
 fmt.Println(str2) // abcabc

 // 第一个参数: 需要替换的字符串
 // 第二个参数: 旧字符串
 // 第三个参数: 新字符串
 // 第四个参数: 用新字符串 替换 多少个旧字符串
 // 注意点: 传入-1代表只要有旧字符串就替换
 // 注意点: 替换之后会生成新字符串, 原字符串不会受到影响
 str3 := "abcdefabcdefabc"
 str4 := strings.Replace(str3, "abc", "mmm", -1)
 fmt.Println(str3) // abcdefabcdefabc
 fmt.Println(str4) // mmmdefmmmdefmmm
}
func custom(r rune) bool {
 fmt.Printf("被调用了, 当前传入的是%c\n", r)
 if r == ',' {
  return true
 }
 return false
}

• 字符串清理
• func Trim(s string, cutset string) string
• func TrimLeft(s string, cutset string) string
• func TrimRight(s string, cutset string) string
• func TrimFunc(s string, f func(rune) bool) string
• func TrimLeftFunc(s string, f func(rune) bool) string
• func TrimRightFunc(s string, f func(rune) bool) string
• func TrimSpace(s string) string
• func TrimPrefix(s, prefix string) string
• func TrimSuffix(s, suffix string) string

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 去除字符串两端指定字符
 str1 := strings.Trim("!!!abc!!!def!!!", "!")
 fmt.Println(str1) // abc!!!def
 // 去除字符串左端指定字符
 str2 := strings.TrimLeft("!!!abc!!!def!!!", "!")
 fmt.Println(str2) // abc!!!def!!!
 // 去除字符串右端指定字符
 str3 := strings.TrimRight("!!!abc!!!def!!!", "!")
 fmt.Println(str3) // !!!abc!!!def
 // // 去除字符串两端空格
 str4 := strings.TrimSpace("   abc!!!def ")
 fmt.Println(str4) // abc!!!def

 // 按照方法定义规则,去除字符串两端符合规则内容
 str5 := strings.TrimFunc("!!!abc!!!def!!!", custom)
 fmt.Println(str5) // abc!!!def
 // 按照方法定义规则,去除字符串左端符合规则内容
 str6 := strings.TrimLeftFunc("!!!abc!!!def!!!", custom)
 fmt.Println(str6) // abc!!!def!!!
 //  按照方法定义规则,去除字符串右端符合规则内容
 str7 := strings.TrimRightFunc("!!!abc!!!def!!!", custom)
 fmt.Println(str7) // !!!abc!!!def

 // 取出字符串开头的指定字符串
 str8 := strings.TrimPrefix("lnj-book.avi", "lnj-")
 fmt.Println(str8) // book.avi

 // 取出字符串结尾的指定字符串
 str9 := strings.TrimSuffix("lnj-book.avi", ".avi")
 fmt.Println(str9) // lnj-book
}

正则表达式

• 正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
• 相关规则标准详见
• 百度百科
• Go语言官方文档regexp包
• Go语言中正则表达式使用步骤
• 1.创建一个正则表达式匹配规则对象
• 2.利用正则表达式匹配规则对象匹配指定字符串

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 创建一个正则表达式匹配规则对象
 // reg := regexp.MustCompile(规则字符串)
 // 利用正则表达式匹配规则对象匹配指定字符串
 // 会将所有匹配到的数据放到一个字符串切片中返回
 // 如果没有匹配到数据会返回nil
 // res := reg.FindAllString(需要匹配的字符串, 匹配多少个)

 str := "Hello 李南江 1232"
 reg := regexp.MustCompile("2")
 res := reg.FindAllString(str, -1)
 fmt.Println(res) // [2 2]
 res = reg.FindAllString(str, 1)
 fmt.Println(res) // [2]
}

• 匹配电话号码

package main
import (
 "strings"
 "fmt"
)
func main() {
 res2 := findPhoneNumber("13554499311")
 fmt.Println(res2) // true

 res2 = findPhoneNumber("03554499311")
 fmt.Println(res2) // false

 res2 = findPhoneNumber("1355449931")
 fmt.Println(res2) // false
}
func findPhoneNumber(str string) bool {
 // 创建一个正则表达式匹配规则对象
 reg := regexp.MustCompile("^1[1-9]{10}")
 // 利用正则表达式匹配规则对象匹配指定字符串
 res := reg.FindAllString(str, -1)
 if(res == nil){
  return  false
 }
 return  true
}

• 匹配Email

package main
import (
 "strings"
 "fmt"
)
func main() {
 res2 = findEmail("123@qq.com")
 fmt.Println(res2) // true

 res2 = findEmail("ab?de@qq.com")
 fmt.Println(res2) // false

 res2 = findEmail("123@qqcom")
 fmt.Println(res2) // false
}
func findEmail(str string) bool {
 reg := regexp.MustCompile("^[a-zA-Z0-9_]+@[a-zA-Z0-9]+\\.[a-zA-Z0-9]+")
 res := reg.FindAllString(str, -1)
 if(res == nil){
  return  false
 }
 return  true
}

时间和日期函数

• 获取当前时间

package main

import (
 "fmt"
 "time"
)
func main()  {
 var t time.Time = time.Now()
 // 2018-09-27 17:25:11.653198 +0800 CST m=+0.009759201
 fmt.Println(t)
}

• 获取年月日时分秒

package main

import (
 "fmt"
 "time"
)
func main()  {
 var t time.Time = time.Now()
 fmt.Println(t.Year())
 fmt.Println(t.Month())
 fmt.Println(t.Day())
 fmt.Println(t.Hour())
 fmt.Println(t.Minute())
 fmt.Println(t.Second())
}

• 格式化时间

package main

import (
 "fmt"
 "time"
)
func main()  {
 var t time.Time = time.Now()
 fmt.Printf("当前的时间是: %d-%d-%d %d:%d:%d\n", t.Year(), 
  t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())

 var dateStr = fmt.Sprintf("%d-%d-%d %d:%d:%d", t.Year(), 
  t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
fmt.Println("当前的时间是:", dateStr)
}

package main

import (
 "fmt"
 "time"
)
func main()  {
 var t time.Time = time.Now()
 // 2006/01/02 15:04:05这个字符串是Go语言规定的, 各个数字都是固定的
 // 字符串中的各个数字可以只有组合, 这样就能按照需求返回格式化好的时间
 str1 := t.Format("2006/01/02 15:04:05")
 fmt.Println(str1)
 str2 := t.Format("2006/01/02")
 fmt.Println(str2)
 str3 := t.Format("15:04:05")
 fmt.Println(str3)
}

• 时间常量
• 一般用于指定时间单位, 和休眠函数配合使用
• 例如: 100毫秒, 100 *time.Millisecond

const (
 Nanosecond  Duration = 1    // 纳秒
 Microsecond          = 1000 * Nanosecond // 微秒
 Millisecond          = 1000 * Microsecond // 毫秒
 Second               = 1000 * Millisecond // 秒
 Minute               = 60 * Second // 分钟
 Hour                 = 60 * Minute // 小时
)

package main

import (
 "fmt"
 "time"
)
func main()  {
 for{
  // 1秒钟打印一次
  time.Sleep(time.Second * 1)
  // 0.1秒打印一次
  //time.Sleep(time.Second * 0.1)
  time.Sleep(time.Millisecond * 100)
  fmt.Println("Hello LNJ")
 }
}

• 获取当前时间戳
• Unix秒
• UnixNano纳秒
• 一般用于配合随机函数使用, 作为随机函数随机种子

package main

import (
 "fmt"
 "time"
)

func main()  {
 t := time.Now()
 // 获取1970年1月1日距离当前的时间(秒)
 fmt.Println(t.Unix())
 // 获取1970年1月1日距离当前的时间(纳秒)
 fmt.Println(t.UnixNano())
}

package main

import (
 "fmt"
 "math/rand"
 "time"
)
func main()  {
 // 创建随机数种子
 rand.Seed(time.Now().UnixNano())
 // 生成一个随机数
 fmt.Println(rand.Intn(10))
}

Go语言中调用C语言函数

• 在Go语言开篇中我们已经知道, Go语言与C语言之间有着千丝万缕的关系, 甚至被称之为21世纪的C语言
• 所以在Go与C语言互操作方面，Go更是提供了强大的支持。尤其是在Go中使用C，你甚至可以直接在Go源文件中编写C代码，这是其他语言所无法望其项背的
• 格式:
• 在import "C"之前通过单行注释或者通过多行注释编写C语言代码
• 在import "C"之后编写Go语言代码
• 在Go语言代码中通过C.函数名称() 调用C语言代码即可
• 注意: import "C"和前面的注释之间不能出现空行或其它内容, 必须紧紧相连

package main
//#include <stdio.h>
//void say(){
// printf("Hello World\n");
//}
import "C"

func main()  {
 C.say()
}

package main
/*
#include <stdio.h>
void say(){
 printf("Hello World\n");
}
*/
import "C"

func main()  {
 C.say()
}

• Go语言中没有包名是C的包, 但是这个导入会促使Go编译器利用cgo工具预处理文件
• 在预处理过程中,cgo会产生一个临时包, 这个包里包含了所有C函数和类型对应的Go语言声明
• 最终使得cgo工具可以通过一种特殊的方式来调用import "C"之前的C语言代码

• 常规问题:
• 如果编译报错cc1.exe: sorry, unimplemented: 64-bit mode not compiled in
• 说明你使用的是64的golang，而你使用的32位的MinGW，所以需要下载64位的mingw并配置环境变量
• 下载地址: https://www.baidu.com/s?wd=sorry%2C%20unimplemented%3A%2064-bit%20mode%20not%20compiled%20in

C语言中调用Go语言函数(很少使用)

• 在Go代码中通过 //export Go函数名称导出Go的函数名称
• 在C代码中通过 extern 返回值类型 Go函数名称(形参列表); 声明Go中导出的函数名称
• 注意: //export Go函数名称和extern 返回值类型 Go函数名称(形参列表);不能在同一个文件中

package main

import "C"
import "fmt"
// 导出Go函数声明, 给C使用
//export GoFunction
func GoFunction() {
 fmt.Println("GoFunction!!!")
}

package main
/*
#include <stdio.h>
// 声明Go中的函数
extern void GoFunction();

void CFunction() {
        printf("CFunction!\n");
        GoFunction();
}
*/
import "C"

func main()  {
 C.CFunction()
}

• 由于不在同一个文件, 所以需要通过go build或者go install同时编译多个文件

• Go中使用C语言的类型
• 基本数据类型
• 在Go中可以用如下方式访问C原生的数值类型：

C.char,
C.schar (signed char),
C.uchar (unsigned char),
C.short,
C.ushort (unsigned short),
C.int, C.uint (unsigned int),
C.long,
C.ulong (unsigned long),
C.longlong (long long),
C.ulonglong (unsigned long long),
C.float,
C.double

• Go的数值类型与C中的数值类型不是一一对应的。因此在使用对方类型变量时必须显式转型操作

package main
/*
#include <stdio.h>
int num = 123;
float value = 3.14;
char ch = 'N';
*/
import "C"
import "fmt"

func main()  {
 var num1 C.int = C.num
 fmt.Println(num1)
 var num2 int
 //num2 = num1 // 报错
 num2 = int(num1)
 fmt.Println(num2)


 var value1 C.float = C.value
 fmt.Println(value1)
 var value2 float32 = float32(C.value)
 fmt.Println(value2)


 var ch1 C.char = C.ch
 fmt.Println(ch1)
 var ch2 byte = byte(C.ch)
 fmt.Println(ch2)
}

• 字符串类型
• C语言中并不没有字符串类型，在C中用带结尾'\0'的字符数组来表示字符串；而在Go中string类型是原生类型，因此在两种语言互操作是必须要做字符串类型的转换
• C字符串转换Go字符串: C.GoString(str)
• Go字符串转换C字符串: C.CString(str)

package main
/*
#include <stdio.h>
char *str = "www.it666.com";
void say(char *name){
 printf("my name is %s", name);
}
*/
import "C"
import (
 "fmt"
 "unsafe"
)

func main()  {
 // 1.C语言字符串转换Go语言字符串
 str1 := C.str
 str2 := C.GoString(str1)
 fmt.Println(str2)

 // 2.Go语言字符串转换C语言字符串
 str := "lnj"
 cs := C.CString(str)
 C.say(cs)
 // 注意: 转换后所得到的C字符串cs并不能由Go的gc所管理，我们必须手动释放cs所占用的内存
 C.free(unsafe.Pointer(cs))
}

• 指针类型
• unsafe.Pointer：通用指针类型，用于转换不同类型的指针，不能进行指针运算
• 原生数值类型的指针类型可按Go语法在类型前面加上*，例如:var p *C.int。
• 而void*比较特殊，用Go中的unsafe.Pointer表示。
• uintptr：用于指针运算，GC 不把 uintptr 当指针，uintptr 无法持有对象。uintptr 类型的目标会被回收
• 也就是说 unsafe.Pointer 是桥梁，可以让任意类型的指针实现相互转换，也可以将任意类型的指针转换为uintptr 进行指针运算

package main
/*
#include <stdio.h>
int num = 123;
void *ptr = &num;
*/
import "C"
import (
 "fmt"
 "unsafe"
)

func main()  {
 // 这是一个C语言变量
 var num C.int = C.num
 // 这是一个C语言指针
 var p1 *C.int = &num
 fmt.Println(*p1)

 //var p2 *C.void = C.ptr // 报错
 // 利用unsafe.Pointer接收viod *
 var p2 unsafe.Pointer = C.ptr
 // 将unsafe.Pointer转换为具体类型
 var p3 *C.int = (*C.int)(p2)
 fmt.Println(*p3)
}

• 枚举类型
• C语言中的枚举类型在Go语言中的表现形式为C.enum_XXX
• 访问枚举和访问普通变量无异, 直接通过C.枚举值即可

package main
/*
#include <stdio.h>
enum Gender {
   GenderMale,
   GenderFemale,
   GenderYao
};
*/
import "C"
import "fmt"

func main()  {
 var sex C.enum_Gender = C.GenderMale
 fmt.Println(sex)
 sex = C.GenderFemale
 fmt.Println(sex)
 sex = C.GenderYao
 fmt.Println(sex)
}

• 结构体类型
• C语言中的结构体类型在Go语言中的表现形式为C.struct_XXX
• 访问结构体 直接通过结构体变量.属性名称即可

package main
/*
#include <stdio.h>
struct Point {
    float x;
    float y;
};
*/
import "C"
import (
 "fmt"
)

func main()  {
 // 1.利用C的结构体类型创建结构体
 var cp C.struct_Point = C.struct_Point{6.6, 8.8}
 fmt.Println(cp)
 fmt.Printf("%T\n", cp)

 // 2.将C语言结构体转换为Go语言结构体
 type GoPoint struct {
  x float32
  y float32
 }
 var gp GoPoint
 gp.x = float32(cp.x)
 gp.y = float32(cp.y)
 fmt.Println(gp)
}

• 数组类型
• C语言中的数组与Go语言中的数组差异较大， C中的数组是指针类型,  Go中的数组是值类型
• 目前似乎无法直接显式的在两者之间进行转型，官方文档也没有说明。

package main
/*
#include <stdio.h>
int cArray[5] = {1, 2, 3, 4, 5};
*/
import "C"
import "fmt"

func main()  {
 var cArr [5]C.int = C.cArray
 fmt.Println(cArr)
 fmt.Printf("%T\n", cArr)
}

• 利用Go语言调用C语言函数, 实现无缓冲区输入
• 请在终端运行

package main
/*
#include <stdio.h>
char lowerCase(char ch){
    // 1.判断当前是否是小写字母
    if(ch >= 'a' && ch <= 'z'){
        return ch;
    }
    // 注意点: 不能直接编写else, 因为执行到else不一定是一个大写字母
    else if(ch >= 'A' && ch <= 'Z'){
        return ch + ('a' - 'A');
    }
    return ' ';
}
char getCh(){
    // 1.接收用户输入的数据
    char ch;
    scanf("%c", &ch);
    setbuf(stdin, NULL);
    // 2.大小写转换
    ch = lowerCase(ch);
    // 3.返回转换好的字符
    return ch;
}
 */
import "C"
import "fmt"

func main()  {
 for{
  fmt.Println("请输入w a s d其中一个字符, 控制小人走出迷宫")
  var ch byte = byte(C.getCh())
  fmt.Printf("%c", ch)
 }
}

文件的打开和关闭

• 和C语言一样, Go语言中操作文件也是通过一个FILE结构体

type file struct {
 pfd     poll.FD
 name    string
 dirinfo *dirInfo 
}
type File struct {
 *file // os specific
}

• Open函数
• func Open(name string) (file *File, err error)
• Open打开一个文件用于读取
• Close函数
• func (f *File) Close() error
• Close关闭文件f

package main
import (
 "fmt"
 "os"
)

func main() {
 // 1.打开一个文件
 // 注意: 文件不存在不会创建, 会报错
 // 注意: 通过Open打开只能读取, 不能写入
 fp, err := os.Open("d:/lnj.txt")
 if err != nil{
  fmt.Println(err)
 }else{
  fmt.Println(fp)
 }

 // 2.关闭一个文件
 defer func() {
  err = fp.Close()
  if err != nil {
   fmt.Println(err)
  }
 }()
}

文件读取

• Read函数(不带缓冲区去读)
• func (f *File) Read(b []byte) (n int, err error)
• Read方法从f中读取最多len(b)字节数据并写入b,

package main

import (
 "fmt"
 "io"
 "os"
)

func main() {
 // 1.打开一个文件
 // 注意: 文件不存在不会创建, 会报错
 // 注意: 通过Open打开只能读取, 不能写入
 fp, err := os.Open("d:/lnj.txt")
 if err != nil{
  fmt.Println(err)
 }else{
  fmt.Println(fp)
 }

 // 2.关闭一个文件
 defer func() {
  err = fp.Close()
  if err != nil {
   fmt.Println(err)
  }
 }()

 // 3.读取指定指定字节个数据
 // 注意点: \n也会被读取进来
 //buf := make([]byte, 50)
 //count, err := fp.Read(buf)
 //if err != nil {
 // fmt.Println(err)
 //}else{
 // fmt.Println(count)
 // fmt.Println(string(buf))
 //}

 // 4.读取文件中所有内容, 直到文件末尾为止
 buf := make([]byte, 10)
 for{
  count, err := fp.Read(buf)
  // 注意: 这行代码要放到判断EOF之前, 否则会出现少读一行情况
  fmt.Print(string(buf[:count]))
  if err == io.EOF {
   break
  }
 }
}

• ReadBytes和ReadString函数(带缓冲区去读)
• func (b *Reader) ReadBytes(delim byte) (line []byte, err error)
• ReadBytes读取直到第一次遇到delim字节
• func (b *Reader) ReadString(delim byte) (line string, err error)
• ReadString读取直到第一次遇到delim字节

package main

import (
 "bufio"
 "fmt"
 "io"
 "os"
)

func main() {
 // 1.打开一个文件
 // 注意: 文件不存在不会创建, 会报错
 // 注意: 通过Open打开只能读取, 不能写入
 fp, err := os.Open("d:/lnj.txt")
 if err != nil{
  fmt.Println(err)
 }else{
  fmt.Println(fp)
 }

 // 2.关闭一个文件
 defer func() {
  err = fp.Close()
  if err != nil {
   fmt.Println(err)
  }
 }()

 // 3.读取一行数据
 // 创建读取缓冲区, 默认大小4096
 //r :=bufio.NewReader(fp)
 //buf, err := r.ReadBytes('\n')
 //buf, err := r.ReadString('\n')
 //if err != nil{
 // fmt.Println(err)
 //}else{
 // fmt.Println(string(buf))
 //}

 // 4.读取文件中所有内容, 直到文件末尾为止
 r :=bufio.NewReader(fp)
 for{
  //buf, err := r.ReadBytes('\n')
  buf, err := r.ReadString('\n')
  fmt.Print(string(buf))
  if err == io.EOF{
   break
  }
 }
}

• ReadFile函数
• func ReadFile(filename string) ([]byte, error)
• 从filename指定的文件中读取数据并返回文件的所有内容
• 不适合大文件读取

package main

import (
 "fmt"
 "io/ioutil"
)

func main() {

 filePath := "d:/lnj.txt"
 buf, err := ioutil.ReadFile(filePath)
 if err !=nil {
  fmt.Println(err)
 }else{
  fmt.Println(string(buf))
 }
}

文件创建和写入

• Create函数
• func Create(name string) (file *File, err error)
• Create采用模式0666（任何人都可读写，不可执行）创建一个名为name的文件
• 如果文件存在会覆盖原有文件
• Write函数
• func (f *File) Write(b []byte) (n int, err error)
• 将指定字节数组写入到文件中
• WriteString函数
• func (f *File) WriteString(s string) (ret int, err error)
• 将指定字符串写入到文件中

package main

import (
 "fmt"
 "os"
)

func main() {

 // 1.创建一个文件
 fp, err := os.Create("d:/lnj.txt")
 if err != nil{
  fmt.Println(err)
 }
 // 2.关闭打开的文件
 defer func() {
  err := fp.Close()
  if err != nil {
   fmt.Println(err)
  }
 }()
 // 2.往文件中写入数据
 // 注意: Windows换行是\r\n
 bytes := []byte{'l','n','j','\r','\n'}
 fp.Write(bytes)
 
 fp.WriteString("www.it666.com\r\n")
 fp.WriteString("www.itzb.com\r\n")
 // 注意: Go语言采用UTF-8编码, 一个中文占用3个字节
 fp.WriteString("李南江")
}

• OpenFile函数

  const (
    O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
    O_WRONLY int = syscall.O_WRONLY // 只写模式打开文件
    O_RDWR   int = syscall.O_RDWR   // 读写模式打开文件
    O_APPEND int = syscall.O_APPEND // 写操作时将数据附加到文件尾部
    O_CREATE int = syscall.O_CREAT  // 如果不存在将创建一个新文件
    O_EXCL   int = syscall.O_EXCL   // 和O_CREATE配合使用，文件必须不存在
    O_SYNC   int = syscall.O_SYNC   // 打开文件用于同步I/O
    O_TRUNC  int = syscall.O_TRUNC  // 如果可能，打开时清空文件
  )
  

  const (
    // 单字符是被String方法用于格式化的属性缩写。
    ModeDir        FileMode = 1 << (32 - 1 - iota) // d: 目录
    ModeAppend                                     // a: 只能写入，且只能写入到末尾
    ModeExclusive                                  // l: 用于执行
    ModeTemporary                                  // T: 临时文件（非备份文件）
    ModeSymlink                                    // L: 符号链接（不是快捷方式文件）
    ModeDevice                                     // D: 设备
    ModeNamedPipe                                  // p: 命名管道（FIFO）
    ModeSocket                                     // S: Unix域socket
    ModeSetuid                                     // u: 表示文件具有其创建者用户id权限
    ModeSetgid                                     // g: 表示文件具有其创建者组id的权限
    ModeCharDevice                                 // c: 字符设备，需已设置ModeDevice
    ModeSticky                                     // t: 只有root/创建者能删除/移动文件
    // 覆盖所有类型位（用于通过&获取类型位），对普通文件，所有这些位都不应被设置
    ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice
    ModePerm FileMode = 0777 // 覆盖所有Unix权限位（用于通过&获取类型位）
  )
  

• 0没有任何权限
• 1.执行权限(如果是可执行程序, 可以运行)
• 2.写权限
• 3.写权限和执行权限
• 4.读权限
• 5.读权限和执行权限
• 6.读权限和写权限
• 7.读权限和写权限以及执行权限
• 第三个参数: 指定权限
• func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
• 第一个参数: 打开的路径
• 第二个参数: 打开的模式

• 不带缓冲区写入

package main

import (
 "fmt"
 "os"
)

func main() {

 // 注意点: 第三个参数在Windows没有效果
 // -rw-rw-rw- (666)   所有用户都有文件读、写权限。
 //-rwxrwxrwx (777)  所有用户都有读、写、执行权限。
 // 1.打开文件
 //fp, err := os.OpenFile("d:/lnj.txt", os.O_CREATE|os.O_RDWR, 0666)
 fp, err := os.OpenFile("d:/lnj.txt", os.O_CREATE|os.O_APPEND, 0666)
 if err != nil {
  fmt.Println(err)
 }
 // 2.关闭打开的文件
 defer func() {
  err := fp.Close()
  if err != nil {
   fmt.Println(err)
  }
 }()

 // 注意点:
 // 如果O_RDWR模式打开, 被打开文件已经有内容, 会从最前面开始覆盖
 // 如果O_APPEND模式打开, 被打开文件已经有内容, 会从在最后追加
 // 3.往文件中写入数据
 bytes := []byte{'l','n','j','\r','\n'}
 fp.Write(bytes)
 fp.WriteString("www.it666.com\r\n")
}

• 带缓冲区写入

package main

import (
 "bufio"
 "fmt"
 "os"
)

func main() {

 // 1.打开文件
 fp, err := os.OpenFile("d:/lnj.txt", os.O_CREATE|os.O_APPEND, 0666)
 if err != nil {
  fmt.Println(err)
 }
 // 2.关闭打开的文件
 defer func() {
  err := fp.Close()
  if err != nil {
   fmt.Println(err)
  }
 }()

 // 3.创建缓冲区
 w := bufio.NewWriter(fp)

 // 4.写入数据到缓冲区
 bytes := []byte{'l','n','j','\r','\n'}
 w.Write(bytes)
 w.WriteString("www.it666.com\r\n")

 // 5.将缓冲区中的数据刷新到文件
 w.Flush()
}

• WriteFile函数

package main

import (
 "fmt"
 "io/ioutil"
)

func main() {

 // 1.写入数据到指定文件
 data := []byte{'l','n','j','\r','\n'}
 err := ioutil.WriteFile("d:/abc.txt", data, 0666)
 if err != nil {
  fmt.Println(err)
 }else{
  fmt.Println("写入成功")
 }
}

判断文件是否存在

• Stat函数
• func Stat(name string) (fi FileInfo, err error)
• 返回值: FileInfo

type FileInfo interface {
    Name() string       // 文件的名字（不含扩展名）
    Size() int64        // 普通文件返回值表示其大小；其他文件的返回值含义各系统不同
    Mode() FileMode     // 文件的模式位
    ModTime() time.Time // 文件的修改时间
    IsDir() bool        // 等价于Mode().IsDir()
    Sys() interface{}   // 底层数据来源（可以返回nil）
}

• 返回值: error
• 返回值error等于nil,代表文件存在
• 返回值error不等于nil, 可以进一步通过IsNotExist判断, 如果返回true代表文件不存在
• 返回值error如果返回其它错误, 则不确定文件是否存在

package main

import (
 "fmt"
 "os"
)

func main() {

 info, err := os.Stat("d:/lnj.txt")
 if err == nil {
  fmt.Println("文件存在")
  fmt.Println(info.Name())
 }else if os.IsNotExist(err) {
  fmt.Println("文件不存在")
 }else{
  fmt.Println("不确定")
 }
}

练习

• 将一个文本文件拷贝到另外一个文件中
• 尝试用上面学习的其它方法实现下

package main

import (
 "fmt"
 "io/ioutil"
)

func main() {

 // 1.读取一个文件
 buf, err := ioutil.ReadFile("d:/lnj.txt")
 if err != nil {
  fmt.Println(err)
  return
 }
 // 2.写入读取的数据到另一个文件
 err =ioutil.WriteFile("d:/abc.txt", buf, 0666)
 if err != nil {
  fmt.Println(err)
  return
 }
 fmt.Println("拷贝完成")

}

• 将一个图片/视频文件拷贝到另一个文件

package main

import (
 "bufio"
 "fmt"
 "io"
 "os"
)

func main() {

 // 1.定义拷贝文件的路径
 scrPath := "D:/a.png"
 destPath := "E:/b.png"
 // 2.打开被拷贝文件
 fr, err := os.Open(scrPath)
 if err != nil {
  fmt.Println(err)
  return
 }
 // 3.关闭打开文件
 defer func() {
  err := fr.Close()
  if err != nil{
   fmt.Println(err)
  }
 }()
 // 4.创建读取缓冲区
 r := bufio.NewReader(fr)

 // 1.创建写入文件
 fw, err := os.Create(destPath)
 if err != nil {
  fmt.Println(err)
  return
 }
 // 2.关闭打开文件
 defer func() {
  err := fw.Close()
  if err != nil{
   fmt.Println(err)
  }
 }()
 // 3.创建写入缓冲区
 w := bufio.NewWriter(fw)
 // 4.利用系统copy函数完成拷贝
 count, err := io.Copy(w, r)
 if err != nil {
  fmt.Println(err)
  return
 }
 fmt.Println(count)
 fmt.Println("拷贝完成")
}