package main
import "fmt"

//带检测的断言
func main(){
  var a interface{}
  var b int
  a = b
  var c float64
  c,ok := a.(float64)
  if ok{
    fmt.Println("ok")
    fmt.Println(c)
  }else{
    fmt.Println("No")
  }

  if c1,ok1 := a.(float64);ok1{
    fmt.Println("Yes")
    fmt.Println(c1)
  }else{
    fmt.Println("no")
  }
}

下面的实例则是判断结构体的断言

//类型断言
type Point struct{
  x int
  y int
}

func main(){
  var a interface{}
  var b Point = Point{1,2}
  a = b//接口可以接受任意类型。
  fmt.Println(a,b)
  var c Point
  c = a.(Point)
  //表示判断a是否为指向Point类型的变量,如果是就转成Point类型
  //然后赋给c,如果不是则报错
  fmt.Println(c)

  //类型断言实例2
  var c1 int
  a = c1
  var c2 int
  //会造成panic,因为float64和int不一样
  //应该确保类型一样。
  //var c3 float64
  //c3 = a.(float64)
  c2 = a.(int)
  fmt.Println(c2)
}

2 文件

2.1 open

通过os这个包打开文件

package main
import "fmt"
import "os"

//file为文件指针
//file叫做文件对象
//file叫文件句柄
func main(){
  file, err := os.Open("d:/test.txt")
  if err!=nil{
    fmt.Println(err)
  }
  fmt.Println(&file)
  file.Close()
}

2.2 read

通过缓存的方法读取文件

package main
import (
  "fmt"
  "os"
  "bufio"
  "io"
)
func main(){
  file, err := os.Open("d:/test.txt")
  if err!=nil{
    fmt.Println(err)
  }
  defer file.Close()

  //带缓存的方法读
  reader := bufio.NewReader(file)
  for{
    str, err := reader.ReadString('\n')//读到一行就结束
    if err == io.EOF{//io.EOF代表末尾
      break
    }
    fmt.Print(str)
  }
  fmt.Println("读取结束")
}

直接读取数据

package main
import "fmt"
import "io/ioutil"
func main(){

  //简单粗暴的读
  //读取的数据不大
  //不用Close因为被封装到Go的底层了
  file := "d:/test.txt"
  content,err := ioutil.ReadFile(file)
  if err!=nil{
    fmt.Println(err)
  }
  fmt.Printf("%v",string(content))
}

但是如果数据比较大的时候用带缓存的读取数据比较好。

2.3 write

写数据:带缓存的写数据

package main
import (
  "fmt"
  "os"
  "bufio"
)


func main(){
  filePaht := "d:/test100.txt"
  file, err := os.OpenFile(filePaht,os.O_WRONLY | os.O_CREATE,0666)
  if err!= nil{
    fmt.Printf("err is %v",err)
    return
  }

  defer file.Close()
  str := "Hello,wolrd\r\n"

  writer := bufio.NewWriter(file)
  for i := 0;i < 5;i ++{
    writer.WriteString(str)
  }
  //调用write方法时候代码是先写入缓存的.所以需要Flush()才可以写到文件中
  
  writer.Flush()
}

强调1
1.要有close方法
2.要flush更新,不然写的文件就在缓存中,没有写到文件中
3.0666这个参数对于windows是没有什么用的。
4.\r\n原因是有的时候由于编码的不同所以会加一个\r

2.4 trunc

覆盖

package main
import "fmt"
import "os"
import "bufio"

func main(){
  filePaht := "d:/abc.txt"
  //os.O_TRUNC的意思为覆盖
  file,err := os.OpenFile(filePaht,os.O_WRONLY|os.O_TRUNC,0666)
  if err!=nil{
    fmt.Printf("%v",err)
    return
  }
  defer file.Close()

  str := "你好\r\n"
  writer := bufio.NewWriter(file)
  for i := 0;i < 5;i++{
    writer.WriteString(str)
  }

  writer.Flush()
}

主要是OpenFile的参数改变,改变为os.O_TRUNC

2.5 append

追加

package main
import (
  "fmt"
  "os"
  "bufio"
)
func main(){
  filePaht := "d:/abc.txt"
  //os.O_APPEND为追加的意思
  file,err := os.OpenFile(filePaht,os.O_WRONLY|os.O_APPEND,0666)
  if err!=nil{
    fmt.Printf("%v",err)
    return
  }
  defer file.Close()

  str := "你好\r\n"
  writer := bufio.NewWriter(file)
  for i := 0;i < 5;i++{
    writer.WriteString(str)
  }

  writer.Flush()
}

主要是OpenFile的参数改变,改变为os.O_APPEND

3 练习

3.1 练习1

先打开一个文件然后读取文件中的内容,然后再追加文件的内容

package main
import "fmt"
import "os"
import "bufio"
import "io"
func main(){
  filePath := "d:/abc.txt"
  //注意以读写的方式打开的
  //先读后写。
  file,err := os.OpenFile(filePath,os.O_RDWR|os.O_APPEND,0666)
  if err!=nil{
    fmt.Printf("%v",err)
    return
  }
  read := bufio.NewReader(file)
  for{
    str,err:=read.ReadString('\n')
    if err == io.EOF{
      break
    }
    fmt.Print(str)
  }

  defer file.Close()

  str := "Ni好\r\n"
  writer := bufio.NewWriter(file)
  for i := 0;i < 6; i++{
    writer.WriteString(str)
  }

  writer.Flush()
}

3.2 复制

复制文件

package main
import "fmt"
import "io/ioutil"

func main(){
  //复制文件
  filePath1 := "d:/abc.txt"
  filePath2 := "d:/a.txt"
  data, err := ioutil.ReadFile(filePath1)
  if err != nil{
    fmt.Printf("%v",err)
    return
  }

  err = ioutil.WriteFile(filePath2,data,0666)
  if err != nil{
    fmt.Printf("%v",err)
    return
  }

}

3.3 统计字符的个数

先定义了一个结构体,然后以结构体的形式输出

package main
import "fmt"
import "os"
import "io"
import "bufio"
//统计字符的个数

//定义一个结构体,用于统计保存的结果
type CharCount struct{
  ChCount int //英文的个数
  NumCount int //数字的个数
  SpaceCount int //空格的个数
  OtherCount int//其他字符的个数
}
func main(){
  //打开一个文件,创建一个Reader
  //每读一行,统计该行有多少个英文,数字,空格,和其他字符
  //然后将结果保存在一个结构体中

  fileName := "d:/test.txt"
  file, err := os.Open(fileName)
  if err != nil{
    fmt.Printf("err is %v",err)
    return
  }

  defer file.Close()
  var count CharCount

  reader := bufio.NewReader(file)
  for{
    str,err := reader.ReadString('\n')
    if err == io.EOF{
      break
    }
    for _,v := range str{
      switch  {
      case v >='a'&&v <= 'z':
        fallthrough
      case v >= 'A'&& v <= 'Z':
        count.ChCount++
      case v == ' ' || v == '\t':
        count.SpaceCount++
      case v >= '0' && v <= '9':
        count.NumCount++
      default:
        count.OtherCount++

        
      }
    }
  }
  fmt.Println(count.ChCount,count.SpaceCount,count.NumCount,count.OtherCount)
}