搜索引擎优化（英语：search engine optimization，缩写为SEO），是一种通过了解搜索引擎的运作规则来调整网站，以及提高目的网站在有关搜索引擎内排名的方式。由于不少研究发现，搜索引擎的用户往往只会留意搜索结果最前面的几个条目，所以不少网站都希望通过各种形式来影响搜索引擎的排序，让自己的网站可以有优秀的搜索排名。当中尤以各种依靠广告维生的网站为甚。

搜索引擎优化维基百科

准备事项

账号注册

• 注册百度站长，先注册百度账号 百度
• 注册google账号 google
• 查看网站收录情况 site:www.yoursite.com 对应搜索引擎输入您的站点域名

安装 sitemap

为了能够让我们的站点被收录，我们需要为我们的hexo博客安装相关支持的包。这两个包分别为：

• hexo-generator-sitemap 【该包用于支持Google搜索引擎】
• hexo-generator-baidu-sitemap 【该包用于支持百度搜索引擎】

1
2

npm install hexo-generator-sitemap --save
npm install hexo-generator-baidu-sitemap --save

sitemap：中文译为“站点地图”

站点地图是一种文件，您可以通过该文件列出您网站上的网页，从而将您网站内容的组织架构告知 Google 和其他搜索引擎。Googlebot 等搜索引擎网页抓取工具会读取此文件，以便更加智能地抓取您的网站。

hexo 配置文件

1. 根目录_config.yaml添加如下的配置（注意每行的空格）生成对应xml文件

   1 2 3 4 5

   # sitemap sitemap: path: sitemap.xml baidusitemap: path: baidusitemap.xml

2. 修改文章链接,找到关键字 permalink，并修改为如下形式：(此步骤按个人喜好)

   SEO搜索引擎优化认为，网站的最佳结构是用户从首页点击三次就可以到达任何一个页面，但是我们使用hexo编译的站点默认打开文章的url是“sitename/year/mounth/day/title”四层的结构，这样的url结构很不利于SEO，爬虫就会经常爬不到我们的文章，于是，我们可以将url直接改成“sitename/title”的形式，并且title最好是用英文（中文的url会出现好多乱码，我这方面还有待改进）。

1
2
3
4
5

# 基于以上原因，我在根目录的站点配置文件下修改url设置如下：
url: https://www.bkduck.cn
root: /
permalink: :title/
permalink_defaults:

3. 博客根目录中的 source 文件夹下，添加蜘蛛协议 “robots.txt” 的文件，内容如下：

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

   User-agent: * Allow: / Allow: /categories/ Allow: /tags/ Allow: /archives/ Allow: /about/ Disallow: /vendors/ Disallow: /js/ Disallow: /css/ Disallow: /fonts/ Disallow: /vendors/ Disallow: /fancybox/ # 记得替换成你的域名 Sitemap: http://yoursite.com/sitemap.xml Sitemap: http://yoursite.com/baidusitemap.xml主动推送

主动推送

新链接由我们主动推送给百度，此步骤需提前注册百度账号并拿到权限token

1. 安装插件

   1 2	# 会生成baidu_urls.txt目录 npm install hexo-baidu-url-submit --save

2. 根目录站点配置文件_config.yaml中新增如下字段

   1 2 3 4 5

   baidu_url_submit: count: 100 # 提交最新的一个链接 host: www.bkduck.cn # 在百度站长平台中注册的域名 token: lY..........Fk # 请注意这是您的秘钥，所以请不要把博客源代码发布在公众仓库里! path: baidu_urls.txt # 文本文档的地址，新链接会保存在此文本文档里

3. 域名和秘钥可以在站长工具平台的连接提交中的接口调用地址中找到，即对应host与token后面的字段。link

4. 根目录_config.yaml, 修改deploy配置

   以后每次执行hexo d，新的链接就会主动推送给百度，然后百度就会更快地派爬虫来发现你站点中的新链接，可以在第一时间收录新建的链接。

   1 2 3 4 5

   # Deployment # 使用hexo deploy指令后，自动推送给百度 ## Docs: https://hexo.io/docs/deployment.html deploy: type: 'baidu_url_submitter'

百度收录

1. 建立站点管理，打开link, 并填写你的域名

   

2. 勾选对应站点属性

3. 下载认证文件，并放在网站根目录,若是html文件,hexo需要在html文件添加layout: false,防止转换

   

google收录

google收录就相对简单点，只要先按上面步骤[安装sitemap](# 安装sitemap)生成好sitemap.xml，然后提交到google后台就ok👌.

1. 验证抓取域名

   打开google search console, 并添加需要抓取的域名，并把googlexxx.html文件放在网站根目录 如下图

2. 然后点击验证按钮，成功则返回下图：

3. 点击上图前往资源页面，或通过link进入，并提交你的sitemap.xml

小结

若以上步骤都完成了，网站就能正常被收录啦，赶紧用site:www.yoursite.com看看具体情况呗，相信网站流量很快破百万，升职ceo，迎娶白富美！！！💪🏻💪🏻💪🏻

Prometheus是一个开源的系统监控和警报工具包。自2012年启动以来，许多公司和组织都采用了Prometheus，该项目拥有非常活跃的开发人员和用户社区。它现在是一个独立的开源项目，独立于任何公司进行维护。Prometheus于2016年加入云原生计算基金会，成为继Kubernetes之后的第二个托管项目。

2. Prometheus 特点

Prometheus是一个开源的完整的监控解决方案，基于的是中央化的规则计算、统一分析和告警的新模型。相对于传统监控系统，Prometheus有以下优点。

2.1 主要功能

• 多维 数据模型（时序由 metric 名字和 k/v 的 labels 构成）。
• 灵活的查询语句（PromQL）。
• 无依赖存储，支持 local 和 remote 不同模型。
• 采用 http 协议，使用 pull 模式，拉取数据，简单易懂。
• 监控目标，可以采用服务发现或静态配置的方式。
• 支持多种统计数据模型，图形化友好。
• 复杂环境，支持手动push模式，通过pushgateway组件收集，server拉取pushgateway

2.2 主要组件

• Prometheus Server：主服务器，负责收集和存储时间序列数据

• Client libraries：应用程序代码插桩，将监控指标嵌入到被监控应用程序中

• Pushgateway：推送网关，为支持short-lived作业提供一个推送网关

• Exporter：专门为一些应用开发的数据摄取组件-exporter，例如：HAProxy、StatsD、Graphite等等 exporter

• Altermanager：专门用于处理alert的组件 altermanager

2.3 原理图

从这个架构图，也可以看出 Prometheus 的主要模块包含， Server, Exporters, Pushgateway, PromQL, Alertmanager, WebUI 等

它大致使用逻辑是这样：

1. Prometheus server 定期从静态配置的 targets 或者服务发现的 targets 拉取数据。 （pull 模式 + pushgateway）
2. 当新拉取的数据大于配置内存缓存区的时候，Prometheus 会将数据持久化到磁盘（如果使用 remote storage 将持久化到云端）。
3. Prometheus 可以配置 rules，然后定时查询数据，当条件触发的时候，会将 alert 推送到配置的 Alertmanager。
4. Alertmanager 收到警告的时候，可以根据配置，聚合，去重，降噪，最后发送警告。
5. 可以使用 API， Prometheus Console 或者 Grafana 查询和聚合数据。

注意事项

• Prometheus 的数据是基于时序的 float64 的值，如果你的数据值有更多类型，无法满足。
• Prometheus 不适合做审计计费，因为它的数据是按一定时间采集的，关注的更多是系统的运行瞬时状态以及趋势，即使有少量数据没有采集也能容忍，但是审计计费需要记录每个请求，并且数据长期存储，这个 Prometheus 无法满足，可能需要采用专门的审计系统。

静态配置和动态配置

静态配置

Prometheus通过static_configs来设定静态方式的监控对象，比如如下Node Exporter的监控数据抓取的配置，其特点是Node Exporter提供的监控数据的/metrics的HTTP服务的IP和端口号都是固定的，在这种情况下可以使用静态配置

1
2
3
4

scrape_configs:
  - job_name: 'node_exporter'
    static_configs:
      - targets: ['192.168.31.242:9100']

动态配置-服务自发现

动态配置是相较于静态配置的说法，在Prometheus中则是结合服务发现来实现的，将服务发现的这个功能和机制分离出去，直接利用现有的服务发现的功能框架比如consul来确认可能会动态变化的监控对象，这样就做到了所谓的动态配置。

常见的动态配置的使用方式如上图所示：

1. 各种服务直接在SD（服务发现能力提供者：比如consule）上进行服务注册
2. Prometheus不直接管理哪些对象需要监控，它直接向SD去获取需要监控的对象的列表
3. SD会返回给Prometheus需要监控的对象列表
4. Prometheus根据返回的监控对象列表使用Pull的方式进行监控数据的收集

基于consul服务发现

Consul提供了服务发现和注册的功能，而Prometheus也支持通过Consul的方式来进行动态配置

1
2
3
4

consul_sd_configs:
     - server: Consul服务的IP:Consul服务的端口号
       services:
         - node_exporter

基本etcd+confd

根据服务注册metrics到etcd，confd 拉取etcd的配置，自动生成配置文件到promethoues，然后热加载来提供自动的指标监控。 github

1. 启动confd

设置 confd 读取的配置和模版的文件夹，并监听 etcd 的变化。

1

confd -confdir ./confd/ -config-file ./confd/conf.d/prometheus.json.toml -backend etcdv3  -watch -node http://127.0.0.1:2379  &

2. 启动 prometheus

   覆盖 /etc/prometheus/prometheus.yml 的文件, 并在 prometheus 的 bin 下面启动:

   1 2 3 4

   >> mkdir /prometheus >> prometheus --web.enable-lifecycle \ --config.file=/etc/prometheus/prometheus.yml \ --storage.tsdb.path=/prometheus

3. Prometheus 配置文件

   1 2 3 4 5 6 7 8 9 10

   global: scrape_interval: 15s scrape_timeout: 10s evaluation_interval: 15s scrape_configs: - job_name: 'test' file_sd_configs: - files: - /tmp/prometheus/targets/target_*.json

   其他配置

   更多有效配置示例

   1 2 3 4 5 6

   #Prometheus数据源的配置主要分为静态配置和动态发现, 常用的为以下几类 1）static_configs: #静态服务发现 2）file_sd_configs: #文件服务发现 3）dns_sd_configs: DNS #服务发现 4）kubernetes_sd_configs: #Kubernetes 服务发现 5）consul_sd_configs: Consul #服务发现

分布式链路追踪就是将一次分布式请求还原成调用链路，将一次分布式请求的调用情况集中展示，比如各个服务节点上的耗时、请求具体到达哪台机器上、每个服务节点的请求状态等等。

链路跟踪主要功能：

• 故障快速定位：可以通过调用链结合业务日志快速定位错误信息。
• 链路性能可视化：各个阶段链路耗时、服务依赖关系可以通过可视化界面展现出来。
• 链路分析：通过分析链路耗时、服务依赖关系可以得到用户的行为路径，汇总分析应用在很多业务场景。

span概念

图中一条完整的链路是：chrome -> 服务A -> 服务B -> 服务C -> 服务D -> 服务E -> 服务C -> 服务A -> chrome。服务间经过的局部链路构成了一条完整的链路，其中每一条局部链路都用一个全局唯一的traceid来标识。

同一层级parent id相同，span id不同，span id从小到大表示请求的顺序，从下图中可以很明显看出服务A是先调了服务B然后再调用了C。

上下层级代表调用关系，如下图服务C的span id为2，服务D的parent id为2，这就表示服务C和服务D形成了父子关系，很明显是服务C调用了服务D。

总结：通过事先在日志中埋点，找出相同traceId的日志，再加上parent id和span id就可以将一条完整的请求调用链串联起来。

Annotations

Dapper中还定义了annotation的概念，用于用户自定义事件，用来辅助定位问题。

通常包含四个注解信息：

cs：Client Start，表示客户端发起请求；

sr：ServerReceived，表示服务端收到请求；

ss：Server Send，表示服务端完成处理，并将结果发送给客户端；

cr：ClientReceived，表示客户端获取到服务端返回信息；

采样

由于每一个请求都会生成一个链路，为了减少性能消耗，避免存储资源的浪费，dapper并不会上报所有的span数据，而是使用采样的方式。举个例子，每秒有1000个请求访问系统，如果设置采样率为1/1000，那么只会上报一个请求到存储端。

zipkin原理

基本结构

zipkin(服务端)包含四个组件，分别是collector、storage、search、web UI。

• collector 就是信息收集器,作为一个守护进程，它会时刻等待客户端传递过来的追踪数据，对这些数据进行验证、存储以及创建查询需要的索引。
• storage 是存储组件。zipkin 默认直接将数据存在内存中，此外支持使用Cassandra、ElasticSearch 和 Mysql。
• search 是一个查询进程，它提供了简单的JSON API来供外部调用查询。
• web UI 是zipkin的服务端展示平台，主要调用search提供的接口，用图表将链路信息清晰地展示给开发人员。

zipkin请求过程

一个 span 表示一次服务调用，那么追踪器必定是被服务调用发起的动作触发，生成基本信息，同时为了追踪服务提供方对其他服务的调用情况，便需要传递本次追踪链路的traceId和本次调用的span-id。服务提供方完成服务将结果响应给调用方时，需要根据调用发起时记录的时间戳与当前时间戳计算本次服务的持续时间进行记录，至此这次调用的追踪span完成，就可以发送给zipkin服务端了。但是需要注意的是，发送span给zipkin collector不得影响此次业务结果，其发送成功与否跟业务无关，因此这里需要采用异步的方式发送，防止追踪系统发送延迟与发送失败导致用户系统的延迟与中断

可以看出服务A请求服务B时先被追踪器拦截，记录tag信息、时间戳，同时将追踪标识添加进http header中传递给服务B，在服务B响应后，记录持续时间，最终采取异步的方式发送给zipkin收集器。span从被追踪的服务传送到Zipkin收集器有三种主要的传送方式：http、Kafka以及Scribe（Facebook开源的日志收集系统）。

参考

https://www.daimajiaoliu.com/series/microservice/479c3a1d51003fc

一文搞懂基于zipkin的分布式追踪系统原理与实现

10张图就可以搞懂分布式链路追踪系统原理

go-kit微服务请求跟踪实现

最近想入手学习k8s，经网上一顿猛如虎搜索后，奈何钱包不够，只好选择腾讯云轻量服务器 2g4核的k3s集成环境。CI/CD持续集成选择了GitHub Actions ，部署好后，只需提交分支到GitHub就自动构建镜像并且发布到线上服务器。至于镜像仓库，还是秉持白嫖原则，使用腾讯云自带的镜像仓。最后博客的框架是Hexo + Fluid静态博客，评论系统则使用Waline。

线上博客请移步www.bkduck.cn

看官们若想折腾一翻，请移步下方教程，倒腾一翻，反正首年40元即可获得,马上戳下面链接领取呗~

【腾讯云】爆款2核2G云服务器首年40元，企业首购最高获赠300元京东卡

事前准备

• 本地部署好博客环境hexo + fluid,具体方法自行google或后期再出一期教程
• 了解GitHub Actions 的基本语法，可以移步看看阮一峰老师的文章《GitHub Actions 入门教程》
• 缺少点Like的Github账号，收藏三连防丢失 github
• 腾讯云一键初始化的轻量服务器k3s环境，请按照官方文档一顿操作 [文档](使用应用镜像实践 K3s 容器集群管理)
• 免费的线上腾讯云镜像仓库，照旧按官方文档走一遍 《管理自定义镜像》

实际操作

k3s环境部署

登录线上k3s的环境，执行 Ingress，Deployment，Service创建

1
2

>> rz -be  # 选择deployment.yaml,上传到服务器
>> kubectl apply -f deployment.yaml# 创建必须的资源

代码修改

镜像仓库调整，全局替换ccr.ccs.tencentyun.com/xxx/blog 变成你的镜像仓地址

GitHub Action环境参数配置

创建action secrets, 然后在.github/workflows/*.yaml 替换成你创建的secrets

一切就绪，push分支到Github,剩下构建镜像，推送镜像，重启k3s的deployment的工作就交给Github Actions完成，cafe啜一口，你的博客构建完成呗！

waline 评论系统的搭建

方案很多，可以百度搜下，我的方案是k3s部署mysql，当然生产环境不推荐，原因你懂的，但毕竟看荷包的活，毕竟不用钱，你也可以额试试部署mysql-*.yaml + deployment.yaml

Go 语言的逃逸分析遵循以下两个不变性:

1. 指向栈对象的指针不能存在于堆中；
2. 指向栈对象的指针不能在栈对象回收后存活；

栈空间不足导致的扩容会经历以下几个步骤：

1. 在内存空间中分配更大的栈内存空间；
2. 将旧栈中的所有内容复制到新栈中；
3. 将指向旧栈对应变量的指针重新指向新栈；
4. 销毁并回收旧栈的内存空间；

在扩容的过程中，最重要的是调整指针的第三步，这一步能够保证指向栈的指针的正确性，因为栈中的所有变量内存都会发生变化，所以原本指向栈中变量的指针也需要调整。我们在前面提到过经过逃逸分析的 Go 语言程序的遵循以下不变性 —— 指向栈对象的指针不能存在于堆中，所以指向栈中变量的指针只能在栈上，我们只需要调整栈中的所有变量就可以保证内存的安全了

栈拓容和缩容

栈缩容

运行时只会在栈内存使用不足 1/4 时进行缩容，新栈的大小会是原始栈的一半，不过如果新栈的大小低于程序的最低限制 2KB，那么缩容的过程就会停止。

修改字符串

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

1. byte类型
s := "hello"
s2 := "你好"
c := []byte(s)  // 将字符串 s 转换为 []byte 类型
c2 := []rune(s2) // 转换中文unicode 占4个字节
c[0] = 'c'
s2 := string(c)  // 再转换回 string 类型
fmt.Printf("%s\n", s2)

2.切片
s := "hello"
s = "c" + s[1:] // 字符串虽不能更改，但可进行切片操作
fmt.Printf("%s\n", s)

连接字符串

1
2
3
4
5
6

// + 号链接 
s := "hello,"
m := " world"
a := s + m
fmt.Printf("%s\n", a)

多行字符串

1
2

m := `hello
  world`

判断字符长度

1
2
3
4
5
6
7

// 判断中文
str := "hello 你好"
if strlen := utf8.RuneCountInString(str); strlen > 500 {
return error.new('wrong len')
}
// 判断字符 占一个字节
if len(str)

字符串比较 - 忽略大小写

如果要忽略大小写来比较包含文字数据的字节切片(byte slice)，
不建议使用bytes包和strings包里的ToUpper()、ToLower()这些函数转换后再用==、byte.Equal()、bytes.Compare()等比较，ToUpper()、ToLower()只能处理英文文字，对其它语言无效。因此建议使用strings.EqualFold()和`bytes.EqualFold()

如果要比较用于验证用户数据密钥信息的字节切片时，使用reflact.DeepEqual()、bytes.Equal()、 bytes.Compare()会使应用程序遭受计时攻击(Timing Attack)，可使用crypto/subtle.ConstantTimeCompare()避免泄漏时间信息

struct 类的String()应用

• 正确用法

  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

  #note #如果类型定义了 String() 方法，它会被用在 fmt.Printf() 中生成默认的输出：等同于使用格式化描述符 %v 产生的输出。还有 fmt.Print() 和 fmt.Println() 也会自动使用 String() 方法。 package main import ( "fmt" "strconv" ) type TwoInts struct { a int b int } func main() { two1 := new(TwoInts) two1.a = 12 two1.b = 10 fmt.Printf("two1 is: %v\n", two1) fmt.Println("two1 is:", two1) fmt.Printf("two1 is: %T\n", two1) fmt.Printf("two1 is: %#v\n", two1) } func (tn *TwoInts) String() string { return "(" + strconv.Itoa(tn.a) + "/" + strconv.Itoa(tn.b) + ")" } 输出： two1 is: (12/10) two1 is: (12/10) two1 is: *main.TwoInts two1 is: &main.TwoInts{a:12, b:10}

• 糟糕写法(内存溢出)

1
2
3
4
5
6
7
8
9

#note
#不在 String() 方法里调用涉及 String() 方法的方法，会导致意料之外的错误，它导致了一个无限递归调用（TT.String() 调用 fmt.Sprintf，而 fmt.Sprintf 又会反过来调用 TT.String()...），很快就会导致内存溢出

type TT float64

func (t TT) String() string {
    return fmt.Sprintf("%v", t)
}
t.String()

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
28
29
30

data := []string{"one","two","three"}

wg := sync.WaitGroup{}
wg.Add(9)
//goroutines print: three, three, three
for _,v := range data {
  go func() {
    fmt.Println(v)
    wg.Done()
  }()
}

//goroutines print: one, two, three
for _,v := range data {
  vcopy := v // 使用临时变量
  go func() {
    fmt.Println(vcopy)
    wg.Done()
  }()
}

//goroutines print: one, two, three
for _,v := range data {
  go func(in string) {
    fmt.Println(in)
    wg.Done()
  }(v)
}

wg.Wait()

在for迭代过程中，迭代变量v会一直保留，只是每次迭代值v不一样,因此在for循环中在闭包里直接引用迭代变量，在执行时直接取迭代变量的值，而不是闭包所在迭代的变量值

闭包要取所在迭代变量的值，需要for中定义临时变量来保存所在迭代的值，或者通过闭包函数传参

定义为指针数组时，输出正常

另一个例子:

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

data := []field{{"one"},{"two"},{"three"}}
for _,v := range data {
  // 解决办法：添加如下语句
  // v := v
  go v.print()
}
time.Sleep(3 * time.Second)     //goroutines print: three, three, three

data2 := []*StructA{{"one"}, {"two"}, {"three"}}  // 注意data2是指针数组 StructA 自定义结构
for _, v := range data2 {
  go v.print()                // go执行是函数，函数执行之前，函数的接受对象已经传过来
}
time.Sleep(3 * time.Second)     //goroutines print: one, two, three

• 主要概念

  1 2	1. interface 可被 struct 等继承 （animalI = catT, catT 实现所有animalI的方法） 2. 了解规则：最好使用new()生成指针类

• 参考链接

type-switch 类型选择

• 参考链接

  1 2	1. 介绍interface的用处 https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/02.6.md

• Comma-ok断言 判断类型 element.(T)

  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

  package main import ( "fmt" "strconv" ) type Element interface{} type List []Element type Person struct { name string age int } //打印 func (p Person) String() string { return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)" } func main() { list := make(List, 3) list[0] = 1 //an int list[1] = "Hello" //a string list[2] = Person{"Dennis", 70} for index, element := range list{ switch value := element.(type) { case int: fmt.Printf("list[%d] is an int and its value is %d\n", index, value) case string: fmt.Printf("list[%d] is a string and its value is %s\n", index, value) case Person: fmt.Printf("list[%d] is a Person and its value is %s\n", index, value) default: fmt.Println("list[%d] is of a different type", index) } } }

• interface 可以嵌套interface

  1 2 3 4 5 6 7 8

  例如io标准库 // io.ReadWriter // Reader和Writer两个 interface type ReadWriter interface { Reader Writer }

类型断言

• 代码

  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

  #NOTE：如果忽略 areaIntf.(*Square) 中的 * 号，会导致编译错误：impossible type assertion: Square does not implement Shaper (Area method has pointer receiver)。 package main import ( "fmt" "math" ) type Square struct { side float32 } type Circle struct { radius float32 } type Shaper interface { Area() float32 } func main() { var areaIntf Shaper sq1 := new(Square) sq1.side = 5 areaIntf = sq1 // Is Square the type of areaIntf? if t, ok := areaIntf.(*Square); ok { fmt.Printf("The type of areaIntf is: %T\n", t) } if u, ok := areaIntf.(*Circle); ok { fmt.Printf("The type of areaIntf is: %T\n", u) } else { fmt.Println("areaIntf does not contain a variable of type Circle") } } func (sq *Square) Area() float32 { return sq.side * sq.side } func (ci *Circle) Area() float32 { return ci.radius * ci.radius * math.Pi } 输出 The type of areaIntf is: *main.Square areaIntf does not contain a variable of type Circle

调用规则

• 规则

  1 2 3 4 5 6

  Go 语言规范定义了接口方法集的调用规则： 类型 *T 的可调用方法集包含接受者为 *T 或 T 的所有方法集 类型 T 的可调用方法集包含接受者为 T 的所有方法 类型 T 的可调用方法集不包含接受者为 *T 的方法

• 代码

  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

  #注意new()的用法 package main import ( "fmt" ) type List []int func (l List) Len() int { return len(l) } func (l *List) Append(val int) { *l = append(*l, val) } type Appender interface { Append(int) } func CountInto(a Appender, start, end int) { for i := start; i <= end; i++ { a.Append(i) } } type Lener interface { Len() int } func LongEnough(l Lener) bool { return l.Len()*10 > 42 } func main() { // A bare value var lst List // compiler error: // cannot use lst (type List) as type Appender in argument to CountInto: // List does not implement Appender (Append method has pointer receiver) // CountInto(lst, 1, 10) if LongEnough(lst) { // VALID:Identical receiver type fmt.Printf("- lst is long enough\n") } // A pointer value plst := new(List) CountInto(plst, 1, 10) //VALID:Identical receiver type if LongEnough(plst) { // VALID: a *List can be dereferenced for the receiver fmt.Printf("- plst is long enough\n") } } 输出 - plst is long enough

空接口复制

• 代码

  1 2 3 4 5 6 7 8 9 10

  #需逐个显式复制 var dataSlice []myType = FuncReturnSlice() var interfaceSlice []interface{} = make([]interface{}, len(dataSlice)) for i, d := range dataSlice { interfaceSlice[i] = d } #错误语法 var dataSlice []myType = FuncReturnSlice() var interfaceSlice []interface{} = dataSlice

• panic 只会触发当前 Goroutine 的 defer；
• recover 只有在 defer 中调用才会生效；
• panic 允许在 defer 中嵌套多次调用；

跨协程失效

panic 只会触发当前 Goroutine 的延迟函数调用

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

func main() {
defer println("in main")
go func() {
defer println("in goroutine")
panic("")
}()

time.Sleep(1 * time.Second)
}

$ go run main.go
in goroutine
panic:
...

当我们运行这段代码时会发现 main 函数中的 defer 语句并没有执行，执行的只有当前 Goroutine 中的 defer

失效的崩溃恢复

在主程序中调用 recover 试图中止程序的崩溃，但是从运行的结果中我们也能看出，下面的程序没有正常退出。

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

func main() {
defer fmt.Println("in main")
if err := recover(); err != nil {
fmt.Println(err)
}

panic("unknown err")
}

$ go run main.go
in main
panic: unknown err

goroutine 1 [running]:
main.main()
...
exit status 2

recover 只有在发生 panic 之后调用才会生效。然而在上面的控制流中，recover 是在 panic 之前调用的，并不满足生效的条件，所以我们需要在 defer 中使用 recover 关键字。

嵌套崩溃

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

func main() {
defer func(){
fmt.Println("5")
fmt.Println("in main")
}()
defer func() {
fmt.Println("2")
defer func() {
fmt.Println("4")
panic("panic again and again and again")
}()
defer func() {
fmt.Println("3")
panic("panic again and again")
}()
panic("panic again")
}()
fmt.Println("1")
panic("panic once") 
}

>>>
1
2
4
5
6
in main

panic: panic once
panic: panic again
panic: panic again and again
panic: panic again and again and again
exit status 2

panic 先执行同级defer,然后同级defer按FILO顺序执行，若defer内部嵌套defer, 其执行顺序按内部嵌套FILO顺序执行。同时注意panic位置在defer 前面则同级后面defer不会执行

panic()和recover()和defer运用

• 程序panic，defer中使用recover恢复

  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

  #执行panic，这时recover就不等于nil，然后程序先执行defer，然后panic终止 #类似于try catch package main import ( "log" ) func protect(g func()) { defer func() { log.Println("done") // Println executes normally even if there is a panic if err := recover(); err != nil { log.Printf("run time panic: %v", err) } }() log.Println("start") g() // possible runtime-error } func main() { protect(func() { log.Println("in g()") panic("dropout g()") }) } 输出 2018/07/25 18:21:23 start 2018/07/25 18:21:23 in g() 2018/07/25 18:21:23 done 2018/07/25 18:21:23 run time panic: dropout g()

基于数组实现，可动态拓容，

切片拓容规则

append() 在分配内存空间之前需要先确定新的切片容量，运行时根据切片的当前容量选择不同的策略进行扩容

• 如果期望容量大于当前容量的两倍就会使用期望容量；

• 如果当前切片的长度小于 1024 就会将容量翻倍；

• 如果当前切片的长度大于 1024 就会每次增加 25% 的容量，直到新容量大于期望容量；

copy拷贝，runtime.memmove 能够提供更好的性能。需要注意的是，整块拷贝内存仍然会占用非常多的资源，在大切片上执行拷贝操作时一定要注意对性能的影响

总结

1. append 注意拓容规则，初始化时可规划好长度
2. copy 避免大切片拷贝

slice使用

slice cap分析

copy() 是值赋值，不会影响原切片cap，同时基于数组的新切片，修改新切片值，会覆盖数组的值。

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

 
 
 arr := [10]int64{1,2,3,4,5,6,7,8,9,10}
s1 := arr[2:4:8] // cap=6,len=2 cap 针对源数组 arr 由2开始
s2 := arr[2:4] // cap=8,len=2
 s3 := arrp[:4] // cap=10,len=4 
 //s1[0] = 4 // arr: [1,2,4,4,5,6,7,8,9,10] //切片指向arr地址，修改会覆盖
 //cp := []int64{22,33}
 //copy(s1,cp) //arr: [1,2,22,33,5,6,7,8,9,10] copy是值复制，不影响s1的cap

fmt.Println(s1) //[3 4]
fmt.Println(s2) //[3 4]
fmt.Println(s1[:cap(s1)]) //[3 4 5 6 7 8]
fmt.Println(cap(s1)) // 6 8-2
fmt.Println(len(s1)) // 2
fmt.Println(s2[:cap(s2)])//[3 4 5 6 7 8 9 10]
fmt.Println(cap(s2)) // 8  10-2
fmt.Println(len(s2)) // 2

 

Slice增加元素重新分配内存

slice在添加元素前，与其它切片共享同一数据区域，修改会相互影响；但添加元素导致内存重新分配之后，不再指向原来的数据区域，修改元素，不再影响其它切片。

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

s1 := []int{1,2,3}
fmt.Println(len(s1),cap(s1),s1) //prints 3 3 [1 2 3]

s2 := s1[1:]
fmt.Println(len(s2),cap(s2),s2) //prints 2 2 [2 3]

for i := range s2 { s2[i] += 20 }

//still referencing the same array
fmt.Println(s1) //prints [1 22 23]
fmt.Println(s2) //prints [22 23]

s2 = append(s2,4)

for i := range s2 { s2[i] += 10 }

//s1 is now "stale"
fmt.Println(s1) //prints [1 22 23]
fmt.Println(s2) //prints [32 33 14]

参考链接

• 切片实现原理

SPL全称：Standard PHP Library (标准php类库)。

引用phpro.org站点的解析：The aim of SPL is to implement some efficient data access interfaces and classes for PHP. Functionally it is designed to traverse aggregate structures (anything you want to loop over). These may include arrays, database result sets, xml trees, directory listings or any list at all.

原文翻译：SPL的目的是实现一些有效的数据访问接口和类的PHP。功能是用来遍历聚合数据结构(任何你想要遍历)。这些可能包括数组、数据库结果集,xml树、目录或者任何list！

个人心得：

• SPL主要对外提供统一，便捷，快速的遍历方式（++一般不能foreach遍历对象Object++）
• SPL已经编写好了基础的structures（数据结构），如SplDoublyLinkedList（双链表）、SplStack（栈）等
• SPL核心是Iterrator（迭代器），同时SPL提供很多Iterator，如RecursiveArrayIterator（递归数组迭代器）、ArrayIterator（数组迭代器）DirectoryIterator(目录迭代器) 等
• SPL 主要组成：数据结构、迭代器、•接口、•异常、SPL 函数、文件处理、各种类及接口

How 如何学

也许很多人常听SPL，但大概入门找不到方向，其实学习无外乎‘3W’（what、why、how）bkduck将围绕这3w做一个系列的记录，方便以后自己查阅

该仓库主要记录php开发遇到的知识点。
针对相应知识点，附上便于理解的链接，若有更好的资源，欢迎提交更正交流。

基础篇

• 了解大部分数组处理函数

• 字符串处理函数 区别 mb_ 系列函数

• & 引用，结合案例分析

  当 unset 一个引用，只是断开了变量名和变量内容之间的绑定。这并不意味着变量内容被销毁了

• == 与 === 区别

• isset 与 empty 区别

  • isset=>false: var $x; $x=null;unset($x)

• 全部魔术函数理解

• 超全局变量 魔术变量 魔术函数总结

• static、$this、self 区别

  static 未实现时，将其指向了运行时最初调用的类

  self 未实现方法时指向父类，实现后指向当前

  $this 指向对象的方法，不能静态方法

• private、protected、public、final 区别 public实例能调用 protected实例不能直接调用 final不能继承和重写

• OOP 思想

• 抽象类、接口 分别使用场景

• Trait 是什么东西

• echo、print、print_r 区别(区分出表达式与语句的区别)

• __construct 与 __destruct 区别

• static 作用（区分类与函数内）手册 、SOF

• __toString() 作用

• 单引号'与双引号"区别

• 常见 HTTP 状态码，分别代表什么含义

• 301 什么意思 404 呢?

• php 499 500 502 504 错误原因 参考

  499 Client Closed Request 客户端超时，nginx&php-fpm正常执行 curl -m 3

  500 Server Internetel Error php-fpm无法正常工作(代码错误)

  502 Bad GateWay php-fpm执行超时，返回给网关无法解析内容(不按套路出牌，fpm数量不够)

  504 GateWay Timeout nginx超时，fastcgi_read_timeout，php-fpm 正常执行

进阶篇

• Autoload、Composer 原理 PSR-4 、原理

  必须有顶级命名空间

  必须有最终类名

  类名必须大小写敏感

  必须文件php后缀

  子命名空间 必须 与相应的「文件基目录」相匹配

  一定不可 抛出异常、一定不可 触发任一级别的错误信息

• Session 共享、存活时间

  • 存活: 默认存活gc_maxlifetime=1440s,默认gc概率1/100 gc_probability/gc_divisor
  • 共享: 文件同步rsync，redis或mc存储，mysql存储

• 异常处理 详情

  php7之前，try catch有部分fatal error无法捕捉需搭配set_exception_handler

  php7之后，Throwable 包含了exception&error

  register_shutdown_function 能捕捉运行中止时错误

• 如何 foreach 迭代对象 Iterator 接口 或者 IteratorIterator

• 如何数组化操作对象 $obj[key]; ArrayAccess接口 或者

• 如何函数化对象 $obj(123); __invoke()或者Closure 预定义接口

• yield 是什么，说个使用场景 yield 鸟哥解析

• PSR 是什么，PSR-1, 2, 4, 7

• 如何获取客户端 IP 和服务端 IP 地址

  • 客户端 IP
  • 服务端 IP
  • 了解代理透传 实际IP 的概念

• 如何开启 PHP 异常提示

  • php.ini 开启 display_errors 设置 error_reporting 等级
  • 运行时，使用 ini_set(k, v); 动态设置

• 如何返回一个301重定向

  • [WARNING] 一定当心设置 301 后脚本会继续执行，不要认为下面不会执行，必要时使用 die or exit

• 如何获取扩展安装路径

  • phpinfo(); 页面查找 extension_dir
  • 命令行 php -i |grep extension_dir
  • 运行时 echo ini_get('extension_dir');

• 字符串、数字比较大小的原理，注意 0 开头的8进制、0x 开头16进制

  • 字符串比较大小，从左(高位)至右，逐个字符 ASCII 比较
  • 注意字符串和数字组合比较 var_dump(‘10a’ == 10); //true 10a转型10

• BOM 头是什么，怎么除去

  • win记事本保存默认开头0xEF,0xBB,0xBF（UTF8）
  • 导入含有BOM的html时，页面始终不置顶(php 当成字符串导入)
  • trim($str, “\xEF\xBB\xBF”);检测、去除

• 什么是 MVC

• 依赖注入实现原理

• 如何异步执行命令

  • <img src="xxx.php">
  • ajax异步 但需要onload后执行
  • 异步执行php脚本 如执行shell脚本exec() 但只能本机脚本
  • 使用curl 但是timeout最小是1s
  • 使用fsockopen 需要自己拼写发送内容

• 模板引擎是什么，解决什么问题、实现原理（Smarty、Twig、Blade）

• 如何实现链式操作 $obj->w()->m()->d();

  • __call() & call_user_func_array() 唤醒调用对象未知方法
  • 调用的函数return $this

• Xhprof 、Xdebug 性能调试工具使用

• 索引数组 [1, 2] 与关联数组 ['k1'=>1, 'k2'=>2] 有什么区别

  • 存在覆盖的问题 $arr1 = array(‘one’,’two’,’three’,1=>’four’); // ‘one four three’
  • 关联数组有界限 $arr1 = array(1=>’four’,’one’,’two’,’three’); // ‘1=>four 2=>one 3=>two’

• 缓存的使用方式、场景

• foreach 引用问题

1
2
3
4
5
6
7
8

$a = [1,2,3];
foreach ($a as $v){}
var_dump($a); // 123
foreach ($a as &$v){}
var_dump($a); //123
# unset($v); 或换了$v
foreach ($a as $v){}
var_dump($a); // 122

实践篇

• 给定二维数组，根据某个字段排序 array_multisort() 多维数组排序

  • array_multisort($field1, SORT_DESC, $field2, SORT_ASC, $data);

• 如何判断上传文件类型，如：仅允许 jpg 上传 详情
  $ext = $_FILES['file']['type']; 或者 解析文件名(explode())

• 不使用临时变量交换两个变量的值 $a=1; $b=2; => $a=2; $b=1; 传送门

  1 2	方案一 int 相加后相减 方案二 先拼接$a .= $b; $b=str_replace($b,'',$a)...

• strtoupper 在转换中文时存在乱码，你如何解决？php echo strtoupper('ab你好c');

  • [方案传送门] https://blog.csdn.net/whd526/article/details/77871433

  1	方案二 自定义函数，使用str_split()按一字节切割，然后ord()转asscii 判断字母asscii

• Websocket、Long-Polling、Server-Sent Events(SSE) 区别 传送门

• “Headers already sent” 错误是什么意思，如何避免

  • 避免header(‘xxx’)之前使用echo print等输出

算法篇

• 快速排序（手写）
• 冒泡排序（手写）
• 二分查找（了解）
• 查找算法 KMP（了解）
• 深度、广度优先搜索（了解）
• LRU 缓存淘汰算法（了解，Memcached 采用该算法）

数据结构篇（了解）

• 堆、栈特性 详细
  • 堆 自行申请和释放空间，存放对象，空间比较大
  • 栈 系统自动申请释放，执行程序，随函数被调用时分配的空间
• 队列
• 哈希表
• 链表

对比篇

• Cookie 与 Session 区别 (深入分析区别)[https://juejin.im/entry/5766c29d6be3ff006a31b84e]

  • cookie 存客户端 用户可见 仅支持字符串二进制 缓存时间长 服务器压力少
  • session 存服务端 用户不可见 支持多种数据类型 缓存时间有限 服务器压力大

• GET 与 POST 区别 (传送门)[https://www.zhihu.com/question/28586791]

• include 与 require 区别

  • include 使用时加载，require一开始就加载
  • include 错误时继续执行代码， require 停止执行

• include_once 与 require_once 区别

• Memcached 与 Redis 区别 [传送门](PHP include()和require()方法的区别)

  • mc 多线程非阻塞IO 只支持K-V类型 key有几率被刷走，非持久化 通过key hashmap分布式
  • redis 单线程阻塞复用IO 支持多类型 key不被刷走，持久化存储，redis-cluster分布式

• MySQL 各个存储引擎、及区别（一定会问 MyISAM 与 Innodb 区别）传送门

  1	MyIsam 写锁优先级更高，因此不适合更新操作，适合读，而且索引结构无须遍历主键索引获得记录

• HTTP 与 HTTPS 区别 传送门

• Apache 与 Nginx 区别 传送门

• define() 与 const 区别 传送门

  • define可用在条件判断中，不成立的条件中，定义的不生效，成功定义后全局可用，可是表达式赋值
  • const不可用在条件判断中，不过可定义在类中，不可表达式赋值，必须是标量

• traits 与 interfaces 区别 及 traits 解决了什么痛点？

  • traits 类似插件 use XXX 直接使用
  • interfaces 接口协议，不带实现方法

• Git 与 SVN 区别

数据库篇

• MySQL

• CRUD

  • 50个基础sql

  • JOIN、LEFT JOIN 、RIGHT JOIN、INNER JOIN 传送门

  • join 索引等优化 传送门

  • UNION， UNION ALL

  • GROUP BY + COUNT + WHERE 组合案例 详情

  • 常用 MySQL 函数，如：now()、md5()、concat()、uuid()等

  • 1:1、1:n、n:n 各自适用场景

  • 了解触发器是什么，说个使用场景 传送门

  • 数据库优化手段

    • 索引、联合索引（命中条件）传送门1 B+树
    • 覆盖索引 返回所有字段包含在组合索引当中
    • 分库分表（水平分表、垂直分表） (水平分表 crc32($str)%5 哈希取模)
    • 分区
    • 分区好处 分区优缺点

  • 索引相关

    • 索引，聚集索引， 非聚集索引

  • 会使用 explain 分析 SQL 性能问题，了解各参数含义 传送门

    • 重点理解 type、rows、key

    • Slow Log（有什么用，什么时候需要）传送门

      • mysqldumoslow 日志汇总
      • show variables like ‘%slow_query_log%’;

    • 锁了解 传送门

      • 悲观锁，排他锁，共享锁的了解

        1 2 3 4 5 6 7 8 9 10 11

        共享锁 共享锁可叠加，排他锁无法加锁 加锁方式 select * from tb where id = 1 lock in share mode； update delete 默认加锁 排它锁 排它锁会阻塞所有的排它锁和共享锁 加锁方式 select status from TABLE where id=1 for update; 解锁 commit就好 表锁 加锁 lock table xxx read; lock table xxx write; 解锁 UNLOCK TABLES

      • 死锁的出现和解决

        1 2 3 4 5 6 7 8 9 10 11

        查询是否锁表 show OPEN TABLES where In_use > 0; 查询进程（如果您有SUPER权限，您可以看到所有线程。否则，您只能看到您自己的线程） show processlist 杀死进程id（就是上面命令的id列） kill id 查看innodb行锁情况 show status like 'innodb_row_lock%'; 查表锁 show open tables where in_use > 0;

* 行锁 表锁  间隙锁  
1
2
3
4
5
6
7
8
9
10
行锁 InnoDB只有在通过索引条件检索数据时使用行级锁，否则使用表锁！并且是等值过滤条件
表锁 InnoDB未通过索引检索
间隙锁 当我们用范围条件而不是相等条件检索数据，并请求共享或排他锁时，InnoDB会给符合条件的已有数据记录的索引项加锁；对于键值在条件范围内但并不存在的记录

行锁优化
尽可能让所有数据检索都通过索引来完成，避免无索引行或索引失效导致行锁升级为表锁。
尽可能避免间隙锁带来的性能下降，减少或使用合理的检索范围。
尽可能减少事务的粒度，比如控制事务大小，而从减少锁定资源量和时间长度，从而减少锁的竞争等，提供性能。
尽可能低级别事务隔离，隔离级别越高，并发的处理能力越低。

* 属性值重复率 (行锁升级表锁)  
1
当“值重复率”低时，甚至接近主键或者唯一索引的效果，“普通索引”依然是行锁；当“值重复率”高时，MySQL 不会把这个“普通索引”当做索引，即造成了一个没有索引的 SQL，此时引发表锁。
* [脏读及隔离级别](https://www.cnblogs.com/fengzheng/p/12557762.html)  [隔离级别实现方式](https://segmentfault.com/a/1190000025156465)* mvcc实现  * mvcc基本版本号实现(事务ID), 隔离级别RU,RC,RR 基于其之上构建

• MSSQL(了解)

  • 查询最新5条数据

• NOSQL

  • Redis、Memcached、MongoDB
  • 对比、适用场景（可从以下维度进行对比）
    • 持久化
    • 支持多钟数据类型
    • 可利用 CPU 多核心
    • 内存淘汰机制
    • 集群 Cluster
    • 支持 SQL
    • 性能对比
    • 支持事务
    • 应用场景
  • 你之前为了解决什么问题使用的什么，为什么选它？

服务器篇

• 查看 CPU、内存、时间、系统版本等信息

• find 、grep 查找文件

• awk 处理文本

• 查看命令所在目录

• 自己编译过 PHP 吗？如何打开 readline 功能

• 如何查看 PHP 进程的内存、CPU 占用

  1 2	ps -aux | grep php-fpm top -p pid

• 如何给 PHP 增加一个扩展

  • phpize安装拓展

• 修改 PHP Session 存储位置、修改 INI 配置参数

  • 配置说明

• 负载均衡有哪几种，挑一种你熟悉的说明其原理 4种

• 数据库主从复制 M-S 是怎么同步的？是推还是拉？会不会不同步？怎么办

  • 主从同步解析
  • 不同步解决 重新主从

• 如何保障数据的可用性，即使被删库了也能恢复到分钟级别。你会怎么做。

  • 增量+全量备份+1小时延时从库

• 数据库连接过多，超过最大值，如何优化架构。从哪些方便处理？

  • 连接池+max_connection+程序bug_连接未释放

• 502 大概什么什么原因？ 如何排查 504呢？ 传送门

  • 502: 请求的fpm由于某些原因没有执行完毕而终止执行(fpm已执行) max_children,request_terminate_timeout，fpm进程数不够，一般数据库有很多慢查询占用进程数
  • 504：与nginx有关(没有请求到可执行的fpm) fastcgi_connect_timeout fastcgi_send_timeout fastcgi_send_timeout，如nginx的buffer设置太小而挂起504

架构篇

• 偏运维（了解）：

  • 负载均衡（Nginx、HAProxy、DNS）
  • 主从复制（MySQL、Redis）
    • redis主从复制
  • 数据冗余、备份（MySQL增量、全量 原理）
  • 监控检查（分存活、服务可用两个维度）
  • MySQL、Redis、Memcached Proxy 、Cluster 目的、原理
  • mysql分片
  • 高可用集群
  • RAID
  • 源代码编译、内存调优

• 缓存

  • 工作中遇到哪里需要缓存，分别简述为什么

• 搜索解决方案 es+solr+lucene

• 性能调优

• 各维度监控方案 传送门

• 日志收集集中处理方案 ELK

• 国际化(传送门)[]

• 数据库设计 传送门

• 静态化方案 传送门

• 画出常见 PHP 应用架构图 传送门

• kafka消息队列

  • 原理图

  • 知识点

  • 面试题

  • nsq对比

    1 2 3

    通过nsqlookup注册和发现服务，去中心化 nsq通过先写内存，再刷硬盘，而kafka直接刷硬盘 nsq更适合二开，和规模小的MQ需求

• 压测工具 apache的ab，java的jmeter

框架篇

• ThinkPHP（TP）、CodeIgniter（CI）、Zend（非 OOP 系列）
• Yaf、Phalcon（C 扩展系）
• Yii、Laravel、Symfony（纯 OOP 系列）
• Swoole、Workerman （网络编程框架）
• 对比框架区别几个方向点
  • 是否纯 OOP
  • 类库加载方式（自己写 autoload 对比 composer 标准）
  • 易用性方向（CI 基础框架，Laravel 这种就是高开发效率框架以及基础组件多少）
  • 黑盒（相比 C 扩展系）
  • 运行速度（如：Laravel 加载一大堆东西）
  • 内存占用

设计模式

• 单例模式（重点）

  • 实现方式
  • 注意：construct&clone()防止被重写，
  • 单例缺点：

  1 2 3 4

  1.多线程运行，实例未创建导致创建多实例 2. 多进程运行，子进程使用父进程实例有问题 3.长时间不使用会被GC回收 4.单一拓展困难

• 工厂模式（重点）

• 观察者模式（重点）传送门

  • 主题Subject实现attach detach notify 观察者Observer实现update()

• 依赖注入（重点）传送门

  • 依赖注入DI: 具有Interface的工厂类，能力实现在外部
  • 控制反转IOC：DI上的容器container概念，make &bind活用闭包实现
  • 主要概念：超人由固定多能力转换成外部赋予单一能力

• 装饰器模式 传送门

• 代理模式 传送门

  • Proxy代理&RealSubject实现Subject的接口方法
  • 可以理解成代理服务器

• 组合模式

安全篇

• SQL 注入
  • mysql_real_escape_string mysqli和pdo 预处理
• XSS 与 CSRF
  • htmlspecialchars过滤 get post区分 token 和 referer校验
• 输入过滤 (goto)[https://laravelacademy.org/post/4610.html]
• Cookie 安全
  • https + AES加密 + 加salt + httponly
• 禁用 mysql_ 系函数
• 数据库存储用户密码时，应该是怎么做才安全 (sha加密 md5+salt)
• 验证码 Session 问题 验证通过后清空
• 安全的 Session ID （让即使拦截后，也无法模拟使用）
  • 位数长，固定时间无效,重要业务加独立密码
• 目录权限安全 770 750 640
• 包含本地与远程文件
  • allow_url_include 开启
• 文件上传 PHP 脚本
  • 检查文件头部 后缀名，重命名文件
• eval 函数执行脚本
• disable_functions 关闭高危函数
• FPM 独立用户与组，给每个目录特定权限
• 了解 Hash 与 Encrypt 区别
  • hash不可逆但能被穷举
  • encrypt 可逆

高阶篇

• PHP 数组底层实现 （HashTable + Linked list）传送

1
2
3

1. 查找：key先time33算法再中间映射表找到下标然后找到对应bucket，然后遍历bucket当key相当返回数据，索引数组和字符数组的覆盖原因
2. 插入&删除：影响索引，按2倍拓容，仅当触发阈值才删除
3. 有序：bucket双向链表存储，避免hash冲突

• Copy on write 原理，何时 GC

  • (手册)[http://php.net/manual/zh/features.gc.php]

  • (其余)[https://www.jianshu.com/p/d73b3ca418b0]

  • 实例代码

    1 2 3

    $a = array( 'one' ); $a[] =& $a; unset($a);

• PHP 进程模型，进程通讯方式，进程线程区别

  • php 进程模型
  • php 进程通讯
  • 进程线程区别
  • 进程的状态

• 僵尸进程和孤儿进程和守护进程

  • 孤儿进程： 一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作
  • 僵尸进程： 一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程（ps 进程状态’Z’）

• yield 核心原理是什么 传送门

• PDO prepare 原理 (绑定变量 相当于预设输入是字符串)

• PHP 7 与 PHP 5 区别 原因

1
2
3
4

1. JIT:opcache的增强版本
2. zval的改变
3. php数组变化
4. 函数调用机制

• Swoole 适用场景，协程实现方式 swoole文档

前端篇

• 原生获取 DOM 节点，属性
• 盒子模型
• CSS 文件、style 标签、行内 style 属性优先级
• HTML 与 JS 运行顺序（页面 JS 从上到下）
• JS 数组操作
• 类型判断
• this 作用域
• .map() 与 this 具体使用场景分析
• Cookie 读写
• JQuery 操作
• Ajax 请求（同步、异步区别）随机数禁止缓存
• Bootstrap 有什么好处
• 跨域请求 N 种解决方案
• 新技术（了解）
  • ES6
  • 模块化
  • 打包
  • 构建工具
  • vue、react、webpack、
  • 前端 mvc
• 优化
  • 浏览器单域名并发数限制
  • 静态资源缓存 304 （If-Modified-Since 以及 Etag 原理）
  • 多个小图标合并使用 position 定位技术 减少请求
  • 静态资源合为单次请求 并压缩
  • CDN
  • 静态资源延迟加载技术、预加载技术
  • keep-alive
  • CSS 在头部，JS 在尾部的优化（原理）

网络篇

• IP 地址转 INT
• 192.168.0.1/16 是什么意思 解析 在线转换
• DNS 主要作用是什么？
• IPv4 与 v6 区别

网络编程篇

• TCP 三次握手 四次挥手流程 传送门

  • 三次握手 server半连接，伪造大量syn包造成ddos攻击

• TCP&UDP区别，分别适用场景 传送门

• OSI七层协议 缩写 物链网 传输会话表示应用

• 有什么办法能保证 UDP 高可用性(了解)

• TCP 粘包如何解决？原因及处理

• 为什么需要心跳？ 传送门

  • TCP并无及时的断线检测
  • TCP的keepalive能检查deadLink，但影响全局

• 什么是长连接？

• HTTPS 是怎么保证安全的？解析 流程图解

  • 非对称加密+对称加密SSL: 服务器明文传输公钥->客服端使用公钥加密得到密文（对称加密的秘钥x）-> 服务器私钥解密得到对称加密的秘钥x->服务器&客服端使用秘钥x进行对称加密传输数据
  • 第三方认证机构的CA证书：hash

• 流与数据报的区别 解析

  • tcp流模式协议，可靠
  • udp数据报模式，数据可能会丢失

• http 1.0 1.1 2.0有哪些改变 参考

  • http 1.0： 增加POST HEADER，支持请求头和相应头，扩充了传输内容格式Content-Type

  • http1.1 ：

    1 2 3 4

    1. 增加PUT DETELE 2. 支持长连接Connection，可以设置keep-alive保持连接不断开 3. 支持缓存 cache-control，客户端的静态文件缓存 4. 支持断点重传，Content-Range: bytes 0-499/22400

  • http2.0

    1 2 3 4

    二进制分帧: HTTP2之后将所有传输的信息分割为更小的消息和帧，并对它们采用二进制格式的编码，提高传输效率 多路复用：在共享TCP链接的基础上同时发送请求和响应 头部压缩: 维护一个头部信息字典，差量进行更新头信息，减少头部信息传输占用的资源 服务器推送：服务器可以额外的向客户端推送资源，而无需客户端明确的请求

• http 断点重传原理 goto

• 进程间通信几种方式，最快的是哪种？解析

  1 2 3 4 5

  1.管道：速度慢，容量有限，只有父子进程能通讯 2.FIFO：任何进程间都能通讯，但速度慢 3.消息队列：容量受到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题 4.信号量：不能传递复杂消息，只能用来同步 5.共享内存区：能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题，相当于线程中的线程安全，当然，共享内存区同样可以用作线程间通讯，不过没这个必要，线程间本来就已经共享了同一进程内的一块内存

• fork() 会发生什么？

  • pid=0:子进程 pid=-1：错误失败 pid=1:父进程

API 篇

• RESTful 是什么 阮一峰

  • 如何设计RESTful 阮一峰
  • php 实现RESTful

• 如何在不支持 DELETE 请求的浏览器上兼容 DELETE 请求

  • form表单添加 < input type = hidden name = _method value = DELETE>

• 常见 API 的 APP_ID APP_SECRET 主要作用是什么？阐述下流程

  • app_id 开发者账号，app_key(账号权限)+app_secret(账号密码) 传送门

• API 请求如何保证数据不被篡改？

  • https，sign排序签名，数据加密

• JSON 和 JSONP 的区别 goto

  • jsonp支持跨域，附带callback，header支持Access-Control-Allow-Origin:domain

• 数据加密和验签的区别 传送门

  • 数据加密 公钥加密，私钥解密，保证接收方数据安全
  • 数据签名 私钥加密，公钥解密，保证发送方数据安全，确保自己发送而不是别人

• RSA非对称加密 是什么 goto

• API 版本兼容怎么处理 传送门

  • url参数加版本号?v=2, header头部添加版本号
  • 通过token参数 服务端确认权限和版本
  • token 生成原理 传送门

  1 2	1. api_token = md5 ('模块名' + '控制器名' + '方法名' + '2017-07-18' + '加密密钥') = 770fed4ca2aabd20ae9a5dd774711de2 2. user_token = user_id + 过期时间 + 加密密钥

• 限流漏桶、令牌桶 传送门

  • 漏桶算法：强调流出速率，以恒定速率处理请求，水满则溢出拒绝服务，类似消息队列
  • 令牌桶： 强调流入，以一定速率往桶里加令牌，处理请求则获取一个令牌，桶满则不加令牌，优点在于能调整令牌加入速率（google Guava的RateLimiter）

• OAuth 2 主要用在哪些场景下 rbac呢

  • oauth2 流程
  • 接口授权，用户权限
  • oauth2：按规则认证，权限粒度更细（查看按钮）。rbac基于节点认证，粒度比较大

• JWT 传送门

• PHP 中 json_encode(['key'=>123]); 与 return json_encode([]); 区别，会产生什么问题？如何解决

  • 输出

    1 2 3 4 5 6

    json_encode(['key'=>123]); return json_encode([]); #输出 string(11) "{"key":123}" string(2) "[]"

    • 区别 {}是对象（key是string），[]是数组（key是int） (传送门)[https://blog.csdn.net/weihuiblog/article/details/79124364]

拓展项

• 了解常用语言特性，及不同场景适用性。
  • PHP VS Golang
  • PHP VS Python
  • PHP VS JAVA
• 了解 PHP 扩展开发
• 熟练掌握 C