go 的重新学习(二)

主要是MAP，LIST，包，结构

map
LIST
包
结构与方法

map

首先都是用make 来进行申请
字典基本和Python的用法差不都，但是还是建议使用切片

package mainfunc mapInitialization() {// map[key:键 类型]value:值 类型var mapOne map[int]string//如果是没有进行申请的空间的map，直接添加元素会报错//mapOne[1] = "sister"mapOne = make(map[int]string, 20)mapOne[1] = "sister of dc"for _, s := range mapOne {println(s)}
}//假设我们想获取一个 map 类型的切片，我们必须使用两次 make() 函数
//，第一次分配切片，第二次分配 切片中每个 map 元素
func mapWithSlice() {var complexMap map[string][]bytecomplexMap = make(map[string][]byte)var keyString = "sisterofdc"var valuebyte = []byte(keyString)//complexMap[keyString] = make([]byte, cap(valuebyte))complexMap[keyString] = valuebytefor s := range complexMap {println(s, string(complexMap[s]))}var complexMapTwo map[string][]intcomplexMapTwo = make(map[string][]int)var originalArray = [5]int{1, 2, 3, 4, 5}var valueSlice = originalArray[2:3]complexMapTwo[keyString] = make([]int, cap(valueSlice))complexMapTwo[keyString] = valueSlicefor s := range complexMapTwo {for i, i2 := range complexMapTwo[s] {println(i, i2)}}
}//map 默认是无序的，不管是按照 key 还是按照 value
//默认都不排序（详见第 8.3 节）。
//如果你想为 map 排序，需要将 key（或者 value）拷贝到一个切片
//，再对切片排序（使用 sort 包，详见第 7.6.6 节）
func mapSort() {var sampleData = map[string]int{"alpha": 34, "bravo": 56, "charlie": 23,"delta": 87, "echo": 56, "foxtrot": 12,"golf": 34, "hotel": 16, "indio": 87,"juliet": 65, "kili": 43, "lima": 98}println(len(sampleData))var stringSlice = make([]string, len(sampleData))var i = 0for s := range sampleData {stringSlice[i] = si = i + 1}for i2, s := range stringSlice {println(i2, s)}// sort包的使用
}func main() {mapSort()
}

map用的机会还没有。先暂时就这些吧，有练习的时候贴出来

LIST

这里先提一句go中的标准输出，fmt.print这个用起来其实和C的输出一模一样

golang中打印数据我们通常是使用fmt.Println()，但是其实golang中也有内置的Println()方法
内置的Println()/Print()函数都是标准错误输出，而fmt.Println()函数是标准输出
内置的Println()/Print()函数输出结果可能与预期结果顺序不一致，而fmt.Println()函数输出结果与预期结果完全一致。(这个特性是由标准错误输出和标准输出决定)
内置Println()/Print()函数不能接受数组和结构体类型的数据
内置Println()/Print()函数对于组合类型的数据输出的结果是参数值的地址，而fmt.Println()函数输出的是字面量
所以如果在List直接输出print会是uint8编码。所以需要用fmt.print标准输出
list中还有一个非常疑惑的点。*list.List 和 list.List
因为创建list.List有两种方式

l := list.New()
var l2 list.List

当传入参数的时候是

func printList(temporaryList *list.List)
func printListTwo(temporaryList list.List)

所以这里同一传入*list.List

https://www.cnblogs.com/huxianglin/p/6924425.htm

List的基本方法

type Elementfunc (e *Element) Next() *Elementfunc (e *Element) Prev() *Elementtype Listfunc New() *Listfunc (l *List) Back() *Element   // 返回最后一个元素func (l *List) Front() *Element  // 返回第一个元素func (l *List) Init() *List  // 链表初始化func (l *List) InsertAfter(v interface{}, mark *Element) *Element // 在某个元素前插入func (l *List) InsertBefore(v interface{}, mark *Element) *Element  // 在某个元素后插入func (l *List) Len() int // 返回链表长度func (l *List) MoveAfter(e, mark *Element)  // 把e元素移动到mark之后func (l *List) MoveBefore(e, mark *Element)  // 把e元素移动到mark之前func (l *List) MoveToBack(e *Element) // 把e元素移动到队列最后func (l *List) MoveToFront(e *Element) // 把e元素移动到队列最头部func (l *List) PushBack(v interface{}) *Element  // 在队列最后插入元素func (l *List) PushBackList(other *List)  // 在队列最后插入接上新队列func (l *List) PushFront(v interface{}) *Element  // 在队列头部插入元素func (l *List) PushFrontList(other *List) // 在队列头部插入接上新队列func (l *List) Remove(e *Element) interface{} // 删除某个元素

这里就简单的进行链表的4个基本操作
1.创建
2.遍历
3.插入
4.删除
1.创建

//创建一个长度为length的链表
func createList(length int) *list.List {newList := list.New()for i := 1; i < length; i++ {newList.PushBack(i)}return newList
}

2.遍历

func printList(temporaryList *list.List) {for i := temporaryList.Front(); i != nil; i = i.Next() {fmt.Printf("%T ,%v \n", i.Value, i.Value)}
}

3.插入
这里面有个很烦的东西
*Element 中为了存任何东西，定义的是Any.写比较就有点难受了。
同时判断两个东西
1.判断是同一个类型
2.判断是否是同一个值
用switch case 和标准输出进行判断

4.删除
找到Element后，传入进行删除就行了
如果后面项目中应用链表的问题。进行补充和修改

包

因为标准库中的包很多的
正则匹配包
锁和同步包
精密计算和 big 包
自定义包
东西很多。这里不再赘述。后面都有以后贴出链接

结构与方法

剩下还有的复杂数据结构，结构体，接口，类型别名
首先先看type 关键字，

func typeStudy() {//可以进行多个类型的定义//由于GO是一种静态语言,由于GO语言不存在隐式转换,用了type后，所有的转换都需要显式说明type (myName stringmyAge  intmyUrl  string)
}

自定义包用的东西
panic
recover
defer
这里和kotlin一样。需要做差错检测和异常处理
差错处理,自定义的error

var myError = errors.New("this is my error")func test() (string, error) {return "this is test", myError
}

这里如果要自定义包后添加这里的代码

接下来是结构体和方法
结构体中的字段除了有名字和类型外，还可以有一个可选的标签（tag）：
它是一个附属于字段的字符串，可以是文档或其他的重要标记
。标签的内容不可以在一般的编程中使用，只有包 reflect 能获取它。

type myInfo struct {myName string "我的名字"myAge  int    "岁数"myUrl  string "链接"
}

结构体的内存布局
Go 语言中，结构体和它所包含的数据在内存中是以连续块的形式存在的，
即使结构体中嵌套有其他的结构体

一些练习内容
练习 10.1 vcard.go：
定义结构体 Address 和 VCard，后者包含一个人的名字、地址编号、出生日期和图像，
试着选择正确的数据类型。构建一个自己的 vcard 并打印它的内容。

func practiseOne() {type Address struct {location string}type VCard struct {name string*Addressdate     stringimageUrl string}var addressOne = Address{"this is neiJiang",}var addressTwo = new(Address)addressTwo.location = "this is cd"var myVC = VCard{name:     "sisterOfDC",Address:  addressTwo,date:     "2002",imageUrl: "",}var myotherVC = VCard{name:     "",Address:  &addressOne,date:     "",imageUrl: "",}fmt.Printf("%v %v", myVC.Address, myotherVC.Address)
}

这里只有一个问题。
var 申请出来是值
new 出来是指针
一般为了方便存储建议用指针，但是都差不多，因为下面方法中就会体现出来

练习 10.6
定义结构体 employee，它有一个 salary 字段，
给这个结构体定义一个方法 giveRaise 来按照指定的百分比增加薪水。

package mainimport "fmt"type employee struct {name   stringsalary float64
}func (thisEmplyee employee) giveRaise(addPercent float64) (money float64) {thisEmplyee.salary = thisEmplyee.salary * addPercentreturn thisEmplyee.salary
}func (thisEmplyee *employee) giveRaiseTwo() float64 {thisEmplyee.salary = thisEmplyee.salary * 3return thisEmplyee.salary
}func testFunction() {var sisterOfDC = employee{name:   "sister",salary: 4000,}sisterOfDC.salary = sisterOfDC.giveRaise(1.85)fmt.Print(sisterOfDC)sisterOfDC.giveRaiseTwo()fmt.Print(sisterOfDC)
}func main() {testFunction()
}

这里可以看到有两个方法
giveRise
giveRisetwo
但是接受器在接受的时候，可以用指针，也可以用值。反正编译的时候GO会帮我们做的
有机会可以去看一下源码怎么实现的

这样做稍微有点昂贵，因为 Point3 是作为值传递给方法的，因此传递的是它的拷贝，这在 Go 中合法的。也可以在指向这个类型的指针上调用此方法（会自动解引用）

然后就是方法应用了
方法和未导出字段
get set

type unexportedFields struct {exportedFields      stringtheUnexportedFields string
}func (thisStruct *unexportedFields) setExportedFields(context string) {thisStruct.exportedFields = context
}func (thisStruct *unexportedFields) getExportedFields() (context string) {return thisStruct.exportedFields
}