01.error接口的使用
package main
import "fmt"
import "errors"
func main() {
//var err1 error = fmt.Errorf("%s","This is normal err")
err1 := fmt.Errorf("%s", "This is normal err1")
fmt.Println("err1 = ", err1)
err2 := errors.New("This is normal err2")
fmt.Println("err2 = ", err2)
}
02.error接口的應用
package main
import "fmt"
import "errors"
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)
}
}
03.顯式調用panic函數
/*
在通常情況下，向程序使用方報告錯誤狀態的方式可以是返回一個額外的error類型值。
但是，當遇到不可恢復的錯誤狀態的時候，如數組訪問越界、空指針引用等，這些運行時錯誤
會引起panic異常，這時，上述錯誤處理方式顯然就不適合了。反過來講，在一般情況下，
我們不應該通過調用panic函數來報告普通的錯誤，而應該只把它作為報告致命錯誤的一種方式。
當某些不應該發生的場景發生時，我們就應該調用panic。
一般而言，當panic異常發生時，程序會中斷運行，並立即執行在該goroutine（線程），當中被延遲的函數（defer機制）。
隨后，程序崩潰並輸出日志信息。日志信息包括panic value和函數調用的堆棧跟蹤信息。
不是所有的panic異常都來自運行時，直接調用內置的panic函數也會引發panic異常
panic函數接受任何值作為參數。
*/
package main
import "fmt"
func testa() {
fmt.Println("aaaaaaaaaaaaaaaaaaaaa")
}
func testb() {
//fmt.Println("bbbbbbbbbbbbbbbbbbbbb")
//顯式調用panic函數，導致程序中斷
panic("This is a panic test")
}
func testc() {
fmt.Println("ccccccccccccccccccccc")
}
func main() {
testa()
testb()
testc()
}
04.數組越界導致panic
package main
import "fmt"
func testa() {
fmt.Println("aaaaaaaaaaaaaaaaaaaaa")
}
func testb(x int) {
var a [10]int
a[x] = 111 //當x為20的時候，導致數組越界，產生一個panic，導致程序崩潰
}
func testc() {
fmt.Println("ccccccccccccccccccccc")
}
func main() {
testa()
testb(20)
testc()
}
05.recover的使用
package main
import "fmt"
func testa() {
fmt.Println("aaaaaaaaaaaaaaaaaaaaa")
}
func testb(x int) {
//設置recover
defer func() {
//recover() //可以打印panic的錯誤信息
//fmt.Println(recover())
if err := recover(); err != nil { // 產生了panic異常
fmt.Println(err)
}
}() //別忘了()，調用此匿名函數
var a [10]int
a[x] = 111 //當x為20的時候，導致數組越界，產生一個panic，導致程序崩潰
}
func testc() {
fmt.Println("ccccccccccccccccccccc")
}
func main() {
testa()
testb(20)
testc()
}
06.字符串操作
package main
import (
"fmt"
"strings"
)
func main() {
//"hellogo"中是否包含"hello"，包含返回true，不包含返回false
fmt.Println(strings.Contains("hellogo", "hello"))
//Join組合,以@作為分隔符將s這個切片轉換為字符串
s := []string{"abc", "hello", "mike", "go"}
buf := strings.Join(s, "@")
fmt.Println("buf =", buf)
//Index,查找子串的位置，存在返回下標，不存在返回-1
fmt.Println(strings.Index("abcdhello", "hello"))
fmt.Println(strings.Index("abcdhello", "go"))
//Repeat,重復10次Go
buf = strings.Repeat("Go", 10)
fmt.Println("buf=", buf)
//Split 以指定的分隔符拆分字符串，返回一個切片
buf = "hello@abc@go@Jason"
s2 := strings.Split(buf, "@")
fmt.Println("s2 =", s2)
//Trim去掉兩頭的字符
buf = strings.Trim(" are u ok? ", " ") //去掉2頭空格
fmt.Printf("buf = #%s#\n", buf)
//去掉空格，把元素放入切片中
s3 := strings.Fields(" are u ok? ")
for i, data := range s3 {
fmt.Println(i, ", ", data)
}
}
07.字符串轉換
package main
import (
"fmt"
"strconv"
)
func main() {
//轉換為字符串后追加到字節數組
slice := make([]byte, 0, 1024)
slice = strconv.AppendBool(slice, true)
//第二個數為要追加的數，第3個為指定10進制方式追加
slice = strconv.AppendInt(slice, 1234, 10)
slice = strconv.AppendQuote(slice, "abcgohello")
fmt.Println("slice = ", string(slice)) //轉換string后再打印
//其他類型轉換為字符串
var str string
str = strconv.FormatBool(false)
//'f'指打印格式，以小數方式，-1指小數點位數（緊縮模式），64以float64處理
str = strconv.FormatFloat(3.14, 'f', -1, 64)
//整型轉字符串，常用
str = strconv.Itoa(66666)
fmt.Printf("str = %s,type = %T\n", str, str)
//字符串轉其他類型
var flag bool
var err error
flag, err = strconv.ParseBool("true")
if err == nil {
fmt.Println("flag = ", flag)
} else {
fmt.Println("err = ", err)
}
//把字符串轉換為整型
a, _ := strconv.Atoi("567")
fmt.Printf("a = %d,type = %T\n", a, a)
}
08.正則表達式1
package main
import (
"fmt"
"regexp"
)
func main() {
buf := "abc azc a7c aac 888 a9c tac"
// 1）解釋規則,它會解析正則表達式，如果成功返回解釋器
reg1 := regexp.MustCompile(`afdsafsac`)
//reg1 := regexp.MustCompile(`a[0-9]c`)
//reg1 := regexp.MustCompile(`a\dc`)
if reg1 == nil { //說明解釋失敗，返回nil
fmt.Println("解釋失敗了，沒有找到匹配項")
return
}
// 2）根據規則提取關鍵信息,-1是匹配所有
result1 := reg1.FindAllStringSubmatch(buf, -1)
fmt.Println("result1 = ", result1)
}
09.正則表達式2
package main
import (
"fmt"
"regexp"
)
func main() {
buf := "34.14 567 agsdg 1.23 7. 8. 99 1sdljgl 6.66121 7.8"
//解析正則表達式,+匹配前一個字符1次或多次
reg := regexp.MustCompile(`\d+\.\d+`)
if reg == nil {
fmt.Println("MustCompile Err")
return
}
//提取關鍵信息
result := reg.FindAllStringSubmatch(buf, -1)
fmt.Println("result = ", result)
}
10.正則表達式3
package main
import (
"fmt"
"regexp"
)
func main() {
//`` 原生字符串
buf := `
<!DOCTYPE HTML>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<meta content=IE=7 http-equiv=X-UA-Compatible>
<meta http-equiv="Cache-Control" content="no-transform" />
<meta http-equiv="Cache-Control" content="no-siteapp" />
<meta name="applicable-device"content="pc">
<title>SW問問搜搜問問 - 這里只有問題和答案</title>
<meta name="keywords" content="搜搜問問,搜搜,問問,sosowenwen,搜搜問答,搜搜知道,soso問問" />
<meta name="description" content="搜搜問問可找到你知道的答案,同時，我們也期待您在搜搜問問平台上回答網友提出的問題，及時貢獻您的知識，與他人分享您的經驗" />
<link rel=stylesheet type=text/css href="/templets/vip_skin/images/base.css" media=screen />
<link rel=stylesheet type=text/css href="/templets/vip_skin/images/home.css" media=screen />
</head>
<div>哈哈哈</div>
<div>測試
法師打發的撒
發
范德薩發生大
rewwwe
切勿讓
</div>
<div>百事可樂</div>
<div>可口可樂</div>
<div>Adidas</div>
<div>Nike</div>
</html>
`
//解析正則表達式,+匹配前一個字符1次或多次
//reg := regexp.MustCompile(`<div>(.*)</div>`)
reg := regexp.MustCompile(`<div>(?s:(.*?))</div>`)
if reg == nil {
fmt.Println("MustCompile Err")
return
}
//提取關鍵信息
result := reg.FindAllStringSubmatch(buf, -1)
//fmt.Println("result = ", result)
//過濾<></>
for _, text := range result {
//fmt.Println("text[0] = ", text[0]) //帶<></>
fmt.Println("text[1] = ", text[1]) //不帶<></>
}
}
11.通過結構體生成JSON
package main
import (
"encoding/json"
"fmt"
)
/*
{
"company":"ITCAST",
"subjects":[
"Go",
"C++",
"Java",
"Python"
],
"isok":true,
"Price":666.666
}
*/
//成員變量名首字母必須大寫
//type IT struct {
// Company string
// Subjects []string
// Isok bool
// Price float64
//}
type IT struct {
Company string `json:"-"` //此字段不會輸出到屏幕
Subjects []string `json:"subjects"` //二次編碼，將大寫轉換為小寫
Isok bool `json:",string"` //將bool轉換為string
Price float64 `json:",string"` //將浮點數轉換為string
}
func main() {
//定義一個結構體變量，同時初始化
s := IT{"itcast", []string{"Go", "C++", "Java", "Python"}, true, 666.666}
//編碼，根據內容生成json文本
//{"Company":"itcast","Subjects":["Go","C++","Java","Python"],"Isok":true,"Price":666.666}
// buf, err := json.Marshal(s)
buf, err := json.MarshalIndent(s, "", " ") //格式化編碼
if err != nil {
fmt.Println("err = ", err)
return
}
fmt.Println("buf = ", string(buf))
}
12.通過map生成JSON
package main
import (
"encoding/json"
"fmt"
)
func main() {
//創建一個map
m := make(map[string]interface{}, 4)
m["company"] = "ITCAST"
m["subjects"] = []string{"Go", "C++", "Java", "Python"}
m["isok"] = true
m["price"] = 888.888
//編碼成JSON
result, err := json.MarshalIndent(m, "", " ") // 格式化編碼
if err != nil {
fmt.Println("err = ", err)
return
}
fmt.Println("result = ", string(result))
}
13.JSON解析成結構體
package main
import (
"encoding/json"
"fmt"
)
// 因為jsonbuf的鍵都為小寫，而結構體的首字母必須大寫，所有在``內手動將結構體強行改為小寫
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"
],
"isok":true,
"Price":666.666
}`
var tmp IT //定義一個結構體變量
err := json.Unmarshal([]byte(jsonBuf), &tmp) // 第二個參數要地址傳遞
if err != nil {
fmt.Println("err=", err)
return
}
// fmt.Println("tmp = ",tmp)
fmt.Printf("tmp = %+v\n", tmp)
//以下是單獨取subjects這一個子類的情況,而非全部
type IT2 struct {
Subjects []string `json:"subjects"` //二次編輯
}
var tmp2 IT2
err = json.Unmarshal([]byte(jsonBuf), &tmp2)
if err != nil {
fmt.Println("err=", err)
return
}
fmt.Printf("tmp2 = %+v\n", tmp2)
}
14.JSON解析成map
package main
import (
"encoding/json"
"fmt"
)
func main() {
jsonBuf := `
{
"company":"ITCAST",
"subjects":[
"Go",
"C++",
"Java",
"Python"
],
"isok":true,
"Price":666.666
}`
// 創建一個map
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
// str = string(m["company"]) // err,無法轉換
// fmt.Println("str = ", str)
var str string
//類型斷言，值，它是value類型
for key, value := range m {
//fmt.Printf("%v ===============>%v\n", key, value)
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)
}
}
}
15.設備文件的使用
package main
import (
"fmt"
"os"
)
func main() {
// os.Stdout.Close() //關閉后，無法輸出
fmt.Println("are u ok?") //往標准輸出設備（屏幕）寫內容
// 標准設備文件，默認已經打開，用戶可以直接使用
os.Stdout.WriteString("Hello,I AM stdout......")
os.Stdin.Close() //關閉后，無法輸入
var a int
fmt.Println("請輸入a: ")
fmt.Scan(&a) //從標准輸入設備中讀取內容，放在a中
fmt.Println("a = ", a)
}
16.文件的讀寫
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)
n, err := f.WriteString(buf)
if err != nil {
fmt.Println("err = ", err)
}
fmt.Println("n = ", n)
}
}
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大小
//n代表從文件讀取內容的長度
n, err1 := f.Read(buf)
if err1 != nil && err1 != io.EOF { // 代表我的文件出錯並且還沒到結束的地方
fmt.Println("err1 = ", err1)
return
}
fmt.Println("buf = ", string(buf[:n]))
}
// 每次讀取一次
func main() {
path := "./demo.txt"
WriteFile(path)
ReadFile(path)
}