异常处理
error 接口 （非致命错误）
err := fmt.Errorf( "%s", "提示erro")
// 第二种：
import "errors"
err2 := errors.New("this is normal err")
eg：
import (
"fmt"
"errors"
)
func main () {
a,b := 12 ,0
result, err := divide(a, b)
if err != nil{
fmt.Println(err)
}else{
fmt.Println(result)
}
}
func divide (a,b int) (result int, err error) {
err = nil
if b == 0 {
err = errors.New("分母不能为0")
}else {
result = a / b
}
return
}
panic( 致命错误，程序崩溃)
// 自己调用panic()
func aa(){
fmt.Println("aaaa")
}
func bb(){
panic("cuowu ")
fmt.Println("bbbb")
}
func cc(){
fmt.Println("cccc")
}
aa()
bb()
cc() // 只会打 aaa 然后报错，程序停止
// 内部自动调用的panic场景有，数组下标访问出界....
recover （防止程序崩溃导致不运行）
func testc ( x int) {
defer func (){
if err := recover(); err !=nil{
fmt.Println(err)
}
}()
a := [10]int{}
a[x] = 11
}
func main () {
testc(20)
fmt.Println("ok----------------------------")
}
文件处理
字符串处理 需要 import "strings"
fmt.Println(strings.Contains("hellow", "hell")) // 包含返回true，否则返回false
s := []string{"abc","efg","hgk"}
fmt.Println(strings.Join(s,"#")) // abc#efg #hgk 将切片组合成字符串
fmt.Println(strings.Index("hellow","ow")) // 4 ，若查不到返回 -1
fmt.Println(strings.Repeat("he", 3)) // hehehe
fmt.Println(strings.Split("aa-bb-cc-dd", "-")) //[aa bb cc dd] 切片
fmt.Println(strings.Trim(" xx xx "," ")) // xx xx 去前后空格
fmt.Println(strings.Fields("xx bb cc dd ")) // [xx bb cc dd] 按照空格，把元素放入到切片中
字符串转换 import "strconv"
slice := make([]byte,0,1024)
slice = strconv.AppendBool(slice, true) //把bool类型转为字符串类型
slice = strconv.AppendInt(slice, 112, 10) // 最后一个参数指定10进制的方式追加
slice = strconv.AppendQuote(slice, "aaa") // 追加字符串
fmt.Println(string(slice)) // 转换成字符串后打印---true112"aaa"
// 其他类型转为字符串
var str string
str = strconv.FormatBool(false) // 把 bool转为string
str = strconv.FormatFloat(3.14, 'f' , -1 ,64) //f 指打印格式，-1指小数点位数，64以float64
str = strconv.Itoa(666) // 整型转字符串 （常用）
// 字符串转为其他类型
a,err := strconv.ParseBool("true") //true --- <nil>
a,err := strconv.Atoi("555") //555--- <nil>
fmt.Println(a,"---",err)
正则表达式 import "regexp"
buf := "avnvv sdsds adc"
reg := regexp.MustCompile(`a.c`) // 创建匹配规则
if reg == nil {
return
}
res := reg.FindAllStringSubmatch(buf, -1) // -1指从头到尾
fmt.Println(res) // 返回一个分组的切片 [[adc]]
JSON处理
通过结构体生成json
package main
import (
"encoding/json"
"fmt"
)
func main() {
type IT struct {
Company string `json:"company"` // 二次编码，改为小写
Subjects []string `json:"-"` // - 代表此字段不输出
IsOk bool `json:"isOk,string"` // 将布尔类型的以string输出
Price float64 `json:"price"`
}
s := IT{"aas", []string{"go", "c++", "node", "web"}, true, 3.22}
//编码，根据内容生成json文本
// buf,err := json.Marshal(s) //json未格式化输出 {"company":"aas","isOk":"true","price":3.22}
buf, err := json.MarshalIndent(s, "", " ") //json格式化代码输出,两个参数表示每一行的前缀和缩进方式,固定写法
if err != nil {
return
}
fmt.Println("buf= ", string(buf))
/*
buf = {
"company": "aas",
"isOk": "true",
"price": 3.22
}
*/
}
通过map生成json
//创建一个map
m := make(map[string]interface{},4)
m["company"] = "aas"
m["subjectes"] = []string{"go","c++"}
m["isok"] = true
// 编码成json
result, err := json.MarshalIndent(m,""," ")
if err != nil{
return
}
fmt.Println("res = ", string(result))
json解析到结构体
jsonBuf :=`
"company": "aas",
"subjects" :[
"go",
"c++"
],
"isok" : true,
"price" : 1.33
`
// 定义结构体：
type IT struct{
Company string `json:"company"` // 二次编码，改为大写
Subjects []string `json:"subjects"` // 定义多少字段会显示多少字段
IsOk bool `json:"isok"`
Price float64 `json:"price"`
}
// 定义一个结构体实体
var tmp IT
err := json.Unmarshal([]byte(jsonBuf), &tmp) // 第二个参数要传地址
if err!= nil{
return
}
fmt.Printf("tmp= %+v\n", tmp)
json解析到map
jsonBuf :=`
"company": "aas",
"subjects" :[
"go",
"c++"
],
"isok" : true,
"price" : 1.33
`
m :=make(map[string]interface{},4)
err :=json.Unmarshal([]byte(jsonBuf), &m)
fmt.Printf("m = %+v \n", m)
//但是要用json数据的话就要使用类型断言，一步步反推，才可以，一般json转结构体。
文件操作 import "os"
os.Create(filename) // 返回一个文件对象和error，如果有清空，不存在就创建
path := "./demo.txt"
WriteFile(path)
// 写文件
func WriteFile( path string){
f,err := os.Create(path)
if err != nil { return }
defer f.Close()
var buf string
for i:=0 ; i <10; i++{
buf = fmt.Sprintf("%d\n",i) // 将保存在buf里面
n, err := f.WriteString(buf)
if err ! = nil{ return }
}
}
// 读文件
func ReadFile(path string){
f,err := os.Open(path)
if err != nil{ return}
defer f.Close()
buf := make([]byte,1024*2) // 定义一个2kb长的切片
n,err1 :=f.Read(buf) // n代表从文件读取内容的长度
if err1 !=nil && err1 != io.EOF{return } //文件出错同时也没到结尾
fmt.Println("buf = ",string(buf[:n]))
}
// 按照行读取，需要bufio这个库，引入
import "bufio"
文件拷贝小列子
package main
import (
"fmt"
"os"
"io"
)
func main () {
orPath, newPath := getPath()
orf,err := os.Open(orPath)
if err != nil { return }
defer orf.Close()
// 创建新的文件目录
f,err2 := os.Create(newPath)
if err2 != nil{ return }
defer f.Close()
// 创建buffer 大小4kb
buf := make([]byte, 4*1024)
for{
n, err := orf.Read(buf)
if err !=nil{
if err == io.EOF{ // 判断读取出错是否由于已经读完引起
break
}
}
f.Write(buf[:n]) // 有多少读多少
}
}
// 获取用户刷
func getPath()(orPath, newPath string){
list := os.Args
if len(list) != 3{
fmt.Println("输入错误")
return
}
orPath = list[1]
newPath = list[2]
return
}
