Go语言进阶第02天（结构体进阶与文件）

最新推荐文章于 2025-02-21 14:39:32 发布

兰公子&

最新推荐文章于 2025-02-21 14:39:32 发布

阅读量122

点赞数

分类专栏： go架构师文章标签： golang 网络

本文链接：https://blog.youkuaiyun.com/qq_51685718/article/details/127694345

版权

go架构师专栏收录该内容

20 篇文章

订阅专栏

1.结构体的使用

package main

import (
	"fmt"
	"unsafe"
)

type Person struct {
	name string
	sex  byte
	age  int
}

type Student struct {
	p     []Person
	id    []int
	score [1000]int
}

func test(man Person) {
	fmt.Println("test temp size:", unsafe.Sizeof(man))

	man.name = "name1"
	man.age = 33

	fmt.Println("test: man", man)
}

func main01() {
	// 1. 顺序初始化, 必须全部初始化完整
	var man Person = Person{"andy", 'm', 18}
	fmt.Println("man:", man)

	// 2. 部分初始化
	man2 := Person{sex: 'f', age: 19}
	fmt.Println("man2:", man2)
	// 索引成员变量 “.”
	fmt.Printf("man2.name = %q\n", man2.name)

	var man3 Person
	man3.name = "mike"
	man3.sex = 'm'
	man3.age = 99
	fmt.Println("man3:", man3)
	man3.age = 1073
	fmt.Println("man3:", man3)

	// 结构体比较
	var p1 Person = Person{"andy", 'm', 18}
	var p2 Person = Person{"andy", 'm', 18}
	var p3 Person = Person{"andy", 'm', 181}

	fmt.Println("p1 == p2 ?", p1 == p2)
	fmt.Println("p1 == p3 ?", p1 == p3)

	// 相同类型结构体赋值
	var tmp Person
	fmt.Println("tmp", tmp)
	tmp = p3
	fmt.Println("tmp", tmp)

	// 函数内部使用结构体传参
	var temp Person
	fmt.Println("main temp size:", unsafe.Sizeof(temp))
	test(temp) // 值传递。将实参的值拷贝一份给形参。
	fmt.Println("temp", temp)

	fmt.Printf("&tmp = %p\n", &temp)
	fmt.Printf("&temp.name = %p\n", &(temp.name))

	fmt.Println("main temp size:", unsafe.Sizeof(true)) // 1 /0
}

2.结构体指针

package main

import (
	"fmt"
	"unsafe"
)

type Person2 struct {
	name string
	sex  byte
	age  int
}

func test2(p *Person2) {
	fmt.Println("test2:", unsafe.Sizeof(p))
	p.name = "Luffy"
	p.age = 779
	p.sex = 'm'
}
func main02() {
	var p1 *Person2 = &Person2{"n1", 'f', 19}
	fmt.Println("p1", p1)

	var tmp Person2 = Person2{"n1", 'f', 19}
	var p2 *Person2
	p2 = &tmp
	fmt.Println("p2", p2)

	p3 := new(Person2)
	p3.name = "n3"
	p3.age = 22
	p3.sex = 'f'
	fmt.Printf("p3, type= %T\n", p3)
	fmt.Println("p3:", p3)

	fmt.Println("main:", unsafe.Sizeof(p3))

	test2(p3)

	fmt.Println("p3:", p3)
}

3.结构体传参

package main

import "fmt"

type Person3 struct {
	name      string
	age       int
	flg       bool
	intereset []string
}

// 通过函数参数 初始化 结构体
func initFunc(p *Person3) {
	p.name = "Nami"
	p.age = 18
	p.flg = true
	p.intereset = append(p.intereset, "shopping")
	p.intereset = append(p.intereset, "sleeping")
}

// 通过函数返回值，初始化结构体。
func initFunc2() *Person3 {
	p := new(Person3)
	p.name = "Nami"
	p.age = 18
	p.flg = true
	p.intereset = append(p.intereset, "shopping")
	p.intereset = append(p.intereset, "sleeping")
	return p // 返回指针变量的值 —— heap的地址。
}

func main03() {
	/*	var person Person3
		initFunc(&person)
		fmt.Println("person:", person)*/

	p2 := initFunc2()
	fmt.Println("p2", p2)

}

4.strings头文件字符串处理

package main

import (
	"fmt"
	"strings"
)

func main04() {

	str := "I love my work and I love my family too"

	// 字符串按 指定分割符拆分
	ret := strings.Split(str, " I")
	for _, s := range ret {
		fmt.Println(s)
	}

	// 字符串按 空格拆分
	ret = strings.Fields(str)
	for _, s := range ret {
		fmt.Println(s)
	}

	// 判断字符串结束标记
	flg := strings.HasSuffix("test.abc", ".mp3")
	fmt.Println(flg)

	// 判断字符串起始标记
	flg = strings.HasPrefix("test.abc", "tes.")
	fmt.Println(flg)

}

5.文件打开和创建

package main

import (
	"fmt"
	"os"
)

func main0501() {
	f, err := os.Create("D:/testFile.xyz")
	if err != nil {
		fmt.Println("create err:", err)
		return
	}
	defer f.Close()
	fmt.Println("successful")

}

func main0502() {
	f, err := os.Open("D:/testFile.xyz")
	if err != nil {
		fmt.Println("open err:", err)
		return
	}
	defer f.Close()

	strings := make([]byte, 10)
	count := 0
	count, err = f.Read(strings)
	if err != nil {

		return
	}

	fmt.Printf("打开文件总共数量：%d , %s\n", count, strings)
}

func main0503() {

	f, err := os.OpenFile("D:/testFile.xyz", os.O_RDWR, 6)
	if err != nil {
		fmt.Println("OpenFile err:", err)
		return
	}
	defer f.Close()

	_, err = f.WriteString("######")
	if err != nil {
		fmt.Println("WriteString err:", err)
		return
	}

	fmt.Println("successful")
}

6.写文件

package main

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

func main06() {
	f, err := os.OpenFile("D:/testFile.xyz", os.O_RDWR, 6)
	if err != nil {
		fmt.Println("OpenFile err:", err)
		return
	}
	defer f.Close()
	fmt.Println("successful")

	n, err := f.WriteString("helloworld\r\n")
	if err != nil {
		fmt.Println("WriteString err:", err)
		return
	}
	fmt.Println("WriteString n = ", n)

	off, _ := f.Seek(-5, io.SeekEnd)
	fmt.Println("off:", off)

	n, _ = f.WriteAt([]byte("1111"), off)
	fmt.Println("WriteAt n :", n)
}

7.读文件

package main

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

func main07() {
	f, err := os.OpenFile("C:/Users/ACER/Desktop/reader.xyz", os.O_RDWR, 6)
	if err != nil {
		fmt.Println("OpenFile err:", err)
		return
	}
	defer f.Close()
	fmt.Println("successful")

	// 创建一个带有缓冲区(用户缓冲)的 reader
	reader := bufio.NewReader(f)
	for {
		buf, err := reader.ReadBytes('\n') // 读一行数据
		if err != nil && err == io.EOF {
			fmt.Println("文件读取完毕")
			return
		} else if err != nil {
			fmt.Println("ReadBytes err:", err)
		}
		fmt.Print(string(buf))
	}
}

8.文件拷贝

package main

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

func main08() {

	// 打开读文件
	f_r, err := os.Open("C:/itcast/01-复习.avi")
	if err != nil {
		fmt.Println("Open err: ", err)
		return
	}
	defer f_r.Close()
	// 创建写文件
	f_w, err := os.Create("C:/itcast/test.avi")
	if err != nil {
		fmt.Println("Create err: ", err)
		return
	}
	defer f_w.Close()

	// 从读文件中获取数据，放到缓冲区中。
	buf := make([]byte, 4096)
	// 循环从读文件中，获取数据，“原封不动的”写到写文件中。
	for {
		n, err := f_r.Read(buf)
		if err != nil && err == io.EOF {
			fmt.Printf("读完。n = %d\n", n)
			return
		}
		f_w.Write(buf[:n]) // 读多少，写多少
	}

}

9.目录操作

package main

import (
	"fmt"
	"os"
)

func main09() {
	// 获取用户输入的目录路径
	fmt.Println("请输入待查询的目录：")
	var path string
	fmt.Scan(&path)

	// 打开目录
	f, err := os.OpenFile(path, os.O_WRONLY, os.ModeDir)
	if err != nil {
		fmt.Println("OpenFile err: ", err)
		return
	}
	defer f.Close()
	// 读取目录项
	info, err := f.Readdir(-1) // -1： 读取目录中所有目录项
	if err != nil {
		fmt.Println("Readdir err: ", err)
		return
	}
	// 变量返回的切片
	for _, fileInfo := range info {
		if fileInfo.IsDir() { // 是目录
			fmt.Println(fileInfo.Name(), " 是一个目录")
		} else {
			fmt.Println(fileInfo.Name(), " 是一个文件")
		}
	}
}

10.练习1

package main

import (
	"fmt"
	"os"
	"strings"
)

func main10() {
	// 获取用户输入的目录路径
	fmt.Println("请输入待查询的目录：")
	var path string
	fmt.Scan(&path)

	// 打开目录
	f, err := os.OpenFile(path, os.O_RDONLY, os.ModeDir)
	if err != nil {
		fmt.Println("OpenFile err: ", err)
		return
	}
	defer f.Close()

	// 读取目录项
	info, err := f.Readdir(-1) // -1： 读取目录中所有目录项
	if err != nil {
		fmt.Println("Readdir err: ", err)
		return
	}
	// 变量返回的切片
	for _, fileInfo := range info {
		if !fileInfo.IsDir() { // 文件
			if strings.HasSuffix(fileInfo.Name(), ".mp3") {
				fmt.Println("jpg 文件有：", fileInfo.Name())
			}
		}
	}
}

11.练习2

package main

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

// 拷贝mp3 文件到指定目录的操作
func cpMP32Dir(src, dst string) {
	//fmt.Println("src:", src)
	//fmt.Println("dst:", dst)

	//打开读文件
	f_r, err := os.Open(src)
	if err != nil {
		fmt.Println("Open err: ", err)
		return
	}
	defer f_r.Close()
	// 创建写文件
	f_w, err := os.Create(dst)
	if err != nil {
		fmt.Println("Create err: ", err)
		return
	}
	defer f_w.Close()

	// 从读文件中获取数据，放到缓冲区中。
	buf := make([]byte, 4096)
	// 循环从读文件中，获取数据，“原封不动的”写到写文件中。
	for {
		n, err := f_r.Read(buf)
		if err != nil && err == io.EOF {
			fmt.Printf("读完。n = %d\n", n)
			return
		}
		f_w.Write(buf[:n]) // 读多少，写多少
	}
}

func main11() {
	// 获取用户输入的目录路径
	fmt.Println("请输入待查询的目录：")
	var path string
	fmt.Scan(&path)

	// 打开目录
	f, err := os.OpenFile(path, os.O_RDONLY, os.ModeDir)
	if err != nil {
		fmt.Println("OpenFile err: ", err)
		return
	}
	defer f.Close()

	// 读取目录项
	info, err := f.Readdir(-1) // -1： 读取目录中所有目录项
	if err != nil {
		fmt.Println("Readdir err: ", err)
		return
	}
	// 变量返回的切片
	for _, fileInfo := range info {
		if !fileInfo.IsDir() { // 文件
			if strings.HasSuffix(fileInfo.Name(), ".mp3") {
				cpMP32Dir(path+"/"+fileInfo.Name(), "./"+fileInfo.Name())
			}
		}
	}
}