GO学习每日一题

注：每日一题来源go语言官方公众号

day5

package main

import "fmt"
//下面这段代码能否通过编译，原因

//答：不能 invalid operation: sm1 == sm2 (struct containing map[string]string cannot be compared)
//考点：结构体比较
//1，结构体只能比较是否相等，但是不能比较大小
//2.相同类型的结构体才能比较，结构体是否相同与属性类型和属性顺序相关。如sn3和sn1就是不同结构体
//3.如果struct的所有成员都可比较，则该结构体可以通过==或者！=进行比较是否相等。比较时逐个进行，如果每一项都相等，则两个结构体才相等，否则不相等

//常见可比较类型： bool、数值、字符、指针、数组、
//不可比较类型：切片、map、函数

func main(){
	sn1 := struct {
		age int
		name string
	}{11,"qq"}

	sn2 := struct {
		age int
		name string
	}{11,"qq"}

	//sn3 := struct{
	//	name string
	//	age int
	//}{11,"qq"}

	if sn1 == sn2{
		fmt.Println("sn1 == sn2")
	}

	sm1 := struct{
		age int
		m map[string]string
	}{
		11, map[string]string{"a" : "1"}}

	sm2 := struct{
		age int
		m map[string]string
	}{
		11, map[string]string{"a" : "1"}}

	if sm1 == sm2{
		fmt.Println("sm1==sm2")
	}
}

day6

package main

import "fmt"

//1.通过指针变量p访问其成员变量name，有哪几种方式？
//答案：AC
//解析：&取值运算符，*指针解引用
//A. p.name
//B. (&p).name
//C. (*p).name
//D. p->name

//2.下面这段代码能否通过编译？如果通过，输出什么？
//cannot use i (type int) as type MyInt1 in assignment
//考点：类型别名与类型定义的区别

//type MyInt1 int  //基于类型int创建新类型MyInt1
//type MyInt2 = int  //创建int的类型别名MyInt2
//
//func main(){
//	var i int = 0

//此时相当于将int类型的变量赋值给MyInt1类型变量，go是强类型语言，编译不通过
//这行代码可以使用强制类型转化 var i1 MyInt1 = MyInt1(i)
//	var i1 MyInt1 = i1 My

//	var i2 MyInt2 = i   //MyInt2只是int的别名，本质上还是int,可以赋值
//	fmt.Println(i1, i2)
//}
//

//3.以下代码输出什么？
//答案：
//%+v
// [7 8 9]
//%+v
// [7 8 9]
//%+v
// [1 8 9]

//解析：
//因为append导致底数组重新分配内存了，ap中的a这个slice的底层数组和外面不是一个，并没有改变外面的，
func main(){
	a := []int{7,8,9}
	fmt.Println("%+v\n", a)
	ap(a)
	fmt.Println("%+v\n",a)
	app(a)
	fmt.Println("%+v\n",a)
}
func ap(a []int){
	a = append(a,10)
}
func app(a []int){
	a[0] = 1
}

day7

package main

import "fmt"

//1.关于字符串连接，下面语法正确的是?
//答案：BD
//解析：字符串连接。除了以上两种，还有 strings.Join()、buffer.WriteString()等
//A. str := 'abc' + '123'
//B. str := "abc" + '123'
//C. str := '123' + "abc"
//D. fmt.Sprintf("abc%d", 123)


//2.下面这段代码能否通过编译？
//答案：能通过，输出结果为：0 2 zz zz 5
//知识点：iota常量计数器的使用，每次const出现时，都会让iota初始化为0 【自增长】
//https://www.cnblogs.com/zsy/p/5370052.html
 const(
 	x = iota
 	_ //可跳过的值
 	y
 	z = "zz"
 	k
 	p = iota
 )

func main(){
	fmt.Println(x,y,z,k,p)
}

//3.下面赋值正确的是
//答案：BD
//解析：nil只能赋值给指针、chan、func、interface、map、slice类型的变量
//A. var x = nil
//B. var x interface{} = nil
//C. var x string = nil
//D. var x error = nil  //error类型。是一种内置接口类型。源码如下
		//type error interface {
		//	Error() string
		//}

day8

package main

// 1.关于init函数，下面的说法正确的是（AB）
//解析：
//1.init()函数是用于程序执行前做包的初始化的函数，比如初始化包李的变量等
//2.一个包可以出现多个init()函数，一个源文件也可以出现包含多个init()函数
//3.同一个包中多个init()函数的执行顺序没有明确定义，但是不同包的init函数是根据包导入的依赖关系决定的
//4.init()函数在代码中不能被显示调用，不能被引用（赋值给函数变量），否则出现编译错误
//5.一个包被引用多次，如A import B，C import B， A import C，B被引用多次，但B包只会初始化一次
//6. 引入包，不可出现死循环，即A import B， B import A, 这种情况编译失败

//A. 一个包中，可以包含多个init函数；
//B. 程序编程时，先执行依赖包的init函数，再执行main包内的init函数
//C. main包中，不能有init函数；
//D. init函数可以被其他函数调用；

//2.下面这段代码输出什么及原因？（B）
//h:= hello 是将hello()赋值给变量h,而不是函数的返回值，所以输出not nil

//func hello() []string {
//	return nil
//}
//
//func main(){
//	h:= hello
//	if h == nil {
//		fmt.Println("nil")
//	}else{
//		fmt.Println("not nil")
//	}
//}

//A.nil
//B.not nil
//C.compilation error


//3.下面这段代码能否通过编译。如果可，输出什么？
//不能：cannot type switch on non-interface value i (type int )
//考点：类型选择，类型选择语法形如: i.(type),其中i是接口，type是固定关键字。注意：只有接口类型才可以使用类型选择
func GetValue() int{
	return 1
}

func main(){
	i := GetValue()
	switch i.(type) {
	case int:
		println("int")
	case string:
		println("string")
	default:
		println("unkown")

	}
}

day9

package main

import "fmt"

// 1.关于channel,下面语法正确的是（A.B.C）
//解析：A、B都是声明channel, C读取channel,写chanel是必须带值
// A. var ch chan int
// B. ch := make(chan int)
// C. <-ch
// D. ch <-


//2.下面这段代码的输出是什么？(A)
// A.0
// B.1
// C.complication error
//解析：打印一个map中不存在的值时，返回元素类型的零值。此例子中m类型是map[person]int,因为m中不存在p,所以打印int类型的零值，即0

//type person struct {
//	name string
//}
//
//func main(){
//	var m map[person]int
//	p := person{"mike"}
//	fmt.Println(m[p])
//}


//3.下面这段代码输出什么？
//答案：18
func hello(num ...int){
	num[0] = 18
}

func main(){
	i := []int{5,6,7}
	hello(i...)
	fmt.Println(i[0])
}

day10

package main

//1.下面代码输出（C）
//解析：a是int类型，b是float,两种类型数值不能相加，编译报错
//func main(){
//	a := 5
//	b := 8.1
//	fmt.Println(a + b)
//}
// A. 13.1
// B.13
// C.compilation error


//2.下面这段代码输出是什么（B）
//解析：t := a[3:4:4]表示切片t为[4],长度和容量都是1。[i,j,k]第三个参数4表示用来限制新切片的容量。即，长度为j-i>容量为k-i
//func main(){
//	a := [5]int{1,2,3,4,5}
//	t := a[3:4:4]
//	fmt.Println(t[0])
//}
//
//A.3
//B.4
//C.compilation error


//3.下段代码的输出是什么（A）
//解析：go中数组是值类型，可比较。数组长度也是数组类型的组成部分，所以a和b是不同类型，不能比较，所以编译错误
//func main(){
//	a := [2]int{5,6}
//	b := [3]int{5,6}
//	if a == b {
//		fmt.Println("equal")
//	}else{
//		fmt.Println("not equal")
//	}
//}
//
//A.compliation error
//B.equal
//C.not equal

day11

package main

import "fmt"

//1.关于cap()函数的适用类型，下面说法正确的是（ABD）
//解析：cap()函数不适用于map
// A.array
// B.slice
// C.map
// channel



//2.下面这段代码的输出是什么？(A)
//解析：当且仅当接口的动态值和动态类型都是nil时，接口类型才是nil
//func main(){
//	var i interface{}
//	if i  == nil{
//		fmt.Println("nil")
//		return
//	}
//	fmt.Println("not nil")
//}

//A.nil
//B.not nil
//C.compilation error


//3.下面这段代码的输出是什么(B)
//解析：删除map不存在的键值对时，不会报错，相当于没有任何作用。获取不存在的键值对时，返回值类型对应的零值，所以返回0
func main(){
	s := make (map[string]int)
	delete(s,"h")
	fmt.Println(s["h"])
}

//A.runtime panic
//B.0
//C.compilation error

day12

package main

import "fmt"

//1.下面属于关键字的是（BAD）
//解析：
//A. func
//B. struct
//C. class
//D. defer

//2.下面这段代码输出什么？(A)
//解析：%d 表示输出十进制数字。 +表示输出数值的符号。这里不表示取反
//func main(){
//	i := -5
//	j := +5
//	fmt.Printf("%+d %+d", i, j )
//}

//A.-5+5
//B.+5+5
//C.0 0


//3.下面这段代码输出什么？
//答案：teacher showB
//知识点：结构体嵌套。
//解析：在嵌套结构体中，People称为内部结构，Teacher称为外部类型；通过嵌套，内部类型的属性、方法，可以为外部类型所有。
//就好像是外部类型自己的一样。此外，外部类型还可以定义自己的属性和方法，甚至可以定义与内部相同的方法，这样内部类型的方法就会被“屏蔽”。这个例子中的showB()就是同名方法
type People struct{}

func (p *People) ShowA(){
	fmt.Println("showA")
	p.ShowB()
}

func (p *People) ShowB(){
	fmt.Println("showB")
}

type Teacher struct {
	People
}

func (t *Teacher) ShowB(){
	fmt.Println("teacher showB")
}

func main(){
	t := Teacher{}
	t.ShowB()
}

day13

package main

//1.定义一个包内全局字符串变量，下面语法正确的是（A.D）
//解析：B只支持局部变量声明；C是赋值，str必须在这之前声明
//A.var str string
//B.str := ""
//C.str = ""
//D. var str = ""

//2.下面这段代码输出什么？
//答案：5
//解析：这个例子中，hello()函数的参数在执行defer语句的时候会保存一份副本，在实际调用hello（）函数时用。
//func hello(i int) {
//	fmt.Println(i)
//}
//func main(){
//	i := 5
//	defer hello(i)
//	i = i + 10
//}

//3.下面这段代码输出什么？
//答案：showA，showB
//知识点：结构体嵌套。结合昨天的题。teacher没有自己的showA(),所以调用内部类型People的同名方法，需要注意的是第五行代码调用的是自己的showB方法。
//type People struct{}
//func (p *People) ShowA(){
//	fmt.Println("showA")
//	p.ShowB()
//}
//func (p *People) ShowB(){
//	fmt.Println("showB")
//}
//
//type Teacher struct{
//	People
//}
//func (t *Teacher) ShowB(){
//	fmt.Println("teacher showB")
//}
//
//func main(){
//	t := Teacher{}
//	t.ShowA()
//}

day14

package main

import "fmt"

//1.下面代码的输出是什么：(C)
//知识点：常量，GO语言中的字符串是只读的
//func main(){
//	str := "hello"
//	str[0] = 'x'
//	fmt.Println(str)
//}

//A. hellp
//B. xello
//C.compilation error

//2.下面代码输出什么？(B)
//知识点：指针，incr()函数里的p是*int类型的指针，指向的是main()函数的变量p的地址。
//第二行代码是将该地址的值执行一个自增操作，incr()返回自增后的结果。
func incr(p *int) int {
	*p++
	return *p
}

func main(){
	p := 1
	incr(&p)
	fmt.Println(p)
}

//A.1
//B.2
//C.3


//3.对add()函数调用正确的是（ABD）
//知识点：可变函数
func add(args ...int) int{
	sum := 0
	for _, arg := range args{
		sum += arg
	}
	return sum
}

//A.add(1,2)
//B.add(1,3,7)
//C.add(int{1,2})
//D.add(int{1,3,7}...)

day15

package main

import "fmt"

//1.下面代码下划线处可以填入哪个选项？（A）
//知识点：nil切片和空切片。
//nil切片和nil相等。一般用来表示一个不存在的切片；空切片和nil不相等，表示一个空的集合
func main(){
	var s1 [] int
	var s2 = [] int{}
	if __ == nil {
		fmt.Println("yes nil")
	}else{
		fmt.Println("no nil")
	}
}

//A.s1
//B.s2
//C.s1,s2都可以


//下面这段代码输出什么？()
//UTF-8编码中，十进制数值65对应的符号是A
func main(){
	i := 65
	fmt.Println(string(i))
}

// A.A
//B.65
//C.compilation error


//3.下面这段代码输出什么？
//答案：13、23
//知识点：接口
//解析：一种类型实现多个接口，结构体Work分别实现了接口A、B，
//所有接口变量a,b调用各自的方法ShowA()和ShowB(),输出13，23
type A interface{
	showA() int
}
type B interface{
	ShowB() int
}

type Work struct{
	i int
}

func (w Work) ShowA() int{
	return w.i + 10
}

func (w Work) ShowB() int{
	return w.i + 20
}

func main(){
	c := Work{3}
	var a A = c
	var b B = c
	fmt.Println(a.ShowA())
	fmt.Println(b.showB())
}

day16

package main

import "fmt"

//1.切片a、b、c、的长度和容量风别是多少？
// a:长度为0.容量为3
// b:长度为2.容量为3
// c:长度为1.容量为2
//解析：形如[i:j],[i:j:k]，切片长度和容量计算方法分别是j-i,-i.（l是底层数组长度）。
//k主要是用来现在切片的容量，但是不能大于数组长度i
func main(){
	s := [3]int{1,2,3}
	a := s[:0]
	b := s[:2]
	c := s[1:2:cap(s)]
}

//2.下面代码中AB两处应该怎么修改才能顺路编译？
//A处只声明了map m,没有分配内存空间，不能直接赋值，需要使用make(),或者字面量的方式直接初始化map
//B处，v,k := m["b"]当key为b的元素不存在时，v会返回值类型对应的零值，k返回false

func main(){
	var m map[string]int //A
	m ["a"] = 1
	if v := m["b"]; v != nil{ //B
		fmt.Println(v)
	}
}


//3.下面代码输出什么？(B)
//解析：接口的静态类型。a,b具有相同的动态类型和动态值，分别时结构体work和{3}；
//a的静态类型是A，b的静态类型是B。接口A不包括方法ShowB(),接口B也不包括方法ShowA(),编译报错
type A interface {
	ShowA() int
}
type B interface {
	ShowB() int
}
type Work struct{
	i int
}

func (w Work) ShowA()int{
	return w.i + 10
}
func (w Work) ShowB()int{
	return w.i + 20
}

func main(){
	c := Work{3}
	var a A = c
	var b B = c
	fmt.Println(a.ShowB())
	fmt.Println(b.ShowA())
}


//A.23 13
//B.compilation error

day17

package main

import "fmt"

//1.下面代码中，x已声明，y没有声明，判断每条语句的对错。
//解析：遍历的声明。
//1. x, _ := f() //×
//2. x, _ = f() //√
//3. x, y := f() //√ 当多值赋值时， :=左边的变量无论声明与否都可以；
//4. x，y = f()  //× y没有声明


//2.下面代码输出什么？B
//知识点：defer、返回值。注意一下，increaseA() 的返回参数是匿名，increaseB() 是具名
func interfaceA() int{
	var i int
	defer func(){
		i++
	}()
	return i
}

func interfaceB() (r int){
	defer func(){
		r++
	}()
	return r
}

func main() {
	fmt.Println(interfaceA())
	fmt.Println(interfaceB())
}

//A. 1 1
//B. 0 1
//C. 1 0
//D. 0 0


//3.下面代码输出什么？A
//知识点：类型断言。这道题可以和第 15 天的第三题 和第 16 天的第三题结合起来看，具体的解析看《Go 语言接口详解（二）》
type A interface{
	ShowA() int
}
type B interface {
	ShowB() int
}
type Work struct{
	i int
}

func (w Work) ShowA() int{
	return w.i + 10
}

func(w Work) ShowB() int{
	return w.i + 20
}

func main(){
	var a A = Work{3}
	s := a.(Work)
	fmt.Println(s.ShowA())
	fmt.Println(s.ShowB())
}

//A. 13 23
//B. compilation error

day18

package main
// 1.f1()、f2()、f3()函数分别返回什么？
// 解析：https://mp.weixin.qq.com/s/Hm8MdrqYgCQPQ4A1nrv4sw
func f1() (r int){
	defer func(){
		r++
	}()
	return 0
}

func f2() (r int) {
	t := 5
	defer func(){
		t = t+5
	}()
	return t
}

func f3() (r int){
	defer func(r int){
		r = r+5
	}(r)
	return 1
}

day19

package main

import "fmt"

package main

//下段代码输出什么？
//29 ，29，28
//变量 person 是一个指针变量 。
//
//1.person.age 此时是将 28 当做 defer 函数的参数，会把 28 缓存在栈中，等到最后执行该 defer 语句的时候取出，即输出 28；
//
//2.defer 缓存的是结构体 Person{28} 的地址，最终 Person{28} 的 age 被重新赋值为 29，所以 defer 语句最后执行的时候，依靠缓存的地址取出的 age 便是 29，即输出 29；
//
//3.闭包引用，输出 29；
//
//又由于 defer 的执行顺序为先进后出，即 3 2 1，所以输出 29 29 28。
type Person struct{
	age int
}

func main(){
	person := &Person{28}

	//1.
	defer fmt.Println(person.age)

	//2.
	defer func(p *Person) {
		fmt.Println(p.age)
	}(person)

	//3.
	defer func(){
		fmt.Println(person.age)
	}()

	person.age = 29
}

day20

package main

import "fmt"

//1.下面这段代码正确输出是什么？(C)
//被调用函数里的 defer 语句在返回之前就会被执行，所以输出顺序是 F D M。
func f() {
	defer fmt.Println("D")
	fmt.Println("F")
}

func main(){
	f()
	fmt.Println("M")
}

//A. F M D
//B. D F M
//C. F D M


//2.下面这段代码输出什么？
//29,28,28
type Person struct{
	age int
}

func main(){
	person := &Person{28}

	//1.
	defer fmt.Println(person.age)

	//2.
	defer func(p *Person){
		fmt.Println(p.age)
	}(person)

	//3.
	defer func(){
		fmt.Println(person.age)
	}()

	person = &Person{29}
}

//这道题在第 19 天题目的基础上做了一点点小改动，前一题最后一行代码 person.age = 29 是修改引用对象的成员 age，这题最后一行代码 person = &Person{29} 是修改引用对象本身，来看看有什么区别。
//
//1处.person.age 这一行代码跟之前含义是一样的，此时是将 28 当做 defer 函数的参数，会把 28 缓存在栈中，等到最后执行该 defer 语句的时候取出，即输出 28；
//
//2处.defer 缓存的是结构体 Person{28} 的地址，这个地址指向的结构体没有被改变，最后 defer 语句后面的函数执行的时候取出仍是 28；
//
//3处.闭包引用，person 的值已经被改变，指向结构体 Person{29}，所以输出 29.
//
//由于 defer 的执行顺序为先进后出，即 3 2 1，所以输出 29 28 28。

day21

package main

//1.下面的两个切片声明中有什么区别？哪个更可取？ A
//.参考答案及解析：A 声明的是 nil 切片；B 声明的是长度和容量都为 0 的空切片。第一种切片声明不会分配内存，优先选择。
//A. var a [] int
//B. a := []int{}

//2.A,B,C,D哪些选项有语法错误？
//BD。函数参数为 interface{} 时可以接收任何类型的参数，
//包括用户自定义类型等，即使是接收指针类型也用 interface{}，而不是使用 *interface{}。
//永远不要使用一个指针指向一个接口类型，因为它已经是一个指针。
type S struct{
}

func f (x interface{}){
}

func g(x *interface{}){
}

func main() {
	s := S{}
	p := &s
	f(s) //A √
	g(s) //B ×
	f(p) //C √
	g(p) //D ×
}


//3.下面A、B两次应该填入什么代码。才能确保顺利打印结果?
//A. &S{"foo"}
//B. *f() 或者 f()
//B 处，如果填 *f()，则 p 是 S 类型；如果填 f()，则 p 是 *S 类型，不过都可以使用 p.m 取得结构体的成员。
 type S struct{
 	m string
 }

 func f() *S{
 	return __ //A
 }

 func main(){
 	P := __ //B
 	fmt.print(p.m) //print"foo"
 }

day22

package main

import "fmt"

//1. 下面的代码有几处语法问题，各是什么？
//nil不能被赋值，也不能跟nil比较
func main(){
	var x string = nil
	if x == nil {
		x = "defalt"
	}
	fmt.Println(x)
}

//2.return之后的defer语句会执行吗，下面这段代码输出什么？
//不能。defer关键字后面的函数或者方法想要执行必须先注册，return之后的defer是不能注册的，所以不能执行后面的函数或者方法
var a bool = true
func main(){
	defer func(){
	fmt.Println("1")
	}()
	if a == true {
		fmt.Println("2")
		return
	}
	defer func(){
		fmt.Println("3")
	}()
}

day23

package main

import "fmt"

//1.下面这段代码输出什么？为什么
//[1,2,4][ 1,2,4]
//解析：切片底层数据结构是数组。
func main(){
	s1 := []int{1,2,3}
	s2 := s1[1:]  //s2和s1共享一个底层数组，所以下一段代码影响了s1
	s2[1] = 4
	fmt.Println(s1)
	s2 = append(s2, 5,6,7) //append会导致底层数组扩容，生成新的数组，所以追加后不会影响s1
	fmt.Println(s1)
}

//2.下面选项正确的是？a
//解析，代码块和变量作用域
func main(){
	if a := 1; false{
	} else if b := 2; false{
	} else{
		println(a,b)
	}
}

//A.1 2
//B.compilation error

day24

package main

import "fmt"

//下面这段代码输出什么？
//0 zero
//1 one
//map的输出是无序的
//func main(){
//	m := map[int]string{0:"zero", 1:"one"}
//	for k,v := range m {
//		fmt.Println(k,v)
//	}
//}

//2.下面这段代码输出什么？
// 10,1,2,3
// 20,0,2,2
// 2,0,2,2
// 1,1,3,4
func main(){
	a := 1
	b := 2
	defer calc("1", a, calc("10", a, b)) //先执行calc("10", a, b)，输出10，1，2，3。再延迟执行calc("1,1,3)
	a = 0
	defer calc("2", a, calc("20", a, b)) //先执行calc("20", a, b)，输出20，0，2，2.再执行calc("2",0,2)
	b = 1
}

func calc(index string, a, b int) int{
	ret := a+b
	fmt.Println(index, a, b, ret)
	return ret
}

day25

package main

import "fmt"

//1.下面这段代码输出什么？B
//基于类型创建的方法必须定义再同一个包里。上面的代码基于int类型创建了PrintInt()方法，
//由于int类型和方法PrintInt()定义在不同的包内，所以编译出错。
//解决：
//type Myint int
//func (i Myint) PrintInt ()  {
//	fmt.Println(i)
//}
//func main() {
//	var i Myint = 1
//	i.PrintInt()
//}

func (i int) printInt(){
	fmt.Println(i)
}

func main(){
	var i int = 1
	i.PrintInt()
}

//A.1
//B.compilation error

//2.下面这段代码输出什么 B
//值类型 Student 没有实现接口的 Speak() 方法，而是指针类型 *Student 实现该方法。
type People interface{
	Speak(string) string
}

type Student struct {
}

func (stu *Student) Speak(think string) (talk string) {
	if think == "speak" {
		talk == "speak"
	}else{
		talk = "hi"
	}
	return
}

func main(){
	var peo People = Student{}
		think := "speak"
		fmt.Println(peo.Speak(think))
}

//A.speak
//B.compilation error

day26

package main

import "fmt"

//1.下面这段代码输出什么？
//0 1 1 2
//iota 是golong语言的常量计数器，只能在常量的表达式中使用。
//iota在const关键字出现时将被重置为0(const内部的第一行之前)，const中每一行新赠一行常量声明使iota计数一次
//golang 使用 iota：https://studygolang.com/articles/2192
const (
	a = iota
	b = iota
)
const (
	name = "name"
	c = iota
	d = iota
)
func main(){
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
	fmt.Println(d)
}

//2.下面这段代码输出什么？
//答案：s is nil / p is not nil
//当且仅当动态值和动态类型都为 nil 时，接口类型值才为 nil。
//上面的代码，给变量 p 赋值之后，p 的动态值是 nil，但是动态类型却是 *Student，是一个 nil 指针，所以相等条件不成立。
//https://mp.weixin.qq.com/s/eDdrHwg0g7kLutDs-ejNpw
type People interface {
	show()
}
type Student struct{}
func (stu *Student) show(){

}
func main(){
	var s *Student
	if s == nil{
		fmt.Println("s is nil")
	} else {
		fmt.Println("s is not nil")
	}
	var p People = s
	if p == nil{
		fmt.Println("p is nil")
	}else{
		fmt.Println("p is not nil")
	}
}

day27

package main

import "fmt"

//1.下面这段代码输出什么？
//South。知识点：iota的用法、类型的String()方法

//根据 iota 的用法推断出 South 的值是 3；
//另外，如果类型定义了 String() 方法，当使用 fmt.Printf()、fmt.Print() 和 fmt.Println() 会自动使用 String() 方法，
//实现字符串的打印。
type Direction int

const (
	North Direction = iota
	East
	South
	West
)

func (d Direction) String() string{
	return [...]string{"North","East","South","West"}[d] //？？
}
func main(){
	fmt.Println(South)
}


//2.下面这段代码输出什么？B
//错误原因：对于类似 X = Y的赋值操作，必须知道 X 的地址，才能够将 Y 的值赋给 X，
//但 go 中的 map 的 value 本身是不可寻址的。

//type Math struct{
//	x,y int
//}
//var m = map[string]Math{
//	"foo":Math{2,3},
//}
//main(){
//	m["foo"].x = 4
//	fmt.Println(m["foo"].x)
//}
//A.4
//B.compilation error

//两个解决方法
//1.使用临时变量
type Math struct{
	x, y int
}

var m = map[string]Math{
	"foo": Math{2,3},
}

func main(){
	tmp := m["foo"]
	tmp.x = 4
	m["foo"] = tmp
	fmt.Println(m["foo"].x)
}

//2.修改数据结构
type Math struct{
	x, y int
}

var m = map[string]*Math{
	"foo": &Math{2,3},
}

func main(){
	m["foo"].x = 4
	fmt.Println(m["foo"].x)
	fmt.Println("%#v", m["foo"])  //%#v 格式化输出详细信息
}