GO 学习笔记——第五天 / 异常，文本文件处理

1.error接口，panic，recover

• error：输出错误信息

package main

import "fmt"
import "errors"

func main() {

	err1 := fmt.Errorf("ERROR")
	fmt.Println(err1)

	err2 := errors.New("THIS IS ERROR")
	fmt.Println(err2)

	result, err := Div(10, 2)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(result)
	}
}

//相除
func Div(a, b int) (result int, err error) {
	err = nil
	if b == 0 {
		err = errors.New("除数不能为0")
	} else {
		result = a / b
	}
	return result, err
}

• panic
  • 致命错误

package main

import "fmt"

func main() {

	TestA()
	TestB()
	TestC()
}

func TestA() {
	fmt.Println("A")
}

func TestB() {
	fmt.Println("B")
	//panic会直接中断程序
	//panic("Error")
}

func TestC() {
	fmt.Println("C")

	//模拟数组越界
	x := [2]int{1, 2}
	x[3] = 10
}

• recover
  • 出错但不停止程序

package main

import "fmt"

func main() {

	TestA()
	TestB(3)
	TestC()

	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}

	}()
}

func TestA() {
	fmt.Println("A")
}

func TestB(x int) {
	fmt.Println("B")
	//panic会直接中断程序
	//panic("Error")

	//模拟数组越界
	i := [2]int{1, 2}
	i[x] = 10
}

func TestC() {
	fmt.Println("C")
}

2.字符串处理

• 字符串操作
  • Contains:是否包含
  • Join:拼接
  • Index:位置
  • Repeat:拼接重复
  • Replace:替换
  • Split:分离
  • Trim:两头去除
  • Fieids:分离更加强大

package main

import "fmt"
import "strings"

//字符串操作
func main() {

	s := "Hello World"

	fmt.Println(strings.Contains(s, "W"))
	//true
	fmt.Println(strings.Contains(s, "A"))
	//false

	s1 := []string{"abc", "def", "ghi", "jk"}
	fmt.Println(strings.Join(s1, "&"))
	//abc&def&ghi&jk

	fmt.Println(strings.Index(s, "W"))
	//6

	s = strings.Repeat("go", 3)
	fmt.Println(s)
	//gogogo

	s = "Hello World"
	fmt.Println(strings.Split(s, " "))
	//[Hello World]

	fmt.Println(strings.Trim("    are you ok ? ", " "))
	//are you ok  ?

	fmt.Println(strings.Fields("    are you ok ?  "))
	//[are you ok ?]
}

• 字符串转换
  • Append：将整数转换成字符串并且追加
  • Format：把其他类型转换成字符串
  • Parse：把字符串转换成其他类型

package main

import "fmt"
import "strconv"

//字符串转换
func main() {

	slice := make([]byte, 0, 1024)
	slice = strconv.AppendBool(slice, true)
	//十进制方式追加
	slice = strconv.AppendInt(slice, 1234, 10)

	fmt.Println(string(slice))
	//true1234

	var str string
	str = strconv.FormatBool(true)
	fmt.Println(str)
	//true
	str = strconv.FormatFloat(3.14, 'f', -1, 32)
	fmt.Println(str)
	//3.14
	str = strconv.Itoa(6556)
	fmt.Println(str)
	//6556

	var flag bool
	var err error
	flag, err = strconv.ParseBool("true")
	if err == nil {
		fmt.Println(flag)
		//true
	} else {
		fmt.Println(err)
	}

	i, err := strconv.Atoi("1867")
	if err == nil {
		fmt.Println(i + 9)
		//1876
	} else {
		fmt.Println(err)
	}

}

3.正则表达式

package main

import "fmt"
import "regexp"

func main() {

	buf := "abc azc a7c aac 888 a9c tac"
	reg := regexp.MustCompile(`a.c`)
	if reg == nil {
		fmt.Println("error")
		return
	}
	result := reg.FindAllStringSubmatch(buf, -1)
	fmt.Println(result)
	//[[abc] [azc] [a7c] [aac] [a9c]]

	//提取有效的小数
	buff := "3.14 ddd wr5 6. 7.12 www 92.1"
	rege := regexp.MustCompile(`\d+\.\d+`)
	if rege != nil {
		result := rege.FindAllStringSubmatch(buff, -1)
		fmt.Println(result)
		//[[3.14] [7.12] [92.1]]
	}

}

4.JSON处理

• Json生成

package main

import "fmt"
import "encoding/json"

//Json 生成
func main() {

	//1.通过结构体生成
	s := IT{"大学", []string{"Java", "C/C++", "GO"}, true, 3.14}
	//buf, err := json.Marshal(s)
	//格式化打印
	buf, err := json.MarshalIndent(s, "", " ")
	if err == nil {
		fmt.Println(string(buf))
		//{"Company":"大学","Subjects":["Java","C/C++","GO"],"IsOk":true,"Price":3.14}
	} else {
		fmt.Println(err)
	}

	fmt.Println("-------------------------------------")

	//2.通过Map生成
	m := make(map[string]interface{}, 4)
	m["company"] = "大学"
	m["subjects"] = []string{"Java", "C/C++", "GO"}
	m["isOk"] = true
	m["price"] = 3.14
	buff, errs := json.MarshalIndent(m, "", " ")
	if errs == nil {
		fmt.Println(string(buff))
		//{"company":"大学","isOk":true,"price":3.14,"subjects":["Java","C/C++","GO"]}
	} else {
		fmt.Println(errs)
	}

	fmt.Println("-------------------------------------")
}

//成员变量名首字母必须大写
type IT struct {
	//需要小写字段 二次编码
	Company  string `json:"company"`
	Subjects []string
	//二次编码转换string
	IsOk  bool `json:",string"`
	Price float64
}

• Json解析

package main

import "fmt"
import "encoding/json"

//Json 解析
func main() {

	sJson := `{"company":"大学","isOk":true,"price":3.14,"subjects":["Java","C/C++","GO"]}`

	//1.解析到结构体
	var tmp IT
	err := json.Unmarshal([]byte(sJson), &tmp)
	if err == nil {
		fmt.Println(tmp)
		//{大学 [Java C/C++ GO] true 3.14}
	}
	//2.解析到map
	m := make(map[string]interface{}, 4)
	json.Unmarshal([]byte(sJson), &m)
	if err == nil {
		fmt.Println(m)
		//map[subjects:[Java C/C++ GO] company:大学 isOk:true price:3.14]
		fmt.Println(m["company"])
		//大学
	}
}

type IT struct {
	Company  string   `json:"company"`
	Subjects []string `json:",subjects"`
	IsOk     bool     `json:",isOK"`
	Price    float64  `json:",price"`
}

5.文件操作

• 设备文件:屏幕（标准输出设备）,键盘（标准输入设备）
• 磁盘文件：放在存储设备上的文件

package main

import "fmt"
import "os"
import "bufio"
import "io"

//Json 解析
func main() {

	//关闭后无法输出
	//os.Stdout.Close()
	fmt.Println("Hello")
	os.Stdout.WriteString("World\n")

	path := "./test.txt"

	//文件的写
	WhiteFile(path)
	//文件的读
	ReadFile(path)
	//换行读取
	ReadLineFile(path)
}

func ReadLineFile(path string) {
	file, err := os.Open(path)
	if err == nil {
		buf := make([]byte, 1024*2)
		//n代表读取内容的长度
		_, err1 := file.Read(buf)
		if err1 == nil {
			//新建一个缓冲区，内容先放在缓冲区
			r := bufio.NewReader(file)
			for {
				bufs, err2 := r.ReadBytes('\n')
				if err2 == nil {
					fmt.Println(string(bufs))
				} else {
					//文件结束
					if err2 == io.EOF {
						break
					}
					fmt.Println(err2)
				}
			}
		} else {
			fmt.Println(err)
		}
	} else {
		fmt.Println(err)
	}
	defer file.Close()
}

func ReadFile(path string) {
	file, err := os.Open(path)
	if err == nil {
		buf := make([]byte, 1024*2)
		//n代表读取内容的长度
		n, err1 := file.Read(buf)
		if err1 == nil {
			fmt.Println(string(buf[:n]))
		} else {
			fmt.Println(err)
		}
	} else {
		fmt.Println(err)
	}
	defer file.Close()
}

func WhiteFile(path string) {
	file, err := os.Create(path)
	if err == nil {
		for i := 0; i < 10; i++ {
			file.WriteString("Hello")
		}
	} else {
		fmt.Println(err)
	}
	defer file.Close()
}

6.拷贝文件案例

package main

import "fmt"
import "os"
import "io"

func main() {
	//获取命令行参数
	list := os.Args
	if len(list) == 3 {
		srcFileName := list[1]
		dstFileName := list[2]
		fmt.Println("srcFileName:", srcFileName, "dstFileName:", dstFileName)
		if srcFileName != dstFileName {
			//只读方式打开源文件
			sF, err1 := os.Open(srcFileName)
			if err1 == nil {
				dF, err2 := os.Create(dstFileName)
				defer sF.Close()
				defer dF.Close()
				if err2 == nil {
					//从源文件读 写入
					buf := make([]byte, 1024*4)
					for {
						n, err3 := sF.Read(buf)
						fmt.Println("n:", n)
						if err3 == nil {
							//写入
							dF.Read(buf[:n])
						} else {
							fmt.Println(err3)
							if err3 == io.EOF {
								break
							}
						}
					}
				} else {
					fmt.Println(err2)
				}
			} else {
				fmt.Println(err1)
			}
		} else {
			fmt.Println("name == name")
		}
	} else {
		fmt.Println("xxx srcFile dstFile")
	}
}