go语言基本操作---五

error接口的使用

Go语言引入了一个关于错误处理的标准模式，即error接口，它是Go语言内建的接口类型

type error interface {Error() string
}

package mainimport ("errors""fmt"
)type Student struct {name stringid   int
}func main() {err1 := fmt.Errorf("%s", "this is normal err")fmt.Println("err1 = ", err1) //err1 =  this is normol errerr2 := errors.New("this is normal err2")err3 := err2.Error()fmt.Println("err2 = ", err2) //err2 =  this is normal err2fmt.Println(err3)            //this is normal err2
}

error接口的应用

package mainimport ("errors""fmt"
)type Student struct {name stringid   int
}func MyDiv(a, b int) (result int, err error) {err = nilif b == 0 {err = errors.New("分母不能为0")} else {result = a / b}return}
func main() {result, err := MyDiv(10, 0)if err != nil {fmt.Println("err = ", err)} else {fmt.Println("result = ", result) //5}
}

显示调用panic函数-----发生致命异常–导致程序崩溃

比如数组越界，空指针引用等等。

package mainimport "fmt"func testa() {fmt.Println("aaaaaaaaaaaaa")
}func testc() {fmt.Println("bbbbbbbbbbbb")//显示调用panic函数，导致程序中断panic("this is a panic test") //产生一个恐慌
}func testb() {fmt.Println("cccccccccccc")
}func main() {testa()testb()testc()
}

数组越界导致panic

package mainimport "fmt"func testa() {fmt.Println("aaaaaaaaaaaaa")
}func testb(x int) {var a [10]int//panic: runtime error: index out of range [20] with length 10a[x] = 111 //当x为20的时候，导致数组越界，产生一个panic，导致程序崩溃
}func testc() {fmt.Println("cccccccccccc")
}func main() {testa()testb(20)testc()
}

recover函数的使用–发生错误导致程序不会崩溃

Go语言为我们提供了专用于"拦截"运行时panic的内建函数–recover。它可以是当前的程序从运行时panic的状态中恢复并重新获得流程控制权.
func recover() interface{}
注意: recover只有在defer调用的函数中有效。
如果调用了内置函数recover，并且定义该defer语句的函数发生了panic异常，recover会使程序从panic中恢复,并返回panic value。导致panic异常的函数不会继承运行，但能正常返回。在未发生panic时调用recover，recover会返回nil。

package mainimport ("fmt"
)func testa() {fmt.Println("aaaaaaaaaaaaa")
}func testb(x int) {//设置recoverdefer func() {//recover() //可以打印panic错误信息//fmt.Println(recover()) //runtime error: index out of range [20] with length 10if err := recover(); err != nil {fmt.Println(err)}}()var a [10]int//panic: runtime error: index out of range [20] with length 10a[x] = 111 //当x为20的时候，导致数组越界，产生一个panic，导致程序崩溃fmt.Println("bbbbbbbbbbbbb")
}func testc() {fmt.Println("cccccccccccc")
}func main() {testa()testb(20)testc()
}

字符串操作常用函数介绍

Contains(s,substr string) bool
功能：字符串s中是否包含substr返回bool值
Join(a[]string,sep string) string
功能:字符串连接，把切片 a通过sep连接起来
Index(s,sep string) int
功能:在字符串s中查找sep所在的位置，返回位置值，找不到返回-1
Repeat(s string,count int) string
功能:重复s字符串count次，最后返回重复的字符串
Replace(s,old,new string,n int) string
功能:在s字符串吧old字符串替换为new字符串,n表示替换的次数，小于0表示全部替换
Split(s,sep string)[]string
功能:把s字符串按照sep分隔，返回slice(切片)
Trim(s string,cutset string) string
功能:在s字符串的头部和尾部取出cutset指定的字符串
Fields(s string) [] string
功能:去除s字符串的空格符，并且按照空格分隔返回切片

字符串操作代码验证

package mainimport ("fmt""strings"
)// 字符串操作代码验证
func main() {//"hellogo"中是否包含"hello" 不包含返回falsefmt.Println(strings.Contains("hellogo", "hello")) //truefmt.Println(strings.Contains("hellogo", "abc"))   //false//Joins 组合s := []string{"abc", "hello", "mike", "go"}buf := strings.Join(s, "@")fmt.Println("buf = ", buf) //buf =  abc@hello@mike@go//Index 查找子串的位置fmt.Println(strings.Index("abcdhello", "hello")) //4fmt.Println(strings.Index("abcdhello", "go"))    //-1//重复出现多少次buf = strings.Repeat("go", 3)fmt.Println("buf = ", buf) //buf =  gogogo//Split 以指定的分隔符拆分buf = "hello@abc@go@mike"s2 := strings.Split(buf, "@")fmt.Println("s2 = ", s2) //s2 =  [hello abc go mike]//Trim去掉两头的字符buf = strings.Trim("         are u ok?     ", " ") //去掉两头空格fmt.Printf("buf = #%s#\n", buf)                    //buf = #are u ok?#//Fields 处理空格 切片 把元素放入切片中s3 := strings.Fields("         are u ok?     ")//fmt.Println(s3) //[aru u ok?]for i, data := range s3 {//0 , aru//1 , u//2 , ok?fmt.Println(i, ",", data)}
}

字符串转换
Append
在这里插入图片描述

package mainimport ("fmt""strconv"
)// 字符串操作代码验证
func main() {//转换为字符串后追加到字节数组slice := make([]byte, 0, 1024)slice = strconv.AppendBool(slice, true)//第二个数为要追加的数，第三个为指定的10进制方式追加slice = strconv.AppendInt(slice, 1234, 10)slice = strconv.AppendQuote(slice, "abcdeasda")slice = strconv.AppendQuoteRune(slice, '单')fmt.Println("slice = ", string(slice)) //slice =  true1234"abcdeasda"'单' 转换为字符串再打印/*for i, data := range slice {fmt.Println(i, ",", string(data))}*///fmt.Println("slice = ", slice) //slice =  [116 114 117 101 49 50 51 52 34 97 98 99 100 101 97 115 100 97 34 39 229 141 149 39]//其他类型转换为字符串var str stringstr = strconv.FormatBool(false)fmt.Println("str = ", str) //str =  false//‘f’指打印格式，小数方式，-1指小数点位数(紧缩模式),64以64处理str = strconv.FormatFloat(3.14, 'f', -1, 64)fmt.Println("str = ", str) //str =  3.14//整型转字符串str = strconv.Itoa(6666)fmt.Println("str = ", str) //str =  6666//字符串转其他类型var flag boolvar err errorflag, err = strconv.ParseBool("true")if err == nil {fmt.Println("flag = ", flag) //flag =  true} else {fmt.Println("err = ", err)}//把字符串转换为整型a, _ := strconv.Atoi("567")fmt.Println("a = ", a) //a =  567
}

正则表达式

Go语言通过regexp标准包为正则表达式提供了官方支持
. 在这里插入图片描述

package mainimport ("fmt""regexp"
)// 字符串操作代码验证
func main() {buf := "abc azc a7c aac 888 a9c tac"//1解析规则 它会解析正则表达式，如果成功就会返回解析器//reg1 := regexp.MustCompile(`a.c`) //result1 =  [[abc] [azc] [a7c] [aac] [a9c]]//reg1 := regexp.MustCompile(`a[0-9]c`) //result1 =  [[a7c] [a9c]]reg1 := regexp.MustCompile(`a\dc`) //result1 =  [[a7c] [a9c]]if reg1 == nil { //解析失败，返回niufmt.Println("err")return}//2 根据规则提取关键信息 -1 解析所有的result1 := reg1.FindAllStringSubmatch(buf, -1)fmt.Println("result1 = ", result1)
}

package mainimport ("fmt""regexp"
)func main() {//提取有效地小数buf := "43.14 567 agsdg 1.23 7. 8.99 lsdljl 6.66"//1解析规则 它会解析正则表达式，如果成功就会返回解析器reg1 := regexp.MustCompile(`\d+\.\d+`) //result1 =  [[43.14] [1.23] [8.99] [6.66]]if reg1 == nil { //解析失败，返回niufmt.Println("err")return}//2 根据规则提取关键信息 -1 解析所有的result1 := reg1.FindAllStringSubmatch(buf, -1)fmt.Println("result1 = ", result1)
}

JSON介绍

JSON是一种比XML更轻量级的数据交换格式，在易于人们阅读和编写的同时，也易于程序解析和生成。
Go语言内建对JSON的支持，使用Go语言内置的encoding/json标准库，开发者可以轻松使用Go程序生成的解析JSON格式的数据。

通过结构体生成json

package mainimport ("encoding/json""fmt"
)// IT 生成json格式成员变量成员首字母必须大写
type IT struct {Company  stringSubjects []stringIsok     boolPrice    float64
}func main() {//定义一个结构体变量，同时初始化s := IT{"itcast", []string{"GO", "C++", "Python", "Test"}, true, 666.666}//编码 根据内容生成json文本,空接口可以是任意类型//buf, err := json.Marshal(s) {"Company":"itcast","Subjects":["GO","C++","Python","Test"],"Isok":true,"Price":666.666}//格式化编码buf, err := json.MarshalIndent(s, "", " ") //格式化编码if err != nil {fmt.Println("err = ", err)return}fmt.Println("buf = ", string(buf))
}

struct_tag的使用

package mainimport ("encoding/json""fmt"
)// IT 生成json格式成员变量成员首字母必须大写 这样就可以改成小写
type IT struct {Company  string   `json:"-"`        //`json:"-"`此字段就不会输出到屏幕Subjects []string `json:"subjects"` //二次编码Isok     bool     `json:",string"`  //`json:",string"`转出字符串类型进行编码Price    float64  `json:",string"`
}func main() {//定义一个结构体变量，同时初始化s := IT{"itcast", []string{"GO", "C++", "Python", "Test"}, true, 666.666}//编码 根据内容生成json文本,空接口可以是任意类型//buf, err := json.Marshal(s) {"Company":"itcast","Subjects":["GO","C++","Python","Test"],"Isok":true,"Price":666.666}//格式化编码buf, err := json.MarshalIndent(s, "", " ") //格式化编码if err != nil {fmt.Println("err = ", err)return}fmt.Println("buf = ", string(buf))
}

通过map生成json

package mainimport ("encoding/json""fmt"
)// 通过map生成json
func main() {//创建一个mapm := make(map[string]interface{}, 4)m["company"] = "itcast"m["subjects"] = []string{"Go", "C++", "Python", "Test"}m["isok"] = truem["price"] = 666.666//编码成json//result, err := json.Marshal(m)result, err := json.MarshalIndent(m, "", " ")if err != nil {fmt.Println("err = ", err)return}//result =  {"company":"itcast","isok":true,"price":666.666,"subjects":["Go","C++","Python","Test"]}fmt.Println("result = ", string(result))
}

json解析到结构体

可以使用json.Unmarshal()函数将JSON格式的文本解码为Go里面预期的数据结构

func Unmarshal(data []byte, v any) error 
type any = interface{}

package mainimport ("encoding/json""fmt"
)type IT struct {Company  string   `json:"company"`  //`json:"-"`此字段就不会输出到屏幕Subjects []string `json:"subjects"` //二次编码Isok     bool     `json:",isok"`    //`json:",string"`转出字符串类型进行编码Price    float64  `json:",price"`
}// 通过map生成json
func main() {jsonBuf := ` {"company": "itcast","isok": true,"price": 666.666,"subjects": ["Go","C++","Python","Test"]}`var tmp IT //定义结构体变量err := json.Unmarshal([]byte(jsonBuf), &tmp) //改内容，取地址if err != nil {fmt.Println("err = ", err)return}fmt.Println("tmp = ", tmp)     //tmp =  {itcast [Go C++ Python Test] true 666.666}fmt.Printf("tmp = %+v\n", tmp) //tmp = {Company:itcast Subjects:[Go C++ Python Test] Isok:true Price:666.666}
}

json解析到map

package mainimport ("encoding/json""fmt"
)// 通过map生成json
func main() {jsonBuf := ` {"company": "itcast","isok": true,"price": 666.666,"subjects": ["Go","C++","Python","Test"]}`//创建一个mapm := make(map[string]interface{}, 4)err := json.Unmarshal([]byte(jsonBuf), &m) //改内容，取地址if err != nil {fmt.Println("err = ", err)return}fmt.Println("tmp = ", m)     //tmp =   map[company:itcast isok:true price:666.666 subjects:[Go C++ Python Test]]fmt.Printf("tmp = %+v\n", m) //tmp =  map[company:itcast isok:true price:666.666 subjects:[Go C++ Python Test]]var str string//类型断言 值，他是value类型for key, value := range m {//fmt.Printf("%v =========>%v\n", key, value)//if key == "company" {//	str = value//	fmt.Println("str = ", str)//}/**map[company]的值为string,内容为value = itcastmap[isok]的值为bool,内容为value = truemap[price]的值为float64,内容为value = 666.666000map[subjects]的值为[]interface{},内容为value = [Go C++ Python Test]*/switch data := value.(type) { //需要反推case string:str = datafmt.Printf("map[%s]的值为string,内容为value = %s\n", key, str)case bool:fmt.Printf("map[%s]的值为bool,内容为value = %v\n", key, data)case float64:fmt.Printf("map[%s]的值为float64,内容为value = %f\n", key, data)case []string:fmt.Printf("map[%s]的值为[]string,内容为value = %v\n", key, data)case []interface{}:fmt.Printf("map[%s]的值为[]interface{},内容为value = %v\n", key, data)}}
}

文件分类和为什么需要文件

文件分类：
设备文件：屏幕(标准输出设备)，键盘(标准输入设备)
磁盘文件:放在存储设备上的文件
1:文本文件
2：二进制文件
为什么需要文件？
内存掉电丢失，程序结束，内存中的内容消失
文件放磁盘，程序结束，文件函数存在

新建文件可以通过如下两个方法
func Create(name string)(file *File,err Error)
根据提供的文件名创建新的文件，返回一个文件对象，默认权限是0666的文件，返回的文件对象时可读写的
func NewFile(fd uintptr,name string) *File
根据文件描述符创建相应的文件，返回一个文件对象通过如下两个文件来打开文件：
func Open(name string)(file *File, err Error)
该方法打开一个名称为name的文件，但是是只读方式，内部实现其实调用了OpenFile
func OpenFile(name string,flag int,perm unit32)(file File，err Error)
打开名称为name的文件，flag是打开的方式，只读，读写等，perm是权限
写文件
func(file *File) write(b []byte)(n int,err Error)
写入byte类型的信息到文件
func(file *File) writeAt(b []byte, off int64)(n int, err Error)
在指定位置开始写入byte类型的信息
func(file *File) writeString(s string)(ret int,err Error)
写入string信息到文件
读文件
func(file *File) Read(b []byte)(n int,err Error)
读取数据到b中
func(file *File)ReadAt(b []byte,off int64)(n int,err Error)
从off开始读取数据到b中
删除文件
func Remove(name string) Error
调用该函数就可以删除文件名为name的文件

标准设备文件的使用

package mainimport ("fmt""os"
)// 通过map生成json
func main() {//os.Stdout.Close() //关闭后无法输出//fmt.Println("are u ok?") //往标准输出设备(屏幕)写内容//标准设备文件（os.Stdout），默认给用户打开，用户可以直接使用//os.Stdoutos.Stdout.WriteString("are u OK?\n")//os.Stdin.Close() //关闭后无法输出var a intfmt.Println("请输入a:")fmt.Scan(&a) //从标准输入设备中读取内容，放在a中fmt.Println("a = ", a)
}

文件的读写

文件写入和写入

package mainimport ("fmt""io""os"
)func WriteFile(path string) {//打开文件,新建文件f, err := os.Create(path)if err != nil {fmt.Println("err = ", err)return}//使用完毕，需要关闭文件defer f.Close() //函数结束前关闭var buf stringfor i := 0; i < 10; i++ {// i = 1\n，这个字符串返回到在buf中buf = fmt.Sprintf("i = %d\n", i)fmt.Println("buf = ", buf) //buf =  i = 0writeString, err := f.WriteString(buf)if err != nil {fmt.Println("err = ", err)return}fmt.Println("writeString = ", writeString)}
}func ReadFile(path string) {//打开文件f, err := os.Open(path)if err != nil {fmt.Println("err = ", err)return}//关闭文件defer f.Close()buf := make([]byte, 1024*2) //2k大小//read代表文件读取内容的长度read, err1 := f.Read(buf)if err1 != nil && err1 != io.EOF { //io.EOF 文件出错同时没有到结尾fmt.Println("err = ", err1)return}fmt.Println("buf = ", string(buf[:read]))}// 通过map生成json
func main() {path := "./demo.txt"WriteFile(path) //写入ReadFile(path)  //读取
}

借助bufio实现按行读取内容

package mainimport ("bufio""fmt""io""os"
)// 每次读取一行
func ReadFileLine(path string) {//打开文件f, err := os.Open(path)if err != nil {fmt.Println("err = ", err)return}//关闭文件defer f.Close()//新建一个缓冲区，把内容先放在缓冲器r := bufio.NewReader(f)for {//遇到\n介绍读取,但是\n也读取进来buf, err1 := r.ReadBytes('\n')if err1 != nil {if err1 == io.EOF { //文件结束break}fmt.Println("err = ", err1)}fmt.Printf("buf = #%s#\n", string(buf))}}
func main() {path := "./demo.txt"//WriteFile(path) //写入//ReadFile(path)  //读取ReadFileLine(path)
}

文件案例：拷贝文件

package mainimport ("fmt""io""os"
)func main() {list := os.Args //获取命令行参数if len(list) != 3 {fmt.Println("usage: xxx srcFile dstFile")return}srcFileName := list[1]dstFileName := list[2]if srcFileName == dstFileName {fmt.Println("源文件和目的文件不能相同")return}//只读方式打开源文件sF, err1 := os.Open(srcFileName)if err1 != nil {fmt.Println("err1 = ", err1)return}//新建目的文件dF, err2 := os.Create(dstFileName)if err2 != nil {fmt.Println("err1 = ", err2)return}//操作文件，需要关闭文件defer sF.Close()defer dF.Close()//核心处理，从源文件读取内容，buf := make([]byte, 1024*4) //临时缓冲区for {read, err := sF.Read(buf)if err != nil {if err == io.EOF { //文件读取完毕break}fmt.Println("err = ", err)}//往目的文件写，读多少写多少n, err3 := dF.Write(buf[:read])if err3 != nil {fmt.Println("err3 = ", err3)return}if n == 0 {return}}
}