Golang 笔记 day-03
内置函数
panic
panic(“error”) //程序崩溃退出
recover
// recover 仅在延迟函数 defer 中有效
// defer 需要在panic前定义
// 有 panic 也有 recover，程序不会宕机，执行完对应的 defer 后，从宕机点退出当前函数后继续执行。
// 不要滥用
结构体
结构体是值类型
自定义类型 和 类型别名
// type 后面跟类型名
// 自定义类型
type myInt int
// 类型别名
type youInt = int
结构体的定义
type person struct {
name string
age int
year int
}
var a person
a.name = "名字"
匿名结构体
// 用于临时场景 ，一次后不用了
var s struct{
name string
age int
}
指针类型结构体
// go 传值是相当于拷贝一份，所以在函数馁修改外面的变量，需要传内存地址
// 获取结构体指针
&person
new(person)
func (x *person){
}
var a = &person{
name:'aaa',
age:1
}
a := &person{
'aaa'
1
}
构造函数 返回一个结构体变量
type person struct{
name string
}
// 结构体大使用指针，较小程序内存开销
func newPreson(name string) person{
return person{
name:name,
}
}
结构体嵌套
type address struct{
addr string
}
type student struct{
name string
addr address
}
// 匿名嵌套 上级找不到会自动找下级 类似js的原型
type student struct{
name string
address
}
// 如果字段冲突，只能写全路径
结构体与json
// 结构体转json
type student struct{
Name string `json "name"`
Id int
}
var a = student{
name:"asdasd",
id:1,
}
b,err := json.Marshal(a)
// 反序列化
var c student
str := "{name:'ceshi',id:1}"
json.Unmarshal([]byte(str),&c)
// 序列化为空 结构体字段要大些，不大写别人访问不到
// 结构体后加。`json:"重命名"` 反序列化要传递指针
方法
// 首字母大写 对外暴露
// 作用域特定类型的函数
type person struct{
name string
}
// 结构体大使用指针，较小程序内存开销
func newPreson(name string) person{
return person{
name:name,
}
}
// 结构体 实现了 sayHi方法
func (p person) sayHi(){
fmt.Println("%s 说 嗨",p.name)
}
func main(){
ren :=newPreson("ren")
ren.sayHi()
}
// 尽量使用指针接受者
函数版简易学生管理系统
package main
import (
"fmt"
"os"
)
type student struct {
id int
name string
}
var (
allStudent map[int]*student
)
func newStudent(id int, name string) *student {
return &student{
id: id,
name: name,
}
}
func showStudents() {
for k, v := range allStudent {
fmt.Printf("学号：%d,姓名：%s\n", k, v.name)
}
}
func addStudent() {
var id int
var name string
fmt.Print("请输入学生学号：")
fmt.Scanln(&id)
fmt.Print("请输入学生姓名：")
fmt.Scanln(&name)
nesStu := newStudent(id, name)
allStudent[id] = nesStu
}
func deleteStudent() {
var id int
fmt.Print("请输入学生学号：")
fmt.Scanln(&id)
delete(allStudent, id)
}
func main() {
allStudent = make(map[int]*student, 12)
for {
fmt.Printf("=======学生管理系统========")
fmt.Println(`
1：查看所有学生
2：新增学生
3：删除学生
4：退出
`)
fmt.Print("请输入你要干啥：")
var num int
fmt.Scanln(&num)
fmt.Printf("您选择了%d号选项", num)
fmt.Println()
switch num {
case 1:
showStudents()
case 2:
addStudent()
case 3:
deleteStudent()
case 4:
os.Exit(1)
default:
fmt.Println("没有")
}
}
}
方法版学生管理系统
package main
import (
"fmt"
"os"
)
type student struct {
id int
name string
}
type studentMgr struct {
allStudent map[int]*student
}
func newStudent(id int, name string) *student {
return &student{
id: id,
name: name,
}
}
// 查看所有学生
func (s *studentMgr) showStudents() {
for _, v := range s.allStudent {
fmt.Println("-----------------------")
fmt.Printf("| 学号：%d | 姓名：%s |\n", v.id, v.name)
fmt.Println("-----------------------")
}
}
// 添加学生
func (s *studentMgr) addStudent() {
var id int
var name string
fmt.Print("请输入学生学号：")
fmt.Scanln(&id)
if hasStudent(id, s) {
fmt.Println("「该学号已存在」")
return
}
fmt.Print("请输入学生姓名：")
fmt.Scanln(&name)
nesStu := newStudent(id, name)
s.allStudent[id] = nesStu
fmt.Println("「添加成功」")
}
// 学生是否存在
func hasStudent(id int, s *studentMgr) bool {
_, ok := s.allStudent[id]
return ok
}
// 删除学生
func (s *studentMgr) deleteStudent() {
var id int
fmt.Print("请输入学生学号：")
fmt.Scanln(&id)
if !hasStudent(id, s) {
fmt.Println("「该学号不存在」")
return
}
delete(s.allStudent, id)
fmt.Println("「删除成功」")
}
func main() {
// 初始化一个内存
allStudent := studentMgr{
make(map[int]*student, 12),
}
for {
fmt.Printf("=======学生管理系统========")
fmt.Println(`
1：查看所有学生
2：新增学生
3：删除学生
4：退出
`)
fmt.Print("请输入你要干啥：")
var num int
fmt.Scanln(&num)
fmt.Printf("您选择了%d号选项", num)
fmt.Println()
switch num {
case 1:
allStudent.showStudents()
case 2:
allStudent.addStudent()
case 3:
allStudent.deleteStudent()
case 4:
os.Exit(1)
default:
fmt.Println("没有")
}
}
}
