Go入门（六）之文本文件处理

最新推荐文章于 2023-10-19 08:00:00 发布

Wielun

最新推荐文章于 2023-10-19 08:00:00 发布

阅读量302

点赞数 1

分类专栏： Golang 文章标签： go正则表达式 JSON 文件操作

本文链接：https://blog.csdn.net/Dream_ya/article/details/118768433

版权

Golang 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

上一篇文章> Go入门（五）之面向对象编程、异常处理

一、文本文件处理

1、字符串处理

（1）contains

func Contains(s, substr string) bool
返回bool值

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Contains("hello wielun", "wielun"))
	fmt.Println(strings.Contains("hello wielun", "wielun11"))
}

结果：

true
false

（2）join

func Join(elems []string, sep string) string
功能：字符串链接，把slice elems通过sep链接起来

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Joins 组合
	s := []string{"abc", "hello", "wielun"}
	fmt.Println(strings.Join(s, "@"))
}

结果：

abc@hello@wielun

（3）Index

func Index(s, substr string) int
功能：在字符串s中查找sbustr所在的位置，返回位置值，找不到返回-1

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Index("hello wielun", "wielun"))
	fmt.Println(strings.Index("hello wielun", "go"))
}

结果：

6
-1

（4）Repeat

func Repeat(s string, count int) string
功能：重复s字符串count次，最后返回重复的字符串

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Repeat("wielun", 3))
}

结果：

wielunwielunwielun

（5）Replace

func Replace(s, old, new string, n int) string
功能：在s字符串中，把old字符串替换为new字符串，n表示替换的次数，小于0表示全部替换

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Replace("hello wielun", "e", "haha", 1))
}

结果：

hhahallo wielun

（6）Split

func Split(s, sep string) []string
功能：把s字符串按照sep分割，返回slice

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Split("hello@wielun@ya", "@"))
}

结果：

[hello wielun ya]

（7）Trim

func Trim(s string, cutset string) string
功能：在s字符串的头部和尾部去除cutset指定的字符串

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Trim("   hello wielun   ", " "))
	fmt.Println(strings.Trim("eehello wielunee", "e"))
}

结果：

hello wielun
hello wielun

（8）Fields

func Fields(s string) []string
功能：去除s字符串的空格符，并且按照空格分割返回slice

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Fields("   hello wielun ya   "))
}

结果：

[hello wielun ya]

2、字符串转换

（1）Append

将整数等转换为字符串后，添加到现有的字节数组中

package main

import (
	"fmt"
	"strconv"
)

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("slice = ", string(slice))
}

结果：

slice =  true1234"ABCgohello"

（2）Format

把其他类型转换为字符串

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 其他类型转换为字符串
	var str string
	str = strconv.FormatBool(false)
	fmt.Println("str = ", str)
	// 'f':指打印格式，以小数方式，-1指小数点位数（紧缩模式），64以float64
	str = strconv.FormatFloat(3.14, 'f', -1, 64)
	fmt.Println("str = ", str)
	// 整型转字符串，常用
	str = strconv.Itoa(666)
	fmt.Println("str = ", str)
}

结果：

str =  false
str =  3.14
str =  666

（3）Parse

把字符串转换为其他类型

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 字符串转其他类型
	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("123")
	fmt.Println("a = ", a)
}

结果：

flag =  true
a =  123

3、正则表达式

（1）匹配字符串

package main

import (
	"fmt"
	"regexp"
)

func main() {
	s := "sdf dwr dwer aerc 123c dsfe"
	// 解释正则表达式
	result := regexp.MustCompile(`d.r`)
	if result == nil {
		fmt.Println("regexp err")
		return
	}
	// 提取关键信息
	result1 := result.FindAllStringSubmatch(s, -1)
	fmt.Println("result1 = ", result1)
}

结果：

result1 =  [[dwr]]

（2）匹配小数

package main

import (
	"fmt"
	"regexp"
)

func main() {
	s := "1.23 434 sf 1.263 7. 31sdf fe123 5.233"

	// 解释正则表达式
	result := regexp.MustCompile(`\d+\.\d+`)
	if result == nil {
		fmt.Println("regexp err")
		return
	}

	// 提取关键信息
	result1 := result.FindAllStringSubmatch(s, -1)
	fmt.Println("result1 = ", result1)
}

结果：

result1 =  [[1.23] [1.263] [5.233]]

4、JSON处理

（1）通过结构体生成json

package main

import (
	"encoding/json"
	"fmt"
)

// 成员首字母必须大写
type IT struct {
	Company  string   `json:"-"`        // 此字段不会输出到屏幕
	Subjects []string `json:"subjects"` //修改为小写
	Isok     bool     `json:",string"`
	Price    float64  `json:",string"`
}

func main() {
	s := IT{"itcase", []string{"Go", "C++", "Python"}, true, 12.13}
	// 编码，根据内容生成json文本
	// result, err := json.Marshal(s)
	result, err := json.MarshalIndent(s, "", "   ") // 格式化编码
	if err != nil {
		fmt.Println("err = ", err)
		return
	} else {
		fmt.Println("result = ", string(result))
	}
}

结果：

result =  {
   "subjects": [
      "Go",
      "C++",
      "Python"
   ],
   "Isok": "true",
   "Price": "12.13"
}

（2）通过map生成json

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	m := make(map[string]interface{}, 4)
	m["company"] = "itcast"
	m["subjects"] = []string{"Go", "C++", "Python"}
	m["isok"] = true
	m["price"] = 123.12

	// 编码成json
	// result, err := json.Marshal(m)
	result, err := json.MarshalIndent(m, "", "   ") // 格式化编码
	if err != nil {
		fmt.Println("err = ", err)
		return
	}
	fmt.Println("result = ", string(result))
}

结果：

result =  {
   "company": "itcast",
   "isok": true,
   "price": 123.12,
   "subjects": [
      "Go",
      "C++",
      "Python"
   ]
}

（3）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": "itcase",
		"subjects": [
			 "Go",
			 "C++",
			 "Python"
		],
		"isok": true,
		"price": 12.13
 }
	`
	var tmp IT
	err := json.Unmarshal([]byte(jsonBuf), &tmp)
	if err != nil {
		fmt.Println("err = ", err)
		return
	}
	fmt.Printf("tmp = %+v\n", tmp)

	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)
}

结果：

tmp = {Company:itcase Subjects:[Go C++ Python] Isok:true Price:12.13}
tmp2 = {Subjects:[Go C++ Python]}

（4）json解析到map

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	jsonBuf := `
	{
		"company": "itcase",
		"subjects": [
			 "Go",
			 "C++",
			 "Python"
		],
		"isok": true,
		"price": 12.13
 }
	`
	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)

	// 类型断言
	for key, value := range m {
		switch data := value.(type) {
		case string:
			fmt.Printf("map[%s]的值类型为string, value = %s\n", key, data)
		case bool:
			fmt.Printf("map[%s]的值类型为bool, value = %v\n", key, data)
		case float64:
			fmt.Printf("map[%s]的值类型为float64, value = %v\n", key, data)
		case []interface{}:
			fmt.Printf("map[%s]的值类型为interface, value = %v\n", key, data)
		}
	}
}

结果：

m = map[company:itcase isok:true price:12.13 subjects:[Go C++ Python]]
map[company]的值类型为string, value = itcase
map[subjects]的值类型为interface, value = [Go C++ Python]
map[isok]的值类型为bool, value = true
map[price]的值类型为float64, value = 12.13

5、文件操作

（1）建立与打开文件

# 新建文件：
	# 根据提供的文件名创建新得文件，返回一个问及那对象，默认权限是0666的文件，返回的文件对象是可读写的
	func Create(name string) (*File, error)
	
	# 根据文件描述符创建相应的文件，返回一个文件对象
	func NewFile(fd uintptr, name string) *File

# 打开文件：
	# 打开一个名称为name的文件，只读方式，内部其实调用了OpenFile
	func Open(name string) (*File, error)
	
	# 打开一个名称为name的文件，flag是打开的方式，只读、读写等，perm是权限
	func OpenFile(name string, flag int, perm FileMode) (*File, error)

（2）写文件

# 写入byte类型的信息到文件
func (f *File) Write(b []byte) (n int, err error)

# 在指定位置开始写入byte类型的信息
func (f *File) WriteAt(b []byte, off int64) (n int, err error)

# 写入string 信息到文件
func (f *File) WriteString(s string) (n int, err error)

（3）读文件

# 读取数据到b中
func (f *File) Read(b []byte) (n int, err error)

# 从off开始读取数据到b中
func (f *File) ReadAt(b []byte, off int64) (n int, err error)

（4）删除文件

# 调用该函数就可以删除文件名为name的文件
func Remove(name string) error

（5）设备文件的使用

package main

import (
	"fmt"
	"os"
)

func main() {
	// os.Stdout.Close()
	// fmt.Println("hello wielun")
	// // 标准设备文件，默认已经打开
	// os.Stdout.WriteString("hello world!")

	os.Stdin.Close()
	var a int
	fmt.Println("请输入a:")
	fmt.Scan(&a)
	fmt.Println("a = ", a)
}

结果：

请输入a:
a =  0

（6）文件的读写

<1> 写

package main

import (
	"fmt"
	"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++ {
		buf = fmt.Sprintf("i = %d\n", i)
		_, err := f.WriteString(buf)
		if err != nil {
			fmt.Println("err = ", err)
		}
	}
}

func main() {
	path := "./demo.txt"
	WriteFile(path)
}

结果（demo.txt）：

i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9

<2> 读

package main

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

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, 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"
	ReadFile(path)
}

结果：

buf =  i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9

<3> 一行一行读

package main

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

func ReadFileLine(path string) {
	//打开文件
	f, err := os.Open(path)
	if err != nil {
		fmt.Println("err = ", err)
		return
	}

	// 关闭文件
	defer f.Close()
	// 新建一个缓冲区，把内容放在缓冲区
	r := bufio.NewReader(f)

	for {
		buf, err1 := r.ReadBytes('\n') // 遇到'\n'结束读取
		if err1 != nil {
			if err1 == io.EOF { //文件已经结束
				break
			}
			fmt.Println("err1 = ", err1)
			return
		}
		fmt.Printf("buf = %s\n", string(buf))
	}
}

func main() {
	path := "./demo.txt"
	ReadFileLine(path)
}

结果：

buf = i = 0

buf = i = 1

buf = i = 2

buf = i = 3

buf = i = 4

buf = i = 5

buf = i = 6

buf = i = 7

buf = i = 8

buf = i = 9

（7）拷贝文件案例

package main

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

func main() {
	list := os.Args // 获取命令行参数
	if len(list) != 3 {
		fmt.Println("usage: xx srcFile dstFile")
		return
	}

	srcFileName := list[1]
	dstFileName := list[2]
	if srcFileName == dstFileName {
		fmt.Println("源文件和目的文件不能相同")
		return
	}

	// 只读方式打开源文件

	sF, err1 := os.Open(srcFileName)
	if err1 != nil {
		fmt.Println("err1 = ", err1)
		return
	}

	// 新建目的文件
	dF, err2 := os.Create(dstFileName)
	if err2 != nil {
		fmt.Println("err2 = ", err2)
		return
	}

	// 关闭文件
	defer sF.Close()
	defer dF.Close()

	// 写入内容进目的文件
	buf := make([]byte, 1024*4)
	for {
		n, err := sF.Read(buf)
		if err != nil {
			if err == io.EOF {
				break
			}
			fmt.Println("err = ", err)
		}
		// 写内容
		dF.Write(buf[:n])
	}
}

下一篇文章> Go入门（七）之并发编程、Socket编程、HTTP编程

Wielun

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
1
评论
Go入门（六）之文本文件处理

一、文本文件处理1、字符串处理（1）containsfunc Contains(s, substr string) bool返回bool值package mainimport ( "fmt" "strings")func main() { fmt.Println(strings.Contains("hello wielun", "wielun")) fmt.Println(strings.Contains("hello wielun", "wielun11"))}结果
复制链接

扫一扫