测试代码
- hello.go
package main
import "fmt"
/**
*该程序目的
* 学习go的复杂数据结构: 数组，指针，结构体，切片，集合
*/
func main() {
/**
* 方式： var arrayName [len] type
* 例: var nums [10] int
* 声明一个数组和遍历它
*/
var nums [10]int //声明一个数组
fmt.Println(len(nums))
fmt.Println(cap(nums))
for idx := 0; idx < len(nums); idx++ {
fmt.Println(nums[idx])
}
/**
* 声明和初始化一起
*/
var names = []string{"jack", "andy", "lisa"}
fmt.Println(names)
/**
* 指针：保存内存地址的变量
* &运算符，获取变量的内存地址
* *运算符，获取内存地址存放的数据
* 空指针： nil判断
* %x十六进制格式输出 小写
* %X十六进制格式输出 大写
*/
var age int = 20
fmt.Println("age变量的内存地址:", &age)
fmt.Printf("age变量的内存地址:%x\n", &age)
fmt.Printf("age变量的内存地址:%X\n", &age)
var ageP *int = &age
fmt.Println(ageP)
fmt.Println(*ageP)
var intp *int
if intp == nil {
fmt.Println("是空指针")
} else {
fmt.Println("非空指针")
}
/**
* 结构体对象的创建
* 对象的判空？
* 结构体指针: '.'操作符访问结构体对象的属性
*/
var jack = Person{"jack", 10}
var andy = Person{"andy", 20}
fmt.Println(jack)
fmt.Println(andy)
fmt.Println(jack.name)
var ppoint *Person = &jack
fmt.Println(ppoint.name)
ppoint.age = 30
fmt.Println(jack.age)
var paul = Person{"paul", 30}
changePersonName(paul, "newPaul")
fmt.Println("name:", paul.name) //修改失败， paul
chagePersonName2(&paul, "PaulJun")
fmt.Println("name:", paul.name) //修改成功，PaulJun
/**
* 切片，类似可以扩容的数组
* make([]type, length, capacity) , length<=capacity, 否则报错
* len(), cap()
* 切片操作：[:]，类似python
* append扩容， copy拷贝元素
*/
var nums2 []int = make([]int, 10, 20) //长度为10， 容量为20
fmt.Printf("len=%d, cap=%d, nums2=%v\n", len(nums2), cap(nums2), nums2) //len=10, cap=20, nums2=[0 0 0 0 0 0 0 0 0 0]
var nums3 = []int{1, 2, 3, 4, 5, 6, 7}
fmt.Println(len(nums3), cap(nums3), nums3) //7 7 [1 2 3 4 5 6 7]
var endIndex = len(nums3) - 1
fmt.Println("endIndex=", endIndex) //6
fmt.Println(nums3[:endIndex]) //索引为0-5的元素 [1 2 3 4 5 6]
fmt.Println(nums3[1:4]) //索引1-3的元素，不包含索引为4 [2 3 4]
fmt.Println(nums3[0:]) //[1 2 3 4 5 6 7]
var nilNums []int
if nilNums == nil {
fmt.Println("空切片")
}
var newNums3 = append(nums3, 10) //append生成一个新的切片
fmt.Println(newNums3)
var doubleNums3 = make([]int, len(nums3)*2, cap(nums3)*2)
copy(doubleNums3, nums3)
fmt.Println(doubleNums3, cap(doubleNums3))
/**
* range关键字
* 用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)、集合(map)或字符串(string)的元素
*/
var nums4 = []int{10, 20, 30, 40}
for idx, val := range nums4 {
fmt.Println(idx, "->", val)
}
var info = "hello,go"
for idx, chr := range info { //第二个是字符Unicode的值
fmt.Println(idx, "->", chr)
}
/**
* map: key-val
* 声明： var map[key_type]val_type
*/
var scores = make(map[string]float32)
scores["jack"] = 98.5
scores["andy"] = 78.5
for k:= range scores {
fmt.Println(k)
}
for k,v := range scores {
fmt.Println(k, "-", v)
}
delete(scores, "jack") //删除key: jack的键值对
fmt.Println(scores)
fmt.Println(factorial(15))
/**
*go类型转换
* type(val)
*/
var val = 50
fmt.Printf("%d\n",val)
fmt.Printf("%f\n", float32(val)) //val转成float32的类型变量
/**
* 接口interface
* new(T) 函数分配内存， 返回一个指向类型为 T，值为 0 的地址的指针
* make(T) 函数初始化 返回一个类型为 T 的初始值
*/
var animal Animal
animal = new(Cat)
fmt.Println(animal.typeName())
animal = new(Dog)
fmt.Println(animal.typeName())
}
/**
* 结构体声明，类似C语言
* type struct关键字
*/
type Person struct {
//声明Person结构体，包含name和age两个属性
name string
age int
}
/**
* 结构体作为参数是值传递
*/
func changePersonName(person Person, newName string) {
person.name = newName
}
/**
* 改变结构体的属性值，函数中须通过指针
*/
func chagePersonName2(personp *Person, newName string) {
personp.name = newName
}
/**
* 递归demo
*/
func factorial(num uint64) uint64 {
if num>1 {
return num* factorial(num-1)
}
return 1
}
/**
* 声明接口
*/
type Animal interface {
typeName() string
}
type Cat struct {
name string
}
/**
* 实现该方法
*/
func (cat Cat) typeName() string {
return "Cat"
}
type Dog struct {
name string
}
func (dog Dog) typeName() string {
return "Dog"
}
- 总结
- 数据，指针，切片，集合，结构体，接口的基本使用
打卡时间： 23:27
