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

编程语言 2023-04-09 12:58:07 阅读次数: 0

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

猜你喜欢

转载自blog.csdn.net/qq_51685718/article/details/127694345
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022