Go语言基础第10天（文件读写与异常处理）

1.error接口

import (
	"errors"
	"fmt"
)

// 编辑时异常
// 编译时异常
// 运行时异常
func test(a int, b int) (value int, err error) {
    
    
	//0不能作为除数
	if b == 0 {
    
    
		err = errors.New("0不能作为除数")
		return
	} else {
    
    
		value = a / b
		return
	}
}

func main01() {
    
    

	//value := test(10, 0)
	value, err := test(10, 0)
	//err不过不等于空表示有错误信息
	if err != nil {
    
    
		fmt.Println(err)
	} else {
    
    
		fmt.Println(value)
	}
}

2.panic异常处理

import "fmt"

func test1() {
    
    
	fmt.Println("hello world1")
}
func test2() {
    
    
	//fmt.Println("hello world2")
	//可以在程序中直接调用panic 调用后程序会终止执行
	panic("hello world2")
	//print 和println 是对错误信息进行处理的  不建议在程序中打印数据时使用
	//print()
	//println()
}
func test3() {
    
    
	fmt.Println("hello world3")
}

func main02() {
    
    
	test1()
	test2()
	test3()
}

3.defer延迟调用

import "fmt"

func main0301() {
    
    
	fmt.Println("我爱你")
	defer fmt.Println("我也爱你")
	//defer 函数调用
	defer fmt.Println("我还爱你")
	fmt.Println("我爱死你")
}

func test4() {
    
    
	fmt.Println("hello world")

}

var value int

func test5(a int, b int) {
    
    
	value = a + b
}

func test6(value int) {
    
    
	fmt.Println(value)
}
func main0302() {
    
    

	test4()
	//函数中有返回值不能使用defer调用
	defer test5(10, 20)
	test6(value)

}

func main0303() {
    
    
	a := 10
	b := 20
	//定义函数类型变量
	//f:=func(a int ,b int){
    
    
	//	fmt.Println(a)
	//	fmt.Println(b)
	//}

	//f(a,b)
	defer func(a int, b int) {
    
    
		fmt.Println(a)
		fmt.Println(b)
	}(a, b)

	a = 100
	b = 200

	fmt.Println(a)
	fmt.Println(b)
}

4.recover接口

import "fmt"

func demo(i int) {
    
    

	//recover()使用一定要在错误出现之前 进行拦截
	//通过匿名函数和recover()进行错误拦截
	defer func() {
    
    
		//recover可以从panic 异常中重新获取控制权
		//recover()//返回值为接口类型

		//fmt.Println(recover())
		err := recover()
		if err != nil {
    
    
			fmt.Println("demo函数异常：19-33行", err)
		}
	}()
	fmt.Println("1")
	//空指针引用
	var p *int
	*p = 123 //err  //recover作用范围

	fmt.Println("2")
	//数组元素个数为10个  len(arr)  数组下标是从0-9
	var arr [10]int

	//如果传递超出数组下标值 导致数组下标越界
	arr[i] = 100 //panic 系统处理  导致程序崩溃

	fmt.Println(arr)
}
func demo1() {
    
    
	fmt.Println("hello world")
}
func main04() {
    
    
	demo(11)
	demo1()
}

5.文件创建

import (
	"fmt"
	"os"
)

func main05() {
    
    

	//路径分为 绝对路径 （从盘符开始到文件的位置）（linux中是以根目录开始的/） 相对路径 （相对某一个文件的位置）
	//\\是一个转义字符表示【\】 在一般文件操作中都是以【/】
	fp, err := os.Create("D:/a.txt")
	//文件创建失败
	if err != nil {
    
    
		fmt.Println("文件创建失败")
		return //如果return出现在主函数中 表示程序的结束
	}

	//延迟调用 关闭文件
	//1、占用内存和缓冲区
	//2、文件打开上限  65535
	defer fp.Close()

	fmt.Println("文件创建成功")

}

6.写入文件

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

func main0601() {
    
    
	//var fp *File
	//os.Create 创建文件时 文件不存在会创建一个新文件  如果文件存在会覆盖源内容
	fp, err := os.Create("D:/a.txt")
	if err != nil {
    
    
		fmt.Println("文件创建失败")
		return
	}
	defer fp.Close()

	//写入文件
	//\n在文件中是换行  window文本文件换行是\r\n
	//n,_:=fp.WriteString("itcast\r\n")

	//fmt.Println(n)
	//在go语言中 一个汉字是3个字符
	n, _ := fp.WriteString("美女\r\n")
	fmt.Println(n)
	fp.WriteString("来玩啊")
}
func main0602() {
    
    
	//创建文件
	fp, err := os.Create("D:/a.txt")
	if err != nil {
    
    
		fmt.Println("文件创建失败")
		return
	}
	//关闭文件
	defer fp.Close()
	//1、将字符切片写入文件中
	//b:=[]byte{'h','e','l','l','o'}
	//
	文件对象.write(字符切片)
	//n,_:=fp.Write(b)
	//fmt.Println(n)

	//2、将字符串转成字符切片写入文件中
	//str:="helloworld"
	str := "锄禾日当午"
	//字符串和字符切片允许转换
	b := []byte(str)

	fp.Write(b)
}

func main0603() {
    
    
	//fp,err:=os.Create("D:/a.txt")

	//打开文件
	//os.Open(文件名)只读方式打开文件
	//os.Open("D:/a.txt")
	//openfile不能创建新文件
	//os.openfile(文件名，打开模式，打开权限)

	fp, err := os.OpenFile("D:/a.txt", os.O_RDWR, 6)

	if err != nil {
    
    
		fmt.Println("文件创建失败")
		return
	}

	defer fp.Close()
	//通过字符串获取字符切片
	//b:=[]byte("你瞅啥")
	当使用writeat 进行指定位置插入数据时会依次覆盖源内容
	//fp.WriteAt(b,0)

	//获取文件字符个数
	//n,_:=fp.Seek(0,io.SeekEnd)
	//n,_:=fp.Seek(3,io.SeekStart)
	//负数是向左偏移 正数是想右偏移
	n, _ := fp.Seek(-3, io.SeekEnd)
	//b:=[]byte("abcd")
	//fp.WriteAt(b,n)
	fmt.Println(n)
}

7.读取文件

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

func main0701() {
    
    
	//只读方式打开文件
	fp, err := os.Open("D:/a.txt")
	/*
		1、文件不存在
		2、文件权限
		3、文件打开上限
	*/
	if err != nil {
    
    
		fmt.Println("文件打开失败")
		return
	}
	defer fp.Close()
	b := make([]byte, 100)
	//换行也会作为字符一部分进行读取
	fp.Read(b)

	//fmt.Println(b)
	//for i:=0;i<len(b);i++{
    
    
	//	if b[i]!=0{
    
    
	//		fmt.Printf("%c",b[i])
	//
	//	}
	//}
	fmt.Println(string(b))
}

func main0702() {
    
    
	fp, err := os.Open("D:/a.txt")
	if err != nil {
    
    
		fmt.Println("文件打开失败")
		return
	}
	defer fp.Close()

	//创建切片缓冲区
	r := bufio.NewReader(fp)
	//读取一行内容
	b, _ := r.ReadBytes('\n')
	//打印切片中字符的ASCII值
	//fmt.Println(b)
	//将切片转成string打印  汉字
	fmt.Print(string(b))
	//如果在文件截取中  没有标志位（分隔符）到文件末尾自动停止  EOF -1 文件结束标志
	b, _ = r.ReadBytes('\n')

	fmt.Println(string(b))
}

func main0704() {
    
    
	fp, err := os.Open("D:/源文件.txt")
	if err != nil {
    
    
		fmt.Println("文件打开失败")
		return
	}
	defer fp.Close()
	b := make([]byte, 20)

	for {
    
    
		//读取文件返回值为 个数和错误信息
		n, err := fp.Read(b)
		//io.EOF 表示文件的结尾 值为-1
		//eof  end of file
		if err == io.EOF {
    
    
			break
		}
		//if err !=nil{
    
    
		//	//io.EOF 表示文件的结尾 值为-1
		//	//eof  end of file
		//	if err == io.EOF{
    
    
		//		break
		//	}
		//}
		fmt.Print(string(b[:n]))
	}
}

func main0705() {
    
    
	fp, err := os.Open("D:/源文件.txt")
	if err != nil {
    
    
		fmt.Println("文件打开失败")
		return
	}
	defer fp.Close()

	//行读取
	r := bufio.NewReader(fp)

	for {
    
    
		b, err := r.ReadBytes('\n')

		fmt.Print(string(b))
		if err == io.EOF {
    
    
			break
		}
	}

}

8.文件拷贝

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

func main08() {
    
    

	//文件拷贝  从一个文件中拷贝数据到新的文件中
	fp1, err1 := os.Open("D:\\0705基础班\\01_Go语言基础第09天（面向对象下）\\03视频\\02接口定义和使用.avi")
	fp2, err2 := os.Create("D:/test.avi")

	if err1 != nil || err2 != nil {
    
    
		fmt.Println("拷贝失败")
		return
	}

	defer fp1.Close()
	defer fp2.Close()

	b := make([]byte, 1024*1024)

	for {
    
    
		//块读取
		n, err := fp1.Read(b)
		if err == io.EOF {
    
    
			break
		}
		fp2.Write(b[:n])

	}
	fmt.Println("拷贝完成")

}