Go基础-文件、字符

文件创建

导入“os”包，创建文件，读写文件的函数都在改包。
指定创建的文件存放路径以及文件名。
执行Create( )函数，进行文件创建。
关闭文件。

package main

import (
	"fmt"
	"os"
)

func main() {
	//创建文件，需要指定文件的存放路径以及文件名称
	//file 为文件指针
	file, err := os.Create("D:/test/a.txt")
	//判断是否出现异常
	if err != nil {
		fmt.Println(err)
		//文件错误,也要关闭文件
		//file.Close()
		return
	}

	defer file.Close() //延迟执行
	//对创建的文件进行相关的操作

	关闭
	//file.Close()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

写入数据_writestring方法—写入string信息到文件

不会追加，会清空文件然后添加数据

package main

import (
	"fmt"
	"os"
)

func main() {
	//创建文件，需要指定文件的存放路径以及文件名称
	//file 为文件指针
	file, err := os.Create("D:/test/a.txt")
	//判断是否出现异常
	if err != nil {
		fmt.Println(err)
		//文件错误,也要关闭文件
		//file.Close()
		return
	}

	defer file.Close() //延迟执行

	// 数据长度
	n, err := file.WriteString("cccc") //写入ccc然后再写成ddd，只会出现dddd并不会追加
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(n) //n为数据的长度

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

写入数据_write方法----写入byte类型的信息到文件

不会追加，会清空文件然后添加数据

package main

import (
	"fmt"
	"os"
)

func main() {
	//创建文件，需要指定文件的存放路径以及文件名称
	//file 为文件指针
	file, err := os.Create("D:/test/c.txt")
	//判断是否出现异常
	if err != nil {
		fmt.Println(err)
		//文件错误,也要关闭文件
		//file.Close()
		return
	}

	defer file.Close() //延迟执行

	var str string = "Hello1 world"
	n, err := file.Write([]byte(str)) //需要将字符串转换为字节切片
	if err != nil {
		return
	}
	fmt.Println(n) //n为数据的长度
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

写入数据WriteAt方法–在指定位置开始写入byte类型的信息

第一个参数为在逛光标最后一个位置然后执行得到0
seek, err := file.Seek(0, io.SeekEnd) //把光标定位到文件中原有内容的后面，返回文件原油有数据的长度
1
2

package main

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

func main() {
	//创建文件，需要指定文件的存放路径以及文件名称
	//file 为文件指针
	file, err := os.Create("D:/test/a.txt")
	//判断是否出现异常
	if err != nil {
		fmt.Println(err)
		//文件错误,也要关闭文件
		//file.Close()
		return
	}

	defer file.Close() //延迟执行
	file.WriteString("hello world")

	var str string = "aaa"
	seek, err := file.Seek(0, io.SeekEnd) //把光标定位到文件中原有内容的后面
	if err != nil {
		return
	}
	//第一个参数 字节切片，第二个参数指定位置写入数据
	n, err := file.WriteAt([]byte(str), seek) //单独写入，也不会追加
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(n) //n为数据的长度
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

向已经存在文件中写入数据----OpenFile( )使用

OpenFile( )这个函数有三个参数：
第一个参数表示：打开文件的路径
第二个参数表示：模式，常见的模式有
O_RDONLY(只读模式)，O_WRONLY(只写模式), O_RDWR( 可读可写模式)，O_APPEND(追加模式)。

第三个参数表示: 权限，取值范围（0-7）
表示如下：
0：没有任何权限
1：执行权限(如果是可执行文件，是可以运行的)
2：写权限
3: 写权限与执行权限
4：读权限
5: 读权限与执行权限
6: 读权限与写权限
7: 读权限，写权限，执行权限

package main

import (
	"fmt"
	"os"
)

func main() {
	//创建文件，需要指定文件的存放路径以及文件名称
	//file 为文件指针
	//file, err := os.OpenFile("D:/test/a.txt", os.O_APPEND, 6)//追加
	file, err := os.OpenFile("D:/test/a.txt", os.O_RDWR, 6) //可读可写，从文件最开始的位置开始写入的
	if err != nil {
		fmt.Println(err)
		return
	}

	defer file.Close()

	//通过文件指针向文件中写入数据或者读写数据
	writeString, err := file.WriteString("ziyeye")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(writeString)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

读取文件数据

读取文件的基本流程如下：
打开要读取的文件
对文件进行读取
关闭文件

package main

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

func main() {
	//打开要读取的文件
	file, err := os.Open("D:/test/a.txt") //只读方式
	if err != nil {
		fmt.Println(err)
		return
	}

	defer file.Close()
	//进行文件内容读取
	//定义一个字符类型切片，存储从文件中读取的数据
	buffer := make([]byte, 1024*2)
	n, err := file.Read(buffer)
	if err != nil {
		if err == io.EOF {
			fmt.Println(err)
		}
		return
	}
	//关闭文件
	fmt.Println(n)
	fmt.Println(string(buffer[:n]))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

循环读取文件内容

package main

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

func main() {
	//打开要读取的文件
	file, err := os.Open("D:/test/a.txt") //只读方式
	if err != nil {
		fmt.Println(err)
		return
	}

	defer file.Close()
	//进行文件内容读取
	//定义一个字符类型切片，存储从文件中读取的数据
	buffer := make([]byte, 10)
	for true {
		n, err := file.Read(buffer)
		if err != nil {
			if err == io.EOF { //表示到达文件末尾了
				fmt.Println(err)
				break
			}
		}
		fmt.Println(n)
		fmt.Println(string(buffer[:n]))
	}
	//关闭文件

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

案例

文件拷贝，将已有的文件复制一份，同时重新命名。

package main

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

func main() {
	//打开原有文件
	file, err := os.Open("D:/test/a.txt")
	if err != nil {
		fmt.Println(err)
	}

	defer file.Close()
	//创建一个新的文件
	file2, err := os.Create("D:/test/zi.txt")
	if err != nil {
		fmt.Println(err)
	}
	defer file2.Close()

	//将原有文件中的内容读取出来，然后写入到新的文件中
	buffer := make([]byte, 10)

	for true {
		n, err := file.Read(buffer)
		if err != nil {
			if err == io.EOF {
				fmt.Println(err)
				break
			}
			fmt.Println(err)
		}
		file2.Write(buffer[:n])
	}
	//关闭文件

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

字符串常用方法

Contains(s,substr string) bool
功能：字符串s中是否包含substr返回bool值
Join(a[]string,sep string) string
功能:字符串连接，把切片 a通过sep连接起来
Index(s,sep string) int
功能:在字符串s中查找sep所在的位置，返回位置值，找不到返回-1
Repeat(s string,count int) string
功能:重复s字符串count次，最后返回重复的字符串
Replace(s,old,new string,n int) string
功能:在s字符串吧old字符串替换为new字符串,n表示替换的次数，小于0表示全部替换
Split(s,sep string)[]string
功能:把s字符串按照sep分隔，返回slice(切片)
Trim(s string,cutset string) string
功能:在s字符串的头部和尾部取出cutset指定的字符串
Fields(s string) [] string
功能:去除s字符串的空格符，并且按照空格分隔返回切片

文档地址：https://studygolang.com/pkgdoc

package main

import (
	"fmt"
	"strings"
)

func main() {
	var str string = "hellogo"
	contains := strings.Contains(str, "go") //是否包含go 判断某个字符串是否在str中存在，如果存在返回true否则返回false
	fmt.Println(contains)                   //true
	contains = strings.Contains(str, "goo") //是否包含go
	fmt.Println(contains)                   //false

	str1 := []string{"abc", "hello", "world"}
	join := strings.Join(str1, "|")
	fmt.Println(join) //abc|hello|world

	//Index 查找某个位置
	var str2 string = "abcHello"
	index := strings.Index(str2, "Hello") //判断Hello在str中出现的位置，注意位置从0开始计算
	fmt.Println(index)

	repeat := strings.Repeat("go", 3) //表示字符串go重复三次
	fmt.Println(repeat)               //gogogo

	//Replace
	str3 := "hello world"
	replace := strings.Replace(str3, "l", "ye", 1) //负数如-1为全部替换 用新的字符串替换旧的字符串，第四个参数表示替换的次数
	fmt.Println(replace)                           //heyelo world

	//Split
	str4 := "ziye@woaini@aini"
	split := strings.Split(str4, "@")
	fmt.Println(split) //[ziye woaini aini]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

案例

让用户输入一个日期格式，如:2018-01-02, 输出日期为2008年1月2日

package main

import (
	"fmt"
	"strings"
)

func main() {
	//输入日期
	fmt.Println("请输入日期，格式:年-月-日")
	var str string
	fmt.Scan(&str)
	//按照-进行分隔
	split := strings.Split(str, "-")
	//输出指定的格式
	fmt.Println(split[0] + "年" + split[1] + "月" + split[2] + "日")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

让用户输入一句话,判断这句话中有没有“邪恶”,如果有“邪恶”就替换成“**”，然后输出。 如:老王很邪恶,输出后变成老王很xxx

package main

import (
	"fmt"
	"strings"
)

func main() {
	//定义变量存储用户输入的一句话
	fmt.Println("请输入一句话")
	var str string
	fmt.Scan(&str)
	//判断用户输入的内容中是否有邪恶
	if strings.Contains(str, "邪恶") {
		str = strings.Replace(str, "邪恶", "**", -1)
	}
	//如果有，则进行替换
	fmt.Println(str)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

字符串转换

把其他类型的转换为字符串。
把字符串转换为其他类型

https://blog.csdn.net/qq_40432598/article/details/132702749?spm=1001.2014.3001.5502