go语言基本操作---五
error接口的使用
Go语言引入了一个关于错误处理的标准模式，即error接口，它是Go语言内建的接口类型
type error interface {
Error() string
}
package main
import (
"errors"
"fmt"
)
type Student struct {
name string
id int
}
func main() {
err1 := fmt.Errorf("%s", "this is normal err")
fmt.Println("err1 = ", err1) //err1 = this is normol err
err2 := errors.New("this is normal err2")
err3 := err2.Error()
fmt.Println("err2 = ", err2) //err2 = this is normal err2
fmt.Println(err3) //this is normal err2
}
error接口的应用
package main
import (
"errors"
"fmt"
)
type Student struct {
name string
id int
}
func MyDiv(a, b int) (result int, err error) {
err = nil
if 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 main
import "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 main
import "fmt"
func testa() {
fmt.Println("aaaaaaaaaaaaa")
}
func testb(x int) {
var a [10]int
//panic: runtime error: index out of range [20] with length 10
a[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 main
import (
"fmt"
)
func testa() {
fmt.Println("aaaaaaaaaaaaa")
}
func testb(x int) {
//设置recover
defer func() {
//recover() //可以打印panic错误信息
//fmt.Println(recover()) //runtime error: index out of range [20] with length 10
if err := recover(); err != nil {
fmt.Println(err)
}
}()
var a [10]int
//panic: runtime error: index out of range [20] with length 10
a[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 main
import (
"fmt"
"strings"
)
// 字符串操作代码验证
func main() {
//"hellogo"中是否包含"hello" 不包含返回false
fmt.Println(strings.Contains("hellogo", "hello")) //true
fmt.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")) //4
fmt.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)
}
}
字符串转换
package main
import (
"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 string
str = 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 bool
var err error
flag, 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 main
import (
"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 { //解析失败，返回niu
fmt.Println("err")
return
}
//2 根据规则提取关键信息 -1 解析所有的
result1 := reg1.FindAllStringSubmatch(buf, -1)
fmt.Println("result1 = ", result1)
}
package main
import (
"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 { //解析失败，返回niu
fmt.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 main
import (
"encoding/json"
"fmt"
)
// IT 生成json格式成员变量成员首字母必须大写
type IT struct {
Company string
Subjects []string
Isok bool
Price 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 main
import (
"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 main
import (
"encoding/json"
"fmt"
)
// 通过map生成json
func main() {
//创建一个map
m := make(map[string]interface{}, 4)
m["company"] = "itcast"
m["subjects"] = []string{"Go", "C++", "Python", "Test"}
m["isok"] = true
m["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 main
import (
"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 main
import (
"encoding/json"
"fmt"
)
// 通过map生成json
func main() {
jsonBuf := ` {"company": "itcast",
"isok": true,
"price": 666.666,
"subjects": [
"Go",
"C++",
"Python",
"Test"
]
}
`
//创建一个map
m := 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 = itcast
map[isok]的值为bool,内容为value = true
map[price]的值为float64,内容为value = 666.666000
map[subjects]的值为[]interface{},内容为value = [Go C++ Python Test]
*/
switch data := value.(type) { //需要反推
case string:
str = data
fmt.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 main
import (
"fmt"
"os"
)
// 通过map生成json
func main() {
//os.Stdout.Close() //关闭后无法输出
//fmt.Println("are u ok?") //往标准输出设备(屏幕)写内容
//标准设备文件（os.Stdout），默认给用户打开，用户可以直接使用
//os.Stdout
os.Stdout.WriteString("are u OK?\n")
//os.Stdin.Close() //关闭后无法输出
var a int
fmt.Println("请输入a:")
fmt.Scan(&a) //从标准输入设备中读取内容，放在a中
fmt.Println("a = ", a)
}
文件的读写
文件写入和写入
package main
import (
"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 string
for i := 0; i < 10; i++ {
// i = 1\n，这个字符串返回到在buf中
buf = fmt.Sprintf("i = %d\n", i)
fmt.Println("buf = ", buf) //buf = i = 0
writeString, 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 main
import (
"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 main
import (
"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
}
}
}