文章目录
1.error(普通错误)
package main
import (
"fmt"
"errors"
)
func main() {
//第一种写法
err1 := fmt.Errorf("%s", "this is normal err")
fmt.Println("err1 =", err1)
//第二种写法
err2 := errors.New("这也是一个错误！")
fmt.Println("err2=", err2)
}
应用
package main
import (
"errors"
"fmt"
)
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)
}
}
2.panic(致命错误，如数组越界、空指针等)
package main
import "fmt"
func test01() {
fmt.Println("aaaaaaaaaa")
}
func test02() {
fmt.Println("bbbbbbbbbb")
//会使程序中断，下面的不会执行
panic("this is a panic test")
}
func test03() {
fmt.Println("cccccccccc")
}
a
func main() {
test01()
test02()
test03()
}
//输出
aaaaaaaaaa
bbbbbbbbbb
panic: this is a panic test
goroutine 1 [running]:
3.recover(使程序不中断继续执行)
package main
import "fmt"
func test04(x int) {
//定义匿名函数
defer func() {
//如果err不等于空，执行recover函数，使得抓住函数的错误
if err := recover(); err != nil {
fmt.Println(err)
}
}()
var a [10]int
a[x] = 111
}
func main() {
test04(20)
}
//输出
runtime error: index out of range
4.字符串的操作
package main
import (
"fmt"
"strings"
)
func main() {
//是否包含
fmt.Println(strings.Contains("HelloGo", "Go"))
fmt.Println(strings.Contains("HelloGo", "ao"))
//以"-"重组数组
s := []string{"我", "爱", "中", "国", "天", "安", "门"}
str := strings.Join(s, "-")
fmt.Println("str=", str)
//索引位置
fmt.Println(strings.Index("abcdgo", "go"))
fmt.Println(strings.Index("abcdgo", "lol"))
//重复两次
buf := strings.Repeat("go", 2)
fmt.Println("nuf=我-爱-中-国-天-安-门", buf)
//依"-"切割
buf = "我-爱-中-国-天-安-门";
s2 := strings.Split(buf, "-")
fmt.Println("s2=", s2)
//去掉两端的空格
fmt.Println(strings.Trim(" are you ok ? ", " "))
//去掉空格把元素放入切片中
s3 := strings.Fields(" are you ok ? ")
for i, data := range s3 {
fmt.Println(i, ",", data)
}
}
5.字符串的转换
package main
import (
"strconv"
"fmt"
)
func main() {
//转换为字符串后追加到字节数组
slice := make([]byte, 0, 1024)
slice = strconv.AppendBool(slice, true)
//第二个数为要追加的数，第三个为追加方式为以10进制追加
slice = strconv.AppendInt(slice, 1234, 10)
slice = strconv.AppendQuote(slice, "abcgohello")
fmt.Println("追加后的数为：" + string(slice))
var str string
str = strconv.FormatBool(false)
fmt.Println("str=", str)
//'f'指的是打印格式，以小数格式，-1指的是小数位数（紧缩模式），64为Float64处理
str = strconv.FormatFloat(3.148713267316, 'f', -1, 64)
fmt.Println("str=", str)
str = strconv.Itoa(6666)
fmt.Println("str=", str)
//字符串转换为bool
var flag bool
var err error
flag, err = strconv.ParseBool("tru")
if err == nil {
fmt.Println("flag = ", flag)
} else {
fmt.Println("err = ", err)
}
//字符串转换为整型
a, _ := strconv.Atoi("567")
fmt.Println("a = ", a)
}
5.正则
package main
import (
"regexp"
"fmt"
)
func main() {
buf := "abc azc a7c aac 888 a9c tac"
//reg := regexp.MustCompile(`a.c`)
//reg := regexp.MustCompile(`a[0-9]c`)
reg := regexp.MustCompile(`a\dc`)
if reg == nil {
fmt.Println("err----")
return
}
result := reg.FindAllStringSubmatch(buf, -1)
fmt.Println("result =", result)
//查找有效的小数
str1 := "3.15 76 djskah 1.23 21. 28.98 das1289 62.22"
regex := regexp.MustCompile(`\d+\.\d+`)
if regex == nil {
fmt.Println("err----")
return
}
res := regex.FindAllStringSubmatch(str1, -1)
fmt.Println("res =", res)
}
网站匹配内容
package main
import (
"regexp"
"fmt"
)
func main() {
str := `
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<title>Go语言标准库文档中文版 | Go语言中文网 | Golang中文社区 | Golang中国</title>
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1.0, user-scalable=no">
<meta http-equiv="X-UA-Compatible" content="IE=edge, chrome=1">
<meta charset="utf-8">
<link rel="shortcut icon" href="/static/img/go.ico">
<link rel="apple-touch-icon" type="image/png" href="/static/img/logo2.png">
<meta name="author" content="polaris <[email protected]>">
<meta name="keywords" content="中文, 文档, 标准库, Go语言,Golang,Go社区,Go中文社区,Golang中文社区,Go语言社区,Go语言学习,学习Go语言,Go语言学习园地,Golang 中国,Golang中国,Golang China, Go语言论坛, Go语言中文网">
<meta name="description" content="Go语言文档中文版，Go语言中文网，中国 Golang 社区，Go语言学习园地，致力于构建完善的 Golang 中文社区，Go语言爱好者的学习家园。分享 Go 语言知识，交流使用经验">
</head>
<frameset cols="15,85">
<frame src="/static/pkgdoc/i.html">
<frame name="main" src="/static/pkgdoc/main.html" tppabs="main.html" >
<noframes>
</noframes>
<div>哈哈</div>
<div>呵呵
你吃饭了吗？
没有
</div>
<div>嘿嘿</div>
<div>咳咳</div>
</frameset>
</html>
`
//提取div中的内容
//?s:处理换行 *？多次匹配前面的字符
regex := regexp.MustCompile(`<div>(?s:(.*?))</div>`)
if regex == nil {
fmt.Println("err----")
return
}
res := regex.FindAllStringSubmatch(str, -1)
//fmt.Println("res =", res)
for _, text := range res {
fmt.Println("text[0]=", text[0])
}
fmt.Println("-----------------------")
for _, text := range res {
fmt.Println("text[1]=", text[1])
}
}
text[0]= <div>哈哈</div>
text[0]= <div>呵呵
你吃饭了吗？
没有
</div>
text[0]= <div>嘿嘿</div>
text[0]= <div>咳咳</div>
-----------------------
text[1]= 哈哈
text[1]= 呵呵
你吃饭了吗？
没有
text[1]= 嘿嘿
text[1]= 咳咳
6.Json
- 结构体转json
package main
import (
"encoding/json"
"fmt"
)
/**
{
"company": "itcast",
"subjects": [
"Go",
"C++",
"Java",
"Python",
"Swift"
],
"isok": true,
"price": 666.66
}
*/
type IT struct {
Company string
Subjects []string
IsOk bool
Price float64
}
func main() {
s := IT{"future", []string{"Go", "C++", "Java", "C", "Python"}, true, 666.66}
//buf, err := json.Marshal(s)
buf, err := json.MarshalIndent(s,""," ")//格式化
if err != nil {
fmt.Println("err=", err)
return
}
fmt.Println("buf=", string(buf))
}
//普通输出
buf= {"Company":"future","Subjects":["Go","C++","Java","C","Python"],"IsOk":true,"Price":666.66}
//格式化输出
buf= {
"Company": "future",
"Subjects": [
"Go",
"C++",
"Java",
"C",
"Python"
],
"IsOk": true,
"Price": 666.66
}
- map转换json
package main
import (
"encoding/json"
"fmt"
)
func main() {
m := make(map[string]interface{}, 4)
m["company"] = "future"
m["subjects"] = []string{"Go", "C++", "Java", "C", "Python"}
m["isOk"] = true
m["price"] = 6666.566
result, err := json.MarshalIndent(m,""," ")
if err != nil {
fmt.Println("err=", err)
return
}
fmt.Println("result=", string(result))
}
result= {
"company": "future",
"isOk": true,
"price": 6666.566,
"subjects": [
"Go",
"C++",
"Java",
"C",
"Python"
]
}
- 注意事项：
type IT struct {
Company string `json:"-"` //此字段不会输出到屏幕
Subjects []string `json:"subjects"` //二次编码，使得首字母小写
IsOk bool `json:",string"`
Price float64 `json:",string"`
}
- json转结构体
package main
import (
"encoding/json"
"fmt"
)
type IT struct {
Company string `json:"company"`
Subjects []string `json:"subjects"` //二次编码，使得首字母小写
Isok bool `json:"isok"`
Price float64 `json:"price"`
}
func main() {
jsonBuf := `
{
"company": "itcast",
"subjects": [
"Go",
"C++",
"Java",
"Python",
"Swift"
],
"isok": true,
"price": 666.66
}
`
var temp IT
err := json.Unmarshal([]byte(jsonBuf), &temp)
if err != nil {
fmt.Println("err=", err)
return
}
//fmt.Println("temp=", temp)
fmt.Printf("temp = %+v\n", temp)
//只解析一个字段
type IT2 struct {
Subjects []string `json:"subjects"` //二次编码，使得首字母小写
}
var temp2 IT2
err2 := json.Unmarshal([]byte(jsonBuf), &temp2)
if err2 != nil {
fmt.Println("err2=", err2)
return
}
//fmt.Println("temp=", temp)
fmt.Printf("temp2 = %+v\n", temp2)
}
temp = {Company:itcast Subjects:[Go C++ Java Python Swift] Isok:true Price:666.66}
temp2 = {Subjects:[Go C++ Java Python Swift]}
- json转map
package main
import (
"encoding/json"
"fmt"
)
func main() {
jsonBuf := `
{
"company": "itcast",
"subjects": [
"Go",
"C++",
"Java",
"Python",
"Swift"
],
"isok": true,
"price": 666.66
}
`
m := make(map[string]interface{}, 4)
err := json.Unmarshal([]byte(jsonBuf), &m)
if err != nil {
fmt.Println("err=", err)
return
}
fmt.Printf("m = %+v\n", m)
var str string
//如何取值(比较麻烦)
for key, value := range m {
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 []interface{}:
fmt.Printf("map[%s]的值类型为[]interface{},value = %v\n", key, data)
}
}
}
m = map[company:itcast subjects:[Go C++ Java Python Swift] isok:true price:666.66]
map[company]的值类型为string,value = itcast
map[subjects]的值类型为[]interface{},value = [Go C++ Java Python Swift]
map[isok]的值类型为bool,value = true
map[price]的值类型为float64,value = 666.660000
