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)
}

文件的读写

文件写入和写入文章来源地址https://www.toymoban.com/news/detail-700228.html

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
		}
	}
}

到了这里，关于go语言基本操作---五的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！