Go基础学习(二)

数组【array】

数组定义【定义后长度不可变】

1 2	symbol := [...]string{USD: "$", EUR: "€", GBP: "￡", RMB: "￥"} fmt.Println(RMB, symbol[RMB])

指针数组

var array3 [5]*int
for i := range array3 {
    array3[i] = new(int)
}
*array3[0] = 1
*array3[1] = 2
*array3[2] = 3
*array3[3] = 4
*array3[4] = 5
array4 := array3
for _, v := range array4 {
    fmt.Println(*v)
}

切片【可变数组】

切片在底层维护一个可以动态扩展的数组，切片这一数据结构包含三个元素，指针、长度、容量【所以切片是引用类型】

source := make([]string, 3, 5) // 访问长度3个元素，底层数组拥有5个元素，不允许创建容量小于长度的切片
source = []string{"red", "green", "blue", "yellow", "black"}
slice := source[2:3:5] // 1个元素，容量为5-2=3
for _, v := range slice {
    fmt.Println(v)
}
fmt.Println(len(slice))
fmt.Println(cap(slice))

切片、字符串互相转换

source := make([]string, 10)
source = []string{"123", "456", "789"}
a := strings.Join(source, ",") // 切片转字符串
m := strings.Split(a, ",")
fmt.Println(a)
fmt.Println(m)

中间插入元素

a := []int{1, 2, 3, 4, 5}
a = append(a, 0)
fmt.Println(a)
copy(a[3:], a[2:]) // 将[2:]的元素拷贝到[3:]中，最后一个元素丢弃
fmt.Println(a)
a[2] = 10          // 修改元素为新元素
fmt.Print(a)

原地删除

// 原地删除，公用底层数组
s := []string{"a", "b", " ", "d", "e", " ", "f"}
b := s[:0]
for _, x := range s {
    if x != " " {
        b = append(b, x) // append函数用于追加元素
    }
}
fmt.Println(b)

slice作为参数

// more本质上就是slice类型
func Sum(a int, more ...int) int {
	for _, v := range more {
		a += v
	}
	return a
}

Map

基本操作

dict := make(map[string]int)
dict["abc"] = 123
dict["efg"] = 456
fmt.Println(dict["abc"])
_, exist := dict[ 大专栏  Go基础学习(二)4;abcd"]
fmt.Println(exist)               // 判断是否存在，如果不赋值，exist就是false，赋值哪怕是零值，也为true
delete(dict, "abcd")             // 即使key不存在也不会报错
for index, value := range dict { // map遍历是无序的
    fmt.Println(index, value)
}

map类型也是引用类型，所以如果作为参数传到函数中修改，会改变变量本身

struct

struct不是引用类型，改变自身需要传指针
继承

type Point struct {
	X, Y int
}

type Circle struct {
	Point
	Radius int
}

interface

interface是一组method的组合，可以通过interface来定义对象的一组行为。如果某个对象实现了某个接口的所有方法，则此对象就实现了此接口。
如果我们定义了一个interface的变量，那么这个变量里面可以存实现这个interface的任意类型的对象。
类型断言，判断一个interface是否是该类型

package main

import "fmt"

type Element interface{}
type List []Element
type People struct {
	Name string
}

func main() {
	list := make(List, 3)
	list[0] = 1
	list[1] = "hello"
	list[2] = People{"test"}
	for _, value := range list {
		n, ok := value.(int)
		if ok {
			fmt.Println(n)
			continue
		}
		s, ok := value.(string)
		if ok {
			fmt.Println(s[:3])
			continue
		}
		p, ok := value.(People)
		if ok {
			fmt.Println(p.Name)
			continue
		}
	}
}

使用switch来简化代码【element.(type)】不能在switch外的任何逻辑里面使用

package main

import "fmt"

type Element interface{}
type List []Element
type People struct {
	Name string
}

func main() {
	list := make(List, 4)
	list[0] = 1
	list[1] = "hello"
	list[2] = People{"test"}
	list[3] = 2.3
	for _, value := range list {
		switch t := value.(type) {
		case int:
			fmt.Println(t + 1)
		case string:
			fmt.Println(t[:3])
		case People:
			fmt.Println(t.Name)
		default:
			fmt.Println("类型异常")
		}
	}
}

interface也可以向struct一样内嵌