Go Web 实战编程-对文件、导出csv和json的解析

我爱海鲸 2024-06-12 11:06:56 go语言学习

简介json、文件、导出csv、xml

1、chomd:

package main

import (
	"fmt"
	"os"
)

func main() {
	// 创建文件
	//文件的创建，Create会根据传入的文件名创建文件，默认权限是0666//-rw-r--r--
	fp, err := os.Create("./chmod1.txt") // 如果文件已存在，会将文件清空。
	// defer延迟调用
	defer fp.Close() //关闭文件，释放资源。
	if err != nil {
		fmt.Println("文件创建失败。")
	}
	fileInfo, err := os.Stat("./chmod1.txt")
	fileMode := fileInfo.Mode()
	fmt.Println(fileMode)
	os.Chmod("./chmod1.txt", 0777)//通过chmod重新赋权限//-rwxrwxrwx
	fileInfo, err =os.Stat("./chmod1.txt")
	fileMode = fileInfo.Mode()
	fmt.Println(fileMode)
}

2、copy：

package main

import (
	"fmt"
	"io"
	"os"
)

func main() {
	//先创建一个名为：test_copy1.zip文件
	_, err := os.Create("./test_copy1.zip") // 如果文件已存在，会将文件清空。
	if err != nil {
		fmt.Println(err)
	}
	//打开文件test_copy1.zip，获取文件指针
	srcFile, err := os.Open("./test_copy1.zip")
	if err != nil {
		fmt.Printf("open file err = %v\n", err)
		return
	}

	defer srcFile.Close()

	//打开文件要复制的新文件名test_copy2.zip，获取文件指针
	dstFile, err := os.OpenFile("./test_copy2.zip", os.O_WRONLY|os.O_CREATE, 0755)
	if err != nil {
		fmt.Printf("open file err = %v\n", err)
		return
	}

	defer dstFile.Close()

	//通过Copy方法
	result, err := io.Copy(dstFile, srcFile)

	if err == nil {
		fmt.Println("复制成功，复制的字节数为: ", result)
	}
}

 

package main

import (
	"fmt"
	"io"
	"log"
	"os"
)

// 自定义复制方法
func DoCopy(srcFileName string, dstFileName string) {
	//打开源文件
	srcFile, err := os.Open(srcFileName)
	if err != nil {
		log.Fatalf("源文件读取失败,err:%v\n", err)
	}
	defer func() {
		err = srcFile.Close()
		if err != nil {
			log.Fatalf("源文件关闭失败,err:%v\n", err)
		}
	}()

	//创建目标文件,稍后会向这个目标文件写入拷贝内容
	distFile, err := os.Create(dstFileName)
	if err != nil {
		log.Fatalf("目标文件创建失败,err:%v\n", err)
	}
	defer func() {
		err = distFile.Close()
		if err != nil {
			log.Fatalf("目标文件关闭失败,err:%v\n", err)
		}
	}()
	//定义指定长度的字节切片,每次最多读取指定长度
	var tmp = make([]byte, 1024*4)
	//循环读取并写入
	for {
		n, err := srcFile.Read(tmp)
		n, _ = distFile.Write(tmp[:n])
		if err != nil {
			if err == io.EOF {
				return
			} else {
				log.Fatalf("拷贝过程中发生错误,错误err:%v\n", err)
			}
		}
	}
}

func main() {
	//先创建一个.zip文件
	_, err := os.Create("./test.zip") // 如果文件已存在，会将文件清空。
	if err != nil {
		fmt.Println(err)
	}
	//复制一个名为test2.zip的文件
	DoCopy("./test.zip", "./test2.zip")
}

 

3、create：

package main

import (
	"fmt"
	"os"
)

func main() {
	// 创建文件
	//文件的创建，Create会根据传入的文件名创建文件，默认权限是0666
	fp, err := os.Create("./demo.txt") // 如果文件已存在，会将文件清空。
	fmt.Println(fp, err)               // &{0xc000054180} <nil>
	fmt.Printf("%T", fp)               // *os.File 文件指针类型

	if err != nil {
		fmt.Println("文件创建失败。")
		//创建文件失败的原因有：
		//1、路径不存在  2、权限不足  3、打开文件数量超过上限  4、磁盘空间不足等
		return
	}

	// defer延迟调用
	defer fp.Close() //关闭文件，释放资源。
}

 

package main

import (
	"fmt"
	"os"
)

func main() {
	// 创建文件
	//文件的创建，Create会根据传入的文件名创建文件，默认权限是0666
	fp, err := os.Create("./demo.txt") // 如果文件已存在，会将文件清空。
	fmt.Println(fp, err)               // &{0xc000054180} <nil>
	fmt.Printf("%T", fp)               // *os.File 文件指针类型

	if err != nil {
		fmt.Println("文件创建失败。")
		//创建文件失败的原因有：
		//1、路径不存在  2、权限不足  3、打开文件数量超过上限  4、磁盘空间不足等
		return
	}

	// defer延迟调用
	defer fp.Close() //关闭文件，释放资源。
}

 

4、delete_file:

 

package main

import (
	"fmt"
	"os"
)

func main() {
	err := os.Remove("./file1.txt")
	if err != nil {
		fmt.Printf("remove ./file1.txt err : %v\n", err)
	}
	err = os.RemoveAll("./file2.txt")
	if err != nil {
		fmt.Printf("remove all ./file2.txt err : %v\n", err)
	}
}

 

5、exportCsv:

package main

import (
	"database/sql"
	"encoding/csv"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"log"
	"os"
	"strconv"
)

var db *sql.DB

type User struct {
	Uid      int
	Name     string
	Phone    string
	Email    string
	Password string
}

//定义一个全局变量
var u User

//初始化数据库连接
func init() {
	db, _ = sql.Open("mysql",
		"root:a123456@tcp(127.0.0.1:3306)/chapter6?"+
			"charset=utf8mb4&parseTime=True&loc=Local")
}

func main() {
	//定义导出的文件名
	filename := "./exportUsers.csv"

	//从数据库中获取数据
	users := queryMultiRow()
	//定义一个二维数组
	column := [][]string{{"手机号", "用户UID", "Email", "用户名"}}
	for _, u := range users {
		str := []string{}
		str = append(str, u.Phone)
		str = append(str, strconv.Itoa(u.Uid))
		str = append(str, u.Email)
		str = append(str, u.Name)
		column = append(column, str)
	}
	//导出
	ExportCsv(filename, column)
}

//导出csv文件
func ExportCsv(filePath string, data [][]string) {
	fp, err := os.Create(filePath) //创建文件句柄
	if err != nil {
		log.Fatalf("创建文件["+filePath+"]句柄失败,%v", err)
		return
	}
	defer fp.Close()
	fp.WriteString("\xEF\xBB\xBF") //写入UTF-8 BOM
	w := csv.NewWriter(fp)         //创建一个新的写入文件流
	w.WriteAll(data)
	w.Flush()
}

// 查询多条数据
func queryMultiRow() ([]User) {
	rows, err := db.Query("select uid,name,phone,email from `user` where uid > ?", 0)
	if err != nil {
		fmt.Printf("query failed, err:%v\n", err)
		return nil
	}
	// 关闭rows释放持有的数据库链接
	defer rows.Close()
	// 循环读取结果集中的数据
	users := []User{}
	for rows.Next() {
		err := rows.Scan(&u.Uid, &u.Name, &u.Phone, &u.Email)
		users = append(users, u)
		if err != nil {
			fmt.Printf("scan failed, err:%v\n", err)
			return nil
		}
	}
	return users
}

 

6、filewalk:

package main

import (
	"fmt"
	"os"
	"path/filepath"
)

func scan(path string, f os.FileInfo, err error) error {
	fmt.Printf("Scaned: %s\n", path)
	return nil
}

func main() {
	//根据path创建多级子目录，例如dir1/dir2/dir3
	err :=os.MkdirAll("test_walk/dir2/dir3", 0777)
	if err != nil {
		fmt.Println(err)
	}
	root := `./test_walk`
	err = filepath.Walk(root, scan)
	fmt.Printf("filepath.Walk() returned %v\n", err)
}

 

7、json_parse:

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
)

// 定义配置文件解析后的结构
type MongoConfig struct {
	MongoAddr       string
	MongoPoolLimit  int
	MongoDb         string
	MongoCollection string
}

type Config struct {
	Port  string
	Mongo MongoConfig
}

func main() {
	JsonParse := NewJsonStruct()
	v := Config{}
	JsonParse.Load("./json_parse.json", &v)
	fmt.Println(v.Port)
	fmt.Println(v.Mongo.MongoDb)
}

type JsonStruct struct {
}

func NewJsonStruct() *JsonStruct {
	return &JsonStruct{}
}

func (js *JsonStruct) Load(filename string, v interface{}) {
	//ReadFile函数会读取文件的全部内容，并将结果以[]byte类型返回
	data, err := ioutil.ReadFile(filename)
	if err != nil {
		return
	}

	//读取的数据为json格式，需要进行解码
	err = json.Unmarshal(data, v)
	if err != nil {
		return
	}
}

 

json_parse:

{
  "port":"27017",
  "mongo":{
    "mongoAddr":"127.0.0.1",
    "mongoPoolLimit":500,
    "mongoDb":"my_db",
    "mongoCollection":"table1"
  }
}

 

8、json_write:

 

package main

import (
	"encoding/json"
	"fmt"
	"os"
)

type User struct {
	UserName string
	NickName string `json:"nickname"`
	Email    string
}

func main() {
	user := &User{
		UserName: "Jack",
		NickName: "Ma",
		Email:    "xxxxx@qq.com",
	}

	data, err := json.Marshal(user)
	if err != nil {
		fmt.Printf("json.Marshal failed,err:", err)
		return
	}

	fmt.Printf("%s\n", string(data))

	file, _ := os.Create("json_write.json")
	defer file.Close()
	file.Write(data)
}

9、link:(改名)

package main

import (
	"fmt"
	"os"
)

func main() {
	// 创建文件
	//文件的创建，Create会根据传入的文件名创建文件，默认权限是0666//-rw-r--r--
	fp, err := os.Create("./link1.txt") // 如果文件已存在，会将文件清空。
	// defer延迟调用
	defer fp.Close() //关闭文件，释放资源。
	if err != nil {
		fmt.Println("文件创建失败。")
	}
	err = os.Link("link1.txt", "link2.txt")
	if err != nil {
		fmt.Println("err:", err)
	}
}

 

package main

import (
	"fmt"
	"os"
)

func main() {
	// 创建文件
	//文件的创建，Create会根据传入的文件名创建文件，默认权限是0666//-rw-r--r--
	fp, err := os.Create("./link2.txt") // 如果文件已存在，会将文件清空。
	// defer延迟调用
	defer fp.Close() //关闭文件，释放资源。
	if err != nil {
		fmt.Println("文件创建失败。")
	}
	err = os.Symlink("link2.txt", "link3.txt")
	if err != nil {
		fmt.Println("err:", err)
	}
}

 

10、log：

package main

import (
	"log"
)

func main() {
	no := []int{6, 8}
	log.Print("Print NO. ", no, "\n")
	log.Println("Println NO.", no)
	log.Printf("Printf NO. with item [%d,%d]\n", no[0], no[1])
}

 

package main

import (
	"log"
)

func main() {
	no := []int{6, 8}
	log.Panicln("Println NO.", no)
}

 

package main

import (
	"log"
)

func main() {
	no := []int{6, 8}
	log.Fatalln("Println NO.", no)
}

 

输出到文件：

package main

import (
	"log"
	"os"
)

func main() {
	fileName := "New.log"
	logFile, err := os.Create(fileName)
	defer logFile.Close()
	if err != nil {
		log.Fatalln("open file error")
	}
	debugLog := log.New(logFile, "[Info]", log.Llongfile)
	debugLog.Println("Info Level Message")
	debugLog.SetPrefix("[Debug]")
	debugLog.Println("Debug Level Message")
}

11、mkdir：

package main

import (
	"fmt"
	"os"
)

func main() {
	//创建一个名为“test”的目录，perm权限为0777
	err := os.Mkdir("test", 0777)
	if err != nil {
		fmt.Println(err)
	}
}

 

package main

import (
	"fmt"
	"os"
)

func main() {
	//根据path创建多级子目录，例如dir1/dir2/dir3
	err := os.MkdirAll("dir1/dir2/dir3", 0777)
	if err != nil {
		fmt.Println(err)
	}
}

 

package main

import (
	"fmt"
	"os"
	"time"
)

func main() {
	uploadDir := "static/upload/" + time.Now().Format("2006/01/02/")
	err := os.MkdirAll(uploadDir, 777)
	if err != nil {
		fmt.Println(err)
	}
}

 

12、modfiy_file:

package main

import (
	"bufio"
	"io"
	"os"
	"strings"
)

func main() {
	f, err := os.Open("index.html")

	buf := bufio.NewReader(f)
	var rep = []string{"<meta name=\"testkey\" content=\"", arg1, "\" /> "}
	var result = ""
	for {
		a, _, c := buf.ReadLine()
		if c == io.EOF {
			break
		}
		if strings.Contains(string(a), "baidu-site-verification") {
			result += strings.Join(rep, "") + "\n"
		} else {
			result += string(a) + "\n"
		}
	}

	fw, err := os.OpenFile("index.html", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666) //os.O_TRUNC清空文件重新写入，否则原文件内容可能残留
	w := bufio.NewWriter(fw)
	w.WriteString(result)
	if err != nil {
		panic(err)
	}
	w.Flush()

}

13、move_file:

 

package main

import (
	"fmt"
	"os"
)

func main() {
	err := os.Rename("./file1", "/tmp/file1")
	if err != nil {
		fmt.Println(err)
		return
	}
}

 

14、open：

package main

import (
	"fmt"
	"os"
)

func main() {
	// 打开文件
	file, err := os.Open("open.txt")
	if err != nil {
		fmt.Printf("打开文件出错：%v\n", err)
	}
	fmt.Println(file)
	// 关闭文件
	err = file.Close()
	if err != nil {
		fmt.Printf("关闭文件出错：%v\n", err)
	}
}

 

package main

import (
	"fmt"
	"os"
)

func main() {
	// 读写方式打开文件
	fp, err := os.OpenFile("./open.txt", os.O_CREATE|os.O_APPEND, 0666)

	if err != nil {
		fmt.Println("文件打开失败。")
		return
	}

	// defer延迟调用
	defer fp.Close()  //关闭文件，释放资源。
}

 

15、os_copy_file:

package main

import (
	"fmt"
	"io"
	"os"
)

func main() {
	// 使用命令行提高拷贝的复用性
	args := os.Args
	if args == nil || len(args) != 3 {
		fmt.Println("useage : go filename.go src File dstFile")
		return
	}
	srcPath := args[1]
	dstPath := args[2]
	fmt.Printf("srcPath = %s, dstPath = %s\r\n", srcPath, dstPath)
	if srcPath == dstPath {
		fmt.Println("源文件和目标文件不能重名")
	}
	//执行复制
	srcFile, err1 := os.Open(srcPath)
	// 关闭文件
	defer srcFile.Close()
	if err1 != nil {
		fmt.Println(err1)
		return
	}
	dstFile, err2 := os.Create(dstPath)
	defer dstFile.Close()
	if err2 != nil {
		fmt.Println(err2)
		return
	}
	readBuf := make([]byte, 1024)
	for {
		//读取文件
		n, err := srcFile.Read(readBuf) //每次文件读取字节的长度
		if err != nil && err != io.EOF {
			fmt.Println(err)
			break
		}
		if n == 0 {
			fmt.Println("文件处理完毕")
		}
		//写入目的文件
		writeBuf := readBuf[:n]
		dstFile.Write(writeBuf)
	}
}

16、os_write_to_file：

package main

import (
	"fmt"
	"os"
)

func main() {
	//新建文件
	fout, err := os.Create("./create_file.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer fout.Close()
	for i := 0; i < 5; i++ {
		outstr := fmt.Sprintf("%s:%d\r\n", "Hello Go", i) //Sprintf控制台输出，并有返回值string
		// 写入文件
		fout.WriteString(outstr) //string信息
		fout.Write([]byte("i love go\r\n")) //byte类型
	}
}

17、read:

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func main() {
	// 打开文件
	file, err := os.Open("read.txt")
	if err != nil {
		fmt.Printf("打开文件出错：%v\n", err)
	}
	// 及时关闭文件句柄
	defer file.Close()
	// bufio.NewReader(rd io.Reader) *Reader
	reader := bufio.NewReader(file)
	// 循环读取文件的内容
	for {
		line, err := reader.ReadString('\n') // 读到一个换行符就结束
		if err == io.EOF { // io.EOF表示文件的末尾
			break
		}
		// 输出内容
		fmt.Print(line)
	}
}

 

package main

import (
	"fmt"
	"io/ioutil"
)

func main() {
	// 使用 io/ioutil.ReadFile 方法一次性将文件读取到内存中
	filePath := "read2.txt"
	content, err := ioutil.ReadFile(filePath)
	if err != nil {
		// log.Fatal(err)
		fmt.Printf("读取文件出错：%v", err)
	}
	fmt.Printf("%v\n", content)
	fmt.Printf("%v\n", string(content))
}

18、reg：（正则表达式）

package main

import (
	"fmt"
	"regexp"
)

func main()  {
	re := regexp.MustCompile(`Go(\w+)`)
	fmt.Println(re.ReplaceAllString("Hello Gopher，Hello GoLang", "Java$1"))

	text := "Hello Gopher，Hello Go Web"
	reg := regexp.MustCompile(`\w+`)
	fmt.Println(reg.MatchString(text))


}

 

package main

import (
	"fmt"
	"regexp"
)

func main()  {
	re := regexp.MustCompile(`Go(\w+)`)
	fmt.Println(re.ReplaceAllString("Hello Gopher，Hello GoLang", "Java$1"))




}

 

package main

import (
	"fmt"
	"strings"
)

func main() {
	value := "a|b|c|d"
	// 分割成3部分
	result := strings.SplitN(value, "|", 3)
	for v := range(result) {
		fmt.Println(result[v])
	}
}

 

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "I_Love_Go_Web"
	res := strings.Split(s, "_")
	for value := range res {
		fmt.Println(value)
	}
}

 

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "I_Love_Go_Web"
	res := strings.Split(s, "_")
	for i := range res {
		fmt.Println(res[i])
	}
	res1 := strings.SplitN(s, "_", 2)
	for i := range res1 {
		fmt.Println(res1[i])
	}
	res2 := strings.SplitAfter(s, "_")
	for i := range res2 {
		fmt.Println(res2[i])
	}
	res3 := strings.SplitAfterN(s, "_", 2)
	for i := range res3 {
		fmt.Println(res3[i])
	}
}

 

package main

import (
	"fmt"
	"strings"
)

func main() {
	value := "i'm gopher"
	result := strings.SplitAfter(value, "")
	for i := range (result) {
		// 获取字母
		letter := result[i]
		fmt.Println(letter)
	}
}

 

package main

import (
	"fmt"
	"regexp"
)

func main() {
	res2 := findPhoneNumber("13688888888")
	fmt.Println(res2) // true

	res2 = findPhoneNumber("02888888888")
	fmt.Println(res2) // false

	res2 = findPhoneNumber("123456789")
	fmt.Println(res2) // false
}

func findPhoneNumber(str string) bool {
	// 创建一个正则表达式匹配规则对象
	reg := regexp.MustCompile("^1[1-9]{10}")
	// 利用正则表达式匹配规则对象匹配指定字符串
	res := reg.FindAllString(str, -1)
	if (res == nil) {
		return false
	}
	return true
}

 

package main

import (
	"fmt"
	"regexp"
)

func main() {
	res := findEmail("8888@qq.com")
	fmt.Println(res) // true

	res = findEmail("shir?don@qq.com")
	fmt.Println(res) // false

	res = findEmail("8888@qqcom")
	fmt.Println(res) // false
}
func findEmail(str string) bool {
	reg := regexp.MustCompile("^[a-zA-Z0-9_]+@[a-zA-Z0-9]+\\.[a-zA-Z0-9]+")
	res := reg.FindAllString(str, -1)
	if (res == nil) {
		return false
	}
	return true
}

 

package main

import (
	"fmt"
	"regexp"
)

func main()  {
	re := regexp.MustCompile(`who(o*)a(a|m)i`)
	fmt.Printf("%q\n", re.FindStringSubmatch("-whooooaai-"))
	fmt.Printf("%q\n", re.FindStringSubmatch("-whoami-"))

	//
	//re := regexp.MustCompile(`w(a*)i`)
	//fmt.Printf("%q\n", re.FindAllStringSubmatch("-wi-", -1))
	//fmt.Printf("%q\n", re.FindAllStringSubmatch("-waaai-", -1))
	//fmt.Printf("%q\n", re.FindAllStringSubmatch("-wi-wai-", -1))
	//fmt.Printf("%q\n", re.FindAllStringSubmatch("-waaaaai-wi-", -1))

	//re := regexp.MustCompile(`wh(|o)`)
	//fmt.Println(re.FindString("who"))
	//re.Longest()
	//fmt.Println(re.FindString("who"))

	//re := regexp.MustCompile(`w(a*)i`)
	//re.Longest()
	//fmt.Println(re.FindString("-waaaaai-wi-")) // waaaaai，不会存在第一个w和最后一个i组合的过程。

	//re1 := regexp.MustCompile(`w.`)
	//fmt.Printf("%d\n", re1.NumSubexp())
	//
	//re2 := regexp.MustCompile(`(.*)((w)eb)(.*)w`)
	//fmt.Println(re2.NumSubexp())


	//re := regexp.MustCompile(`w(a*)i`)
	//fmt.Printf("%s\n", re.ReplaceAll([]byte("-wi-waaaaai-"), []byte("T")))
	//// $1表示匹配的第一个子串，这是wi的中间无字符串，所以$1为空，然后使用空去替换满足正则表达式的部分。
	//fmt.Printf("%s\n", re.ReplaceAll([]byte("-wi-waaaaai-"), []byte("$1")))
	//// "$1W"等价与"$(1W)"，值为空，将满足条件的部分完全替换为空。
	//fmt.Printf("%s\n", re.ReplaceAll([]byte("-wi-waaaaai-"), []byte("$1W")))
	//// ${1}匹配(x*)，保留
	//fmt.Printf("%s\n", re.ReplaceAll([]byte("-wi-waaaaai-"), []byte("${1}W")))



	//s := "Hello Gopher, let's go!"
	////定义一个正则表达式reg，匹配Hello或者Go
	//reg := regexp.MustCompile(`(Hell|G)o`)
	//
	//s2 := "2020-08-01,this is a test"
	////定义一个正则表达式reg2,匹配 YYYY-MM-DD 的日期格式
	//reg2 := regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)
	//
	////最简单的情况，用“T替换”"-ab-axxb-"中符合正则"a(x*)b"的部分
	//reg3 := regexp.MustCompile("w(a*)i")
	//fmt.Println(reg3.ReplaceAllString("-wi-waai-", "T"))
	//
	////${1}匹配"2020-08-01,this is a test"中符合正则`(Hell|G)`的部分并保留，去掉"Hello"与"Go"中的'o'并用"hi"追加
	//rep1 := "${1}hi"
	//fmt.Printf("%q\n", reg.ReplaceAllString(s, rep1))
	//
	////首先，"2020-08-01,this is a test"中符合正则表达式`(\d{4})-(\d{2})-(\d{2})`的部分是"2020-08-01",将该部分匹配'(\d{4})'的'2020'保留，去掉剩余部分
	//rep2 := "${1}"
	//fmt.Printf("%q\n", reg2.ReplaceAllString(s2,rep2))
	//
	////首先，"2020-08-01,this is a test"中符合正则表达式`(\d{4})-(\d{2})-(\d{2})`的部分是"2020-08-01",将该部分匹配'(\d{2})'的'08'保留，去掉剩余部分
	//rep3 := "${2}"
	//fmt.Printf("%q\n", reg2.ReplaceAllString(s2,rep3))
	//
	////首先，"2020-08-01,this is a test"中符合正则表达式`(\d{4})-(\d{2})-(\d{2})`的部分是"2020-08-01",将该部分匹配'(\d{2})'的'01'保留，去掉剩余部分,并追加"13:30:12"
	//rep4 := "${3}:15:25:12"
	//fmt.Printf("%q\n", reg2.ReplaceAllString(s2,rep4))

}

 

package main

import (
	"fmt"
	"regexp"
)

func main()  {
	//re := regexp.MustCompile(`[^eovbgramin]`)
	//fmt.Println(re.ReplaceAllStringFunc("I love Go web programming", strings.ToUpper))


	//re := regexp.MustCompile(`w(a*)i`)
	//fmt.Println(re.ReplaceAllLiteralString("-wi-waai-", "T"))
	//fmt.Println(re.ReplaceAllLiteralString("-wi-waai-", "$1"))
	//fmt.Println(re.ReplaceAllLiteralString("-wi-waai-", "${1}"))


	reg := regexp.MustCompile(`^http://blog.sina.com.cn/([\d]{4})/([\d]{2})/([\d]{2})/([\w-]+).html$`)
	params := reg.FindStringSubmatch("http://blog.sina.com.cn/2020/08/20/blog_dfcfef2f0102yyd1.html")
	// 返回[]string{}数据类型
	for _, param := range params {
		fmt.Println(param)
	}
}

 

package main

import (
	"fmt"
	"regexp"
)


func main() {
	text := `Hi,Gopher,Enjoy learning Go Web,加油！`

	// 查找连续的小写字母
	reg := regexp.MustCompile(`[a-z]+`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找连续的非小写字母
	reg = regexp.MustCompile(`[^a-z]+`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找连续的单词字母
	reg = regexp.MustCompile(`[\w]+`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找连续的非单词字母、非空白字符
	reg = regexp.MustCompile(`[^\w\s]+`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找连续的大写字母
	reg = regexp.MustCompile(`[[:upper:]]+`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找连续的非 ASCII 字符
	reg = regexp.MustCompile(`[[:^ascii:]]+`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找连续的标点符号
	reg = regexp.MustCompile(`[\pP]+`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找连续的非标点符号字符
	reg = regexp.MustCompile(`[\PP]+`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找连续的汉字
	reg = regexp.MustCompile(`[\p{Han}]+`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找连续的非汉字字符
	reg = regexp.MustCompile(`[\P{Han}]+`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找 Hello 或 Go
	reg = regexp.MustCompile(`Hello|Go`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找行首以 H 开头，以空格结尾的字符串
	reg = regexp.MustCompile(`^H.*\s`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找行首以 H 开头，以空白结尾的字符串（非贪婪模式）
	reg = regexp.MustCompile(`(?U)^H.*\s`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找以 hello 开头（忽略大小写），以 Go 结尾的字符串
	reg = regexp.MustCompile(`(?i:^hello).*Go`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找 Go.
	reg = regexp.MustCompile(`\QGo.\E`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找从行首开始，以空格结尾的字符串（非贪婪模式）
	reg = regexp.MustCompile(`(?U)^.* `)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找以空格开头，到行尾结束，中间不包含空格字符串
	reg = regexp.MustCompile(` [^ ]*$`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找“单词边界”之间的字符串
	reg = regexp.MustCompile(`(?U)\b.+\b`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找连续 1 次到 4 次的非空格字符，并以 o 结尾的字符串
	reg = regexp.MustCompile(`[^ ]{1,4}o`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找 Hello 或 Go
	reg = regexp.MustCompile(`(?:Hell|G)o`)
	fmt.Printf("%q\n", reg.FindAllString(text, -1))

	// 查找 Hello 或 Go，替换为 Hellooo、Gooo
	reg = regexp.MustCompile(`(?:o)`)
	fmt.Printf("%q\n", reg.ReplaceAllString(text, "${n}ooo"))

	// 交换 Hello 和 Go
	reg = regexp.MustCompile(`(Hello)(.*)(Go)`)
	fmt.Printf("%q\n", reg.ReplaceAllString(text, "$3$2$1"))

	// 特殊字符的查找
	reg = regexp.MustCompile(`[\f\t\n\r\v\123\x7F\x{10FFFF}\\\^\$\.\*\+\?\{\}\(\)\[\]\|]`)
	fmt.Printf("%q\n", reg.ReplaceAllString("\f\t\n\r\v\123\x7F\U0010FFFF\\^$.*+?{}()[]|", "-"))
}

 

19、remove：

package main

import (
	"log"
	"os"
)

func main() {
	err := os.Remove("dir1")
	if err != nil {
		log.Fatal(err)
	}
}

 

20、remove_file:

 

package main

import (
	"fmt"
	"os"
)

func main() {
	//创建一个名为“test_rename”的目录，perm权限为0777
	err := os.Mkdir("test_remove", 0777)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("created dir:test_remove")
	//创建一个名为“test_remove1.txt”的空文件
	_, err = os.Create("./test_remove/test_remove1.txt") // 如果文件已存在，会将文件清空。
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("created file:test_remove1.txt")
	_, err = os.Create("./test_remove/test_remove2.txt")
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("created file:test_remove2.txt")
	_, err = os.Create("./test_remove/test_remove3.txt")
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("created file:test_remove3.txt")
	err = os.Remove("./test_remove/test_remove1.txt")
	if err != nil {
		fmt.Printf("removed ./test_remove/test_remove1.txt err : %v\n", err)
	}
	fmt.Println("removed file:./test_remove/test_remove1.txt")
	err = os.RemoveAll("./test_remove")
	if err != nil {
		fmt.Printf("remove all ./test_remove err : %v\n", err)
	}
	fmt.Println("removed all files:./test_remove")
}

 

21、removeall：

package main

import (
	"log"
	"os"
)

func main() {
	//先创建多级子目录
	os.MkdirAll("test1/test2/test3", 0777)
	//删除test1目录及其子目录
	err := os.RemoveAll("test1")
	if err != nil {
		log.Fatal(err)
	}
}

 

22、rename:

package main

import (
	"fmt"
	"log"
	"os"
)

func main() {
	//创建一个名为“dir_name1”的目录，perm权限为0777
	err := os.Mkdir("dir_name1", 0777)
	if err != nil {
		fmt.Println(err)
	}
	oldName := "dir_name1"
	newName := "dir_name2"
	//将dir_name1重命名为dir_name2
	err = os.Rename(oldName, newName)
	if err != nil {
		log.Fatal(err)
	}
}

 

package main

import (
	"fmt"
	"os"
)

func main() {
	//创建一个名为“test_rename.txt”的空文件
	_, err := os.Create("./test_rename.txt") // 如果文件已存在，会将文件清空。
	if err != nil {
		fmt.Println(err)
	}
	//创建一个名为“test_rename”的目录，perm权限为0777
	err = os.Mkdir("test_rename", 0777)
	//将test_rename.txt移动到test_rename目录，并将名字重命名为test_rename_new.txt
	err = os.Rename("./test_rename.txt", "./test_rename/test_rename_new.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
}

 

23、write：

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.OpenFile("write1.txt", os.O_CREATE|os.O_RDWR, 0666)
	if err != nil {
		fmt.Println(err)
	}
	defer file.Close()

	content := []byte("你好世界！")
	if _, err = file.Write(content); err != nil {
		fmt.Println(err)
	}
	fmt.Println("写入成功！")
}

 

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.Create("writeAt.txt")
	if err != nil {
		panic(err)
	}
	defer file.Close()
	file.WriteString("Go Web编程实战派从入门到精通")
	n, err := file.WriteAt([]byte("Go语言Web"), 24)
	if err != nil {
		panic(err)
	}
	fmt.Println(n)
}

 

package main

import (
	"os"
)

func main() {
	file, err := os.Create("WriteString.txt")
	if err != nil {
		panic(err)
	}
	defer file.Close()
	file.WriteString("Go Web编程实战派从入门到精通")
}

 

package main

import (
	"fmt"
	"os"
)

func main() {
	//新建文件
	fout, err := os.Create("./write4.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer fout.Close()
	for i := 0; i < 5; i++ {
		outstr := fmt.Sprintf("%s:%d\r\n", "Hello Go", i) //Sprintf格式化
		// 写入文件
		fout.WriteString(outstr)            //string信息
		fout.Write([]byte("i love go\r\n")) //byte类型
	}
}

 

24、xml_parse:

package main

import (
	"encoding/xml"
	"fmt"
	"io/ioutil"
	"os"
)

type EmailConfig struct {
	XMLName  xml.Name `xml:"config"`
	SmtpServer string `xml:"smtpServer"`
	SmtpPort int `xml:"smtpPort"`
	Sender string `xml:"sender"`
	SenderPassword string `xml:"senderPassword"`
	Receivers EmailReceivers `xml:"receivers"`
}

type EmailReceivers struct {
	Flag string `xml:"flag,attr"`
	User []string `xml:"user"`
}

func main() {
	file, err := os.Open("email_config.xml")
	if err != nil {
		fmt.Printf("error: %v", err)
		return
	}
	defer file.Close()
	data, err := ioutil.ReadAll(file)
	if err != nil {
		fmt.Printf("error: %v", err)
		return
	}
	v := EmailConfig{}
	err = xml.Unmarshal(data, &v)
	if err != nil {
		fmt.Printf("error: %v", err)
		return
	}

	fmt.Println(v)
	fmt.Println("SmtpServer is : ",v.SmtpServer)
	fmt.Println("SmtpPort is : ",v.SmtpPort)
	fmt.Println("Sender is : ",v.Sender)
	fmt.Println("SenderPasswd is : ",v.SenderPassword)
	fmt.Println("Receivers.Flag is : ",v.Receivers.Flag)
	for i,element := range v.Receivers.User {
		fmt.Println(i,element)
	}
}

 

25、xml_write:

package main

import (
	"encoding/xml"
	"fmt"
	"os"
)

type Languages struct {
	XMLName xml.Name `xml:"languages"`
	Version string `xml:"version,attr`
	Lang []Language `xml:"language"`
}

type Language struct {
	Name string `xml:"name"`
	Site string `xml:"site`
}

func main() {
	v := &Languages{Version: "2"}
	v.Lang = append(v.Lang, Language{"JAVA", "https://www.java.com/"})
	v.Lang = append(v.Lang, Language{"Go", "https://golang.org/"})
	output, err := xml.MarshalIndent(v, " ", " ")
	if err != nil {
		fmt.Printf("error %v", err)
		return
	}
	file, _ := os.Create("languages.xml")
	defer file.Close()
	file.Write([]byte(xml.Header))
	file.Write(output)
}

你好：我的2025

上一篇：Go Web 实战编程-http的使用

下一篇：Go Web 实战编程-gin

go语言学习

go语言学习

go语言学习

最近更新

最近更新

最近更新

Copyright 2025 Inc. AllRights Reserved. Design by 我爱海鲸 湘ICP备19022671号-1