golang第二天

测试代码

• 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