Java程序员学习Go语言入门笔记-index4

本篇内容：异常处理，文本、文件处理

异常处理

error接口

普通错误

package main

import (
	"errors"
	"fmt"
)

func main() {
	// 生成方式1
	var err1 = errors.New("errors.New err")
	fmt.Printf("%v\n", err1)

	// 生成方式2
	var err2 = fmt.Errorf("%s", "fmt.Errorf err")
	fmt.Printf("%v\n", err2)
}

panic内置函数

致命错误，程序中断运行
当遇到类似Java中的运行时异常时，会产生
也可直接调用panic内置函数产生

package main

import (
	"fmt"
)

func func1() {
	fmt.Println(1)
}

func func2() {
	fmt.Println(2)
	panic("直接调用panic内置函数，模拟异常")
}

func func3() {
	fmt.Println(3)
}

func main() {
	func1() // 1
	func2() // 2，然后产生异常，不再往下执行
	func3()
}

recover内置函数

相当于捕获异常，使程序继续运行
只能跟在defer后使用

package main

import (
	"fmt"
)

func func1() {
	fmt.Println(1)
}

func func2() {
	defer func() { // defer匿名函数
		pan := recover() // 若发生panic异常，返回panic信息，未发生panic，返回nil
		fmt.Printf("%v\n", pan)
	}()
	fmt.Println(2)
	panic("直接调用panic内置函数，模拟异常")
}

func func3() {
	fmt.Println(3)
}

func main() {
	func1() // 1
	func2() // 2，然后产生异常
	func3() // 3，因为上一步捕获了异常，可以继续往下执行
}

文本文件处理

字符串处理

字符串操作

来自strings包的常用函数

Contains(s, substr string) bool

判断字符串s中是否包含字符串substr，返回true或false

Join(elems []string, sep string) string

使用字符串sep将字符串切片elems中的元素连接，返回新的字符串

Index(s, substr string) int

获取字符串substr在字符串s中第一次出现的位置，返回下标

Repeat(s string, count int) string

将字符串s重复count次，返回新的字符串

Replace(s, old, new string, n int) string

将字符串s中的字符串old替换为字符串new，n表示替换的次数，n为次数表示全部替换

Split(s, sep string) []string

将字符串s根据sep分割，返回切片

Trim(s, cutset string) string

去除字符串s开头和结尾的字符串cutset，返回新的字符串

下面是代码:

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Contains
	fmt.Println(strings.Contains("hello world", ""))      // true
	fmt.Println(strings.Contains("hello world", " "))     // true
	fmt.Println(strings.Contains("hello world", "  "))    // 两个空格，false
	fmt.Println(strings.Contains("hello world", "123"))   // false
	fmt.Println(strings.Contains("hello world", "hello")) // true

	// Join
	var s = []string{"i", "eat", "apple"}
	fmt.Println(strings.Join(s, "*")) // i*eat*apple

	// Index
	fmt.Println(strings.Index("hello world", "hello")) // 0
	fmt.Println(strings.Index("hello world", "world")) // 6
	fmt.Println(strings.Index("hello world", "123"))   // -1，表示不存在
	fmt.Println(strings.Index("hello world", "o"))     // 4，第一次出现的位置

	// Repeat
	fmt.Println(strings.Repeat("123", 3)) // 123123123

	// Replace
	fmt.Println(strings.Replace("hello world", "o", "0", 1)) // hell0 world，将第一个o替换为0

	// Split
	var str = "123,456,789"
	s = strings.Split(str, ",")
	fmt.Println(s) // [123 456 789]

	// Trim
	str = "   hello world "
	fmt.Printf("#%s#\n", str)                    // #   hello world #
	fmt.Printf("#%s#\n", strings.Trim(str, " ")) // #hello world#
}

字符串转换

来自strconv包的常用函数

Append

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var s = make([]byte, 0, 64) // 字符切片

	s = strconv.AppendBool(s, true)
	fmt.Println(string(s)) // 将字符切片转换为字符串类型输出

	s = strconv.AppendInt(s, 123, 10) // 以10进制的表示形式将123追加到字符串s
	fmt.Println(string(s))

	s = strconv.AppendQuote(s, "abc") // 追加字符串
	fmt.Println(string(s))
}

Format

将其它类型转换为字符串

package main

import (
	"fmt"
	"strconv"
)

func main() {
	a := strconv.FormatBool(true)
	b := strconv.FormatInt(123, 10) // 以十进制的形式将123转换为字符串
	c := strconv.Itoa(1024)         // 数字转字符串
	fmt.Println(a, b, c)            // true 123 1024
}

Parse

将字符串转换为其它类型

package main

import (
	"fmt"
	"strconv"
)

func main() {
	a, err := strconv.ParseBool("true") // a, err，返回转换后的值和错误信息
	fmt.Println(a, err)                 // true <nil>
	b, err := strconv.ParseFloat("123.12", 64)
	fmt.Println(b, err) // 123.12 <nil>
	c, err := strconv.ParseInt("123", 10, 64)
	fmt.Println(c, err)            // 123 <nil>
	d, err := strconv.Atoi("1024") // 字符串转数字
	fmt.Println(d, err)            // 1024 <nil>
}

正则表达式

解析表达式

返回匹配器，若发生异常，匹配器为空

提取匹配结果

package main

import (
	"fmt"
	"regexp"
)

func main() {
	var str = "a1c,a2c,a3c,m1n"
	// 1解析表达式
	// ``：反引号，表示原始字符串，可以换行
	var reg = regexp.MustCompile(`a.c`) // 要求匹配"a*c"格式的字符串
	if nil == reg {
		fmt.Println("解析表达式异常")
		return
	}
	// 2提取，返回匹配的字符串切片
	s := reg.FindAllStringSubmatch(str, -1) // -1表示提取所有匹配结果
	fmt.Println(s)                          // [[a1c] [a2c] [a3c]]
}

json

没什么好说的，直接看代码吧

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	id       int
	no       int
	username string // 成员变量首字母需要大写才能进行json序列化，相当于public
	password string
	Height   int
	Weight   string `json:"weight"` // 在json中的key
	Age      int    `json:"-"`      // 隐藏年龄
}

func main() {
	// 结构体转json
	var user = User{1, 123, "yw", "123", 170, "130斤", 30}
	jsonStr, err := json.Marshal(user) // 返回转换后的结果和错误
	// jsonStr为字符切片
	fmt.Println(string(jsonStr)) // {"Height":170,"weight":"130"}
	fmt.Println(err)             // <nil>

	// json转map
	var m = map[string]interface{}{}  // 声明一个Map<String, Object>类型的map
	err = json.Unmarshal(jsonStr, &m) // 需要修改m，这里引用传递
	if nil != err {
		fmt.Println(err)
	}
	fmt.Println(m)           // map[Height:170 weight:130斤]
	fmt.Println(m["weight"]) // 130斤
}

大家看到了，我的身材是非常的完美啊…0v0

文件操作

package main

import (
	"fmt"
	"os"
)

func writeFile(filePath string) {
	file, err := os.Create(filePath) // 创建文件，返回文件和错误
	if nil != err {
		fmt.Println(err)
		return
	}
	defer file.Close()               // 结束前关闭文件
	file.WriteString("hello world,") // 写入字符串
	file.Write([]byte("hello go\n")) // 写入二进制数据，将"hello go"转换为了byte切片
}

func readFile(filePath string) {
	file, err := os.Open(filePath)
	if nil != err {
		fmt.Println(err)
		return
	}
	defer file.Close()           // 结束前关闭文件
	buffer := make([]byte, 1024) // 开辟1024个字节的slice作为缓冲区
	for {
		n, _ := file.Read(buffer) // 读取文件
		if n == 0 {               // 0表示到文件结束
			break
		}
	}
	fmt.Println(string(buffer)) //输出文件内容
}

func main() {
	var file string = "./xxx.txt" // 当前目录下的xxx.txt文件
	writeFile(file)
	readFile(file)
}

不当之处，请予指正。

上一篇：Java程序员学习Go语言入门笔记-index3
下一篇：Java程序员学习Go语言入门笔记-index5