1. 什么是缓存以及缓存的应用场景
2. 从架构的发展看缓存的使用
3. 从单体、集群和微服务看缓存的使用
4. 缓存的分类以及它们的应用场景
5. 缓存定义的规范

动手学习篇

1. 常见缓存框架的技术选型
2. 每个常见缓存框架的原理及使用
3. 解读 Redis 常见的命令
4. 解读 Redis6.0 多线程模型

时间技巧篇

1. 缓存穿透、并发、雪崩的发生场景及破解技巧
2. 如何保证缓存一致性
3. 如何实现分布式并发锁
4. 如何部署多机房场景下的缓存
5. 自己实现一个基本的缓存框架

综合案例篇

配置中心的缓存案例

1. 配置中心架构
2. 配置中心如何保存配置数据

秒杀场景的缓存案例

1. 秒杀的业务架构
2. 秒杀如何利用缓存实现库存扣减

支付中台的缓存案例

1. 支付中台业务架构
2. 支付中台通知中心架构
3. 通知中心如何利用 redis 保存和发送消息

参考

课件地址

• 分布式session
• 热点排名
• 计数器
• 发布订阅
• 分布式锁

缓存分类

客户端缓存分类

1. 页面缓存
2. 浏览器缓存
3. APP 缓存

服务端缓存分类

1. 数据库缓存
2. 平台级缓存(Ehcache,Jboss Cache, OSCache,Guava Cache)
3. 应用级缓存(CDN, Redis, Memcached)

缓存的淘汰策略

1. FIFO：First In First Out，先进先出。判断被存储的时间，离目前最远的数据优先被淘汰。
2. LRU：Least Recently Used，最近最少使用。判断最近被使用的时间，目前最远的数据优先被淘汰。
3. LFU：Least Frequently Used，最不经常使用。在一段时间内，数据被使用次数最少的，优先被淘汰。

参考

课件地址
Redis maxmemory-policy 淘汰策略

测试环境
PHP version 5.3.29/5.6.29/7.1.0
Apache/2.4.25 (Win32) mod_fcgid/2.3.9

问题描述

Apache使用mod_fcgid 配置php出现的问题：在php.ini中配置output_buffering = Off或者output_buffering = 4096 均不能使用ob_flush()和flush()刷出缓冲区内容

在php.ini中设置缓冲区
output_buffering = 4096 ;开启php缓冲区
output_buffering = Off ;关闭php缓冲区

问题分析

1. 在不同版本的php.ini中均关闭缓冲区，测试发现全都不生效，排除php.ini配置文件的问题；
2. 由于三个版本的php是由mod_fcgid配置的，初步定位是mod_fcgid配置问题。

解决办法

1. 查找官方文档发现，FcgidOutputBufferSize配置信息如下：mod_fcgid document

   Description: CGI output buffer size Syntax: FcgidOutputBufferSize bytes Default: FcgidOutputBufferSize 65536 Context: server config, virtual host Status: External Module: mod_fcgid

2. Apache mod_fcgid模式默认为开启buffer，所以在Apache配置文件中设置 FcgidOutputBufferSize 0

3. 重新测试代码，发现ob_flush()和flush()函数可用，即php.ini中配置缓冲区信息生效。

测试代码

测试要求在浏览器中间隔一秒出现一个数字：
一次php代码文件请求涉及两个缓冲区：

1. php缓冲区：php编译生成的静态内容首先被php缓冲区收集，之后再对外输出;
2. browser缓冲区：从服务器过来的内容到达浏览器里边的时候，首先被浏览器缓冲区收集，收集满之后再逐渐展示到页面上;

<?php
    //提前开启缓冲区，在php.ini中配置output_buffering = 4096;
    //提前开启缓冲区，或者在运行时设置ob_start();
    for($i=0;$i<5;$i++){
        echo $i,'<br/>';
        ob_flush(); //刷出php缓冲区内容
        flush(); //刷出浏览器缓冲区内容
        sleep(1);
    }

在终端输入 go help 可显示所有的命令及功能简介，比较常用的有：

• go build 用于编译我们指定的源码文件或代码包以及它们的依赖包
• go get 根据要求和实际情况从互联网上下载或更新指定的代码包及其依赖包，并对它们进行编译和安装。
• go test 用于对Go语言编写的程序进行测试
• go clean 删除掉执行其它命令时产生的一些文件和目录
• go env 用于打印Go语言的环境信息

每个命令的参数可以用 go help <command> 查看

Go is a tool for managing Go source code.

Usage:

	go <command> [arguments]

The commands are:

	bug         start a bug report
	build       compile packages and dependencies
	clean       remove object files and cached files
	doc         show documentation for package or symbol
	env         print Go environment information
	fix         update packages to use new APIs
	fmt         gofmt (reformat) package sources
	generate    generate Go files by processing source
	get         download and install packages and dependencies
	install     compile and install packages and dependencies
	list        list packages or modules
	mod         module maintenance
	run         compile and run Go program
	test        test packages
	tool        run specified go tool
	version     print Go version
	vet         report likely mistakes in packages

Use "go help <command>" for more information about a command.

Additional help topics:

	buildmode   build modes
	c           calling between Go and C
	cache       build and test caching
	environment environment variables
	filetype    file types
	go.mod      the go.mod file
	gopath      GOPATH environment variable
	gopath-get  legacy GOPATH go get
	goproxy     module proxy protocol
	importpath  import path syntax
	modules     modules, module versions, and more
	module-get  module-aware go get
	module-auth module authentication using go.sum
	module-private module configuration for non-public modules
	packages    package lists and patterns
	testflag    testing flags
	testfunc    testing functions

Use "go help <topic>" for more information about that topic.

参考

• Go 命令教程-极客学院
• About the go command
• Command go

本文不定期汇总 go 学习资源，包括但不限于框架文档，开源图书，论坛等

社区

• Awesome Go
• Go 语言中文网
• GoCN Forum

Library

• Go语言标准库

Framework

• gin-github
• Go gin Example
• beego
• go-micro

ORM

• GORM

书籍

• Go 入门指南
• Go 语言圣经
• Go语言高级编程(Advanced Go Programming)
• Build Web Application with Golang
• Go 语言四十二章经
• GO专家编程
• 浅谈 Go 语言实现原理
• 煎鱼的迷之博客
• 通过 Go 语言学习测试驱动开发
• go101
• 深入解析Go
• Go RPC 开发指南
• go 语言并发编程

1. 编码
   1. golang 默认编码是 utf-8;
   2. golang 中 string 底层是通过 byte数组 实现的;
   3. 中文字符在unicode下占2个字节，在utf-8编码下占3个字节;
2. 基础数据类型
   1. rune 数据类型是 int32 的别名，常用来处理unicode或utf-8字符，例如汉字的长度使用 len([]rune("你好"));
   2. byte 数据类型是 uint8 的别名，常用来处理ascii字符
3. rand 包实现了用于加解密的更安全的随机数生成器
   1. rand.Seed(time.Now().UnixNano()) 设置随机种子
   2. rand.NewSource(time.Now().UnixNano())
   3. Intn()
   4. Int63()
4. strings 包实现了用于操作字符的简单函数
   1. strings.Builder
   2. WriteByte()
   3. String()

结论

1. 如果字符串是英文字母大小写，可以用 byte 代替 rune，速度提升 22% ，内存分配减少了 67%
2. 用 rand.Int63() 代替 rand.Intn() 速度提升 21%
3. 使用位运算性能下降了 22% ，但是充分利用 rand.Int63() 速度可提升 3 倍
4. 使用 rand.Source() 代替 rand.Rand() 速度提升 17%
5. 使用 strings.Builder 速度提升不大，但是内存分配减少 50%
6. 使用 unsafe 代替 strings.Builder 速度提升 14%
7. 优化到最后，与第一个生成随机字符串的方法对比可发现速度提升了 6 倍，内存分配减少了 83%

goos: darwin
goarch: amd64
pkg: study/cmd
BenchmarkRunes-8                         2000000               568 ns/op              96 B/op          2 allocs/op
BenchmarkBytes-8                         3000000               442 ns/op              32 B/op          2 allocs/op
BenchmarkBytesRmndr-8                    5000000               347 ns/op              32 B/op          2 allocs/op
BenchmarkBytesMask-8                     3000000               422 ns/op              32 B/op          2 allocs/op
BenchmarkBytesMaskImpr-8                10000000               138 ns/op              32 B/op          2 allocs/op
BenchmarkBytesMaskImprSrc-8             20000000               115 ns/op              32 B/op          2 allocs/op
BenchmarkBytesMaskImprSrcSB-8           20000000               109 ns/op              16 B/op          1 allocs/op
BenchmarkBytesMaskImprSrcUnsafe-8       20000000                94.3 ns/op            16 B/op          1 allocs/op
PASS
ok      study/cmd       15.894s

随机生成固定长度字符串方法

random.go 文件
以下代码来自于参考链接

package main

import (
	"math/rand"
	"strings"
	"time"
	"unsafe"
)

// Implementations

func init() {
	rand.Seed(time.Now().UnixNano())
}

var letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

func RandStringRunes(n int) string {
	b := make([]rune, n)
	for i := range b {
		b[i] = letterRunes[rand.Intn(len(letterRunes))]
	}
	return string(b)
}

const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
const (
	letterIdxBits = 6                    // 6 bits to represent a letter index
	letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
	letterIdxMax  = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
)

func RandStringBytes(n int) string {
	b := make([]byte, n)
	for i := range b {
		b[i] = letterBytes[rand.Intn(len(letterBytes))]
	}
	return string(b)
}

func RandStringBytesRmndr(n int) string {
	b := make([]byte, n)
	for i := range b {
		b[i] = letterBytes[rand.Int63()%int64(len(letterBytes))]
	}
	return string(b)
}

func RandStringBytesMask(n int) string {
	b := make([]byte, n)
	for i := 0; i < n; {
		if idx := int(rand.Int63() & letterIdxMask); idx < len(letterBytes) {
			b[i] = letterBytes[idx]
			i++
		}
	}
	return string(b)
}

func RandStringBytesMaskImpr(n int) string {
	b := make([]byte, n)
	// A rand.Int63() generates 63 random bits, enough for letterIdxMax letters!
	for i, cache, remain := n-1, rand.Int63(), letterIdxMax; i >= 0; {
		if remain == 0 {
			cache, remain = rand.Int63(), letterIdxMax
		}
		if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
			b[i] = letterBytes[idx]
			i--
		}
		cache >>= letterIdxBits
		remain--
	}

	return string(b)
}

var src = rand.NewSource(time.Now().UnixNano())

func RandStringBytesMaskImprSrc(n int) string {
	b := make([]byte, n)
	// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
	for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
		if remain == 0 {
			cache, remain = src.Int63(), letterIdxMax
		}
		if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
			b[i] = letterBytes[idx]
			i--
		}
		cache >>= letterIdxBits
		remain--
	}

	return string(b)
}

func RandStringBytesMaskImprSrcSB(n int) string {
	sb := strings.Builder{}
	sb.Grow(n)
	// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
	for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
		if remain == 0 {
			cache, remain = src.Int63(), letterIdxMax
		}
		if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
			sb.WriteByte(letterBytes[idx])
			i--
		}
		cache >>= letterIdxBits
		remain--
	}

	return sb.String()
}

func RandStringBytesMaskImprSrcUnsafe(n int) string {
	b := make([]byte, n)
	// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
	for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
		if remain == 0 {
			cache, remain = src.Int63(), letterIdxMax
		}
		if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
			b[i] = letterBytes[idx]
			i--
		}
		cache >>= letterIdxBits
		remain--
	}

	return *(*string)(unsafe.Pointer(&b))
}

基准测试代码

新建 random_test.go 文件，执行测试命令 go test -benchmem study/cmd -bench .
以下代码来自于参考链接

package main

import "testing"

// Benchmark functions
const n = 16

func BenchmarkRunes(b *testing.B) {
	for i := 0; i < b.N; i++ {
		RandStringRunes(n)
	}
}

func BenchmarkBytes(b *testing.B) {
	for i := 0; i < b.N; i++ {
		RandStringBytes(n)
	}
}

func BenchmarkBytesRmndr(b *testing.B) {
	for i := 0; i < b.N; i++ {
		RandStringBytesRmndr(n)
	}
}

func BenchmarkBytesMask(b *testing.B) {
	for i := 0; i < b.N; i++ {
		RandStringBytesMask(n)
	}
}

func BenchmarkBytesMaskImpr(b *testing.B) {
	for i := 0; i < b.N; i++ {
		RandStringBytesMaskImpr(n)
	}
}

func BenchmarkBytesMaskImprSrc(b *testing.B) {
	for i := 0; i < b.N; i++ {
		RandStringBytesMaskImprSrc(n)
	}
}
func BenchmarkBytesMaskImprSrcSB(b *testing.B) {
	for i := 0; i < b.N; i++ {
		RandStringBytesMaskImprSrcSB(n)
	}
}

func BenchmarkBytesMaskImprSrcUnsafe(b *testing.B) {
	for i := 0; i < b.N; i++ {
		RandStringBytesMaskImprSrcUnsafe(n)
	}
}

参考

• how to generate a random string of a fixed length in go

1.存储引擎其实就是如何实现存储数据，如何为存储的数据建立索引以及如何更新，查询数据等技术实现的方法。

2.MySQL中的数据用各种不同的技术存储在文件（或内存）中，这些技术中的每一种技术都使用不同的存储机制，索引技巧，锁定水平并且最终提供广泛的不同功能和能力。在MySQL中将这些不同的技术及配套的相关功能称为存储引擎。

查看数据库存储引擎

1.show engines;//查看MySQL支持的存储引擎
2.show variables like '% storage_engine';//查看默认支持的存储引擎
3.show create table tablename ; //查看某个表使用的存储引擎
4.show table status from database where name="tablename";// 查看某个数据库中某个数据表存储引擎

常用存储引擎的特点

MySQL中常用的几种存储引擎：MyISAM、InnoDB、bdb、MEMORY，对比如下：

MyISAM存储引擎

每一个表在MyISAM存储引擎中都以三个以表名命名的物理文件构成。

1. 任何存储引擎都不可或缺的存放表结构定义的.frm（Form）文件
2. 存放表数据的.MYD文件（My Data）
3. 存放索引数据的.MYI文件（My Index）

1. MyISAM 这种存储引擎不支持事务，不支持行级锁，只支持并发插入的表锁，主要用于高负载的select。所以其写入的并发处理能力相对较弱。
2. MyISAM类型的数据表（.MYD文件）支持三种不同的存储结构：静态型、动态型、压缩型。

静态型：就是定义的表列的大小是固定（即不含有：xblob、xtext、varchar等长度可变的数据类型），这样mysql就会自动使用静态myisam格式。

使用静态格式的表的性能比较高，因为在维护和访问的时候以预定格式存储数据时需要的开销很低。但是这高性能是有空间换来的，因为在定义的时候是固定的，所以不管列中的值有多大，都会以最大值为准，占据了整个空间。

动态型：如果列（即使只有一列）定义为动态的（xblob, xtext, varchar等数据类型），这时myisam就自动使用动态型，虽然动态型的表占用了比静态型表较少的空间，但带来了性能的降低，因为如果某个字段的内容发生改变则其位置很可能需要移动，这样就会导致碎片的产生。随着数据变化的怎多，碎片就会增加，数据访问性能就会相应的降低。

对于因为碎片的原因而降低数据访问性，有两种解决办法：

@1.尽可能使用静态数据类型
@2.经常使用optimize table语句，他会整理表的碎片，恢复由于表的更新和删除导致的空间丢失。
(如果存储引擎不支持 optimize table 则可以转储并重新加载数据，这样也可以减少碎片)

压缩型：如果在这个数据库中创建的是在整个生命周期内只读的表，则这种情况就是用myisam的压缩型表来减少空间的占用。

3. 支持的索引类型有：B-Tree,R-Tree,Full-Text索引

4. COUNT(*)问题——MyISAM存储引擎记录表行数，所以在使用COUNT(*)时，只需取出存储的行数，而不用遍历表，效率较高。

innoDB存储引擎

1. 同MyISAM一样的是，InnoDB存储引擎也有.frm文件存储表结构定义
2. 与MyISAM不同的是，InnoDB的表数据与索引数据是存储在一起的，保存为.ibd文件（聚簇索引的形式存储数据），但在这个文件中每张表是独自占有一块表空间还是共享所有表空间，是由用户决定的（设置 set global innodb_file_per_table = 1;即可每张表独占一块表空间）。如果独享表空间，每个表的表数据与索引数据都会存放在一个.ibd(innoDB data)文件中；如果是共享表空间，通过innodb_data_file_path指定后，每次增加数据文件后必须停机重启才能生效，很不方便。

1. innodb存储引擎该mysql表提供了事务，回滚以及系统崩溃修复能力和多版本迸发控制的事务的安全。

   InnoDB有支持事务及安全的日志文件，这个文件非常重要，InnoDB可以通过日志文件将数据库崩溃时已经完成但还没来得及将内存中已经修改但未完全写入磁盘的数据写入磁盘，也可以把已部分完成并写入磁盘的未完成事务回滚，保证数据一致性。如果错误删除日志文件会导致数据库崩溃且无法启动。

2. innodb支持自增长列（auto_increment）,自增长列的值不能为空，如果在使用的时候为空的话就会进行自动存现有的值开始增值，如果有但是比现在的还大，则就保存这个值。

3. innodb存储引擎支持外键（foreign key） ,外键所在的表称为子表而所依赖的表称为父表。

4. innodb存储引擎支持MVCC的行级锁，为承受高并发增加了竞争力。

5. 增删改查性能——如果执行大量的增删改操作，推荐使用InnoDB存储引擎，它在删除操作时是对行删除，不会重建表。

6. COUNT(*)问题——InnoDB存储引擎会遍历表以计算数量，效率较低。

MEMORY存储引擎

1. memory存储引擎相比前面的一些存储引擎，有点不一样，其使用存储在内存中的数据来创建表，而且所有的数据也都存储在内存中。正因为如此，如果mysqld进程发生异常，重启或关闭机器这些数据都会消失。所以memory存储引擎中的表的生命周期很短，一般只使用一次。

2. 每个基于memory存储引擎的表实际对应一个磁盘文件，该文件的文件名和表名是相同的，类型为.frm。该文件只存储表的结构，而其数据文件，都是存储在内存中，这样有利于对数据的快速处理，提高整个表的处理能力。

3. memory存储引擎默认使用哈希（HASH）索引，其速度比使用B-Tree型要快，如果读者希望使用B树型，则在创建的时候可以引用。

存储引之间的相互转化

1. alter table tablename engine = Innodb /MyISAM/Memory ; //修改这个表的存储引擎

优点：简单，而且适合所有的引擎。

缺点：

1. 这种转化方式需要大量的时间 和I/O，mysql要执行从旧表 到新表的一行一行的复制所以效率比较低
2. 在转化这期间源表加了读锁
3. 从一种引擎到另一种引擎做表转化，所有属于原始引擎的专用特性都会丢失，比如从innodb到 myisam 则 innodb的索引会丢失！

2.使用dump（转储） import（导入）

优点：使用mysqldump这个工具将修改的数据导出后会以 .sql 的文件保存，你可以对这个文件进行操作，所以你有更多更好的控制， 如修改表名，修改存储引擎等！

3、第一种方式简便，第二种方式安全，这第三种方式算是前两种方式的折中，create select:

1. create table newtable like oldtable;

2. alter table newtable engine= innodb/ myisam / memory

3. insert into newtable select * from oldtable;

如果数据量不大的话这种方式还是挺好的！

还有更高效的办法就是增量填充，在填充完每个增量数据块之后提交一次事务，这样就不会导致撤销日志文件过大；

1. start transaction;
2. insert into newtable select * from oldtable where id(主键) between x and y;
3. commit;

这样等数据填充之后有了需要的新表，旧表也存在。

知乎大神给的优化顺序如下：

1. 优化 SQL 和索引；
2. 加入缓存，如 Memcached，Redis等；
3. 主从复制或者主主复制，进行读写分离；
4. MySQL 自带分区表，sql 语句针对分区表做优化(查询条件上带上分区条件的列)，将查询定位到少量的分区上，避免扫描全部分区；
5. 垂直分区，根据模块耦合度将大系统切分为小系统；
6. 水平分区，此操作改动的较多，涉及到表结构的变动，逆范式，sharding等。

优化方案汇总

1. 对查询进行优化，要尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。
2. 应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描。

   select id from t where num is null;
   最好不要给数据库留NULL，尽可能的使用 NOT NULL填充数据库.
   备注、描述、评论之类的可以设置为 NULL，其他的，最好不要使用NULL。
   不要以为 NULL 不需要空间，比如：char(100) 型，在字段建立时，空间就固定了， 不管是否插入值（NULL也包含在内），都是占用 100个字符的空间的，如果是varchar这样的变长字段， null 不占用空间。
   可以在num上设置默认值0，确保表中num列没有null值。

3. 应尽量避免在 where 子句中使用 != 或 <> 操作符，否则将引擎放弃使用索引而进行全表扫描。
4. OR 原则应尽量避免在 where 子句中使用 or 来连接条件，如果一个字段有索引，一个字段没有索引，将导致引擎放弃使用索引而进行全表扫描。

   select id from t where num=10 or Name = 'admin'
   改进方法：
   select id from t where num = 10
union all
select id from t where Name = 'admin'
   联合查询 union all比union更有效，因为union all只是简单的将两个结果集进行合并，并且不会去重，union 默认带distinct属性，会对筛选后的结果去重，并且按照字段的顺序排序；

5. in 和 not in 也要慎用，否则会导致全表扫描。

select id from t where num in(1,2,3);
对于连续的数值，能用 between 就不要用 in 了：
select id from t where num between 1 and 3;
很多时候用 exists 代替 in 是一个好的选择：
select num from a where num in(select num from b);
用下面的语句替换：
select num from a where exists(select 1 from b where num=a.num);

1. 下面的查询也将导致全表扫描，若要提高效率，可以考虑全文检索。

   select id from t where name like '%abc%'

2. 如果在 where 子句中使用参数，也会导致全表扫描。因为SQL只有在运行时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运行时；它必须在编译时进行选择。然 而，如果在编译时建立访问计划，变量的值还是未知的，因而无法作为索引选择的输入项。如下面语句将进行全表扫描：

   select id from t where num = @num;
   可以改为强制查询使用索引：
   select id from t with(index(索引名)) where num = @num;

3. 字段独立原则 应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：

   select id from t where num/2 = 100;
   应改为:
   select id from t where num = 100*2;

4. 应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。如：

   select id from t where substring(name,1,3) = 'abc'; -– name以abc开头的id
select id from t where datediff(day,createdate,'2005-11-30') = 0 ; -– '2005-11-30' 生成的id
   应改为:
   select id from t where name like 'abc%';
select id from t where createdate >= '2005-11-30' and createdate < '2005-12-1';

5. 不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。

6. 左原则 在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致。

7. 不要写一些没有意义的查询，如需要生成一个空表结构：

   select col1,col2 into #t from t where 1=0;
   这类代码不会返回任何结果集，但是会消耗系统资源的，应改成这样：
   create table #t(…);

8. Update 语句，如果只更改1、2个字段，不要Update全部字段，否则频繁调用会引起明显的性能消耗，同时带来大量日志。

9. 对于多张大数据量（这里几百条就算大了）的表JOIN，要先分页再JOIN，否则逻辑读会很高，性能很差。

10. select count(*) from table；这样不带任何条件的count会引起全表扫描，并且没有任何业务意义，是一定要杜绝的。

11. 索引并不是越多越好，索引固然可以提高相应的 select 的效率，但同时也降低了 insert 及 update 的效率，因为 insert 或 update 时有可能会重建索引，所以怎样建索引需要慎重考虑，视具体情况而定。一个表的索引数最好不要超过6个，若太多则应考虑一些不常使用到的列上建的索引是否有必要。

12. 应尽可能的避免更新 clustered 索引数据列，因为 clustered 索引数据列的顺序就是表记录的物理存储顺序，一旦该列值改变将导致整个表记录的顺序的调整，会耗费相当大的资源。若应用系统需要频繁更新 clustered 索引数据列，那么需要考虑是否应将该索引建为 clustered 索引。

13. 尽量使用数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。

14. 任何地方都不要使用 select * from t ，用具体的字段列表代替“*”，不要返回用不到的任何字段。

15. 尽量使用表变量来代替临时表。如果表变量包含大量数据，请注意索引非常有限（只有主键索引）。

16. 避免频繁创建和删除临时表，以减少系统表资源的消耗。临时表并不是不可使用，适当地使用它们可以使某些例程更有效，例如，当需要重复引用大型表或常用表中的某个数据集时。但是，对于一次性事件， 最好使用导出表

17. 在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，以提高速度；如果数据量不大，为了缓和系统表的资源，应先create table，然后insert。

18. 如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。

DROP TABLE 用于删除表（表的结构、属性以及索引也会被删除）;
TRUNCATE TABLE DDL语言,无法回退，默认所有的表内容都删除，删除速度比delete快，操作不触发trigger，不能用于参与了索引视图的表。；
DELETE DML语言，可以回退，可以有条件的删除，每次删除一行，并在事务日志中为所删除的每行记录一项；

1. 尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过1万行，那么就应该考虑改写。
2. 使用基于游标的方法或临时表方法之前，应先寻找基于集的解决方案来解决问题，基于集的方法通常更有效。
3. 与临时表一样，游标并不是不可使用。对小型数据集使用 FAST_FORWARD 游标通常要优于其他逐行处理方法，尤其是在必须引用几个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要比使用游标执行的速度快。如果开发时 间允许，基于游标的方法和基于集的方法都可以尝试一下，看哪一种方法的效果更好。
4. 在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ，在结束时设置 SET NOCOUNT OFF 。无需在执行存储过程和触发器的每个语句后向客户端发送 DONE_IN_PROC 消息。
5. 尽量避免大事务操作，提高系统并发能力。
6. 尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理。

友情链接

• 数据库SQL优化大总结之 百万级数据库优化方案
• MySQL 对于千万级的大表要怎么优化？

• DDL (Data Definition Language) 数据库定义语言
• DML (Data Manipulation Language) 数据操作语言
• DCL (Data Control Language) 数据库控制语言
• TCL (Transaction Control Language) 事务控制语言

DDL

用于定义SQL模式、基本表、视图和索引的创建和撤消操作，在建表的时候使用。

• CREATE
• ALTER
• DROP
• TRUNCATE
• COMMIT
• RENAME

DML

数据操纵分成数据查询和数据更新两类。数据更新又分成插入、删除、和修改三种操作。

• SELECT
• INSERT
• UPDATE
• DELETE
• MERGE
• CALL
• EXPLAIN PLAN
• LOCK TABLE
  SELECT 也可以称为DQL语言

DCL

包括对基本表和视图的授权，完整性规则的描述，事务控制等内容。

• GRANT
• REVOKE

TCL

事务控制，设置保存点，回滚，改变事务选项，保存以完成的工作等

• COMMIT
• SAVEPOINT
• ROLLBACK
• SET TRANSACTION

1. 预处理语句

a. 执行预处理：$stmt = $pdo->prepare($sql);
  //sql语句中的参数使用？占位符或者 :para 命名参数进行占位
b. 设置参数$stmt->bindValue($parameter,$value);
  //注意使用？和：val占位符方式，此函数的参数标识符不同
c. 执行预处理语句：$stmt->execute();

2. 事务处理

a. 开启事务：$pdo->beginTransaction();
b. 提交事务：$pdo->commit();
c. 回滚事务：$pdo->rollBack();

3. 错误处理 try catch语句

原理

使用PDO需要PHP开启PDO扩展，使用步骤如下：

1. 在php.ini中开启extension=php_pdo_mysql.dll；
2. 设置dsn ，$dsn="mysql:host=localhost;port=3306;dbname=test_db";
3. 设置字符集，$opt=array(PDO::MYSQL_ATTR_INIT_COMMAND=>'set names utf8');
4. 实例化PDO对象，$pdo = new PDO($dsn,$user_name,$pwd,$opt);返回的是PDO对象
5. 执行语句，查询使用$pdo->query()返回的是结果集对象PDOStatement或false，增删改使用$pdo->exec()返回的是true or false;
6. 处理结果集对象$stmt->fetch(PDO::FETCH_ASSOC)或$stmt->fetchAll()
7. 关闭结果集$stmt->closeCursor();
8. 销毁PDO对象：$pdo = null;

场景

1. 预处理语句可以防SQL注入,“重复执行”多条结构类似的sql语句，避免重复分析/编译/优化周期；
2. 不同数据库使用相同的方法名，解决数据库连接不统一的问题。

实例

<?php
  $sql="select user_id,user_name,age,edu from user_list where user_id=:v1 and user_name=:v2";
  $stmt=$pdo->prepare($sql);
  $stmt->bindValue(":v1",6);   //占位符按自然顺序排,从1开始,user_id=6
  $stmt->bindValue(":v2",'user2');
  $stmt->execute();
  $arr=$stmt->fetch(PDO::FETCH_ASSOC);
  print_r($arr);

把 session 默认的存储方式由file 改为 redis 会提高速度，由于redis是在内存中读取的，其读取速度必然比在文件中读取速度快，同时解决了session共享的问题。

实现代码如下：

<?php
header('Content-type:text/html;charset=utf-8');
// 配置session 存储方式
ini_set('session.save_handler', 'redis');
ini_set('session.save_path', 'tcp://127.0.0.1:6379');
//开启session
session_start();

$_SESSION['Redis_session'] = ['name'=>'yann','string'=>'hello redis'];
//连接 Redis
$redis= new Redis();
$redis->connect('127.0.0.1',6379);
echo 'session_id:'.session_id();
echo "<br>";
//redis用session_id作为key
echo $redis->get('PHPREDIS_SESSION:' . session_id());

项目优化的时候，不要仅限于PHP 性能优化（占比30%~40%），还要注意其周边问题的性能优化。

PHP 代码运行流程

什么时候会出现性能问题？when

1. 语法使用不恰当；
2. 使用PHP 做它不擅长的事情；
3. 连接 PHP 的服务性能的问题；
4. PHP 自身短板；
5. 自己未知的问题；

优化方向

1. 语言级的性能优化，见效最快；
2. 周边问题的性能优化，如web server ，MySQL，缓存等；
3. php 语言自身分析和优化（底层代码分析）；

优化工具

安装：

Linux OS 中任意目录下执行 yum -y install httpd-tools
Windows OS 中 Apache bin 目录下自带 ab.exe

Apache Benchmark(ab)

./ab -n100 -c100 url地址 请求数和并发数要设置的少一点以免对正常使用的网站造成实际的影响
//重点关注以下解析结果：
Requests per second (每一秒钟处理的请求数)优化后要尽可能多
Time per request(每一个请求处理的时间)优化后要尽可能小

用法举例：

执行 ab -n100 -c100 http://www.baidu.com/

[root@iZ2zedvndklojgb9e7bppqZ ~]# ab -n100 -c100 http://www.baidu.com/
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking www.baidu.com (be patient).....done


Server Software:        BWS/1.1
Server Hostname:        www.baidu.com
Server Port:            80

Document Path:          /
Document Length:        102087 bytes

Concurrency Level:      100
Time taken for tests:   0.185 seconds
Complete requests:      100
Failed requests:        98
   (Connect: 0, Receive: 0, Length: 98, Exceptions: 0)
Write errors:           0
Total transferred:      10306408 bytes
HTML transferred:       10211042 bytes
Requests per second:    539.96 [#/sec] (mean)
Time per request:       185.199 [ms] (mean)
Time per request:       1.852 [ms] (mean, across all concurrent requests)
Transfer rate:          54346.14 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        3    4   0.7      4       6
Processing:    31   35  19.5     33     172
Waiting:        4   20  21.2     19     165
Total:         36   40  19.3     37     175

Percentage of the requests served within a certain time (ms)
  50%     37
  66%     37
  75%     37
  80%     37
  90%     37
  95%     38
  98%    173
  99%    175
 100%    175 (longest request)

优化点 How

语言级的性能优化

1. 少写代码降低代码冗余，多用 PHP 自身能力，多使用 PHP 内置变量，常量，函数；

   php代码运行流程：zend引擎扫描.php文件，Scanning之后将PHP代码转换成语言片段(Tokens),parsing之后将Tokens解析成自己能识别的格式，再编译成opcode（最终执行的机器码），然后顺次执行，输出。

2. PHP 内置函数之间，依然存在快慢差异，多了解 PHP 内置函数的时间复杂度；

   相同条件下isset（）比array_key_exists()时间消耗更少

3. 尽量少用魔术函数，省事的同时，牺牲了 PHP 的性能；

4. 错误抑制符@会产生额外的开销；

   在代码开始前，结束后增加Opcode，忽略报错信息。
   vld扩展 可以查看PHP Opcode，linux下安装步骤，源码编译在php.ini中开启此扩展。
   执行 php -dvld.active=1 -dvld.execute=0 xxx.php 可查看分析结果

5. 合理使用内存，虽然 PHP 有内存回收机制，但是可以利用unset()及时释放不使用的内存(unset()会出现注销不掉的情况)；

6. 正则表达式性能比较低，如果能利用字符串函数完成的，尽量少使用正则表达式；

7. 避免在循环内做运算，如在循环判断式中被重复计算；

8. PHP 不适合做密集型业务：大批量的日志分析、大批量数据处理、处理大数据；

9. 使用带引号的字符串当作键值，PHP 会将没有引号的键值当作常量，产生查找常量的开销；

周边问题的性能优化

1. 服务器性能会影响PHP 的执行速度；

2. 文件存储，硬件，数据库，缓存，网络等周边依赖决定了PHP 的运行速度；

3. 找出问题的核心，抓大头去优化；

4. 减少文件类的操作，开销如下：读写内存< 读写数据库< 读写磁盘< 读写网络数据(socket通信)；

5. 优化网络请求

   1. 设置超时请求：连接超时不超过200ms,读超时不超过800ms,写超时不超过500ms；
   2. 将串行请求并行化：

      a.使用curl_multi_*()系列函数，注意有一个请求慢了，整个请求就变慢了；
      b.使用swoole扩展；

6. 压缩 PHP 接口输出压缩，使用gzip即可，加快数据传输速度，但是会产生额外的CPU开销(100k以上的数据效果更明显)；

7. 缓存复用，如smarty 模板缓存。

PHP 性能瓶颈究极方案

Opcode 做缓存，使用 APC扩展，（已停止维护），PHP 5.5.0 及后续版本中已经绑定了 OPcache 扩展。
使用 PHP 扩展代替原生代码中的高频逻辑；
Runtime 优化 ，HHVM；

性能问题分析工具

xhprof 来自facebook的php性能分析工具，先做性能分析，再进行优化。php –ri xhprof,检查当前服务器扩展是否支持xhprof,如果输出xprof的版本，说明可以支持。
xhprof_enable();开启xhprof,通过xhprof_disable()返回的性能数据,将性能数据保存在目录中。
注：此工具在PHP7 上无效，建议使用tideways。PHP性能被动分析工具之xhgui加tideways的安装实践

附录

vld 扩展的使用举例

good.php文件内容如下，其中包含错误抑制符@。

<?php
    @file_get_contents('xxx');//xxx文件不存在

执行 php -dvld.active=1 -dvld.execute=0 good.php 可查看Opcode，在错误抑制符代码前后新增了BEGIN_SILENC，END_SILENCE

[root@iZ2zedvndklojgb9e7bppqZ default]# php -dvld.active=1 -dvld.execute=0 good.php
Finding entry points
Branch analysis from position: 0
Jump found. Position 1 = -2
filename:       /home/wwwroot/default/good.php
function name:  (null)
number of ops:  5
compiled vars:  none
line     #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   2     0  E >   BEGIN_SILENCE                                    ~0
         1        SEND_VAL                                                 'xxx'
         2        DO_FCALL                                      1          'file_get_contents'
         3        END_SILENCE                                              ~0
   3     4      > RETURN                                                   1

branch: #  0; line:     2-    3; sop:     0; eop:     4; out1:  -2
path #1: 0,

XHProf 使用简介

1. 使用XHProf查找PHP性能瓶颈
2. 深入理解PHP Opcode缓存原理

Memcache 简介

Memcache 是高速分布式的内存对象缓存系统，用于动态Web应用以减轻数据库的负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高了网站访问的速度。

Memcache 特性

• MemCache虽然被称为”分布式缓存”，但是MemCache本身完全不具备分布式的功能，MemCache集群之间不会相互通信，所谓的”分布式”，完全依赖于客户端程序的实现。
• 其数据保存在内存中，所以服务器宕机或者重启数据都会失效；
• Memcache中可以保存的item数量没有限制，只要内存足够；
• Memcache单进程在32bit机上最大使用内存为2G,64bit机无限制；
• key最大为250byte，超过该长度则无法保存；
• 单个item最大数据是1M，超过1M的数据不能存储；
• 不能遍历所有的item，这个操作的速度相对缓慢且会阻塞其他操作；
• Memcache设置添加一个key的时候，传入expire为0表示永不过期，设置了过期时间，不能超过30天，这个key会在30天之后失效；
• Memcache的高性能源自于两阶段哈希结构：第一阶段在客户端，通过Hash算法根据Key值算出一个节点；第二阶段在服务端，通过一个内部的Hash算法，查找真正的item并返回给客户端。从实现的角度看，MemCache是一个非阻塞的、基于事件的服务器程序。

PHP 操作Memcache 类

创建memcache实例，然后连接至memcache服务器即可使用memcache，默认端口是11211;

$memcache = new Memcache;
$memcache->connect('127.0.0.1', 11211);
$memcache->pconnec('127.0.0.1', 11211);
// 打开一个到服务器的持久化连接 , 连接不会在脚本执行结束后或者close()被调用后关闭
$memcache->addServer('123.57.210.55', 11211,$persistent,$weight);
// 向连接池中添加一个memcache服务器 $persistent 是否持久化连接
// $weight 控制桶的数量控制被选中的权重 $timeout 表示连续持续时间
$memcache->set('name', 'TK');
// 默认存储不压缩 不过期 , 其中字符串和数值直接存储，其他类型序列化后存储
// set其实是add方法和replace方法集合
$memcache->set('email', 'yann09@163.com',MEMCACHE_COMPRESSED,5);
// MEMCACHE_COMPRESSED设置存储是否压缩 , 5表示5秒后过期但是最大只能设置2592000秒(30天)
// 如果设置为0 表示永不过期, 可以设置将来的时间戳
$memcache->set('info',array('age'=>'26','salary'=>'1000'));
// 可以直接存储数组,redis中存储需要手动serialize()序列化
$memcache->add('counter', '10', MEMCACHE_COMPRESSED, 0);
// 如果键值存在会返回false , 如果不存在, 和set方法一样，生成一个counter的key并赋值10
$memcache->replace ('counter', '10');
// 如果键值不存在会返回false , 如果存在, 替换counter的值为10
$memcache->increment('counter', 3);
// 首先将元素当前值转换成数值然后加上value 操作counter键值+3
// 若键不存在 则返回false 不能用于压缩的键值操作，否则get键会失败
$memcache->decrement('counter', 3); // 操作counter键值-3, 若键不存在 则返回false
$memcache->delete('counter', 3); // 操作删除键counter, 3表示3秒内删除，默认是0即立即删除
$memcache->flush();
// 立即使所有已经存在的元素失效, 并不会真正的释放任何资源，
// 而是仅仅标记所有元素都失效了，因此已经被使用的内存会被新的元素复写。
$memcache->getExtendedStats ();
// 返回一个二维关联数据的服务器统计信息。数组的key由host:port方式组成
$memcache->getServerStatus ('127.0.0.1'); // 获取返回一个服务器的在线/离线状态  0表示离线 非0在线
$memcache->getStats(); // 获取服务器统计信息
$memcache->getVersion(); // 返回服务器版本信息
$memcache->setCompressThreshold ($threshold, $min_saving);
//  开启大值自动压缩   $threshold设置压缩阀值 2000字节 ，即字节数大于2K 就压缩
//  $min_saving  0--1之间  0.2表示压缩20%
$memcache->setServerParams('memcache_host', 11211, 1, 15, true, '_callback_memcache_failure');
// $memcache->addServer('memcache_host', 11211, false, 1, 1, -1, false);
// 已经通过addServer 配置过服务器 使用setServerParams 重新设置配置信息

友情链接

• MemCache详细解读

PHP 5.5.0 起已废弃，并在自 PHP 7.0.0 开始被移除。应使用 MySQLi 或 PDO_MySQL 扩展来替换。

基本的连接步骤如下：

1. 连接数据库 mysql_connect()
2. 设置字符集 mysql_set_charset('utf8') mysql_query('set names utf8')
3. 选择数据库 mysql_select_db('db_name') mysql_query('use db_name')
4. 执行查询语句 mysql_query()
5. 打印结果集 mysql_fetch_array() mysql_fetch_row
6. 释放结果集 mysql_free_result($result)
7. 关闭连接 mysql_close($link)

<?php
// 连接、选择数据库
$link = mysql_connect('mysql_host', 'mysql_user', 'mysql_password')
    or die('Could not connect: ' . mysql_error());
echo 'Connected successfully';
mysql_select_db('my_database') or die('Could not select database');

// 执行 SQL 查询
$query = 'SELECT * FROM my_table';
$result = mysql_query($query) or die('Query failed: ' . mysql_error());

// 以 HTML 打印查询结果
echo "<table>\n";
while ($line = mysql_fetch_array($result, MYSQL_ASSOC)) {
    echo "\t<tr>\n";
    foreach ($line as $col_value) {
        echo "\t\t<td>$col_value</td>\n";
    }
    echo "\t</tr>\n";
}
echo "</table>\n";

// 释放结果集
mysql_free_result($result);

// 关闭连接
mysql_close($link);
?>

• Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。
• Redis 将数据库完全保存在内存中，仅使用磁盘进行持久化。所以可以实现非常高的读写操作；
• Redis 跟其他键值存储的数据相比，具有丰富的数据类型。
• Redis 可以将数据复制到任意的从机中。
• 在一些需要大容量数据集的应用，Redis也并不适合，因为它的数据集不会超过系统可用的内存。所以如果你有大数据应用，而且主要是读取访问模式，那么Redis并不是正确的选择。

PHP 操作 Redis 基本步骤如下：

1. 实例化 Redis 对象 $redis = new Redis();；
2. 连接 Redis 服务器 $redis->connect('127.0.0.1', 6379);；
3. 设置 Redis 模式；
4. 进行基本的操作；

//创建redis实例
$redis = new Redis();
//连接redis实例，有以下几种方式
$redis->connect('127.0.0.1', 6379);
$redis->connect('127.0.0.1'); // port 6379 by default
$redis->connect('127.0.0.1', 6379, 2.5); // 2.5 sec timeout.
$redis->connect('/tmp/redis.sock'); // unix domain socket.
$redis->connect('127.0.0.1', 6379, 1, NULL, 100); // 1 sec timeout, 100ms delay between reconnection attempts.
//如果设置密码，则使用以下方法进行密码认证
$redis->auth('foobared');

返回类型

Redis::REDIS_STRING - String
Redis::REDIS_SET - Set
Redis::REDIS_LIST - List
Redis::REDIS_ZSET - Sorted set
Redis::REDIS_HASH - Hash
Redis::REDIS_NOT_FOUND - Not found / other

string 操作

Strings 数据结构是简单的key-value类型，value其实不仅是String，也可以是数字，除了一般的set,get之外还有以下功能：

• 获取字符串长度
• 往字符串append内容
• 设置和获取字符串的某一段内容
• 设置及获取字符串的某一位（bit）
• 批量设置一系列字符串的内容

string 操作用到的命令有:
getSet append getRange setRange strlen getBit/setBit incr, incrBy decr, decrBy get set setex setnx delete mset mget

使用场景

1. 计数

Example-1

<?php
 $redis= new Redis();
 $redis->connect('127.0.0.1',6379);
 $redis->set('key','string value');
 $redis->set('test','123');
 $result = $redis->getMultiple(['key','test']);
 echo "<pre>";
 var_dump($redis->incr('test'));
 var_dump($redis->decr('test'));
 print_r($result);

list 操作

Redis list的实现为一个双向链表，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销，Redis内部的很多实现，包括发送缓冲队列等也都是用的这个数据结构。
用Lists的PUSH操作，将任务存在Lists中，然后工作线程再用POP操作将任务取出进行执行。Redis还提供了操作Lists中某一段的api，你可以直接查询，删除Lists中某一段的元素。

list 操作用到的命令有(以l开头)：

lPush/rPush lPushx/rPushx lPop/rPop blPop/brPop lSize lIndex, lGet lSet lRange, lGetRange lTrim, listTrim lRem, lRemove lInsert rpoplpush

使用场景

1. 显示最新的项目列表
2. 删除与过滤

Example-2

<?php
 $redis= new Redis();
 $redis->connect('127.0.0.1',6379);
 $redis->delete('test');
 $redis->lpush('test','111');
 $redis->lpush('test','222');
 $redis->rpush('test','333');
 $redis->rpush('test','444');
 var_dump($redis->lpop('test')); //string(3) "222"
 var_dump($redis->rpop('test')); //string(3) "444"
 var_dump($redis->lsize('test')); //int(2)
 var_dump($redis->lset('test',1,'555')); //bool(true) "555"
 var_dump($redis->lget('test',1)); //string(3)
 var_dump($redis->lgetRange('test',0,-1));

set 操作

Set 集合的概念就是一堆不重复值的组合。
当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。
Redis 还为集合提供了求交集、并集、差集等操作，可以非常方便的实现如共同关注、共同喜好、二度好友等功能。

set 操作用到的命令有(以s开头)：
sAdd sRem, sRemove sMove sIsMember, sContains sCard, sSize sPop sRandMember sInter sInterStore sUnion sUnionStore sDiff sDiffStore sMembers, sGetMembers

使用场景

1. 特定时间内的特定项目
2. 删除与过滤

Example-3

<?php
 $redis= new Redis();
 $redis->connect('127.0.0.1',6379);
 $redis->delete('test');
 $redis->delete('test1');
 $redis->sadd('test',111);
 $redis->sadd('test',333);
 $redis->sadd('test',222);
 $redis->sadd('test1',444);
 $redis->sadd('test1',555);
 $redis->sremove('test',111);
 $redis->smove('test','test1',333);
 echo "<pre>";
 var_dump($redis->sort('test1'));
 var_dump($redis->scontains('test1',555)); //检查集合中是否存在指定的值
 echo $redis->ssize('test1'); //返回集合中存储值的数量
 var_dump($redis->sinter('test','test1')); //返回一个所有指定键的交集。
 var_dump($redis->sdiffstore('new','test','test1')); //执行sdiff命令并把结果储存到新建的变量中。
 print_r($redis->smembers('new')); //返回集合的内容

zset (sorted set)操作

Redis sorted set的使用场景与set类似，区别是set不是自动有序的，而sorted set可以通过用户额外提供一个优先级(score)的参数来为成员排序，并且是插入有序的，即自动排序。当你需要一个有序的并且不重复的集合列表，那么可以选择sorted set数据结构。

zset 操作用到的命令有(以z开头)：
zAdd zDelete, zRem zRange zRevRange zRangeByScore, zRevRangeByScore zCount zRemRangeByScore, zDeleteRangeByScore zSize, zCard zScore zRank, zRevRank zIncrBy zUnion/zInter

使用场景

1. 排行榜相关
2. 按照用户投票和时间排序
3. 处理过期项目
4. 社交关系

Example-4

<?php
 $redis= new Redis();
 $redis->connect('127.0.0.1',6379);
 $redis->zadd('zset',1,'b'); //向有序集合key中添加元素value，score用于排序。
 $redis->zadd('zset',0,'a');
 $redis->zadd('zset',2,'c');
 $redis->zAdd('zset', 4, 'R');
 $redis->zAdd('zset', 5, 'd');
 $redis->zdelete('zset','c'); // 删除有序集合key中的元素value
 print_r($redis->zrange('zset',0,-1)); // 返回有序集合key中的index从start到end的所有元素【升序】
 print_r($redis->zcount('zset',0,3)); // 返回有序集合key中，index从start到end间的【包括start和end】所有元素的个数。
 $redis->zIncrBy('zset', 2, 'R'); // 将有序集合key中的元素value的score增加increment,不存在则创建
 print_r($redis->zScore('zset','R')); // 返回有序集合key中元素value的score

hash 操作

Hash结构可以使你像在数据库中Update一个属性一样只修改某一项属性值。
Redis Hash对应Value内部实际就是一个HashMap，实际这里会有2种不同实现:

• 这个Hash的成员比较少时Redis为了节省内存会采用类似一维数组的方式来紧凑存储，而不会采用真正的HashMap结构，对应的value redisObject的encoding为zipmap;
• 当成员数量增大时会自动转成真正的HashMap,此时encoding为ht。

hash 操作用到的命令有(以h开头)：
hSet hGet hLen hDel hKeys hVals hGetAll hIncrBy hExists hMset hMget

使用场景

1. 消息通知

Example-5

<?php
 $redis= new Redis();
 $redis->connect('127.0.0.1',6379);
 $redis->hset('hash','lang1','php'); // 向哈希表hash中添加key为key，值为value的元素。
 $redis->hset('hash','lang2','mysql');
 $redis->hset('hash','lang3','mysql2');
 $redis->hset('hash','lang4','1');
 echo $redis->hget('hash','lang1');
 echo $redis->hlen('hash'); // 返回哈希表hash中元素的个数
 $redis->hdel('hash','lang3');
 print_r($redis->hvals('hash')); // 返回哈希表hash中所有的value
 print_r($redis->hgetall('hash')); // 返回哈希表hash中所有的元素
 var_dump( $redis->hExists('hash', 'lang1') ); // 检测哈希表hash中是否有元素key
 var_dump($redis->hincrby('hash','lang4',3)); // 哈希表hash中元素key的value加number
 $redis->hMSet('hash',['lang5'=>'java','lang6'=>'c']); // 批量向哈希表hash中添加元素。
 var_dump($redis->hMget('hash',['lang1','lang2'])); // 量获取哈希表hash中的元素。

Redis 操作

• 事务模式： multi, exec, discard 分别是开启事务，执行事务，取消事务

• 清除数据库
  a. 清除当前数据库 flushDB
  b. 清除所有数据库 flushAll

• 随机返回key randomKey

• 选择一个数据库 select

• 转移一个 key 到另一个数据库 move

• 查看数据库有多少key dbSize

• 使用 AOF 进行数据持久化 bgrewriteaof

• 选择从服务器 saveof

• 数据保存到磁盘
  a. 同步保存到磁盘 save
  b. 异步保存到磁盘 bgsave

• 返回 Redis 的版本信息 info

友情链接

• github phpredis
• php redis操作
• Redis 命令参考
• Redis 和 Memcached的区别
• Redis应用场景

Nginx

1. nginx常见面试题
2. 关于nginx的五大面试题
3. Nginx面试中最常见的18道题 抱佛脚必备

PHP

1. php面试相关提纲
2. PHP 高级工程面试题汇总
3. 2019PHP面试题最全面归纳总结
4. 2019年PHP面试题大汇总（收藏）
5. 2018最新高级PHP面试题整理
6. Laravel 核心代码学习
7. PHP 数据结构

SWOOLE

MySQL

1. 史上最详细的一线大厂Mysql面试题详解
2. MySQL常见面试题
3. Mysql数据库相关面试题总结（30道）
4. 我必须得告诉大家的 MySQL 优化原理
5. 提高mysql千万级大数据SQL查询优化30条经验

正则表达式

1. 知道这20个正则表达式，能让你少写1,000行代码
2. 搞定PHP面试 - 正则表达式知识点整理

NoSQL

Redis

1. Redis常见面试题
2. Redis和Memcache区别，优缺点对比

memcache

MQ

1. 如果面试问​RabbitMQ，你可以吊打他
2. 面试：分布式之消息队列要点复习

前端

VUE

1. Vue面试中，经常会被问到的面试题/Vue知识点整理

测试环境
PHP version 5.3.29/5.6.29/7.1.0
Apache 2.4.25

常量是一个简单值的标识符（名字）。如同其名称所暗示的，在脚本执行期间该值不能改变（除了所谓的魔术常量，它们其实不是常量）。常量默认为大小写敏感。传统上常量标识符总是大写的。

常量和变量有如下不同：

• 常量前面没有美元符号（$）；
• 在PHP5.3.0之前的版本中，常量只能用 define() 函数定义，而不能通过赋值语句；
• 常量可以不用理会变量的作用域而在任何地方定义和访问；
• 常量一旦定义就不能被重新定义或者取消定义；
• 常量的值只能是标量；
  注意：在PHP5.6之后可以使用const关键字定义数组常量，在PHP7.0.0之后可以使用define()定义数组常量。

define()函数

bool define(string $name, mixed $value[,bool $case_insensitive = false])
函数用于在运行时定义一个常量。
参数:
name：常量名。
value：常量的值；
	仅允许标量和 null。标量的类型是 integer， float，string 或者 boolean。
	也能够定义常量值的类型为 resource ，但并不推荐这么做，可能会导致未知状况的发生。
	PHP 7.0.0 版本后array values are allowed.
case_insensitive：可选项，如果设置为 TRUE，该常量则大小写不敏感。默认是大小写敏感的。
返回值：
	成功时返回 TRUE， 或者在失败时返回 FALSE。

const常量

• PHP 5.3.0 后支持const关键字；
• const 可以用在类内和类外；
• PHP 7.1.0 之后可显式写访问控制修饰符，之前的版本均不可使用；
• const定义的常量在PHP 5.6.0 之后可用于常量运算；
• const的值除了标量外，PHP 5.6.0 版本后还可以是常量表达式，不能是变量，类属性，函数调用；

Example-1

常量在PHP不同版本中的差异。

<?php
// PHP 5.3.0开始支持const关键字
const CONSTANT = 'Hello World';
echo CONSTANT;

// PHP 5.6.0 const开始支持运算和数组常量
const ANOTHER_CONST = CONSTANT.'; Goodbye World';
echo ANOTHER_CONST;

const ANIMALS = array('dog', 'cat', 'bird');
echo ANIMALS[1]; // outputs "cat"

// PHP 7.0.0 define()开始支持数组常量
define('ANIMAL', array('dog','cat','bird'));
echo ANIMAL[2]; // outputs "bird"

Example-2

<?php
/**
* MyClass为了说明以下情况：
* 1.const可用于类内部
* 2.PHP7.1.0之后可显式写访问控制修饰符，之前的版本均不可使用
*/
class MyClass
{
	public const CONSTANT = 'constant value'; //PHP 7.1.0支持访问控制修饰符可见
	//define('DEFINECONST','defineConst');    //语法错误，define()不能用于类内
	function showConstant() {
		echo  self::CONSTANT. "<br/>\n";
	}
}

const ONE = 1; //const可在类外使用
define('PI',3.14); //defnie()可在类外使用
/**
* Foo类为了说明以下情况：
* 1.const定义的常量在PHP 5.6.0 之后可用于运算
* 2.const的值在PHP 5.6.0 之后可以是常量表达式
*/
class Foo {
	// As of PHP 5.6.0
	public $i=1;
	const TWO = ONE * 2;
	const THREE = ONE + self::TWO;
	const SENTENCE = 'The value of THREE is '.self::THREE;
	const CONST_VAR1 = 1 + 1; //支持常量算数运算
	const CONST_VAR2 = 'Hello'.' World!' ; //支持字符串运算
	const CONST_VAR3 = (1<<2); //支持常量位运算
	const CONST_VAR4 = 1<0; //支持常量比较运算
	const CONST_VAR5 = true||false; //支持常量逻辑运算
	// const CONST_VAR6 = $i; //语法错误
}
echo Foo::SENTENCE ."<br/>\n";
echo PI*2 ."<br/>\n"; //define()定义的常量可用于运算
echo Foo::CONST_VAR1 ."<br/>\n";
echo Foo::CONST_VAR2 ."<br/>\n";
echo Foo::CONST_VAR3 ."<br/>\n";
echo Foo::CONST_VAR4 ."<br/>\n";
echo Foo::CONST_VAR5 ."<br/>\n";

echo MyClass::CONSTANT . "<br/>\n";
$class = new MyClass();
$class->showConstant();

define('DEFINE_VAR1',$class instanceof MyClass);
// const CONST_VAR4 = $class instanceof MyClass; //const不支持类型运算符instanceof
var_dump(DEFINE_VAR1);
$i=4;
define('DEFINE_VAR2', $i << 1);
echo DEFINE_VAR2;

echo $class::CONSTANT."<br/>\n"; // As of PHP 5.3.0

Example-3

不能在函数内、循环内以及if语句之内用const来定义常量。

<?php
	if (1) {
		// const CONST_VAR1 = 'BAR1'; //语法错误
		define('CONST_VAR2', 'BAR2');
	}

Example-4

define()可以定义大小写不敏感的常量，而const没有此功能。

<?php
//define()的第3个参数为true时，表示大小写不敏感
define('DEFINE_VAR', 'define_test', true);
echo DEFINE_VAR; //define_test
echo define_var; //define_test
echo DefINE_Var; //define_test

const CONST_VAR = 'const_test';
echo CONST_VAR;  //const_test
echo const_var;  //PHP提示常量未定义
echo ConST_Var;  //PHP提示常量未定义

Example-5

const定义的常量受命名空间的限制，define()定义的常量不受命名空间的限制。

<?php
namespace first;
const CONST_VAR1 = 'FIRST_CONST_VAR1';
define('DEFINE_VAR', 'define_var');

namespace second;
const CONST_VAR1 = 'SECOND_CONST_VAR1';
define('DEFINE_VAR', 'define_var');//Notice: Constant DEFINE_VAR already defined

Example-6

使用define()定义常量时，可以使用PHP内置关键字声明常量，使用constant()返回常量值，但是使用const定义PHP内置关键字常量则会报错，不能重新声明常量。

<?php
define('TRUE','My constant value');
echo constant('TRUE'); // outputs 'My constant value'

//const ECHO = 'My constant value ECHO'; //致命错误，不能重新声明常量
echo ECHO;

Example-7 const关键词拓展

php7.0.0之后self代表的类常量只能是当前类，PHP 7.0.0 之前的版本则有后期静态绑定的意味。

<?php
class A{
	const X=1;
	const Y=self::X;
}
class B extends A{
	const X=1.0;
}
var_dump(B::Y); // PHP 5.6.29 运行结果为float(1), PHP 7.1.0 运行结果为int(1)

Summary

PHP中const关键字和define()函数定义常量的区别：

版本差异

函数define()在PHP4和PHP5中均可使用，关键字const只能在PHP 5.3.0及其后的版本中使用。
PHP 5.6.0 const开始支持常量运算和数组常量
PHP 7.0.0 define()开始支持数组常量

定义位置的区别

由于函数define()定义的常量是在 执行define()函数 时定义的，因此可以在函数内、循环内、if语句内等函数能够被调用的任何地方使用define()函数定义常量;
由于const关键字定义的常量是在 编译 时定义的，因此const关键字定义常量必须处于最顶端的作用区域。这也就意味着不能在函数内、循环内以及if语句之内用const来定义常量。

对值的表达式支持的差异

虽然关键字const和define()定义的常量值都只能为null或标量数据(boolean，integer，float和string类型)以及resource类型(不推荐定义resource类型的常量，否则可能出现无法预知的结果)。PHP5.6.0 之前的版本中const关键字定义的常量值的表达式中不支持算术运算符、位运算符、比较运算符等多种运算符，而这些运算符在define()函数定义常量时都是可以直接使用的。

php5.6.0 之后的版本中constant关键字的值支持常量表达式，表达式可以是算术运算符、位运算符、比较运算符等多种运算符，不过define()函数定义常量时还支持变量。

define()支持instanceof操作符，const不支持instanceof操作符。

对命名空间限制的差异

const定义的常量受命名空间的限制，define()定义的常量不受命名空间的限制。

对字符大小写敏感的支持差异

函数define()可以接收第3个参数，如果该参数为true，则表示常量名的大小写不敏感。而使用const关键字定义常量却没有提供类似的功能。

对系统内置关键字重新声明的差异

使用define()定义常量时，可以使用PHP内置关键字声明常量，使用constant()返回常量值，但是使用const定义PHP关键字常量则会报错，不能重新声明常量。

测试环境
PHP version 5.3.29/5.6.29/7.1.0
Apache 2.4.25

函数参数

Example-1

• 自PHP 5.0 支持参数类型声明为对象类型，即参数必须是某个对象的类；
• 自PHP 5.1 新增参数类型声明为array，即形参类型必须是数组；
• 自PHP 7.0 新增函数参数类型为标量类型，同时参数类型声明支持严格模式，此时只支持标量类型int string float bool。

<?php
	//PHP 7.0 
	declare(strict_types=1); //声明严格类型
	
	function sum(int $a, int $b) { 
	    return $a + $b;
	}
	
	var_dump(sum(1, 2));
	var_dump(sum(1.5, 2.5)); //类型错误
 

Example-2

方法的参数类型约束为对象类型：

<?php
	class C {}
	class D extends C {}

	// This doesn't extend C.
	class E {}

	function f(C $c) {
	    echo get_class($c)."\n";
	}

	f(new C);
	f(new D);
	f(new E); //错误，参数必须是C的实例

Example-3

PHP5.6+版本支持可变数量的参数列表。在 PHP 5.5 及更早版本中，使用函数 func_num_args()，func_get_arg()，和 func_get_args() 。

<?php
	function sum(...$numbers) {
	    $accum = 0;
	    foreach ($numbers as $n) {
	        $accum += $n;
	    }
	    return $accum;
	}

	echo sum(1, 2, 3, 4);

Example-4

使用默认参数时，任何默认参数必须放在任何非默认参数的右侧；否则，函数将不会按照预期的情况工作。

<?php
	function makeyogurt($type = "acidophilus", $flavour){
	    return "Making a bowl of $type $flavour.\n";
	}
	echo makeyogurt("raspberry");   // won't work as expected

可变函数

可变函数不能用于例如 echo，print，unset()，isset()，empty()，include，require 以及类似的语言结构。

Example-1

调用静态方法时，函数调用要比静态属性优先。

<?php
class Foo
{
    static $variable = 'static property';
    static function Variable()
    {
        echo 'Method Variable called';
    }
}

echo Foo::$variable; // This prints 'static property'.
$variable = "Variable";
Foo::$variable();  // This calls $foo->Variable()

Example-2

PHP 7.0 支持类调用方法为可变方法，而之前的版本则报错。

<?php
namespace Project\TestClass;
 class Test {
     static function funcToCall() {
         echo "test";
     }
 }

namespace Project\OtherTestClass;
 class OtherTest {
     static function callOtherFunc() {
         $func = '\Project\TestClass\Test::funcToCall';
         $func();
     }
 }

 echo OtherTest::callOtherFunc(); //outputs test

匿名函数

匿名函数（Anonymous functions），也叫闭包函数（closures），允许临时创建一个没有指定名称的函数。最经常用作回调函数（callback）参数的值。

Example-1

闭包函数也可以作为变量的值来使用。PHP 会自动把此种表达式转换成内置类 Closure 的对象实例。

<?php
//PHP 7.0+
	(function($name){
		echo 'My name is ' . $name;
	})('Zhang San');

Example-2

闭包可以从父作用域中继承变量。 任何此类变量都应该用 use 语言结构传递进去。

<?php
$fruits = ['apples', 'oranges'];

$example = function () use ($fruits) {
	echo $fruits[0];
};
$example();

Example-3

PHP 5.4 $this可用于匿名函数。

<?php

class Test{
	public function testing(){
		return function() {
			var_dump($this);
		};
	}
}

$object = new Test;
$function = $object->testing();
$function();

Return

• 如果在全局范围中调用，则当前脚本文件中止运行。
• 如果当前脚本文件是被 include 的或者 require 的，则控制交回调用文件。
• 如果当前脚本是被 include 的，则 return 的值会被当作 include 调用的返回值。
• 如果在主脚本文件中调用 return，则脚本中止运行。
• 如果当前脚本文件是在 php.ini 中的配置选项 auto_prepend_file 或者 auto_append_file 所指定的，则此脚本文件中止运行。

Example-1

PHP 7.0 可以强制函数返回类型。语法为 function FunctionName ($arg1, $arg2, ...) : TYPE { }

<?php
	declare(strict_types=1);   //strict_types

	function welcome($name):string {
	     return $name;
	}
	echo welcome(90.99);

<?php
	class C {}

	function getC(): C {
	    return new C;
	}

	var_dump(getC()); //object(C)#1 (0) { }

Example-2

PHP 7.0 如果指定了返回类型，则不能为null.

<?php
declare(strict_types=1);

function add2ints(int $x, int $y):int{
    $z = $x + $y;
    if ($z===0){
       return null; //返回类型错误
    }
    return $z;
}
$a = add2ints(3, 4);
echo is_null($a) ? 'Null' : $a;
$b = add2ints(-2, 2);
echo is_null($b) ? 'Null' : $b;
exit();

测试环境
PHP version 5.3.29/5.6.29/7.1.0
Apache 2.4.25

• PHP 中的变量用一个美元符号$后面跟变量名来表示。变量名区分大小写；
• 变量名与 PHP 中其它的标签一样遵循相同的规则。一个有效的变量名由字母或者下划线开头，后面跟上任意数量的字母，数字，或者下划线。按照正常的正则表达式，它将被表述为：[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*；
• PHP 中全局变量在函数中使用时必须声明为 global；
• 静态变量仅在局部函数域中存在，但当程序执行离开此作用域时，其值并不丢失；

变量基础

Example-1

不能为$this关键字赋值

<?php
	//$this = 'text'; // error:Cann't re-assign $this
	$name = 'this';
	$$name = 'text'; // sets $this to 'text',在PHP 5.6.29上可运行，在PHP 7.1.0上依然是错误
	echo $this;

Example-2

使用异或操作可以在不增加临时变量的情况下互相交换变量值，对integer和string型变量有效，数组和对象无效。

<?PHP
	$a=5;
	$b=3;
	//使用异或(XOR)可以在不添加临时变量的情况下，交换两个变量的数据。
	//以下代码会交换$a,$b的值。
	$a^=$b;
	$b^=$a;
	$a^=$b;
	echo $a.PHP_EOL.$b;

Example-3

unset()销毁局部变量$a，全局变量$a仍然存在，同理unset()销毁全局变量$a，局部变量仍然存在。
使用NULL将局部变量置空，则局部和全局变量均为NULL.

<?php
 $var = 1;
 function foo() {
     global $var;
     unset($var);               // unset local $a, the global $a is still there.
     var_dump($var);            // Undefined variable: var
     var_dump($GLOBALS['var']); // this is ok.
}
foo();
var_dump($var);                // this is ok.

Example-4

销毁类的实例化对象的时候，类的静态方法内部的静态变量并不会被销毁。

<?php
class Foo {
     public static function Bar() {
         static $var = 0;
         return ++ $var;
     }
 }

$Foo_instance = new Foo;
print $Foo_instance->Bar(); // prints 1
unset($Foo_instance);
echo "<br/>";
$Foo_instance2 = new Foo;
print $Foo_instance2->Bar(); // prints 2

Example-5

在函数嵌套的结构里，函数的参数相对于内部函数的变量并不是全局变量

<?php
// $var1 is not declared in the global scope
function a($var1){
     function b(){
         global $var1;
         echo $var1; // there is no var1 in the global scope so nothing to echo 
     }
     b();
 }
a('hello');

可变变量

一个可变变量获取了一个普通变量的值作为这个可变变量的变量名。

Example-1

在可变变量中，可以使用花括号来给变量名清晰定界。

<?php
	//在可变变量中，使用花括号来给属性名清晰定界
	$a = 'hello';
	$$a = 'world';
	echo "$a ${$a}"; //等价于 echo "$a $hello";

Example-2

可以在变量前添加更多的$符号。

<?php
	$I = 'love';
	$love = 'you';
	$you = 'I';
	echo $$$I." ".$$$$I." ".$$I;

Example-3

可变变量$符号之间有空格、注释时，可变变量仍然可以被合法解析

<?php
    $foo = 'bar';
    $ 
    /**
     * 可变变量$符号之间有空格、注释，可变变量仍然可以被合法解析.
     */
    $foo = 'magic';
    echo $bar; // Outputs magic.

Example-4

类中的可变属性如果为数组，其默认解析规则在PHP 5 和PHP 7中有所不同，为了解决版本兼容问题，建议使用{}给属性名清晰定界。

<?php
	class foo {
	    public $bar = 'I am bar.';
	    public $arr = array('I am A.', 'I am B.', 'I am C.');
	    public $r   = 'I am r.';
	}
	$foo = new foo();
	$bar = 'bar';
	$baz = array('foo', 'bar', 'baz', 'quux');
	echo $foo->$bar . "<br/>\n";
	echo $foo->$baz[1]. "<br/>\n"; 
	//PHP 5 中按 $foo->{$baz[1]}解析，
	//PHP 7中按$foo->{$baz}[1]解析，会通知未定义属性 foo::$Array

	$start = 'b';
	$end   = 'ar';
	echo $foo->{$start . $end} . "<br/>\n";

	$arr = 'arr';
	echo $foo->{$arr}[1] . "<br/>\n"; 
	//PHP 5 中按$foo->{$arr[1]}解析成$foo->r,
	//PHP 7 中按$foo->{$arr}[1]解析为$foo->arr[1]
	echo $foo->{$arr}[1] . "<br/>\n";

Example-5

可以使用变量、常量、函数调用拼接成另一个变量，但是不能拼接函数名。

<?php 
	define('ONE', 1); 
	function one() { 
	    return 1; 
	} 
	$one = 1; 

	${"foo$one"} = 'foo'; 
	echo $foo1,"<br/>"; // foo 
	${'foo' . ONE} = 'bar'; 
	echo $foo1,"<br/>"; // bar 
	${'foo' . one()} = 'baz'; 
	echo $foo1,"<br/>"; // baz 

	$foo = 'info'; 
	//{"php$foo"}(); // 解析错误 
	// You'll have to do: 
	$func = "php$foo"; 
	$func(); 
 

来自PHP之外的变量

Example-1

来自表单中的变量，变量名中的点和空格被转换成下划线。例如 <input name="a.b" /> 变成了 $_REQUEST["a_b"]。

<form action='./test.php' method='POST'>
	<input name="a. b[x. y]" value="foo" />
	<input type="submit" name="submit" />
</form>

test.php文件如下

<?php
	var_dump($_POST);

常量

常量是一个简单值的标识符（名字）。如同其名称所暗示的，在脚本执行期间该值不能改变（除了所谓的魔术常量，它们其实不是常量）。常量默认为大小写敏感，一般常量标识符总是大写的。

常量名和其它任何 PHP 标签遵循同样的命名规则。合法的常量名以字母或下划线开始，后面跟着任何字母，数字或下划线。用正则表达式是这样表达的：[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*。

PHP 5.3.0之后新增const关键字定义常量；

Example-1

定义常量时，常量名不可以有空格。

<?php
   define ("YEAR ",  2017);
   echo YEAR;

Example-2

PHP 7.1.0 之后const可以显式使用访问控制修饰符，在此之前不能使用访问控制修饰符。

<?php
class constants {
    const MAX_VALUE = 10;
    public const MIN_VALUE =1;
 }
echo constants::MAX_VALUE;
echo constants::MIN_VALUE; //PHP 7.1.0 之后可显式写访问控制修饰符

Example-3

使用define()定义常量时，可以使用内置关键字声明常量，使用constant()返回常量值，但是使用const定义常量则会报错，不能重新声明常量。

<?php
	define('TRUE','My constant value');
	echo constant('TRUE'); // outputs 'My constant value'

	//const ECHO = 'My constant value ECHO'; //致命错误，不能重新声明常量
	//echo ECHO;

有关const和define()定义常量的区别，参见PHP定义常量时const关键字和define()函数的区别.

测试环境
PHP version 5.3.29/5.6.29/7.1.0
Apache 2.4.25

在PHP中，命名空间用来解决在编写类库或应用程序时创建可重用的代码如类或函数时碰到的两类问题：

1. 用户编写的代码与PHP内部的类/函数/常量或第三方类/函数/常量之间的名字冲突。
2. 为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名（或简短）的名称，提高源代码的可读性。

<?php
     namespace NS;

     define(__NAMESPACE__ .'\foo','111');
     define('foo','222');

     echo foo;  // 111.
     echo \foo;  // 222.
     echo \NS\foo;  // 111.
     echo NS\foo;  // fatal error. assumes \NS\NS\foo.

只有 类（包括抽象类和traits）、接口、函数和const定义的常量 类型的代码受命名空间的影响。

同一个命名空间可以定义在多个文件中，即允许将同一个命名空间的内容分割存放在不同的文件中。

所有非 PHP 代码包括空白符都不能出现在命名空间的声明之前。

Example-1

PHP 命名空间允许使用反斜杠 \ 指定层次化的命名空间的名称。
命名空间不可以嵌套，但是可以使用子命名空间，达到相同的效果。

<?php
     namespace my\stuff {
          namespace nested {//错误，命名空间不可以嵌套
               class foo {}
          }
     }
     /*
       namespace my\stuff\nested {
            class foo {}
       }
     */

Example-2

在同一个文件中定义多个命名空间有两种语法形式：简单组合语法与大括号语法，但是两种风格在一个文件中不能混合使用。

如果使用大括号语法，请注意花括号{}外面不允许有任何代码。结束标签 ?> 后面如果有空格或者是换行则会报错，因此建议在纯PHP代码的文件中不要写PHP结束标签 ?>。

<?php
     namespace MyProject; //简单组合语法
     const CONNECT_OK = 1;
     class Connection { /* ... */ }
     function connect() { /* ... */  }
     namespace AnotherProject{ //大括号语法
     const CONNECT_OK = 1;
     class Connection { /* ... */ }
     function connect() { /* ... */  }
     }
 　

Example-3

use 关键字必须在文件全局范围或者是已经声明的其他命名空间里，不可以在块作用域里，这是因为外部命名空间导入是在编译时而不是运行时完成的。

<?php
     namespace Languages;
     function toGreenlandic(){
          use Languages\Danish;
     // ...
     }

Example-4

PHP5.6 之前只能通过use导入命名空间和类，PHP 5.6 之后允许导入常量和方法。
PHP 7.0 后支持分组导入命名空间。

<?php
     // Pre PHP 7.0 code
     use some\Mynamespace\ClassA;
     use some\Mynamespace\ClassB;
     use some\Mynamespace\ClassC as C;

     use function some\Mynamespace\fn_a;
     use function some\Mynamespace\fn_b;
     use function some\Mynamespace\fn_c;

     use const some\Mynamespace\ConstA;
     use const some\Mynamespace\ConstB;
     use const some\Mynamespace\ConstC;

     // PHP 7+ code
     use some\Mynamespace\{ClassD, ClassE, ClassF as F};
     use function some\Mynamespace\{fn_d, fn_e, fn_f};
     use const some\Mynamespace\{ConstD, ConstE, ConstF};

测试环境
PHP version 5.3.29/5.6.29/7.1.0
Apache 2.4.25

PHP中的数据类型

PHP 支持 8 种原始数据类型。

• 四种标量类型：
  boolean（布尔型）
  integer（整型）
  float（浮点型，也称作 double)
  string（字符串）

• 两种复合类型：
  array（数组）
  object（对象）

• 最后是两种特殊类型：
  resource（资源）
  NULL（无类型）

Boolean

当转换为 boolean 时，以下值被认为是 FALSE：

• 布尔值 FALSE 本身
• 整型值0 （零）
• 浮点型值 0.0（零）
• 空字符串，以及字符串 “0”
• 不包括任何元素的数组
• 特殊类型 NULL（包括尚未赋值的变量）
• 从空标记生成的 SimpleXML 对象

所有其它值都被认为是 TRUE（包括任何资源）。

Example-1

<?php
	 $a= '0.00';
	 echo $a ?'true':'false';//true
?>

<?php
	$array = array('key'=>true);
	if($array['key'] != 'false')
	     echo 'The value of key is '.$array['key'];
?>

<?php
	var_dump(0 == 'all');//bool(true)
?>

<?php 
	//TRUE和FALSE不能当成是1和0的常量
	$var1 = TRUE; 
	$var2 = FALSE; 

	echo $var1; // outputs: 1 
	echo $var2; //outputs: nothing
	echo (int)$var2; //outputs:0 

	//注意 true 和 false 输出结果的差异
	echo false ;		  //nothing
	echo (false) ;		//nothing
	echo false+false ;    //0
	echo (false+false) ;  //0
	echo intval(false) ;  //0
	echo '"'.false.'"' ;  //""
	echo "<hr/>";
	echo true ;  		//1
	echo (true) ;  	  //1
	echo true+true ; 	//2
	echo (true+true) ;   //2
	echo intval(true) ;  //1
	echo '"'.true.'"' ;  //"1"
?> 

Integer

整型值可以使用十进制，十六进制，八进制或二进制表示，前面可以加上可选的符号（- 或者 +）。

二进制表达的 integer 自 PHP 5.4.0 起可用，PHP 5.4.0 之前的版本则报语法错误。

要使用八进制表达，数字前必须加上0（零）;要使用十六进制表达，数字前必须加上 0x;要使用二进制表达，数字前必须加上 0b。

Example-1

• PHP 7.0.0 之前的版本，如果向八进制数传递了一个非法数字（即 8 或 9），则后面其余数字会被忽略；
• PHP 7.0.0 之后，如果向八进制数传递了一个非法数字，则会解析错误；

<?php
	var_dump(01090); // 八进制 010 = 十进制 8
?>

Example-2

• 如果给定的一个数超出了 integer 的范围，将会被解释为 float。同样如果执行的运算结果超出了 integer 范围，也会返回 float；
• PHP 不支持无符号整数；
• 自 PHP 5.0.5 后，最大值可以用常量 PHP_INT_MAX 来表示；
• 自 PHP 7.0.0 后，最小值可以用常量 PHP_INT_MIN 来表示；

<?php
	$max = PHP_INT_MAX ; //PHP 5.0.5版本后支持该常量
	$min = PHP_INT_MIN; //PHP 7.0.0 版本之后支持该常量
	echo $max,$min;

	$large_number = 2147483647;
	var_dump($large_number);                     // int(2147483647)

	$large_number = 2147483648;
	var_dump($large_number);                     // float(2147483648)

	$million = 1000000;
	$large_number =  50000 * $million;
	var_dump($large_number);                     // float(50000000000)
?>

Example-3

当从浮点数转换成整数时，将向下取整。如果浮点数超出了整数范围，则结果为未定义，因为没有足够的精度给出一个确切的整数结果。在此情况下没有警告，甚至没有任何通知！

自 PHP7.0.0 之后 NAN和Infinity 强制转换成整型结果总是0

<?php
	var_dump((int)NAN); // PHP 7.0.0之前为 -2147483648，之后为0
	var_dump((int)INF); // PHP 7.0.0之前为 0 ，之后也是0
?> 

Example-4

决不要将未知的分数强制转换为 integer，这样有时会导致不可预料的结果。

<?php
	echo (int) ((0.1+0.7) * 10); // outputs: 7
?> 

Example-5

数字前面有0代表八进制，但是字符串型数字前面有0并不是八进制。

<?php
	$x = 0123;          // 83
	$y = "0123" + 0;    // 123 
	echo $x,$y;
?>

Example-6

对超过int型最大值的数字进行取模运算时，会强制将float类型转化成int类型，从而出现错误。

<?php
     $i = 6887129852; //超过int型最大值则为float类型
     echo "i=$i <br/>\n";
     echo "i%36=".($i%36)."<br/>\n";
     echo "alternative i%36=".($i-floor($i/36)*36)."\n";
?>

Float

某些数学运算会产生一个由常量 NAN 所代表的结果。此结果代表着一个在浮点数运算中未定义或不可表述的值。任何拿此值与其它任何值进行的松散或严格比较的结果都是 FALSE。

由于 NAN 代表着任何不同值，不应拿 NAN 去和其它值进行比较，包括其自身，应该用 is_nan() 来检查。

浮点数之间不能进行比较，要测试浮点数是否相等，要使用一个仅比该数值大一点的最小误差值。

Example-1

<?php
	echo intval(19.31*100),'<br/>'; //获取一个变量的整数,echo 1930
	echo number_format(19.31*100,20); //格式化数字
	echo "<hr/>";
	
	//不要拿浮点数进行比较
	$x = 8 - 6.4;  // which is equal to 1.6
	$y = 1.6;
	//echo number_format($y,20);
	var_dump($x == $y); // is not true
?>

String

一个字符串 string 就是由一系列的字符组成，其中每个字符等同于一个字节。这意味着 PHP 只能支持 256 的字符集，因此不支持 Unicode 。

一个字符串可以用 4 种方式表达：

• 单引号
• 双引号
• heredoc 语法结构
• nowdoc 语法结构（自 PHP 5.3.0 起）

string 中的字符可以通过一个从 0 开始的下标，用类似 array 结构中的方括号包含对应的数字来访问和修改，比如 $str[42]，也可用花括号访问，比如 $str{42}。

PHP 的字符串在内部是字节组成的数组。因此用花括号访问或修改字符串对多字节字符集很不安全。

Example-1

自 PHP 5.4 起字符串下标必须为整数或可转换为整数的字符串，否则会发出警告。

PHP 5.5 增加了直接在字符串原型中用[]访问字符的支持。

<?php
	$str = 'abc';
	var_dump($str['1']);
	var_dump(isset($str['1']));
	echo "<br>";

	//以下字符串下标在 PHP 5.4 以上的版本中会发出警告。
	var_dump($str['1.0']);
	var_dump(isset($str['1.0']));
	echo "<br>";
	var_dump($str['x']);
	var_dump(isset($str['x']));
	echo "<br>";
	var_dump($str['1x']);
	var_dump(isset($str['1x']));

	//PHP 5.5 支持在字符串原型中使用[]访问字符
	var_dump('abc'[0]);
	var_dump('abc'{1});//在PHP 5.6 版本中解析错误，在PHP 7.1 上运行成功
?>

Example-2

自 PHP 7.1.0 开始, 字符串支持负索引下标。

<?php
	$array = [-3 => 'foo'];
	echo "The element at index -3 is $array[-3].";
?> 

Example-3

双引号内可以解析单引号内的变量，但是在关联数组中，双引号并不能解析单引号内的索引。
解决办法是使用复杂语法{}或者去掉索引的单引号。

<?php
	$str = 'abc';
	echo "this is a '$str'".'<br/>';

	$fruit=array('a'=>'apple','b'=>'banana');
	echo "This is a $fruit['a']";  //语法错误T_ENCAPSED_AND_WHITESPACE
	//解决办法
	echo "This is a $fruit[a]";
	echo "This is a {$fruit['a']}";
	echo "This is a ${fruit['a']}";
?>

Array

PHP 中的数组实际上是一个有序映射。映射是一种把 values 关联到 keys 的类型。此类型在很多方面做了优化，因此可以把它当成真正的数组，或列表（向量），散列表（是映射的一种实现），字典，集合，栈，队列以及更多可能性。由于数组元素的值也可以是另一个数组，树形结构和多维数组也是允许的。

key 可以是 integer 或者 string。value 可以是任意类型。

如果对给出的值没有指定键名，则取当前最大的整数索引值，而新的键名将是该值加一。如果指定的键名已经有了值，则该值会被覆盖。

Example-1

只对某些单元指定键名而对其它的空置，新的键名将是该值+1，如果当前还没有整数索引，则键名将为 0.

<?php
$array = array(
         "a",
         "b",
    6 => "c",
         "d",
);
var_dump($array);
?> 

Example-2

自 5.4 起可以使用短数组定义语法，用 [] 替代 array()。

<?php
$array1 = array(
    "foo" => "bar",
    "bar" => "foo",
);
// 自 PHP 5.4 起，可使用[]代替array()
$array2 = [
    "foo" => "bar",
    "bar" => "foo",
];
?> 

Example-3

如果在数组定义中多个单元都使用了同一个键名，则只使用了最后一个，之前的都被覆盖了。

<?php
	$array = array(
	    1    => "a",
	    "1"  => "b",
	    1.5  => "c",
	    true => "d",
	);
	var_dump($array);
?> 

<?php
$array = array(0,
     1,
     "2.99999999" => 56,
     2 => 2,
     3.9999 => 3,
     3 => 3.1,
     1 => 4,
     0 => 6,
 );
print_r($array);
?> 

Examlpe-4

自 PHP 5.4 起可以用数组间接引用函数或方法调用的结果。之前只能通过一个临时变量。

自 PHP 5.5 起可以用数组间接引用一个数组原型。

<?php
	function getArray() {
	    return array(1, 2, 3);
	}
	$secondElement = getArray()[1];// on PHP 5.4

	// PHP 5.4 之前只能通过一个临时变量
	$tmp = getArray();
	$secondElement = $tmp[1];
	// or
	list(, $secondElement) = getArray();
?>

Example-5

unset() 函数允许删除数组中的某个键。但要注意数组并不会重建索引。如果需要删除后重建索引，可以用 array_values() 函数。

<?php
	// 创建一个简单的数组
	$array = array(1, 2, 3, 4, 5);
	print_r($array);
	
	// 现在删除其中的所有元素，但保持数组本身不变:
	foreach ($array as $i => $value) {
	    unset($array[$i]);
	}
	print_r($array);
	
	// 添加一个单元（注意新的键名是 5）
	$array[] = 6;
	print_r($array);
	
	// 重新索引：
	$array = array_values($array);
	$array[] = 7;
	print_r($array);
?>

Example-6

在双引号字符串中，不给索引加上引号是有效的，但是最好始终在用字符串表示的数组索引上加上引号。
以下是例子错的，但可以正常运行。错误是因为代码中有一个未定义的常量（bar）而不是字符串（’bar’－注意引号），而 PHP 可能会在以后定义此常量，不幸的是你的代码中有同样的名字。它能运行，是因为 PHP 自动将裸字符串转换成一个其值为该裸字符串的正常字符串。

<?php
	$foo[bar] = 'enemy';
	echo $foo[bar];
?>

Example-7

对于任意 integer，float，string，boolean 和 resource 类型，如果将一个值转换为数组，将得到一个仅有一个元素的数组，其下标为 0，该元素即为此标量的值。

如果一个 object 类型转换为 array，则结果为一个数组，其单元为该对象的属性。键名将为成员变量名，不过有几点例外：静态属性不可访问；私有变量前会加上类名作前缀；保护变量前会加上一个 ‘*’ 做前缀。这些前缀的前后都各有一个 NULL 字符(\0)。

<?php
	class A {
	    private $A; // 转换成数组后索引为\0A\0A
	}
	
	class B extends A {
	    private $A; // 转换成数组后索引为\0B\0A
	    public $AA; // 转换成数组后索引为AA
	}
	
	var_dump((array) new B());
?> 

Object

如果将一个对象转换成对象，它将不会有任何变化。如果其它任何类型的值被转换成对象，将会创建一个内置类 stdClass的实例。如果该值为 NULL，则新的实例为空。数组转换成对象将使键名成为属性名并具有相对应的值。对于任何其它的值，名为 scalar 的成员变量将包含该值。

Example-1

<?php
	$obj1 = (object) array('1' => 'foo', 2=>'bar');
	var_dump($obj1);  
	// outputs : object(stdClass)#1 (2) { [1]=> string(3) "foo" [2]=> string(3) "bar" }
	var_dump(isset($obj1->{'1'})); 
	// outputs : 'bool(false)'
	var_dump(key($obj1)); 
	// outputs : 'int(1)'

	$obj2 = (object) 'ciao';
	var_dump($obj2);
	echo $obj2->scalar;  // outputs : 'ciao'
?> 

Example-2

自 5.4 起可以使用短数组定义语法，创建一个stdClass对象。

<?php
   $object =(object) [
     'propertyOne' => 'foo',
     'propertyTwo' => 42,
   ];
   var_dump($object);
?>

Example-3

自 PHP 7.0.0 之后，多了以下几种创建空对象的方法。（在PHP 7.1.0上成功运行）

<?php
	$obj1 = new \stdClass; // stdClass 对象实例
	$obj2 = new class{}; // class@anonymous 对象实例
	$obj3 = (object)[]; // 空数组强转对象
	echo "<pre>";
	var_dump($obj1); // object(stdClass)#1 (0) {}
	var_dump($obj2); // object(class@anonymous)#2 (0) {}
	var_dump($obj3); // object(stdClass)#3 (0) {}
?>

Resource

资源 resource 是一种特殊变量，保存了到外部资源的一个引用。资源是通过专门的函数来建立和使用的。

由于资源类型变量保存有为打开文件、数据库连接、图形画布区域等的特殊句柄，因此将其它类型的值转换为资源没有意义。

由于 Zend 引擎引进了引用计数系统，可以自动检测到一个资源不再被引用了（和 Java 一样）。这种情况下此资源使用的所有外部资源都会被垃圾回收系统释放。因此，很少需要手工释放内存。 请注意：持久数据库连接比较特殊，它们不会被垃圾回收系统销毁。

NULL

NULL 值表示一个变量没有值。NULL 类型唯一可能的值就是 NULL。

使用 (unset) $var 将一个变量转换为 null 将不会删除该变量或 unset 其值。仅是返回 NULL 值而已。

Example-1

<?php
	$test['_string'] = "";
	$test['_int'] = 0;
	$test['_float'] = 0.0;
	$test['_null'] = null;
	$test['_arr'] = array();
	$test['_obj'] = new \stdClass; //is not null

	 foreach($test as $key => $value)
	 {
	     echo $key.": ";
	     if($value == null)
	         echo "is null\n";
	     else
	         echo "is not null\n";
	 }
	 die();
?>

Example-2

有趣的是貌似只有当变量$a="0"的时候以下条件才能成立。

<?php
	$a = '0';
	echo ($a != NULL) && ((bool)$a == NULL) ?'not null':'null';
?>

Example-3

注意unset($a)函数销毁变量和$a = NULL的区别

<?php
	// unset($a)
	$a = 5;
	$b = & $a;
	unset($a);
	print "b $b "; // b 5 

	// $a = NULL; 
	$a = 5;
	$b = & $a;
	$a = NULL;
	print "b $b "; // b 
	print(! isset($b)); // 1 
?> 

测试环境
PHP version 5.3.29/5.6.29/7.1.0
Apache 2.4.25

PHP标记的作用

• 当解析一个文件时，PHP 会寻找起始和结束标记，也就是 ，这告诉 PHP 开始和停止解析二者之间的代码。此种解析方式使得 PHP 可以被嵌入到各种不同的文档中去，而任何起始和结束标记之外的部分都会被 PHP 解析器忽略。

• PHP 也允许使用短标记 ，但不鼓励使用。只有通过激活 php.ini 中的 short_open_tag 配置指令或者在编译 PHP 时使用了配置选项 –enable-short-tags 时才能使用短标记。

• 如果文件内容是纯 PHP 代码，最好在文件末尾删除 PHP 结束标记。这可以避免在 PHP 结束标记之后万一意外加入了空格或者换行符，会导致 PHP 开始输出这些空白，而脚本中此时并无输出的意图。

变更日志

自 PHP 7.0.0 起，已经移除 ASP 标记 <%, %>, <%=和 script标记 <script language="php" > ;
自 PHP 5.4 起，短格式的 echo 标记 <?= 总会被合法识别，而不管 short_open_tag 设置的是on还是off。

开始标记<?php 后应该有空白

这里的空白指的是换行、回车、tab、空格。

Example-1

<?php 标签后没有空白echo 不起作用:

<?php/*blah*/ echo "a"?> 

以下四种空白方式都起作用:

1. <?php /*php 后面有空白[space]*/ echo "a"?>

2. <?php
/*php 后面是行结束*/ echo "a"?>

3. <?php    /*php后面是 tab*/ echo "a"?>

4. <?php 
/*php 后面是空格然后是行结束*/ echo "a"?>

标记可分离

标记分离适用于PHP和HTML混编的代码中

Example-2

<?php for ($i = 0; $i < 5; ++$i): ?>
Hello, there!
<?php endfor; ?>

结束标记?>在//单行注释中

结束标记?>在//单行注释中会退出php模式，并返回html模式

Example-3

<?php
//  $file_contents  = '<?php die(); ?>' . "\n";
 ?>

//会输出' . "\n"; ?>
//解决办法是使用 /**/块注释，或者使用字符串拼接标记
<?php
   $file_contents  = '<' . '?php die(); ?' . '>' . "\n";
?> 

测试环境
PHP version 5.3.29/5.6.29/7.1.0
Apache 2.4.25

php注释

• PHP 支持 C，C++ 和 Unix Shell 风格（Perl 风格）的注释；
• C 风格的注释在碰到第一个 */ 时结束，要确保不要嵌套 C 风格的注释;
• // … ?> 或者 # … ?> 之后的 HTML 代码将被显示出来，这是因为?> 跳出了 PHP 模式并返回了 HTML 模式;
• HTML注释里的php代码可执行，因为php不解析html方式的注释;
• 如果代码行包含正则表达式，正则表达式里包含?>字符，可以使用/**/注释此行;
• 如果代码行包含正则表达式，正则表达式里包含*/字符，最好将正则表达式分隔符改成#;

Example-1

//或#方式的单行注释到?>结束，?>跳出php模式，返回html模式。

<?php
// echo '<?php ?>';
 ?>

Example-2

php不解析html方式的注释。

<!-- comment
<?php echo some_function(); ?>
-->

Example-3

注释正则表达式的时候，//注释遇到?>字符即停止注释，可以使用块注释注释此行。

注释正则表达式的时候，/**/注释遇到*/字符即停止注释，可以使用#作为正则表达式的分隔符。

<?php

//preg_match('/^(?>c|b)at$/', 'cat', $matches);

/*
  $f->setPattern('/^\d.*/');
 */
?>

测试环境
PHP version 5.3.29/5.6.29/7.1.0
Apache 2.4.25

流程控制语句替代语法

替代语法的基本形式是把左花括号（{）换成冒号（:），把右花括号（}）分别换成 endif;，endwhile;，endfor;，endforeach; 以及 endswitch;。

Example-1

不可以在一个控制模块里混用两种流程控制语法。

<?php
$a =2;
 if($a):
     echo $a;
    if($b) {
       echo $b;
    }
else: //解析错误
    echo $c;
 endif;

Example-2

替代语法也可以写成如下形式，方便在混编代码中随意循环HTML元素。

<?php for( $a = 0; $a < 5; $a++ ) { ?>
 //可随意循环HTML元素
<?php }; ?>

Example-3

只有do while循环没有替代语法。

<?php
	//代码解析错误
	do : 
	     $a++
	 while ($a <= 10);
 

循环控制语句

Example-1

for()循环的简写形式：

<?php
	for ($i = 1, $j = 0; $i <= 10; $j += $i, print $i, $i++);

Example-2

请注意for循环表达式的执行顺序：expr1在循环开始前无条件求值（并执行）一次；expr2 在每次循环开始前求值；expr3 在每次循环之后被求值（并执行）。

<?php
	 $array = array(0 => "a", 1 => "b", 2 => "c", 3 => "d");
	 for($i = 0; $i < count($array); $i++){
	 echo $array[$i]; //outputs ab
	 unset($array[$i]);
 }

Example-3

foreach 不支持用”@”来抑制错误信息的能力。
PHP 5.5 增添了遍历一个数组的数组的功能并且把嵌套的数组解包到循环变量中，只需将 list() 作为值提供。list() 中的单元可以少于嵌套数组的，此时多出来的数组单元将被忽略。

<?php
	$array = [
	    [1, 2],
	    [3, 4],
	];
	foreach ($array as list($a, $b)) {
	    echo "A: $a; B: $b\n";  // A: 1; B: 2 A: 3; B: 4
	}

Example-4

如果想遍历多维数组，list()函数可嵌套使用。

<?php
	$array = [
	    [1, 2, array(3, array(4, 5))],
	    [3, 4, array(5, array(6, 7))],
	];

	foreach ($array as list($a, $b, list($c, list($d, $e)))) {
	    echo "A: $a; B: $b; C: $c; D: $d; E: $e;<br>";
	}

Example-5

关联数组的索引如果是由float转换过来的字符串，其索引仍然是string类型，如果是int型转换过来的字符串，其索引会强制转换成int。

<?php
	$arr = array();
	$arr[0] = "zero";            // will stay an int
	$arr["1"] = "one";            // will be cast to an int !
	$arr["two"] = "2";            // will stay a string
	$arr["3.5"] = "threeandahalf";    // will stay a string

	foreach($arr as $key => $value) {
	    var_dump($key);
	}

Example-6

PHP 7 以下代码会报错，因为break不在循环或者switch语句中，而PHP 7 之前的版本则不会报错。

<?php
	function a() {
		if (1 === 1) {
		break;
		}
		echo 'something';
	}

测试环境
PHP version 5.3.29/5.6.29/7.1.0
Apache 2.4.25

表达式

在 PHP 中，几乎所写的任何东西都是一个表达式。简单但却最精确的定义一个表达式的方式就是“任何有值的东西”。

Example-1

子表达式的操作顺序其实没那么严格。see

<?php
	function a() {echo 'a';}
	function b() {echo 'b';}
	a() == b(); // outputs "ab", 从左到右求值

	$a = 3;
	var_dump( $a == $a = 4 ); // outputs bool(true), 从右到左求值

Example-2

PHP中的逗号运算符只有在for()条件中有用，在其他的表达式中无效。

<?php
	// $a = 2, $b = 4; //无效
	// echo $a.$b."\n";

	for ($a = 2, $b = 4; $a < 3; $a++){
	   echo $a,$b."\n"; //outputs:2 4
	}

测试环境
PHP version 5.3.29/5.6.29/7.1.0
Apache 2.4.25

运算符

运算符是可以通过给出的一或多个值（表达式）来产生另一个值（因而整个结构成为一个表达式）的东西。

PHP中运算符包括如下内容：

• 运算符优先级
• 算术运算符
• 赋值运算符
• 位运算符
• 比较运算符
• 错误控制运算符
• 执行运算符
• 递增／递减运算符
• 逻辑运算符
• 字符串运算符
• 数组运算符
• 类型运算符

运算符优先级

PHP中运算符优先级请参考：运算符优先级

Example-1

注意：逻辑运算符的两套符号优先级不同，优先级从高到低依次为：&& > || > = > and > xor > or

<?php
	$bool = true && false;
	var_dump($bool); // false

	$bool = true and false;
	var_dump($bool); // true

算术运算符

• 除法运算符总是返回浮点数。只有两个操作数都是整数（或字符串转换成的整数）并且正好能整除时返回一个整数；

• 取模运算符的操作数在运算之前都会转换成整数（向下取整，除去小数部分）；

• 取模运算符 % 的结果和被除数的符号相同，即$a % $b的结果和 $a 的符号相同；

Example-1

PHP 5.6 新增幂运算符，等同于pow()函数;

<?php
   $a=3;
   $b=4;
   echo $a**$b; //PHP 5.6 新增幂运算符

Example-2

取模运算符%只在integer数据范围内有效，对较大的数进行取模运算的时候最好使用fmod()函数代替取模运算符%；

<?php
    echo 3333333333 % 3,'<br/>'; //prints -1
    echo fmod(3333333333 ,3); //prints 0
 

赋值运算符

Example-1

PHP先计算组合运算符右侧的值，最后再用左侧的变量和右侧表达式的结果进行计算；
和javascript计算结果不同。

<?php
	$a = 0;
	$a -= (++$a) + (++$a);
	echo $a; //outputs: -1,右侧计算结果为3,此时$a为2，最后结果是2-3=-1
?>

<script>
	var a = 0;
	a -= (++a) + (++a);
	alert(a); //alert: -3，等效于a=a-((++a)+(++a));
</script>

位运算符

位移在 PHP 中是数学运算。向任何方向移出去的位都被丢弃。左移时右侧以零填充，符号位被移走意味着正负号不被保留。右移时左侧以符号位填充，意味着正负号被保留。

如果位运算符&,|,^两侧都是string类型的，则按照ASCII码值进行计算，返回的结果也是string类型，其他情况下则会强制转化成整型，结果必然也是整型。

如果位运算符 ~ 是string类型的，则按照ASCII码值进行计算，返回的结果也是string类型，其他情况下则会强制转化成整型，结果必然也是整型。

位运算符<<,>>总是被转换成整型计算。

Example-1

字符串类型的位运算

<?php
if (('18' & '32') == '10') {
	//ord()返回字符串第一个字符的ASCII
    echo ord('18'); //return 十进制 49, 数字1的二进制为 110001
    echo ord('32'); //return 十进制 51, 数字3的二进制为 110011
    echo ord('10'); //return 十进制 49, 数字1的二进制为 110001
    //因此 110001 & 110011 = 110001
}