vue项目准备

• 安装node
• 安装npm
• 安装cnpm
• 安装vue-cli
• vue create giligili
• cd giligili
• vue add element
• 多个lement组件的使用：https://www.cnblogs.com/liziyou/p/6708537.html
• import axios from “axios” 默认会引到node_modules里面
• this.$notify 饿了吗的组件

gin框架bind的用法

• https://blog.csdn.net/u013210620/article/details/82787010
• go语言中访问一个map不存在的key默认值为0值
• 指针就是指向内存地址
• 引用就是等号，对象上的引用操作，贴了一个标签
• go语言中要主动判断一下是不存在还是0值
• go语言中访问的key不存在不会返回nil 而是返回0
• go map实现工厂模式

//map的工厂模式

func TestFactory(t *testing.T) {
	m := map[int]func(op int) int{}
	m[1] = func(op int) int { return op }
	m[2] = func(op int) int { return op * op }
	m[3] = func(op int) int { return op * op * op }
	t.Log(m[1](2), m[2](2), m[3](2))
}

• go语言内置并没有提供set类型，可以通过map来实现 key为任意你想要的类型，value为bool类型
• 基本操作：保证元素的唯一性的前提下 基本操作：添加元素，判断元素是否存在，删除元素，元素的个数
• go特有的map两个用法：工厂模式+set

string

• go与其他预言帝差异
• string是数据类型，不是引用或指针类型
• string是只读的byte slice，len函数可以它所包含的byte数
• string的byte数组可以存放任何数据（可以存储二进制）
• 存储中文会输出byte的数 3
• string是不可变的byte slice 不能a[1] = “a” 会编译错误
• unicode是一种字符集，UTF8是存储的实现（转换为字节序列的规则）
• rune函数可以取到unicode

func TestGoString(t *testing.T) {
	var s string
	s = "中"
	t.Log(len(s))// 长度为byte字节长度为3
	res := []rune(s)
	t.Log(len(res)) // 就一个中字，unicode中长度为1
	t.Log(res[0])
	t.Logf("%x", res[0]) // 取unicode
	t.Logf("%x", s)  // 取UTF8
}

• 单元测试包以_test结尾，函数以Test开头，引入testing包
• 打印go语言变量的类型reflect.TypeOf包
• 整形转字符串，字符串转整形 strconv.Itoa strconv.Atoi

	rr := strconv.Itoa(10)
	t.Log(rr)
	result, err := strconv.Atoi("10")
	if err == nil {
		t.Log(result)

Atoi的写法略微有一点不同，会返回两个参数，需要进行判断

函数一等公民

• 函数可以返回多个值
• 所有参数都是值传递slice，map，channel会有传引用的错觉
• 函数可以作为变量的值
• 函数可以作为参数和返回值
• 装饰者模式用来计时，打日志

package main

import (
	"fmt"
	"math/rand"
	"testing"
	"time"
)

func demo() (int, int) {
	return rand.Intn(10), rand.Intn(20)
}

func TestFuncGo(t *testing.T) {
	a, _ := demo()
	t.Log(a)
	tsSF:=timeSpent(slowFun)
	t.Log(tsSF(10))
}

func timeSpent(inner func(op int) int) func(op int) int {
	return func(n int) int {
		start := time.Now()
		ret := inner(n)
		fmt.Println("time spent", time.Since(start).Seconds())
		return ret
	}
}

func slowFun(op int)int{
	time.Sleep(time.Second*2)
	return op
}

计算机程序的构造和解释

装饰器模式

package main

import (
	"fmt"
	"time"
)

func timerNow() {

	var a []int
	// var num int
	for i := 0; i < 1000; i++ {
		res := append(a, i)
		fmt.Print(res)
	}
}

func run(add func()) func() {
	time.Sleep(time.Second * 1)
	fmt.Print(5)
	time.Sleep(time.Second * 1)
	fmt.Print(4)
	time.Sleep(time.Second * 1)
	fmt.Print(3)
	time.Sleep(time.Second * 1)
	fmt.Print(2)
	time.Sleep(time.Second * 1)
	fmt.Print(1)
	start := time.Now()
	add()
	end := time.Now()
	resTime := end.Sub(start)
	fmt.Print("运行时间为：", resTime)
	return func() {}
}

func main() {
	run(timerNow)

耗时 4.4426014s
1000数据用数组追加耗时4.4秒

import time


def run_time(run):
	def timer_now(x):
		start = time.time()

		run(x)
		end = time.time()
		print(end-start)
		print("计时完毕")

	return timer_now

class Run():
	def __init__(self):
		print("计时开始")

	@run_time
	def run(self):
		print("I can run")
		# time.sleep(1)
		# print(5)
		# time.sleep(1)
		# print(4)
		# time.sleep(1)
		# print(3)
		# time.sleep(1)
		# print(2)
		# time.sleep(1)
		# print(1)
		res = [i for i in range(100000)]

		print(res)
		print(res.__sizeof__())

a = Run()
a.run()

耗时 0.10372114181518555s
10w数据用列表生成式写耗时0.1秒

go语言的面向对象

• go中结构体不需要“，”分割
• 结构体可以 new出来 new出来的是指针类型
• go通常定义成结构体的指针来创建方法，也可以不用指针
• 传递指针数据被复制了一份，有空间上的开销，所以推荐传指针
• go中采用ducktype的方式

接口

• 定义交互协议的
• go的接口
• 接口非入侵性
• 变量初始化有类型和数据

自定义类型

• 对于传递参数为函数的时候可以自定义类型简化代码

继承

• &Demo{} new（Demo） 都是返回一个指针，存内存地址
• 空接口与断言：
• 结构体的三种实例化形式：
• a. var stu Student
• b. var stu *Student = new (Student)
• c. var stu *Student = &Student{}
• https://www.cnblogs.com/zhangyafei/p/10667465.html

2. 链表定义

type Student struct {
Name string
Next* Student
}
每个节点包含下一个节点的地址，这样把所有的节点串起来了，通常把链表中的第一个节点叫做链表头

3. 双链表定义

type Student struct {
Name string
Next* Student
Prev* Student
}
如果有两个指针分别指向前一个节点和后一个节点，我们叫做双链表

4. 二叉树定义

type Student struct {
Name string
left* Student
right* Student
}

• 结构体是用户单独定义的类型，不能和其他类型进行强制转换
• var a int
  var b interface{}
  b = a
  fmt.Println(b)
• 空接口可以传递任何类型