- 安装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
- 链表定义
type Student struct {
Name string
Next* Student
}
每个节点包含下一个节点的地址,这样把所有的节点串起来了,通常把链表中的第一个节点叫做链表头
- 双链表定义
type Student struct {
Name string
Next* Student
Prev* Student
}
如果有两个指针分别指向前一个节点和后一个节点,我们叫做双链表
- 二叉树定义
type Student struct {
Name string
left* Student
right* Student
}
- 结构体是用户单独定义的类型,不能和其他类型进行强制转换
- var a int
var b interface{}
b = a
fmt.Println(b) - 空接口可以传递任何类型