论如何高效且有质量的处理工作

• 目的 预测 实践 反馈
• SMART原则构成
  • 绩效指标必须是具体的（Specific）
  • 绩效指标必须是可以衡量的（Measurable）
  • 绩效指标必须是可以达到的（Attainable）
  • 绩效指标是要与其他目标具有一定的相关性(Relevant)
  • 绩效指标必须具有明确的截止期限（Time-bound）

其它待整理的方法论

• 大圈小圈：指导职场晋升的方法论
  • 影响圈是自己本质，是基础；关注圈是扩展区域，是下一步发展；只有把影响圈做好才能进一步扩大影响圈；
  • 虽然关注圈对你当下的绩效产出往往没有很明显的价值，但是只有提前关注关注圈，你才有机会，也才有可能扩大影响圈。
  • 所以，当你抱怨“自己怀才不遇”的时候，请首先反思的问题是：我当下的“影响圈”做到极致了吗？
  • 80% 的精力 用与关注影响圈内部，20%的精力用于关注影响圈外部
• 721原则 ：指导个人发展的方法论
  • 技能获得：70% 是由实践获得，20% 是学习获得，10% 是培训（被指导）获得。
  • 推论一：最快学习路径是：优先选择学习，能够立刻或者即将实践的知识或技能
    • 推论看似简单，但是周围，往往有很多人都没有注意到这一点；比如他们往往更注重于：更前沿知识（专刊、博客），而忽略了那些能够直接在工作中实践的知识点。
    • 一个人的从小白成为某项领域的专家，所需要学习的知识会非常多；如果你规划好整体学习知识点后，其实如何让自己快速的成长，就是一个路径选择问题。
  • 推论二：请不要尝试，只通过学习或者培训方式，能够掌握某项技能或者成为某方面的专家
    • 如果你想尽快真正的成为某方面的专家，这个方法告诉你的是：最重要的首先要考虑如何实践或者哪儿可以找到实践机会
• 人无完人：自我驱动的方法论
  • 简单说解决方案有：向上、横向、向下沟通问题收集；横向对比，和高阶同学对比思考差距在那里；思考学习哪些知识来开拓自己的当前面临的视野局限问题等等
  • 第一层循环：在层次内，提升的过程
  • 第二层循环：是突破层次的瓶颈，达到上一个层次的过程
• 抽象问题具体化，具体问题抽象化：解决实际问题的方法论
  • 1、在问题分析时多从全局观进行思考，而不是局限在问题本身。
  • 2、问题最后抽象到的最后只有两类：技术问题 or 管理问题（流程）。切忌把一切问题都归到“人的问题”上

如何思考与有效工作

• 该如何更高效地工作，怎样才能把时间和精力尽可能地放在处理本质复杂度的事情上，减少在偶然复杂度上的消耗

我们在哪 我们要去哪 我们怎么去 这种方法论

• 如果一个人能够清晰地回答出这三个问题，通常意味着他对要做的事有着清晰的认识
• 优秀程序员的开发效率是普通程序员的 10 倍

四个思考原则

• 以终为始
  • 真正的目标
• 任务分解
  • 分解越细致，工作越轻松
• 沟通反馈
  • 是为了疏通与其他人交互的渠道。一方面，我们保证信息能够传达出去，减少因为理解偏差造成的工作疏漏；
  • 另一方面，也要保证我们能够准确接收外部信息，以免因为自我感觉良好，阻碍了进步。
• 自动化
  • 就是将繁琐的工作通过自动化的方式交给机器执行
  • 形成完善的层次，完善到可以自动化代码生成

当面对一个新需求时

• 为什么要做这个特性，它会给用户带来怎样的价值？
• 什么样的用户会用到这个特性，他们在什么场景下使用，他们又会怎样使用它？
• 达成这个目的是否有其它手段？是不是一定要开发一个系统？
• 这个特性上线之后，怎么衡量它的有效性？

总结

• 大多数人工作低效是由于工作中偶然复杂度太多造成的，只要能够更多地将注意力放到本质复杂度上，减少偶然复杂度造成的消耗，我们“真实”的工作效率自然会得大幅度提升。
• 我们不是一个人孤独地在工作，而是与其他人在协作，想要做到高效工作，我们就要“抬起头”来，跳出写代码这件事本身。 所以，程序员解决的问题，大多不是程序问题。
• 面对问题 现状 目标与路径

五级工程师理论

第五级工程师

• 能够独立设计和实现一项功能的人

• 这是对工程师的基本要求，如果一个人只是懂一点工程实现的手段，需要别人告诉他怎么做，那最多算是助理工程师或者技工。虽然能独立写出一项功能，关于业务的内容完全都是问需求经理啊，技工是说的好听，其实就是最底层开发人员，以后要加强工程师的概念，努力向上一级跃进。

第四级工程师

• 需要有些产品头脑

• 在做一件事之前，要知道所做出来的东西是否有用 、易用，是否便于维护，是否性能稳定，等等。除了要具备产品设计方面的基本知识，还要具有一定的领导才能，能在整个产品的生命周期从头到尾将一个产品负责到底。这在很多硅谷的公司里，基本上是一个高级工程师所应有的基本素质。对大部分工程师来讲，这些素质不是一个工学院就能培养出来的，而是需要在工业界实际锻炼三四年甚至更长时间。当然。个别天赋很好的年轻人在学校里就具备了这种素质，但这是可遇不可求的。

• 这需要长时间的锻炼和自己的悟性，这个阶段的工程师就像是组内的开发组长、系统架构师之类的角色，对技术使用纯熟，并有产品经理的素质，会从用户角度考虑产品的易用性，会从运维工程师角度考虑系统的可维护性，会从下批搞二次开发的程序员角度考虑系统的可读性与可扩展性等。这个确实需要时间和精力去锤炼技术水平和产品意识。

第三级工程师

• 可以做出行业里最好的产品

• 他们与第四等工程师有着质的差别，这不仅反映在技术水平、对市场的了解 、对用户心理的了解以及组织能力等诸方面，而且也反映在悟性的差异上。当然这种悟性很多是后天培养出来的，但这就需要更长的时间了。有些人从工作一开始，可能需要十年八年，经过多次失败，不断总结，终于在某个时间点豁然开朗。而另一些人可能非常幸运，在一开始就有幸和最优秀的人一起工作，加上善于学习，五六年下来就能达到第三等的水平。在硅谷，有极少数工程师只花了五六年时间就达到了这个水平。但是即使一个人再聪明，基础再好，也需要在工程上花够足够的时间才能达到这个水平，一个年轻人工作了四五年就开始做行政管理工作，基本上就和这个水平无缘了。

• 到这一级别的工程师，由于心智坚定加上长期的刻苦努力再加上个人的天赋和一些机遇，终于一飞冲天。都说机会是给有准备的人的，这类人其实就是被机会垂青的一类人，因为他们确实有准备，也准备的很充分。他们是行业内的佼佼者，对技术、产品都有自己的一套感觉、系统，都有自己独到的认识，并做出过业内称赞的产品。我觉得在一等的工程师里也可以分三等，初级、中级和高级。初级就是经过自己的长期努力，对技术掌握扎实，对新技术也有很快的理解能力和应用能力，能够胜任一般公司产品经理、CTO的角色。中级就是在初级的基础上，加上了个人的艺术修养，加上了个人长期经验、经历、感悟的总结，形成了一套完整的对技术、产品、美学、用户、包括市场的基础正确的认识，这超越了大多数技术好的工程师。这一级别高段位的工程师，就有点需要借助些小的时运了，比如刚好移动互联网兴起，刚好加入移动互联创业公司，刚好开发出了能行业执牛耳的产品。

第二级工程师

• 刻意给世界带来惊喜的人

• 比如实现第一台实用化个人电脑的沃兹尼亚克(这个在池老师的《跨越边界》里有专门一章讲他，并他合照)、DSL之父约翰西奥菲、iPhone和Google Glass的总设计师，以及前面提到的鲁宾、迪恩等。他们与第三、四等工程师的差别在于其工作的原创性以及对世界的影响力。当然他们的工作不是科学研究，这一点和科学家毕竟不同。

• 关于这一点，吴军博士还专门介绍过硅谷的公司有多元的文化，开发产品会立足于世界，多语言版本不会比英语版本晚六个月。因此公司的很多产品就是世界级产品，还提到微信的国际化走的不顺畅，只是在国内是爆品。

第一级工程师

• 开创一个全新行业的人

• 历史上有爱迪生（直流电等）、特斯拉（交流电等）、福特，二战后有保时捷博士、本田宗一郎和硅谷的诺伊斯（集成电路等）等人。这些工程师不仅在技术和产品等各个方向与第二等工程师有质的差别，而且在经验和管理上也是好手，他们通常是企业家，并通过自己的产品改变了世界。这一类人常常是可遇而不可求的，正如朗道列出的第一等物理学家只有个位数一样，第一等的工程师也是如此。朗道认为每一等物理学家之间的贡献相差十倍，每一等的工程师差距也是这么大。当然很多企业家都希望能够遇到一些第二等甚至第一等的工程师，这就需要由工程师构建的完整金字塔：要想出几个第一等的工程师，就需要有足量的第二等工程师作为基础；同样，产生第二等工程师要靠大量的第三等工程师为基础。在一个产业里，不可能指望在一大堆第五等工程师的基础上突然冒出一两个第一或者第二等的工程师的。甚至有时，即时高薪聘请来一个第二等的工程师，如果没有第三、第四等的工程师与之配合，他也很难直接依靠第五等的人做出一流的产品。

• 第一等的工程师，完全是和推动人类文明进步最有力的人归为一类的，他们永远是时代的先行者，时代的开拓者，处于时代的浪潮之巅。

• 和马斯洛的五层需求理论类似，永远都是一级依靠一级，每上层级都需要大量的下一级作为支撑与配合，然而在大多中国IT企业里，大家喜欢当领导，也有许多在选择做技术还是管理两者间纠结的人，所以在第五等工程师上会有断层，影响到产品开发的质量和原创性。

以终为始

• 遇见事情，倒着想，远见不是天生会有的，不断预测，失败后加以复盘，整理自己思维误区才能走的更远
• 构建一个共同的想象
• 测试驱动开发，
• 践行“以终为始”就是在做事之前，先考虑结果，根据结果来确定要做的事情。
• 向后工作的方法，开发一项产品的顺序为：
  • 写新闻稿；
  • 写 FAQ（常见问题解答）；
  • 写用户文档；
  • 写代码。
• 拿到一个需求先写接口文档，评审过了再开发代码。争取做到接口文档就是最终的实现方案，不需要做着做着再去沟通方案。而不是拿了需求文档，直接就写代码。
• 定好目标后，倒推时间表，安排好每一步要做的事情。梳理出关键节点，提前发现问题。

对于完成的定义不一致

• DoD 对于完成的定义 Definition of Done
  • DoD 是一个清单，清单是由一个个的检查项组成的，用来检查我们的工作完成情况。
  • DoD 的检查项应该是实际可检查的。
  • DoD 是团队成员间彼此汇报的一种机制。别把“汇报”想复杂了，最简单的汇报就是说一句“这个功能做完了”。
  • 当我们有了 DoD，做事只有两种状态，即“做完”和“没做完”。
• 它不仅局限在团队内部协作上，如果你可以放开思路，会发现 DoD 的思维在工作中用途非常广泛。
• DoD 是一个的思维模式，是一种尽可能消除不确定性，达成共识的方式。
• 人与人协作，总会有这样或那样的理解差异。开始协作之前，我们最好先同步一下彼此的理解，确保之后不会因为理解不一致，而让协作方措手不及.

范式与实现

• 目前关系数据库有六种范式：第一范式（1NF）、
• 第二范式（2NF）、
• 第三范式（3NF）、
• 巴斯-科德范式（BCNF）、
• 第四范式(4NF）
• 和第五范式（5NF，又称完美范式）
• 满足最低要求的范式是第一范式（1NF）在第一范式的基础上进一步满足更多规范要求的称为第二范式（2NF），其余范式以次类推。
• 一般来说，数据库只需满足第三范式(3NF）就行了

第一范式

• 所谓第一范式（1NF）是指在关系模型中，对于添加的一个规范要求，所有的域都应该是原子性的，即数据库表的每一列都是不可分割的原子数据项，而不能是集合，数组，记录等非原子数据项。
• 即实体中的某个属性有多个值时，必须拆分为不同的属性。在符合第一范式（1NF）表中的每个域值只能是实体的一个属性或一个属性的一部分。
• 简而言之，第一范式就是无重复的域。
• 每一项都是独立与原子，不可分割

第二范式

• 在第一范式的基础上
• 要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性，
• 如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。
• 为实现区分通常需要为表加上一个列，以存储各个实例的唯一标识。
• 简而言之，第二范式就是在第一范式的基础上属性完全依赖于主键。1对1

第三范式

• 在2NF基础上，任何非主属性不依赖于其它非主属性（在2NF基础上消除传递依赖）
• 第三范式就是属性不依赖于其它非主属性，也就是在满足2NF的基础上，任何非主属性不得传递依赖于主属性。
• 如员工表不应出现部门名称的属性

error 处理

• 没有异常机制

• error 类型实现了 error 接口

  1 2 3

  type error interface{ Error string }

• 可以通过 errors.New 来快速创建错误实例

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

  errors.New(" error info") var NumberLess2Error = errors.New("n must be not less than 2") var NumberLarger100Error = errors.New("n must be not larger than 100") func GetFibonacci(n int) (c []int, err error) { // 及早失败 if n < 2 { err = NumberLess2Error return } if n > 100 { err = NumberLarger100Error return } c = append(c, 1,1) a, b := 1, 1 for i := 0; i < n; i++ { a, b = b, a+b c = append(c, b) } return c, nil } func TestGetFibonacci(t *testing.T) { if n,err := GetFibonacci(-10);err!=nil{ if err == NumberLess2Error{ fmt.Printf("less ") } t.Error(err) }else { t.Log(n) } }

panic 与 recover

• panic 与 os.Exit

  • os.Exit 退出时不会调用 defer 指定的函数
  • os.Exit 退出时不输出当前调用栈信息

• recover 错误恢复

• recover 成为恶魔

  • 形成僵尸服务进程，导致 health check 失效
  • “Let it Crash!” 往往是我们恢复不确定性的最好方法 简称实在不行就重启

map

• 声明

1
2
3
4
5
6
7
8
9
10

// 直接声明并赋值
m := map[string]int{"one":1,"two":2,"three":3}
t.Log(m, len(m))//map[one:1 two:2 three:3] len 3
// 声明并赋予零值
m1 := map[string]int{}
m1["one"] = 1
t.Log(m1, len(m1))//map[one:1] len 1
// slice map
m2 :=make(map[string]int,5/*cap 实际上预先设定了5的容量*/)// map 类型 ,len
t.Log(m2,len(m2))//map[] len 0

• 访问不存在的key

1
2
3
4
5
6
7
8
9
10
11
12

m3 := map[int]int{}
t.Log(m3[1]) // 0
m3[2] = 0
t.Log(m3[2]) // 0
m3[3] = 0;
// 判断存在或者为 零值
if v, ok := m3[3]; ok {
    t.Log(v, "key 3 is exist.")
} else {
    t.Log("KEY 3 is not existing.")
}
// 在访问 不存在的 key 的时候 会返回对应的零值 而不是异常

• 遍历

1
2
3
4

m := map[string]int{"one": 1, "two": 2, "three": 3}
for k, v := range m {
    t.Log(k, "=>", v)
}

• map 实现工厂模式

1
2
3
4
5
6
7
8
9
10
11

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))// 2 4 8

• 用 map 实现 set 的功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 元素是唯一的
// 1) 添加元素
// 2) 判断元素是否存在
// 3) 删除元素
// 4) 元素个数
    mySet := map[int]bool{}
    mySet[1] = true
    mySet[3] = true
    n:= 3
    if mySet[n]{
        t.Logf("%d is existing",n)
    }else {
        t.Logf("%d is not existing",n)
        t.Log(mySet[n])
    }

    t.Log(len(mySet))
    delete(mySet, n)

    if mySet[n]{
        t.Logf("%d is existing",n)
    }else {
        t.Logf("%d is not existing",n)
        t.Log(mySet[n])
    }

字符串

• string 是数据类型,不是引用或是指针类型,零值为空字符串
• string 是 只读的 byte slice , len 函数可以展示它所包含的 byte
• string 的 byte 数组可以存放任何数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

var s string
t.Log(s)// ""
s = "hello"
// s[1] = '2'//can't assign s[1]
t.Log(len(s))// 5
s = "\xE4\xB8\xA5"
t.Log(s,len(s))// 严 3 len 是 byte 长度
// Unicode 是一种字符集（code point) 只规定了对应关系，没有规定怎么实现
// UTF8 是 unicode 的存储实现（转换为字节序列的规则）

s ="中"
t.Log(len(s))// byte 数 3

c:=[]rune(s)
t.Log(len(c))// 1
t.Log("rune size :", unsafe.Sizeof(c))// 24 3*8 就是 3 byte 24字节

t.Logf("中 unicode %x",c[0])
t.Logf("中 UTF8 %x",s)

// 遍历string的时候，实际自动把string转成了rune再遍历。
// 而不是根据 len(string)的byte数组个数
s = "中华人民共和国"
for _,v := range s {
    t.Logf("%[1]c %[1]x",v)
}

// strings strconv
// 字符串分割 string
s = "A,B,C"
parts := strings.Split(s,",")// []string 的切片
t.Logf("%T", parts)
for _,v := range parts{
    t.Logf("%T", v)// string
}
// 合并
t.Log(strings.Join(parts,"-"))
// 转换
s1 := strconv.Itoa(10)// Itoa AtoI
t.Log("str "+ s1)
if s2,err := strconv.Atoi(s1);err == nil{
    t.Log(10+s2)
}

函数

• 函数是一等公民
  • 函数有多个返回值
  • 所有参数都是值传递：slice map channel 会有传引用的错觉
  • 函数可以作为变量的值
  • 函数可以作为参数和返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 支持多返回值
func returnMultiValues() (a, b int) {
    return rand.Intn(10), rand.Intn(20)
}
// 可以作为参数与返回值
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*1)
    return  op
}
func TestFn(t *testing.T) {
    i, l := returnMultiValues()
    t.Log(i, l)

    tsSF := timeSpent(slowFun)
    t.Log(tsSF(10))
}

可变长参数与 defer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// 可变长参数 参数类型一致
func Sum(ops ...int)(res int){
    res = 0
    for _,v := range ops{
        res += v
    }
    return
}
func TestFn1(t *testing.T){
    t.Log(Sum(1,2,3,4,5))
    t.Log(Sum(1,2,3,4,5,6))
}


func Clear(){
    defer fmt.Println("errs")
    fmt.Println("close")
    panic("err")
}
func Clear2(){
    defer fmt.Println("errs2")
    fmt.Println("close2")
    panic("err")
}

func TestDefer(t *testing.T){
    defer Clear()
    defer Clear2()
    fmt.Println("Start")
    panic("err")
}
// 执行顺序为
// Start close2 errs2 close errs
// defer 类似于栈结构 先进后出
// 在 defer 中引发 panic 只会导致当前的 defer 体里面的程序中断

面向对象

封装数据和行为（方法）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 数据封装
type Employee struct {
    Id   string
    Name string
    Age  int
}

func TestCreateEmployeeObj(t *testing.T){
    e:= Employee{"0","张三",23}
    e1 := Employee{Id:"张三",Name:"李四",Age:25}
    e2 := new(Employee) // 返回的是一个指针
    e2.Age = 29
    e2.Name = "王五"
    e2.Id = "3"
    t.Log(e)
    t.Log(e1)
    t.Log(e2)
    t.Logf("e is %T", e)
    t.Logf("e2 is %T", e2)
}

//    main_test.go:437: {0 张三 23}
//    main_test.go:438: {张三 李四 25}
//    main_test.go:439: &{3 王五 29}
//    main_test.go:440: e is main.Employee
//    main_test.go:441: e2 is *main.Employee

1
2
3
4
5
6
7
8
9
10
11

// 行为封装
// 通过引用去使用这个方法
func (e *Employee) String() string {
    fmt.Printf("Address is %x\n", unsafe.Pointer(&e.Name))
    return fmt.Sprintf("ID:%s-Name:%s-Age:%d", e.Id, e.Name, e.Age)
}
// 通过值拷贝去使用这个方法 这种会带来更大的内存消耗
func (e Employee) String() string {
    fmt.Printf("Address is %x\n", unsafe.Pointer(&e.Name))
    return fmt.Sprintf("ID:%s-Name:%s-Age:%d", e.Id, e.Name, e.Age)
}

接口的定义

• 非入侵的，实现不依赖接口定义
• 所以接口的定义可以包含在接口使用者包内

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

type Programmer interface {
    WriterHelloWorld() string
}

type  GoProgrammer struct {

}
func (to *GoProgrammer) WriterHelloWorld() string{
    return "fmt.Println(\"hello world!\")"
}

func TestClient(t *testing.T){
    var p Programmer
    p = new(GoProgrammer)
    t.Log(p.WriterHelloWorld())
}

接口变量

• 声明 var prog Coder = &GoPaogrammer{}
• prog 由两部分组成
  • type GoPaogrammer struct{} 数据类型
  • &GoPaogrammer{} 数据实例

继承与组合

• golang 中组合的成分高于继承,甚至可以说没有一般语言的继承概念

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

type Pet struct {

}

func (p *Pet) Speck()  {
    fmt.Println("...")
}

func (p *Pet) SpeckTo(host string) {
    p.Speck()
    fmt.Println(" ", host)
}

type Dog struct {
    //p *Pet // 复合
    Pet
}

func (d *Dog) Speck()  {
    fmt.Println("www")
    d.SpeckTo("laowan")
}

//func (d *Dog) SpeckTo(host string) {
//  //d.SpeckTo(host)
//  d.Speck()
//  fmt.Println(host)
//}

func TestInherit(t *testing.T){
    // var dog Pet = new(Dog) 不能使用 Dog 去作为 Pat 类型
    var dog = new(Dog)
    //dog.SpeckTo("张三") // ... 张三 匿名变量 只能调用 变量自己的方法
    dog.Speck() //www ... lanwan
    // 子类可以调用 匿名变量的方法但是这不算是完整意义上的继承

    // 关于继承这部分 跟 php 差距很大，与其说是继承，我更加倾向于说这是 组合
    // 类似于 php 中的 traits 但又不像，因为匿名变量分界线很清楚，
    // traits 是可以在被使用后 根据使用者的情况展示不同的特性
    // 是你的就是你的，是我的就是我的，你用我的，那就是我的，上层不能使用下层的方法
    // 下层在使用上层的方法时候，可以理解为全在上层使用

接口与多态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

type Code string
type Programmer interface {
    WriterHelloWorld() Code
}

type GoProgrammer struct {
}

func (to *GoProgrammer) WriterHelloWorld() Code {
    return "fmt.Println(\"hello world!\")"
}

type JavaProgrammer struct {
}

func (to *JavaProgrammer) WriterHelloWorld() Code {
    return "fmt.Println(\"hello world!\")"
}

func WriterFirstProgrammer(programmer Programmer) {
    fmt.Printf("%T %v\n", programmer, programmer.WriterHelloWorld())
}

func TestPolymorphism(t *testing.T) {
    goProg := new(GoProgrammer)// 指针
    javaProg := new(JavaProgrammer)// 指针
    WriterFirstProgrammer(goProg)
    WriterFirstProgrammer(javaProg)
}

空接口与断言

• 空接口可以表示任何类型

• 通过断言来将空接口转换为指定类型

  • v,ok := p.(int) // ok=true 时为转换成功

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  func DoSomething(p interface{}) { //if i,ok := p.(int);ok{ // fmt.Println("Integer", i) // return //} //if i,ok := p.(string);ok{ // fmt.Println("String", i) // return //} switch i := p.(type) { case int: fmt.Println("Integer", i) return case string: fmt.Println("String", i) return default: fmt.Println("unKnow Type") } } func TestDoSomething(t *testing.T) { DoSomething(10) DoSomething("10") DoSomething('1') }

Go接口最佳实践

• 倾向于使用小的接口定义，很多接口只包含一个方法（对于实现者负担更新 single Interface）

  1 2 3 4 5 6

  type Reader interface{ Read(p []byte)(n int, err error) } type Writer interface{ Write(p []byte)(n int, err error) }

• 较大的接口定义，可以由多个小接口定义组合而成

  1 2 3 4

  type ReadWriter interface{ Reader Writer }

• 只依赖必要功能的最小接口(会使方法的复用性更强)

  1 2 3

  func StoreData(reader Reader) error{ ... }

• composer dump-autoload -o

1
2
3
4
5
6

Compsoer\ClassLoader 会优先查看 autoload_classmap 中所有生成的注册类。
如果在classmap 中没有发现再 fallback 到 psr-4 然后 psr-0

所以当打了 composer dump-autoload -o 之后，
composer 就会提前加载需要的类并提前返回。
这样大大减少了 IO 和深层次的 loop

问题点 You made a reference to a non-existent script @php artisan package:discover

1
2

composer -V
Composer version 1.2.1 2016-09-12 11:27:19

• 解决方法，升级 composer 版本
• composer selfupdate

1
2
3
4

Updating to version 1.6.3 (stable channel).
    Downloading: 100%
Use composer self-update --rollback to return to version 1.2.1

PHPer web 技能点

• 后端技能点

必需技能

• git-版本控制
• ssh-安全外壳协议
• http/https 协议和 API
• 命令行基础指令
• 学习理解
• 数据结构与算法
• 字符编码
• 设计模式

• github/gitlab 平台与工作流

• php7

  • 包管理工具 composer
  • 调试/分析工具
    • xDebug
    • XHProf
    • New Relic
    • Blackfire
  • 开发框架
    • Laravel -> symfony
    • Slim->lumen
  • 测试工具
    • PHPUnit
    • phpspec
    • Codeception
    • Mockery
  • 消息代理
    • RabbitMQ
    • Apache Kafak
  • 存储
    • 缓存
      • Memcached
      • Redis
    • 关系数据库
      • PostgreSQL
      • MariaDB
      • MySQL
    • 非关系数据库
      • Redis
      • MongoDB
  • Web 服务器
    • Apache
    • Nginx
  • RESTful API 架构
  • 身份认证机制
    • JWT
    • OAuth2.0
  • SOLID,YAGNI,KISS
  • 正则
  • Docker
  • 搜索引擎
    • ElasticSearch
    • Sphinx
    • Solr
  • GOF 设计模式
  • 体系结构模式
  • 了解 DDD
  • 学习各类测试技术

php之道中文链接

ContOS7 php 多环境的配置

使用最小化安装之后的第一个问题，内外网不通

• vi /etc/sysconfig/network-scripts/ifcfg-ens33
• 修改 ONBOOT=yes 后 systemctl restart network.service
• 重启主机，如果此时内外网通了但是 yum list 失败，主要是服务不可达，考虑为 DNS 的原因

• 修改 vi /etc/resolv.conf 修改 dns 为 nameserver 8.8.8.8

  1 2 3 4 5 6 7

  yum update # 成功 yum install wget -y # 装一个下载工具 mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup # 备份 wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo # 添加阿里源 yum clean all # 清除缓存 yum makecache # 生成缓存 yum update -y # 更新

一些准备工作

• yum install vim -y && yum install net-tools -y 习惯了 vim 加上一个网络分析小工具
• yum install gcc gcc-c++ httpd-tools autoconf pcre pcre-devel make automake -y 安装一些编译测试工具
• systemctl stop firewalld.service && systemctl disable firewalld.service 关闭并禁用 防火墙
• vim /etc/selinux/config
• 修改 SELINUX=disabled 千万不要改错位置
• 下面的 selinuxtype 要是改成 disable 建议删了重装会快一些
• 不然 selinux 可能会导致你的网络端口不可访问

安装 nginx

• 参考
• vim /etc/yum.repos.d/nginx.repo 创建 yum 源文件

• 根据官方提示修改为

  1 2 3 4 5

  [nginx] name=nginx repo baseurl=http://nginx.org/packages/centos/7/$basearch/ gpgcheck=0 enabled=1

• yum list|grep nginx 能够看到 nginx

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  [root@localhost ~]# yum list|grep nginx nginx.x86_64 1:1.16.0-1.el7.ngx nginx nginx-debug.x86_64 1:1.8.0-1.el7.ngx nginx nginx-debuginfo.x86_64 1:1.16.0-1.el7.ngx nginx nginx-module-geoip.x86_64 1:1.16.0-1.el7.ngx nginx nginx-module-geoip-debuginfo.x86_64 1:1.16.0-1.el7.ngx nginx nginx-module-image-filter.x86_64 1:1.16.0-1.el7.ngx nginx nginx-module-image-filter-debuginfo.x86_64 1:1.16.0-1.el7.ngx nginx nginx-module-njs.x86_64 1:1.16.0.0.3.1-1.el7.ngx nginx nginx-module-njs-debuginfo.x86_64 1:1.16.0.0.3.1-1.el7.ngx nginx nginx-module-perl.x86_64 1:1.16.0-1.el7.ngx nginx nginx-module-perl-debuginfo.x86_64 1:1.16.0-1.el7.ngx nginx nginx-module-xslt.x86_64 1:1.16.0-1.el7.ngx nginx nginx-module-xslt-debuginfo.x86_64 1:1.16.0-1.el7.ngx nginx nginx-nr-agent.noarch 2.0.0-12.el7.ngx nginx pcp-pmda-nginx.x86_64 4.1.0-5.el7_6 updates

• yum install nginx -y 安装 nginx

• systemctl enable nginx 开机自启 nginx
• systemctl start nginx 启动 nginx
• 然后输入 IP 到浏览器访问成功
• 默认配置位置 /etc/nginx/nginx.conf /etc/nginx/conf.d/default.conf

安装 PHP

• 参考

  1 2	yum install epel-release rpm -Uvh https://mirror.webtatic.com/yum/el7/webtatic-release.rpm

• 安装 php 全扩展 yum install mod_php72w php72w-bcmath php72w-cli php72w-common php72w-dba php72w-devel php72w-embedded php72w-enchant php72w-fpm php72w-gd php72w-imap php72w-interbase php72w-imap php72w-intl php72w-ldap php72w-mbstring php72w-mysqlnd php72w-odbc php72w-opcache php72w-pdo php72w-pdo_dblib php72w-pear php72w-pecl-apcu php72w-pecl-imagick php72w-pecl-mongodb php72w-pgsql php72w-phpdbg php72w-process php72w-pspell php72w-recode php72w-snmp php72w-soap php72w-sodium php72w-tidy php72w-xml php72w-xmlrpc -y

• 配置文件位置 /etc/php.ini
• php -m 就可以查看装了哪些扩展 嗯 基本都开了
• systemctl start php-fpm 虽然是一台机器但我们还是用 php-fpm 模式,便于后期加入 docker 的扩展 也可以使用 .sock 的模块加载模式 理论上会快一些

• systemctl enable php-fpm 开机自启

• 发现一个坑，并没有 redis 扩展 原生进行编译扩展

  • wget http://pecl.php.net/get/redis-4.2.0.tgz
  • tar zxvf redis-4.2.0.tgz
  • cd redis-4.2.0
  • /usr/bin/phpize(这个根据 phpize 实际情况来)
  • ./configure --with-php-config=/usr/bin/php-config(这个根据 php-config 实际情况来)
  • make && make install
  • vim /etc/php.d/redis.ini 这个根据实际情况去决定 是改 php.ini 还是别的什么
  • 写入 extension=redis.so
  • systemctl restart php-fpm 就 ok 了

php与nginx 链接起来

1
2
3
4

[root@localhost ~]# cd dev
[root@localhost dev]# mkdir -p www/php/test/
[root@localhost dev]# cd www/php/test/
[root@localhost test]# echo "<?php phpinfo();" >> ./index.php

• vim /etc/nginx/conf.d/default.conf

  1 2 3 4 5 6 7 8 9 10 11

  location / { root /dev/www/php/test; index index.php index.html index.htm; } location ~* \.php$ { fastcgi_index index.php; fastcgi_pass 127.0.0.1:9000; include fastcgi_params; fastcgi_param SCRIPT_FILENAME /dev/www/php/test$fastcgi_script_name; }

• nginx -t && nginx -s reload

使用docker 构建 php5.4 环境

• 更换镜像，使用阿里云的镜像加速
• https://cr.console.aliyun.com/#/accelerator
• vim /etc/docker/daemon.json
• 修改成自己的镜像加速
• "registry-mirrors": ["https://xxxxx.mirror.aliyuncs.com"]
• systemctl daemon-reload
• systemctl restart docker

• 运行生成一个 php5.4 的容器

  1 2 3 4

  docker run -d \ -v /dev/www/php/:/var/www/html \ -p 9001:9000 \ --name phpfpm54 --privileged=true php:5.4-fpm

docker 中 扩展安装

• docker exec -ti phpfpm54 /bin/bash
• -ti 打开图形界面
• /bin/bash 执行 这个命令
• exec 可以在 不 exit 的情况下进行附加操作
• 进去后需要 apt-get update 里面是 debian9 系统
• docker-php-ext-install pdo_mysql 来装 pdo_mysql 扩展
• 以下这些扩展都可以安装 不过好多有坑0.0

1

bcmath bz2 calendar ctype curl dba dom enchant exif fileinfo filter ftp gd gettext gmp hash iconv imap interbase intl json ldap mbstring mysqli oci8 odbc opcache pcntl pdo pdo_dblib pdo_firebird pdo_mysql pdo_oci pdo_odbc pdo_pgsql pdo_sqlite pgsql phar posix pspell readline recode reflection session shmop simplexml snmp soap sockets sodium spl standard sysvmsg sysvsem sysvshm tidy tokenizer wddx xml xmlreader xmlrpc xmlwriter xsl zend_test zip

docker Debian 换源安装 gd 库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

cd /etc/apt && cp sources.list ./sources.list.bak
apt-get install vim

vim sources.list
deb http://mirrors.163.com/debian/ stretch main non-free contrib
deb http://mirrors.163.com/debian/ stretch-updates main non-free contrib
deb http://mirrors.163.com/debian/ stretch-backports main non-free contrib
deb-src http://mirrors.163.com/debian/ stretch main non-free contrib
deb-src http://mirrors.163.com/debian/ stretch-updates main non-free contrib
deb-src http://mirrors.163.com/debian/ stretch-backports main non-free contrib

//如果连apt-get update都做不到   可以先 rm sources.list 再创一个新的
echo "deb http://mirrors.163.com/debian/ stretch main non-free contrib
deb http://mirrors.163.com/debian/ stretch-updates main non-free contrib
deb http://mirrors.163.com/debian/ stretch-backports main non-free contrib
deb-src http://mirrors.163.com/debian/ stretch main non-free contrib
deb-src http://mirrors.163.com/debian/ stretch-updates main non-free contrib
deb-src http://mirrors.163.com/debian/ stretch-backports main non-free contrib" >> sources.list
//将源更换为上述  新的源

apt-get update
apt-get install libfreetype6-dev -y
apt-get install libpng-dev -y
apt-get install libjpeg62-turbo-dev -y
//如果源没出问题 上述应该都能安装
docker-php-ext-configure gd --with-freetype-dir=/usr/include --with-jpeg-dir=/usr/include
//先编译gd库的扩展
docker-php-ext-install gd
// 这样就在docker容器内完美安装了gd库

• 装 redis 扩展

1
2
3
4
5
6
7
8
9
10
11

curl -L -o /tmp/redis.tar.gz https://github.com/phpredis/phpredis/archive/3.1.3.tar.gz

tar xfz /tmp/redis.tar.gz

rm -r /tmp/redis.tar.gz

mkdir -p /usr/src/php/ext

mv phpredis-3.1.3 /usr/src/php/ext/redis

docker-php-ext-install redis

• 退出测试
• vim /etc/nginx/conf.d/default.conf
• 修改 fastcgi_param SCRIPT_FILENAME /var/www/html/test$fastcgi_script_name;
• 这里由于是在容器内执行所以修改路径为这个

• 设置 phpstrom 的 sftp 自动上传到 本地虚拟机

• ps aux|grep php

1
2
3
4
5
6

1 root 0:00 php-fpm: master process (/usr/local/etc/php-fpm.conf)
7 www-data 0:00 php-fpm: pool www
8 www-data 0:00 php-fpm: pool www

# 发现id 1就是php了，给它个信号让它重启即可，执行命令如下：
kill -USR2 1

• 如果是在外面也可以：docker exec -it 容器id或名称 kill -USR2 1
• 或者重启容器 docker restart 容器id或名称

安装 swoole

• yum install git openssl-devel -y
• git clone https://gitee.com/swoole/swoole.git
• wget https://github.com/redis/hiredis/archive/v0.14.0.zip
• yun install -y unzip
• unzip v0.14.0.zip
• cd hiredis-0.14.0
• make -j

1
2
3
4
5
6
7

./configure \
--with-php-config=/usr/bin/php-config \
--enable-openssl  \
--enable-http2  \
--enable-async-redis \
--enable-sockets \
--enable-mysqlnd && make clean && make && sudo make install

1
2
3
4
5

cd /etc/php.d/
cp sockets.ini ./swoole.ini
ls
vim swoole.ini 修改为 swoole
systemctl restart php-fpm

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

[root@localhost swoole]# php --ri swoole

swoole

Swoole => enabled
Author => Swoole Team <team@swoole.com>
Version => 4.4.0-alpha
Built => May 10 2019 20:30:06
coroutine => enabled
epoll => enabled
eventfd => enabled
signalfd => enabled
cpu_affinity => enabled
spinlock => enabled
rwlock => enabled
sockets => enabled
openssl => OpenSSL 1.0.2k-fips  26 Jan 2017
http2 => enabled
pcre => enabled
zlib => enabled
mutex_timedlock => enabled
pthread_barrier => enabled
futex => enabled
mysqlnd => enabled
async_redis => enabled

Directive => Local Value => Master Value
swoole.enable_coroutine => On => On
swoole.display_errors => On => On
swoole.use_shortname => On => On
swoole.unixsock_buffer_size => 8388608 => 8388608

docker 安装 mysql 服务

• dokcer pull mysql:5.7
• mkdir -p /data/mysql/datadir #用于挂载mysql数据文件

• mkdir -p /data/mysql/conf.d #用于挂载mysql配置文件

  1 2 3 4 5

  docker run -d \ --name mysql5.7 -p 3306:3306 \ -v /data/mysql/datadir:/var/lib/mysql \ -v /data/mysql/conf.d:/etc/mysql/conf.d \ -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

• -e：设置环境变量，此处指定 root 密码

程序入口

• 必须为 package main
• 必须是 func main(){}
• 文件名称可以不为 main.go
• Go 中 main 函数不支持返回值
• 可以通过 os.Exit() 来传出 返回值

• main 函数不支持传入参数 可以通过 os.Args 来获取

  1 2 3 4 5 6 7 8 9 10

  func main(){// 不支持入参 fmt.Println("hello world!") if len(os.Args) >1 {//通过 os.Args 来获取传入的参数 for arg,value := range os.Args{ fmt.Println(arg,value) } } os.Exit(0) }

变量，常量以及与其它语言的区别

编写测试程序

• 源码文件以 _test 结尾： xxx_test.go
• 测试方法名以 Test 开头 TestXXX(t *testing.T){...}
• go test -v xxx_test.go 才能输出 t.Log 里的文字

• 实现斐波拉契数列

  1 2 3 4 5 6 7

  func TestFibList(t *testing.T) { a,b := 1,1 for i := 0; i < 5; i++ { fmt.Println(b) a,b = b,a+b } }

变量与其它静态编程语言的差异

• 赋值可以进行自动类型推断
• 同一个赋值语句中可以对多个变量进行同时赋值

常量与其它静态编程语言的差异

• 快速设置连续值 iota 遇到下一个 const 之前连续递增1,遇到之后变为0

• iota 只能在常量中使用

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

  const ( Monday = iota + 1 // 1 Tuesday // 2 Wednesday // 3 ) const ( Readable = 1 << iota //1 0001 Writable //2 0010 Executable //4 0100 ) const ( i = iota // i=0 j = 3.14 // j=3.14 k = iota // k=2 l // l=3 ) type ByteSize float64 const ( _ = iota // ignore first value by assigning to blank identifier KB ByteSize = 1 << (10 * iota) // 1 << (10*1) MB // 1 << (10*2) GB // 1 << (10*3) TB // 1 << (10*4) PB // 1 << (10*5) EB // 1 << (10*6) ZB // 1 << (10*7) YB // 1 << (10*8) )

数据类型

• 基本数据类型 值类型 初始化时默认会有零值
  • bool : false
  • string : ""
  • int int8 int16 int32 int64 : 0
  • uint uint8 uint16 uint32 uint64 uintptr : 0
  • byte : 0 // alias for uint8
  • rune: 0 // alias for int32，represents a Unicode code point
  • float32 float64:0
  • complex64 complex128: (0+0i)
• 复合类型
  • pointer function interface slice channel map : nil
  • 对于复合类型, go 语言会自动递归地将每一个元素初始化为其类型对应的零值。比如：数组， 结构体

整型占用字节问题

• int，uint整型：和机器平台有关，最小32位，占用4字节，64位，占用8字节。

  1 2 3 4 5 6

  //机器位数 cpu := runtime.GOARCH t.Log(cpu) // amd64 //int占用位数 int_size := strconv.IntSize t.Log(int_size) // 64

数值范围

数据类型与其它静态编程语言的差异

• Go语言不允许隐式类型转换

• 别名和原有类型也不能进行隐式类型转换

  • 在某些语言中允许小范围类型向大范围类型转换，因为数据精度不会丢失
  • 大范围向小范围转换会导致精度丢失

  1 2 3 4 5 6 7 8 9

  type MyInt int64 func TestDataType(t *testing.T){ var a int32 = 1 var b int64 b = int64(a) var c MyInt c = MyInt(b) t.Log(a,b,c) }

• Go 语言不支持指针运算

• string 是值类型，其默认的初始值为 "" 空字符串，而不是nil

  1 2 3 4 5 6 7 8 9 10 11 12

  func TestPoint(t *testing.T) { a := 1 aPtr := &a // aPtr = aPtr + 1 是不被允许的 t.Log(a, aPtr)// 1 0xc00000a2b8 t.Logf("%T %T", a, aPtr)// int *int var s string if s == "" { t.Log("string 零值为空字符串") } t.Log(len(s)) //0 }

golang代码编写最佳实践

运算符号与其它静态编程语言的差异

算术运算符

• + - * / % 后++ 后--

比较运算符

• == != > < >= <=

• 在 golang 比较数组 如果两个数组的维度相等是可以比较的

  1 2 3 4 5

  a :=[...]int{1,2,3,4} // 数组声明 b :=[...]int{1,2,4,3} c :=[...]int{1,2,3,4} t.Log(a == b) // false t.Log(a == c) // true

逻辑运算符

• ！ && ||

位运算符号

• & 按位与（A & B） 结果为12 二进制为00001100
• | 按位或（A|B）结果为61，二进制为00111101
• ^ 按位异或（A^B）结果为49，二进制为00110001
• <<A << 2 结果为240 ，二进制为11110000
• >>A >> 2 结果为15 ，二进制为00001111

• &^ 按位清零 运算符 右边为1 则左边清零 为0则左边为原值

  1 2 3 4

  1 &^ 0 --> 1 // 右边为0 则左边不变 1 &^ 1 --> 0 // 右边为1 则左边清零 0 &^ 1 --> 0 // 右边为1 则左边清零 0 &^ 0 --> 1 // 右边为0 则左边不变

第八讲 流程控制

只有 for 一个关键字

• for 不需要前后的括号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// while 循环
func TestWhileLoop(t *testing.T){
  n:= 0
  for n <5{
  n++
  t.Log(n)
  }
  // 无限循环
  for{

  }
  // 这个类似于 goto 与 php 的 break 2 跳出指定的控制结构
  n:= 0
  m:=0
  I:
  for m < 5 {
      m++
      t.Log(m)
      for n <5{
          n++
          if n>3{
              break I
          }
          t.Log(n)
      }
  }
}

if 条件

• 只有结果为 bool 值，才能成为 if 的条件

1
2
3
4
5
6
7
8
9
10
11

if condition {
    // code will be executed if condition is true
}  else if condition-1 {
    // code will be executed if condition-1 is true
} else {
    // code will be executed if condition-1 and condition are false
}
// 前半部分支持 赋值
if var delaration; condition{

}

switch 条件

• 条件表达式 不限制为常量或者整数
• 单个case中，可以出现多个结果选项，用逗号分隔
• 与 C 语言规则相反， Go 不需要加上break 来明确推出一个case

• 可以不设定 swtich 之后的条件表达式，在此种情况下，整个 switch 结构与多个 if…else… 的逻辑作用相同

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  for i := 0; i < 5; i++ { switch i { case 0, 2: t.Log("Even") case 1, 3: t.Log("Odd") default: t.Log("it is not 0-3") } } for i := 0; i < 5; i++ { switch { case i%2 == 0: t.Log("Even") case i%2 != 0: t.Log("Odd") default: t.Log("unKnow") } }

第九讲 数组与切片

数组

• 数组的声明

1
2
3
4
5
6
7
8
9
10
11
12
13

var arr [3]int            // 声明并初始化为默认零值
t.Log(arr[0], arr[1])     // 0,0
arr1 := [3]int{1}         // 声明并初始化
t.Log(arr1[0], arr1[1])   // 1,0
arr2 := [...]int{1, 1, 1} // 声明并初始化 ... 代表根据后面的值来确定前面的长度
t.Log(arr2[0], arr2[1])   // 1,1
arr2[2] = 3               // 修改 直接访问下标即可

// 多维数组的声明
b := [2][3]int{{1, 2, 3}, {2, 3}}
t.Log(b)
c := [2][2]int{{2, 3}, {1, 2}}
t.Log(c)

• 数组与 slice 的循环

1
2
3
4
5
6
7
8
9

arr := [...]int{1, 2, 3, 4, 5, 6}
// 原始 for 循环
for i := 0; i < len(arr); i++ {
    t.Log(arr[i])
}
// for range 类似于 php foreach
for _, e := range arr {
    t.Log(e)
}

• 数组与slice 的截取

1
2
3
4
5
6
7
8
9
10
11
12
13

// 数组截取操作 包括开始不包括结束
arr := [...]int{1, 2, 3, 4, 5, 6}
a1 := arr[:3]
a2 := arr[1:3]
a3 := arr[1:]
a4 := arr[1:2]
a4 = append(a4, 1)
t.Log(len(a4), cap(a4))// len 2 cap 5
t.Log(a4[1])
// 截取出来的东西 实际上是一个 slice
// 修改slice的值后 其它截取的slice 都发生了改变 也就是 说
// slice 实际上是对于 arr 的一个引用 并没有实际的空间去存储值
t.Log(a1, a2, a3, a4, arr)

切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// slice 可以看作一个结构体 包括三部分
// 指针 指向连续内存 数组 *ptr
// len 元素的个数 len
// cap 内部数组的容量

// 声明 区别在于 不用加 ... 与显示的申明长度
var s0 []int
s0 = append(s0, 1) // 增 append 后记得接受值
t.Log(len(s0), cap(s0))//1,1

s1 := []int{1, 2}
t.Log(len(s1), cap(s1))//2,2

// make 可用于声明一个 slice 第二个c
s2 := make([]int, 3, 5) // 长度为3 容量为5
t.Log(len(s2), cap(s2))
t.Log(s2[0], s2[1], s2[2])
// len 初始化元素的个数
// cap 总容量
s2 = append(s2, 1)
t.Log(len(s2), cap(s2)) // 4,5
s2 = append(s2, 2)
t.Log(len(s2), cap(s2)) // 5,5
s2 = append(s2, 3)
t.Log(len(s2), cap(s2)) // 6,10
// 如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）
// 如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的 1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
// 如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量(cap)

// 切片共享存储结构
year := []string{
    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct",
    "Nov", "Dec"}
Q2 := year[3:6]
t.Log(Q2, len(Q2), cap(Q2))// 3,9
summer := year[5:8]
t.Log(summer,len(summer), cap(summer))
summer[0] = "unKnow"
t.Log(Q2,year)
// 共享内存修改值会相互影响

区别

• 容量是否可伸缩

  • 切片容量可伸缩
    • 首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）
    • 否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap）
    • 否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的 1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
    • 如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量(cap)
    • slice的共享内存存在一个隐患，就是使用共享内存的双方slice如果有一方出现扩容，则扩容一方将不再指向原有空间。所以程序中想以修改一方达到数据同步时需要小心
    • 扩容后会指向一个更大的空间,不再指向原有空间,所以共享内存失效
  • 数组声明后长度不可修改

• 是否可比较

  • 数组可以比较 同一类型 同一长度的数组可以比较
  • slice 只能与 nil 进行比较

关于在windows服务器上使用定时任务执行 laravel artisan 命令行

• 需解决的问题

  • 公司windows 服务器上 的 laravel 项目需要定时去更新一批数据（频率不高）

• 解决思路

  • 1. 可以使用 golang 去完成 更新数据的操作，编译打包成 exe 文件 用windows 自带的计划任务去处理
  • 2. 对外提供一个 url 接口，在外部服务器上定时去 curl 请求
  • 3. 使用 windows 自带的 .bat 脚本加计划任务，配合larave artisan 命令行去处理

• 实际方案

  • 考虑了生产环境比较封闭，采取第三种方式去处理

• bat 脚本的编写

  • cd /d D:\path\to php artisan queue:check
  • 因为我已经将 php.exe 写入环境变量 所以可以直接在 test.bat 中这么写
  • 如果为独立的 php 脚本文件，也是一样的写法

• laravel 命令行的编写

  • php artisan make:command QueueCheck
  • 然后去对应的文件下面去修改与完成逻辑代码即可

• windows 计划任务

  • win+R 输入 taskschd.msc 即可使用图形化的计划任务表
  • 新增计划任务，选择执行频次与触发时机，最后要记得改为管理员权限去执行，

原生 golang 构建 web 服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package main

import (
	"fmt"
	"log"
	"net/http"
	"strings"
)

func sayHello(w http.ResponseWriter, r *http.Request) {
	r.ParseForm()       // 解析参数 默认不会解析参数
	fmt.Println(r.Form) // 输出参数
	fmt.Println(r.Form["url_long"])
	for k, v := range r.Form {
		fmt.Println("key :", k)
		fmt.Println("value :", strings.Join(v, ""))
	}
	write := "访问方法是:" + r.Method + "<br />"
	write += "请求变量是:" + r.URL.Path
	fmt.Fprintf(w, write) // 这个写入到客户端
}

func main() {
	http.HandleFunc("/", sayHello) // 设定访问路由
	if err := http.ListenAndServe(":9090", nil); err != nil {
		log.Fatal("ListenAndServer : ", err)
	}
}

原生 php 构建web 服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

<?php
$_SERVER = array();
//创建一个tcp套接字,并监听8088端口
if ($web = stream_socket_server('0.0.0.0:9090', $errno, $errstr)) {
    while (true) {
        $conn = @stream_socket_accept($web);
        if ($conn) {
            $_SERVER = array();
            decode(fgets($conn));
            fwrite($conn, encode("访问方法是:" . $_SERVER['REQUEST_METHOD'] . "\n<br />请求变量是:" . $_SERVER['QUERY_STRING']));
            fclose($conn);
        }
    }
} else {
    die($errstr);
}

//http协议解码
function decode($info)
{
    global $_SERVER;
    list($header,) = explode("\r\n\r\n", $info);
    //将请求头变为数组
    $header = explode("\r\n", $header);
    $data = explode(' ', $header[0]);
    if ($data[0]) {
        list($_SERVER['REQUEST_METHOD'], $_SERVER['REQUEST_URI'], $_SERVER['SERVER_PROTOCOL']) = $data;
        $_SERVER['QUERY_STRING'] = parse_url($_SERVER['REQUEST_URI'], PHP_URL_QUERY);
    } else {
        $_SERVER['REQUEST_METHOD'] = '';
        $_SERVER['QUERY_STRING'] = '';
    }
}

//http协议加密
function encode($str)
{
    $content = "";
    $content .= "HTTP/1.1 200 OK\r\n";
    $content .= "Server: php_web/1.0.0\r\n";
    $content .= "Content-Type:text/html;charset=utf-8\r\n";
    $content .= "Content-Length: " . strlen($str) . "\r\n\r\n{$str}";
    return $content;
}

说明

• 从以上的两种构建方式,可以看出 php 和 go 的原生对于 web 服务的封装
• golang 很显然 是 http包 对 请求进行了封装,但是 底层两者在处理请求上并没有什么区别

  对于web服务器的分析

• 大致可以抽象为 一下的四点
  • Request：用户请求的信息，用来解析用户的请求信息，包括post、get、cookie、url等信息
  • Response：服务器需要反馈给客户端的信息
  • Conn：用户的每次请求链接
  • Handler：处理请求和生成返回信息的处理逻辑
• 我们所有的工作 都是 对于上面四点的封装
• 从简易的 php web 服务器 构成来看
  • 如何监听端口?
  • 如何接收客户端请求?
  • 如何分配handle?
  • 这三点 是我们要处理的
• golang 使用了 http.ListenAndServe() 来实现端口监听
  • 根据源码可知, 底层就是初始化一个server对象，然后调用了 net.Listen(“tcp”, addr) ，也就是底层用TCP协议
    搭建了一个服务，然后监控我们设置的端口。

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

    # 第一步 构建了一个Server结构体的引用 func ListenAndServe(addr string, handler Handler) error { server := &Server{Addr: addr, Handler: handler} return server.ListenAndServe() } # 第二步 关闭服务 根据端口 开启一个 tcp 监听 func (srv *Server) ListenAndServe() error { if srv.shuttingDown() { return ErrServerClosed } addr := srv.Addr if addr == "" { addr = ":http" } ln, err := net.Listen("tcp", addr) if err != nil { return err } return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)}) } # 第三步 处理 请求 func (srv *Server) Serve(l net.Listener) error { if fn := testHookServerServe; fn != nil { fn(srv, l) // call hook with unwrapped listener } l = &onceCloseListener{Listener: l} defer l.Close() if err := srv.setupHTTP2_Serve(); err != nil { return err } if !srv.trackListener(&l, true) { return ErrServerClosed } defer srv.trackListener(&l, false) var tempDelay time.Duration // how long to sleep on accept failure baseCtx := context.Background() // base is always background, per Issue 16220 ctx := context.WithValue(baseCtx, ServerContextKey, srv) for { rw, e := l.Accept() if e != nil { select { case <-srv.getDoneChan(): return ErrServerClosed default: } if ne, ok := e.(net.Error); ok && ne.Temporary() { if tempDelay == 0 { tempDelay = 5 * time.Millisecond } else { tempDelay *= 2 } if max := 1 * time.Second; tempDelay > max { tempDelay = max } srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay) time.Sleep(tempDelay) continue } return e } tempDelay = 0 c := srv.newConn(rw) c.setState(c.rwc, StateNew) // before Serve can return go c.serve(ctx) } }