ZYF.IM BLOG

从 1Password 迁移到 Vaultwarden

Thu, 23 Apr 2026 15:06:07 +0000

背景

1Password 在尼日利亚价差优惠没有，Family Annual 1 Year ¥498 属实有些贵，同事们都推荐 Vaultwarden。

Vaultwarden 与 Bitwarden 的关系：

前置准备

一台 Debian 12 VPS（建议 1C/1G 起步即可，家用绰绰有余）
一个域名，例如 vault.example.com，在 DNS 服务商把 A 记录指向 VPS 公网 IP
一个 SMTP 邮箱（用于邀请家人、找回密码），推荐 Resend

环境初始化

apt update && apt upgrade -y

adduser evan && \
usermod -aG sudo evan

apt install -y curl ca-certificates

timedatectl set-timezone Asia/Shanghai

curl -fsSL https://get.docker.com | sh
systemctl enable --now docker
usermod -aG docker evan

部署 Vaultwarden + Caddy

su evan && cd && \
mkdir -p ~/vaultwarden && cd ~/vaultwarden && \
mkdir -p vw-data caddy-data caddy-config

vim docker-compose.yml

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    environment:
      DOMAIN: ${DOMAIN}
      ADMIN_TOKEN: ${ADMIN_TOKEN}
#      EXPERIMENTAL_CLIENT_FEATURE_FLAGS: "ssh-agent-v2,ssh-key-vault-item"
      SIGNUPS_ALLOWED: "false"
      SMTP_HOST: "smtp.resend.com"
      SMTP_FROM: ${SMTP_FROM}
      SMTP_PORT: "465"
      SMTP_SECURITY: "force_tls"
      SMTP_USERNAME: "resend"
      SMTP_PASSWORD: ${SMTP_PASSWORD}
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
    volumes:
      - ./vw-data:/data
    networks: [internal]

  caddy:
    image: caddy:2
    container_name: caddy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - ./caddy-data:/data
      - ./caddy-config:/config
    networks: [internal]

networks:
  internal:
    driver: bridge

vim .env

DOMAIN="https://vault.lizhi.dev"
SMTP_FROM="vault@notify.lizhi.dev"
SMTP_PASSWORD="re_ArLMVTZ5_F6f9J7QL4ZvsujG4fGm34GHP"
ADMIN_TOKEN='$argon2id$v=19$m=65540,t=3,p=4$OhgDeYazJhgmzIWBIRx+wSNlbIZg1yuN7WsvOgfUKrk$EUv0j+9CphudSOMNjR91yblkI+hvVCr72y1shNIfVTw'

vim Caddyfile

vault.lizhi.dev {
    encode zstd gzip
    reverse_proxy vaultwarden:80
}

docker compose up -d
docker compose logs -f

部署完成

PHP Migrating 8.4 to 8.5

Mon, 05 Jan 2026 21:33:57 +0000

简介

PHP 8.5 引入了许多令人兴奋的新特性，包括管道运算符（Pipe Operator）、URI 扩展、Clone With 语法、#[\NoDiscard] 属性等。本文将介绍主要变化和如何从 PHP 8.4 迁移到 PHP 8.5。

参考资源

在线测试环境：https://3v4l.org/
官方发布说明：https://www.php.net/releases/8.5/en.php
迁移指南：https://www.php.net/manual/en/migration85.php
更新详情：https://php.watch/versions/8.5

PHP 8.5 新特性

管道运算符（Pipe Operator）

PHP 8.5 引入了管道运算符 |>，使函数链式调用更加清晰易读：

// PHP 8.5 之前 - 嵌套函数调用，难以阅读
$slug = strtolower(str_replace('.', '', str_replace(' ', '-', trim($title))));

// PHP 8.5 - 使用管道运算符，从左到右清晰阅读
$slug = $title
    |> trim(...)
    |> (fn($str) => str_replace(' ', '-', $str))
    |> (fn($str) => str_replace('.', '', $str))
    |> strtolower(...);

管道运算符将左侧的值作为右侧函数的第一个参数传递，实现函数组合的链式调用。

URI 扩展

PHP 8.5 新增了内置的 URI 扩展，遵循 RFC 3986 和 WHATWG URL 标准来解析和处理 URL。

URI 与 URL 的关系：URI（统一资源标识符）用于标识资源，URL（统一资源定位符）用于定位资源。所有 URL 都是 URI，但不是所有 URI 都是 URL。该扩展命名为 URI 是因为它能处理更广泛的标识符格式。

示例：

// PHP 8.5 之前
$components = parse_url('https://php.net/releases/8.5/en.php');
var_dump($components['host']); // "php.net"

// PHP 8.5 - 使用新的 URI 扩展
use Uri\Rfc3986\Uri;

$uri = new Uri('https://php.net/releases/8.5/en.php');
var_dump($uri->getHost());   // "php.net"
var_dump($uri->getPath());   // "/releases/8.5/en.php"
var_dump($uri->getScheme()); // "https"

新的 URI 扩展由 uriparser 和 Lexbor 库驱动，提供更安全、更符合标准的 URI 解析 API。

Clone With 语法

PHP 8.5 简化了对象克隆时更新属性的操作，特别适用于 readonly 类的 “with-er” 模式。

什么是 “with-er” 模式：一种用于不可变对象的设计模式，方法名以 with 开头（如 withId()、withName()），不修改原对象，而是返回一个修改了某个属性的新对象。常见于 PSR-7 HTTP 消息接口和 DateTimeImmutable 等。

示例：

class Color {
    public function __construct(
        public readonly int $red,
        public readonly int $green,
        public readonly int $blue,
        public readonly int $alpha = 255,
    ) {}

    // PHP 8.5 之前
    public function withAlphaOld(int $alpha): self {
        $values = get_object_vars($this);
        $values['alpha'] = $alpha;
        return new self(...$values);
    }

    // PHP 8.5 - 使用 clone with
    public function withAlpha(int $alpha): self {
        return clone($this, ['alpha' => $alpha]);
    }
}

$color = new Color(255, 128, 0);
$transparent = $color->withAlpha(128);

#[\NoDiscard] 属性

新的 #[\NoDiscard] 属性用于标记函数返回值不应被忽略：

#[\NoDiscard("检查操作是否成功")]
function saveData(array $data): bool {
    // 保存数据...
    return true;
}

// 忽略返回值会触发警告
saveData(['key' => 'value']);
// Warning: return value of saveData() should be used or cast to (void)

// 正确使用
$success = saveData(['key' => 'value']);
if (!$success) {
    // 处理错误
}

// 显式忽略（不会警告）
(void) saveData(['key' => 'value']);

常量表达式中的闭包

PHP 8.5 允许在属性、常量和默认值中使用静态闭包和一等可调用对象：

class Validator {
    public const RULES = [
        'email' => filter_var(...),
        'trim' => trim(...),
    ];
}

function process(
    callable $callback = strtoupper(...)
): string {
    return $callback('hello');
}

新的 curl_share_init_persistent() 函数可以跨请求维护 cURL 共享句柄：

// 创建持久化的共享句柄
$share = curl_share_init_persistent('my-share-handle');

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_SHARE, $share);
curl_exec($ch);

PHP 8.5 新增函数

array_first() 和 array_last()

获取数组的第一个或最后一个元素，数组为空时返回 null：

$events = ['login', 'view_page', 'checkout', 'logout'];

$first = array_first($events);  // 'login'
$last = array_last($events);    // 'logout'

$empty = [];
var_dump(array_first($empty));  // null
var_dump(array_last($empty));   // null

get_error_handler() 和 get_exception_handler()

获取当前注册的错误处理器和异常处理器：

// 设置自定义错误处理器
set_error_handler(function($errno, $errstr) {
    echo "Error: $errstr";
});

// 获取当前错误处理器
$handler = get_error_handler();
var_dump($handler); // Closure

// 获取当前异常处理器
$exceptionHandler = get_exception_handler();

IntlListFormatter 类

新的国际化列表格式化类：

$formatter = new IntlListFormatter('zh-CN', IntlListFormatter::TYPE_AND);
echo $formatter->format(['苹果', '香蕉', '橙子']);
// 输出: 苹果、香蕉和橙子

$formatter = new IntlListFormatter('en-US', IntlListFormatter::TYPE_OR);
echo $formatter->format(['apple', 'banana', 'orange']);
// 输出: apple, banana, or orange

curl_multi_get_handles()

从 multi-cURL 会话中获取所有句柄：

$mh = curl_multi_init();
$ch1 = curl_init('https://example.com/1');
$ch2 = curl_init('https://example.com/2');

curl_multi_add_handle($mh, $ch1);
curl_multi_add_handle($mh, $ch2);

$handles = curl_multi_get_handles($mh);
var_dump(count($handles)); // 2

locale_is_right_to_left() / Locale::isRightToLeft()

判断语言环境是否使用从右到左的文字方向：

var_dump(locale_is_right_to_left('ar'));    // true (阿拉伯语)
var_dump(locale_is_right_to_left('he'));    // true (希伯来语)
var_dump(locale_is_right_to_left('zh-CN')); // false (中文)
var_dump(Locale::isRightToLeft('fa'));      // true (波斯语)

grapheme_levenshtein()

计算两个字符串之间的 Levenshtein 编辑距离（基于字形簇）：

$distance = grapheme_levenshtein('café', 'cafe');
var_dump($distance); // 1

Closure::getCurrent()

在闭包内部获取当前闭包实例，便于实现递归：

$factorial = function(int $n): int {
    if ($n <= 1) return 1;
    return $n * Closure::getCurrent()($n - 1);
};

echo $factorial(5); // 120

其他改进

致命错误包含堆栈跟踪

PHP 8.5 中，致命错误现在会包含完整的堆栈跟踪信息，大大提升了调试体验。

新的 DOM 方法

$doc = new DOMDocument();
$doc->loadHTML('A
B
');

// getElementsByClassName()
$elements = $doc->getElementsByClassName('box');
echo $elements->length; // 2

// insertAdjacentHTML()
$div = $doc->querySelector('div');
$div->insertAdjacentHTML('beforeend', 'New');

属性可以应用于常量

class MyClass {
    #[Deprecated("Use NEW_CONST instead")]
    public const OLD_CONST = 'old';

    public const NEW_CONST = 'new';
}

静态属性支持非对称可见性

class Counter {
    public private(set) static int $count = 0;

    public static function increment(): void {
        self::$count++;
    }
}

echo Counter::$count; // 可读
Counter::$count = 10; // 错误：不可写

构造函数提升支持 final 属性

class User {
    public function __construct(
        public final string $id,
        public string $name,
    ) {}
}

setcookie() 支持 “partitioned” 选项

setcookie('name', 'value', [
    'expires' => time() + 3600,
    'path' => '/',
    'secure' => true,
    'partitioned' => true,  // 新选项
]);

新的全局常量

// 构建提供者标识
echo PHP_BUILD_PROVIDER; // 例如: "debian" 或 "remi"

// 构建日期
echo PHP_BUILD_DATE; // 例如: "Jan 1 2026"

CLI 新选项

# 显示与默认值不同的 INI 配置
php --ini=diff

max_memory_limit INI 指令

管理员可以设置内存限制的上限：

; php.ini
max_memory_limit = 256M

应用程序无法将 memory_limit 设置为超过 max_memory_limit 的值。

弃用特性

反引号运算符（shell_exec 别名）

// ❌ PHP 8.5 已弃用
$output = `ls -la`;

// ✅ 使用 shell_exec()
$output = shell_exec('ls -la');

非标准类型转换

// ❌ PHP 8.5 已弃用
$bool = (boolean) $value;
$int = (integer) $value;
$float = (double) $value;
$bin = (binary) $value;

// ✅ 使用标准类型转换
$bool = (bool) $value;
$int = (int) $value;
$float = (float) $value;
$bin = (string) $value;

mysqli_execute()

// ❌ 已弃用
mysqli_execute($stmt);

// ✅ 使用 mysqli_stmt_execute()
mysqli_stmt_execute($stmt);

curl_close() 和 curl_share_close()

这些函数自 PHP 8.0 起就是空操作，现在正式弃用：

// ❌ 已弃用（实际上不需要调用）
curl_close($ch);
curl_share_close($sh);

// cURL 句柄现在会自动清理

xml_parser_free()

// ❌ 已弃用（自 PHP 8.0 起是空操作）
xml_parser_free($parser);

// XML 解析器现在会自动清理

socket_set_timeout()

// ❌ 已弃用
socket_set_timeout($stream, 30);

// ✅ 使用 stream_set_timeout()
stream_set_timeout($stream, 30);

MHASH_* 常量

所有 MHASH_* 相关常量已弃用，应使用 hash() 函数替代。

sleep() 和 wakeup()

这两个魔术方法被软弃用（soft-deprecated），建议使用 __serialize() 和 __unserialize() 替代：

// ❌ 软弃用
class OldStyle {
    public function __sleep(): array {
        return ['data'];
    }
    public function __wakeup(): void {}
}

// ✅ 推荐方式
class NewStyle {
    public function __serialize(): array {
        return ['data' => $this->data];
    }
    public function __unserialize(array $data): void {
        $this->data = $data['data'];
    }
}

case 语句后使用分号

// ❌ PHP 8.5 已弃用
switch ($value) {
    case 1;  // 分号
        break;
}

// ✅ 使用冒号
switch ($value) {
    case 1:  // 冒号
        break;
}

null 作为数组偏移量

// ❌ PHP 8.5 已弃用
$array[null] = 'value';

// ✅ 使用空字符串或其他明确的键
$array[''] = 'value';

移除的特性

disable_classes INI 设置

disable_classes INI 设置已被完全移除。

CLI -z / –zend-extension 选项

从命令行加载 Zend 扩展的选项已被移除。

兼容性变化

类型转换警告

NAN 转换为其他类型时会产生警告
浮点数转整数时的精度损失会产生警告
对非数组使用解构语法会产生警告

class_alias() 限制

“array” 和 “callable” 不再是 class_alias() 的有效类名。

总结

PHP 8.5 带来了许多实用的新特性和改进：

主要新特性：

管道运算符 |>
URI 扩展
Clone With 语法
#[\NoDiscard] 属性
array_first() 和 array_last() 函数
常量表达式中的闭包
致命错误堆栈跟踪
IntlListFormatter 类

需要注意的变化：

反引号运算符已弃用
非标准类型转换已弃用
__sleep() 和 __wakeup() 软弃用
disable_classes INI 设置已移除

通过了解这些变化并遵循迁移建议，可以顺利地从 PHP 8.4 迁移到 PHP 8.5。

NGINX 启用 HTTP/3

Fri, 27 Jun 2025 10:12:12 +0000

简介

HTTP/2 解决了"多路复用、头部压缩、优先级"等 HTTP/1.x 的瓶颈，但仍受 TCP 先天限制。

HTTP/3 则把同样的语义搬到 QUIC。Quick UDP Internet Connections 是 Google 设计的一种基于 UDP 的多路复用安全传输层协议。标准化后，HTTP/3 = HTTP over QUIC。

层级	HTTP/2	HTTP/3
传输	TCP（必）+ TLS 1.2/1.3（多数场景）	QUIC（UDP 之上）+ TLS 1.3（强制）
流（Stream）	Mux 在 TCP 里的逻辑流	Mux 在 QUIC 原生流
头压缩	HPACK	QPACK（避免队头阻塞）

HTTP/2 浏览器要求必须跑在 TLS 之上（ALPN=“h2”）。栈变为 HTTP/2 → TLS → TCP → IP。
HTTP/3 使用 QUIC 替换 TCP，栈变为 HTTP/3 → QUIC（拥塞/重传）→ UDP → IP，加密集成在 QUIC（基于 TLS 1.3）。
Mux 即 multiplex，多路复用。
HTTP/2 必须顺序传输，而 HTTP/3 支持乱序。
如果沿用 HPACK，丢一个 UDP 包就会让所有流的头部解码卡住，因此 IETF 为 HTTP/3 设计了 QPACK 来"避开队头阻塞（Head-of-Line Blocking, HoL）"。
连接迁移：通过 Connection ID 识别会话，IP 或端口改变（如移动网络/Wi-Fi 切换）无需重新建立连接。

使用 HTTP/3 的网站：

https://cloudflare-quic.com/

开始实验

启用 HTTP/3 需要使用 HTTPS，请先参考在本地环境使用 HTTPS ｜ ZYF.IM。

修改 NGINX default.conf 配置文件，启用 HTTP/3：

# vi default.conf
server {
    # for better compatibility it's recommended
    # to use the same port for http/3 and https
    # 浏览器首次只能走 TCP，因此必须提供一个 HTTPS 入口，再通过 `Alt-Svc` 升级到 HTTP/3
    listen 443 ssl;
    # Quick UDP Internet Connections
    # quic 关键字表示使用 UDP 监听，承载 QUIC/HTTP-3
    # reuseport 关键字表示复用端口，允许多个 NGINX 实例共享同一端口
    listen 443 quic reuseport;

    http2 on;
    # 启用 HTTP/3，默认是 on
    http3 on;

    server_name localhost;
    ssl_certificate /etc/ssl/certs/localhost.pem;
    ssl_certificate_key /etc/ssl/certs/localhost-key.pem;

    # 启用 TLS 允许 0-RTT（Early Data），允许客户端在 TLS 1.3 的重连阶段携带早期数据
    # 对 HTTP/3 非必需，但 QUIC 天生支持 0-RTT；此处保持一致
    ssl_early_data on;

    # 仅启用 TLSv1.3
    ssl_protocols TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    # 添加 Alt-Svc 头，向客户端声明可升级到 HTTP/3
    # Alt-Svc 头告诉浏览器"该资源在同一主机的 UDP/443 上能用 h3 协议"，浏览器会自动重试
    # ma max-age 缓存时间，86400 秒 = 1 天
    # always 关键字保证即使发生 4xx/5xx 也发送 Alt-Svc，便于调试
    add_header alt-svc 'h3=":443"; ma=86400' always;

    location / {
        root /usr/share/nginx/html;
        index  index.html index.htm;
    }
}

# docker rm -f nginx-ssl

# 添加监听 UDP 端口
docker run -d --name nginx-ssl \
  -p 443:443 \
  -p 443:443/udp \
  -v ./default.conf:/etc/nginx/conf.d/default.conf:ro \
  -v ./localhost.pem:/etc/ssl/certs/localhost.pem:ro \
  -v ./localhost-key.pem:/etc/ssl/certs/localhost-key.pem:ro \
  -v ./html/:/usr/share/nginx/html/:ro \
  nginx:alpine

# docker container restart nginx-ssl

测试

curl

# 使用支持 HTTP/3 的 curl
# docker run -ti --rm alpine/curl-http3 curl -V
docker run -ti --network host --rm alpine/curl-http3 curl -I --http3 https://localhost/

HTTP/3 200
server: nginx/1.29.0
date: Fri, 27 Jun 2025 03:26:09 GMT
content-type: text/html
content-length: 656
last-modified: Fri, 27 Jun 2025 03:17:07 GMT
etag: "685e0d33-290"
alt-svc: h3=":443"; ma=86400
accept-ranges: bytes

浏览器

无法验证成功！分析原因：

之前 UDP 使用的是 8443，当将相关配置都改为 443 仍然在 Chrome Network 里无法看见 h3。
可能 Chrome 对 localhost 或者域名解析到 127.0.0.1 的访问阻止了 HTTP/3。

为了验证第 2 种情况，通过 AWS EC2 + 自己的域名 + Let’s Encrypt 颁发的证书，再仿照本地配置的方法启用 HTTP/3。最终在 Chrome 中成功验证 HTTP/3。

使用 Chrome 插件 HTTP Indicator：

HTTP/1.1 显示为灰色
HTTP/2 显示为蓝色
HTTP/3 显示为绿色

如何配置 AWS EC2 + 自己的域名 + Let’s Encrypt 颁发的证书，参考：

使用 Certbot 获取 Let’s Encrypt 颁发的 TLS 证书｜ ZYF.IM

References

NGINX HTTP/3 模块

– EOF –

在本地环境使用 HTTPS

Thu, 26 Jun 2025 12:00:00 +0000

公网环境使用 HTTPS 参考：使用 Certbot 获取 Let’s Encrypt 颁发的 TLS 证书｜ ZYF.IM。

简介

HTTPS（HyperText Transfer Protocol Secure）是在 HTTP 之上通过 TLS/SSL 实现加密的安全通信协议，用来保护浏览器与服务器之间的数据机密性、完整性与身份可信性。

开始实验

mkcert 会在本地生成一套根 CA（包含根证书和私钥），并把根证书导入系统/浏览器的信任列表。随后，它用这套 CA 的私钥为 localhost 等域名签发服务器证书；因为根证书已被信任，浏览器访问时就会把服务器证书视为可信。

brew install mkcert
mkcert -install
mkcert localhost
# The certificate is at "./localhost.pem" and the key at "./localhost-key.pem" ✅

# vi default.conf
server {
    listen 443 ssl;

    server_name localhost;
    ssl_certificate /etc/ssl/certs/localhost.pem;
    ssl_certificate_key /etc/ssl/certs/localhost-key.pem;

    # 只允许 TLSv1.2 和 TLSv1.3 协议，显式禁止 TLSv1.0 和 TLSv1.1 协议
    ssl_protocols TLSv1.2 TLSv1.3;
    # 只保留高强度、带身份验证、且不使用 MD5 的 TLS 1.2（及以下）套件
    ssl_ciphers HIGH:!aNULL:!MD5;
    # 优先使用服务器端加密套件
    ssl_prefer_server_ciphers on;

    location / {
        root /usr/share/nginx/html;
        index  index.html index.htm;
    }
}

docker run -d --name nginx-ssl \
  -p 8443:443 \
  -v ./default.conf:/etc/nginx/conf.d/default.conf:ro \
  -v ./localhost.pem:/etc/ssl/certs/localhost.pem:ro \
  -v ./localhost-key.pem:/etc/ssl/certs/localhost-key.pem:ro \
  nginx:alpine

# docker rm -f nginx-ssl
# docker container restart nginx-ssl

测试

浏览器

浏览器访问 https://localhost:8443/，如果证书是绿色的，说明成功了。

curl

curl -I https://localhost:8443/

HTTP/1.1 200 OK
Server: nginx/1.29.0
Date: Fri, 27 Jun 2025 01:54:36 GMT
Content-Type: text/html
Content-Length: 615
Last-Modified: Tue, 24 Jun 2025 17:57:38 GMT
Connection: keep-alive
ETag: "685ae712-267"
Accept-Ranges: bytes

# -v 显示详细信息，查看 TLS 版本
curl -I https://localhost:8443/ -v

...
* SSL connection using TLSv1.3 / AEAD-AES256-GCM-SHA384 / [blank] / UNDEF
...

深入探索

HTTP 的三大安全缺陷

网络早已布满监听、篡改与伪装。

明文传输：任何中间节点（Wi-Fi 热点、ISP、CDN、政府网关）都能直接读取用户名、密码、Cookie、表单内容等敏感信息。
缺少完整性保护：中间人可随意插入、删除或修改页面内容（广告注入、恶意脚本、暗链植入），客户端亦无法察觉。
无法验证身份：客户端无法确认自己连接的是"真正的 server"，攻击者可通过 DNS 欺骗、ARP 攻击或流量劫持将流量导向钓鱼站点。

为什么需要 HTTPS

TLS 通过"加密 + 身份认证 + 完整性校验"应对上述风险。

加密（Confidentiality）：对称加密保护数据内容；密钥通过非对称算法安全协商。
数据完整性（Integrity）：MAC（消息鉴别码）或 AEAD 算法确保内容未被篡改。
身份认证（Authentication）：服务器出示数字证书；浏览器验证证书链与域名匹配。

MAC vs AEAD

MAC 提供数据完整性与对称实体认证，需要与独立的加密步骤结合来保障机密性。
- Message Authentication Code
- 只负责"认证"，不加密数据；与加密算法解耦。典型实现是 HMAC-SHA1/HMAC-SHA256。
AEAD 将"加密 + 认证"合二为一，接口更简单、实现更安全、性能更佳，是现代协议的首选。
- Authenticated Encryption with Associated Data
- 加密数据 + 认证数据
- 典型实现是 AES-GCM/ChaCha20-Poly1305
在 TLS/QUIC/Noise 等现代协议中，AEAD 已全面取代传统的"MAC-then-Encrypt"。

证书类型

按层级角色：

根证书（Root CA）：最高级别，Subject = Issuer 自签名，预装在操作系统/浏览器的"根信任库"内，用于验证下级证书。
中级证书（Intermediate CA）：由根证书签名，用于验证下级证书，降低根密钥泄露风险。
最终实体证书（End Entity Certificate）：由中级证书签名，绑定具体域名或主体，用于验证服务器身份。

按验证级别：

DV（Domain Validation）证书仅验证域名所有权，通过自动化流程颁发，价格低廉甚至免费（如 Let’s Encrypt）。
OV（Organization Validation）证书需要验证组织实体信息，在浏览器证书详情中可查看公司名称。
EV（Extended Validation）证书验证最为严格，地址栏会显示公司名称，但多数现代浏览器已弱化此功能的 UI 展示。

证书链

在 HTTPS、TLS、S/MIME 等基于 X.509 的公钥基础设施（PKI）中，任何一张服务器或用户证书都必须被"信任根（Root CA）“间接或直接签名。从根证书一路向下到最终实体证书所形成的"逐级签名"路径，就称为证书链，也叫信任链（Chain of Trust）。

HTTPS 在网络堆栈中的位置

HTTP/HTTPS 仍是应用层协议。
TLS（Transport Layer Security）位于 HTTP 与 TCP 之间；它把上层的明文字节（HTTP 报文）加密后再交给 TCP。
TCP 提供可靠的字节流；IP 负责寻址和路由；最底层是物理/链路层。
HTTPS = HTTP over TLS over TCP over IP。

协议	主要职责	典型端口
HTTP	应用语义：URL、方法、头、状态码…	80（无加密）
TLS	机密性、完整性、身份认证	443（惯例）
TCP	可靠传输、流量控制、重传	任意（443）
IP	路由、分片、寻址	—

HTTPS ≠ 新协议。它只是"HTTP 报文透过 TLS 隧道运输"的俗称。协议栈中依然能看到标准的 HTTP 语法，只是先被 TLS 加密，运输途中看不到明文。
TLS 与 TCP 的独立性。TLS 不关心丢包、重传；这些由 TCP 处理。相反，TCP 不理解证书、握手；这些由 TLS 负责。

TLS 握手过程

客户端                           服务器
   |<--- SYN → SYN/ACK → ACK --->| 建立可靠的 TCP 连接

   |--- ClientHello (TLS)    --->| 浏览器发起 TLS 握手，告诉服务器自己支持的协议版本、密码套件、随机数（Client Random）等信息
   |<-- ServerHello + 证书     ---|
   |--- 密钥协商/Finished ------->|
   |<-- Finished ----------------|

   TLS 信道建立完成
   |--- HTTP GET / ------------->|
   |<-- HTTP/1.1 200 OK ---------|

sequenceDiagram
  participant Client
  participant Server
  Client->>Server: ClientHello
– 支持的 TLS 版本、随机数、加密套件
  Server-->>Client: ServerHello
– 选定版本/套件、随机数
  Server-->>Client: Certificate
  Server-->>Client: ServerHelloDone
  Client->>Server: ClientKeyExchange
– 预主密钥（用公钥加密）
  Client->>Server: ChangeCipherSpec
  Client->>Server: Finished（用对称密钥加密）
  Server-->>Client: ChangeCipherSpec
  Server-->>Client: Finished
  note over Client,Server: 之后开始对称加密的数据传输

双方首先协商算法与随机数
客户端用服务器公钥加密预主密钥
双方基于随机数与预主密钥生成会话密钥
后续通信全部使用对称加密，提高效率

TLS 1.3

TLS 1.3（RFC 8446）是在 2018 年 8 月正式发布的最新版本，相比 TLS 1.2 做了深度"瘦身 + 加速 + 强化安全”。

TLS 1.3 把握手变成 1-RTT 并引入 0-RTT，显著降低延迟。
强制 ECDHE + AEAD + SHA-2，淘汰所有过时与高危算法，默认提供前向保密。
握手更多字段被加密，降低被动监听价值，同时带来运维与抓包新挑战。
配置侧仅需保留少量推荐套件（TLS_AES_128_GCM_SHA256、TLS_CHACHA20_POLY1305_SHA256 等），比 TLS 1.2 更易运维。

RTT vs. 0-RTT

“RTT"本身确实是一个时间量（Round-Trip Time），指数据包从客户端发出、到达服务端，再把响应返回客户端所经历的往返延迟，常用毫秒（ms）表示。

在协议说明里看到的"1-RTT 握手 / 2-RTT 握手"属于约定俗成的缩写：把"一次往返时间"抽象成"一次来回（round trip）“这个计数单位来用。

证书与密钥

openssl version
# 看看证书
openssl x509 -in localhost.pem -noout -text

证书的结构：

Certificate:
｜- Data:
  ｜- Version: 3
  ｜- Serial Number: ...
  ｜- Signature Algorithm: sha256WithRSAEncryption
  ｜- Issuer: O=mkcert development CA, OU=..., CN=mkcert ...
  ｜- Validity:
    ｜- Not Before: Jun 27 03:39:39 2025 GMT
    ｜- Not After : Sep 27 03:39:39 2027 GMT
  ｜- Subject: O=mkcert development CA, OU=...
  ｜- Subject Public Key Info: <网站的公钥>
    ｜- Public Key Algorithm: rsaEncryption
      ｜- Public-Key: (2048 bit)
      ｜- Modulus: <模数>
      ｜- Exponent: 65537 (0x10001)
   |- X509v3 extensions
｜- Signature Algorithm: sha256WithRSAEncryption
｜- Signature Value: <颁发机构（CA）用自己私钥算出的数字签名，浏览器用 CA 公钥验证>

在 RSA 体系里，公钥由两部分组成：

n：模数（Modulus）
e：公钥指数（Exponent）

# 导出公钥
openssl x509 -in localhost.pem -pubkey -noout > pubkey.pem
# 查看导出的公钥
openssl pkey -pubin -in pubkey.pem -text -noout

# 看看私钥里有什么
openssl rsa -in localhost-key.pem -text -noout

私钥的结构：

Private-Key: (2048 bit, 2 primes)
# 模 n = p × q
modulus: ...
# e 公钥指数
publicExponent: 65537 (0x10001)

# m = c^d mod n
privateExponent: ...

# p 和 q 是两个大质数
prime1: ...
prime2: ...

# exponent1 = d mod (p-1)
exponent1: ...
# exponent2 = d mod (q-1)
exponent2: ...
# coefficient = inv(q) mod p
coefficient: ...

HTTP/2

当前使用的是 HTTP/1.1，如何启用 HTTP/2，请移步 NGINX 启用 HTTP/2 ｜ ZYF.IM。

HTTP/3

请移步 NGINX 启用 HTTP/3 ｜ ZYF.IM。

References

– EOF –

PHP Migrating 8.3 to 8.4

Sat, 01 Feb 2025 17:42:42 +0000

简介

PHP 8.4 引入了许多新特性，如属性钩子（Property Hooks）、非对称可见性（Asymmetric Visibility）、#[Deprecated] 属性以及更新的 DOM API 等。本文将介绍主要变化和如何进行迁移。

参考资源

在线测试环境：https://onlinephp.io/
官方发布说明：https://www.php.net/releases/8.4/en.php
迁移指南：https://www.php.net/manual/en/migration84.php
更新详情：https://php.watch/versions/8.4

PHP 8.4 新特性

属性钩子与非对称可见性

// 属性钩子（Property Hooks）与非对称可见性（Asymmetric Visibility）
class User {
    private bool $isModified = false;
    public function __construct(public private(set) string $first, private string $last)
    {
    }
    public string $fullName {
        get => $this->first . " " . $this->last;
        set {
            [$this->first, $this->last] = explode(' ', $value, 2);
            $this->isModified = true;
        }
    }
}
$user = new User("Ming", "Li");
echo $user->fullName; // 输出: Ming Li
$user->fullName = "Hong Xiao";
echo $user->fullName; // 输出: Hong Xiao

// 非对称可见性示例
echo $user->first; // 输出: Hong
$user->first = "Hua";
// 错误: Fatal error: Uncaught Error: Cannot modify private(set) property User::$first

属性钩子允许我们定义属性的获取和设置行为，而非对称可见性允许我们为属性设置不同的读写权限。在上例中，$first 属性可以公开读取但只能私有写入。

#[Deprecated] 属性

PHP 8.4 引入了 #[Deprecated] 属性，可以用来标记已弃用的代码：

#[Deprecated("Use newFunction() instead", since: "2.0")]
function oldFunction(): void {
    // ...
}

oldFunction();
// Warning: Function oldFunction() is deprecated, Use newFunction() instead

这使得开发者可以在自己的代码库中使用与 PHP 内部相同的弃用机制。

增强的 DOM API

PHP 8.4 更新了 DOM API，提供了更现代、更易用的接口：

// 新的 DOM API 示例
$doc = \Dom\HTMLDocument::createFromString('Hello
');

// 使用 querySelector 和 querySelectorAll
$span = $doc->querySelector('span');
echo $span->textContent; // 输出: Hello

// 使用 innerHTML/outerHTML
$div = $doc->querySelector('div');
echo $div->innerHTML; // 输出: Hello
$div->innerHTML = 'World
';
echo $div->outerHTML; // 输出: World

BCMath 的对象 API

// BCMath 的对象 API
use BcMath\Number;
$num1 = new Number('0.12345');
$num2 = new Number('2');
$result = $num1 + $num2;
echo $result; // 输出: '2.12345'
var_dump($num1 > $num2); // 输出: false

// PHP 8.4 之前的写法
$num1 = '0.12345';
$num2 = 2;
$result = bcadd($num1, $num2, 5);
echo $result; // 输出: '2.12345'
var_dump(bccomp($num1, $num2) > 0); // 输出: false

// 新增 bcdivmod() 函数 - 同时返回商和余数
[$quotient, $remainder] = bcdivmod('10', '3', 2);
echo $quotient;  // 输出: 3
echo $remainder; // 输出: 1.00

PHP 8.4 为 BCMath 引入了对象 API，使用起来更加直观和面向对象。

HTTP/3 支持

PHP 8.4 的 cURL 扩展新增了 HTTP/3 支持：

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_3);
// 或强制使用 HTTP/3
curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_3ONLY);
$response = curl_exec($ch);

其他新增的 cURL 选项包括：CURLOPT_PREREQFUNCTION、CURLOPT_DEBUGFUNCTION、CURLOPT_SERVER_RESPONSE_TIMEOUT、CURLOPT_TCP_KEEPCNT。

PHP 8.4 新增函数

新的数组操作函数

// array_find() - 查找第一个满足条件的元素
$animal = array_find(
    ['dog', 'cat', 'cow', 'duck', 'goose'],
    static fn (string $value): bool => str_starts_with($value, 'c'),
);
var_dump($animal); // 输出: string(3) "cat"

// array_find_key() - 查找第一个满足条件的元素的键
$key = array_find_key(
    ['a' => 1, 'b' => 2, 'c' => 3],
    fn($v) => $v > 1
);
var_dump($key); // 输出: string(1) "b"

// array_any() - 检查是否至少有一个元素满足条件
$result = array_any([1, 2, 3, 4], fn($n) => $n > 3); // true

// array_all() - 检查是否所有元素都满足条件
$result = array_all([1, 2, 3, 4], fn($n) => $n > 0); // true

新的字符串处理函数

// 多字节字符串修剪函数
$str = "　こんにちは　"; // 包含全角空格
echo mb_trim($str);   // "こんにちは"
echo mb_ltrim($str);  // "こんにちは　"
echo mb_rtrim($str);  // "　こんにちは"

// 多字节首字母大小写转换
echo mb_ucfirst('ñoño'); // "Ñoño"
echo mb_lcfirst('ÑoÑo'); // "ñoÑo"

// 按字形簇拆分字符串
$chars = grapheme_str_split('👨‍👩‍👧‍👦');
var_dump($chars); // ['👨‍👩‍👧‍👦']

日期时间新方法

// 从时间戳创建 DateTime 对象
$dt = DateTime::createFromTimestamp(1704067200);
$dti = DateTimeImmutable::createFromTimestamp(1704067200.123456);

// 微秒处理
$dt = new DateTime();
echo $dt->getMicrosecond(); // 获取微秒
$dt->setMicrosecond(500000); // 设置微秒

round() 函数新舍入模式

// PHP 8.4 新增舍入模式
echo round(1.5, 0, PHP_ROUND_HALF_UP);       // 2 (四舍五入)
echo round(1.5, 0, PHP_ROUND_HALF_DOWN);     // 1 (五舍六入)
echo round(1.5, 0, PHP_ROUND_HALF_EVEN);     // 2 (银行家舍入)
echo round(1.5, 0, PHP_ROUND_HALF_ODD);      // 1 (舍入到奇数)
echo round(1.2, 0, PHP_ROUND_CEILING);       // 2 (向上取整)
echo round(1.8, 0, PHP_ROUND_FLOOR);         // 1 (向下取整)
echo round(-1.5, 0, PHP_ROUND_TOWARD_ZERO);  // -1 (向零取整)
echo round(-1.5, 0, PHP_ROUND_AWAY_FROM_ZERO); // -2 (远离零取整)

// 注意：无效的舍入模式现在会抛出 ValueError

其他新函数

// request_parse_body() - 解析请求体
[$_POST, $_FILES] = request_parse_body();

// HTTP 响应头处理
$headers = http_get_last_response_headers(); // 获取最后一次响应头
http_clear_last_response_headers(); // 清除响应头缓存

// IANA 时区 ID
echo intltz_get_iana_id('Asia/Shanghai'); // 获取规范时区 ID

兼容性与迁移

弃用特性

隐式可空类型

// ❌ PHP 8.4 已弃用
function save(Book $book = null) {}

// ✅ 修复方法：显式声明可空类型
function save(?Book $book = null) {}

在 PHP 8.4 中，隐式可空类型已被弃用，需要使用问号（?）显式声明可空类型。

其他弃用

// ❌ E_STRICT 常量已弃用
error_reporting(E_ALL & ~E_STRICT);

// ❌ session_set_save_handler() 超过 2 个参数已弃用
session_set_save_handler($open, $close, $read, $write, $destroy, $gc);

// ✅ 使用 SessionHandlerInterface
session_set_save_handler(new MySessionHandler(), true);

// ❌ CSV 函数的 $escape 参数默认值已弃用，需显式传递
fgetcsv($handle, 0, ',', '"'); // 需要传递第四个参数

// ❌ CURLOPT_BINARYTRANSFER 已弃用（实际上从未有任何效果）

行为变化

exit/die 变为函数

exit 和 die 从语言结构变为函数，这意味着：

// 现在可以作为 callable 使用
$callback = exit(...);

// 参数类型更严格
exit(new stdClass()); // TypeError: exit(): Argument #1 ($status) must be of type string|int

常量类型变化

// PHP_ZTS 和 PHP_DEBUG 从 int 变为 bool
var_dump(PHP_ZTS);   // bool(true) 或 bool(false)
var_dump(PHP_DEBUG); // bool(true) 或 bool(false)

已移除的扩展

以下扩展从 PHP 核心移至 PECL：

Pspell - 拼写检查扩展
IMAP - 邮件协议扩展
OCI8 - Oracle 数据库扩展
PDO-OCI - Oracle PDO 驱动

如需继续使用，需从 PECL 安装。

最低版本要求

OpenSSL：最低版本 1.1.1
libcurl：最低版本 7.61.0
Bcrypt：密码哈希默认 cost 从 10 提升到 12

总结

PHP 8.4 带来了许多实用的新特性和改进：

主要新特性：

属性钩子和非对称可见性
#[Deprecated] 属性
现代化的 DOM API
BCMath 对象 API
HTTP/3 支持
新的数组和字符串函数

需要注意的变化：

隐式可空类型已弃用
exit/die 变为函数
部分扩展移至 PECL
依赖库最低版本要求提升

通过了解这些变化并遵循迁移建议，可以顺利地从 PHP 8.3 迁移到 PHP 8.4。

PHP Migrating 8.2 to 8.3

Thu, 01 Aug 2024 17:37:13 +0000

简介

PHP 8.3 引入了许多新特性，包括类型化类常量（Typed Class Constants）、#[\Override] 属性、json_validate() 函数、只读属性的深度克隆等。本文将介绍主要变化和如何从 PHP 8.2 迁移到 PHP 8.3。

参考资源

在线测试环境：https://onlinephp.io/
官方发布说明：https://www.php.net/releases/8.3/en.php
迁移指南：https://www.php.net/manual/en/migration83.php
更新详情：https://php.watch/versions/8.3

PHP 8.3 新特性

类型化类常量（Typed Class Constants）

PHP 8.3 允许为类常量声明类型，增强了类型安全性：

interface DatabaseInterface {
    public const string ENGINE = 'mysql';
}

trait ConfigTrait {
    final protected const int MAX_CONNECTIONS = 100;
}

enum Status: string {
    public const string DEFAULT = 'pending';
    case Pending = 'pending';
    case Active = 'active';
}

class Database implements DatabaseInterface {
    use ConfigTrait;

    // 类型遵循 LSP（里氏替换原则），子类可以收窄类型
    public const string ENGINE = 'postgresql';
}

类常量类型遵循里氏替换原则（LSP），子类可以收窄父类常量的类型：

class ParentClass {
    public const string|int VALUE = 'MyValue';
}

class ChildClass extends ParentClass {
    // ✅ 可以将 string|int 收窄为 string
    public const string VALUE = 'MyValue';
}

#[\Override] 属性

新的 #[\Override] 属性确保方法确实覆盖了父类方法，有助于捕获拼写错误和简化重构：

class ParentClass {
    protected function setUp(): void {}
}

class ChildClass extends ParentClass {
    #[\Override]
    protected function setUp(): void {} // ✅ 正确覆盖

    #[\Override]
    protected function setUpP(): void {} // ❌ Fatal error: 父类没有该方法
}

这在重构时特别有用 - 如果父类方法被重命名或删除，PHP 会立即报错而不是静默失败。

动态类常量和枚举成员访问

PHP 8.3 支持使用变量语法访问类常量，无需使用 constant() 函数：

class Config {
    const DATABASE = 'mysql';
    const CACHE = 'redis';
}

$key = 'DATABASE';

// PHP 8.3 之前
echo constant(Config::class . "::{$key}");

// PHP 8.3 - 新语法
echo Config::{$key}; // 输出: mysql

同样适用于枚举：

enum Color: string {
    case Red = '#FF0000';
    case Green = '#00FF00';
}

$color = 'Red';
echo Color::{$color}->value; // 输出: #FF0000

只读属性的深度克隆

PHP 8.3 允许在 __clone() 方法中重新初始化只读属性，解决了深度克隆的问题：

readonly class User {
    public function __construct(
        public string $name,
        public DateTime $createdAt,
    ) {}

    public function __clone(): void {
        // PHP 8.3 允许在 __clone() 中修改只读属性
        $this->createdAt = clone $this->createdAt;
    }
}

$user1 = new User('Alice', new DateTime());
$user2 = clone $user1;
// $user2->createdAt 现在是独立的副本

json_validate() 函数

新的 json_validate() 函数用于验证 JSON 字符串语法，比 json_decode() 更高效：

// 验证 JSON 语法
var_dump(json_validate('{"name": "PHP", "version": 8.3}')); // true
var_dump(json_validate('{invalid json}')); // false
var_dump(json_validate('[1, 2, 3]')); // true

// 相比 json_decode()，不需要解码完整内容，更节省内存
if (json_validate($jsonString)) {
    $data = json_decode($jsonString);
}

Random 扩展增强

PHP 8.3 为 Random 扩展增加了新方法：

$randomizer = new Random\Randomizer();

// getFloat() - 生成指定范围的随机浮点数
echo $randomizer->getFloat(0, 10); // 例如: 6.7810757668383

// 使用边界类型
echo $randomizer->getFloat(
    0,
    10,
    Random\IntervalBoundary::ClosedOpen  // [0, 10)
);

// nextFloat() - 生成 [0, 1) 范围的随机浮点数
echo $randomizer->nextFloat(); // 例如: 0.21185336351144

// getBytesFromString() - 从指定字符集生成随机字符串
$chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
echo $randomizer->getBytesFromString($chars, 16); // 例如: a7b3x9k2m5n8p1q4

匿名类可以是只读的

$instance = new readonly class {
    public function __construct(
        public string $name = 'Anonymous',
    ) {}
};

echo $instance->name; // Anonymous

INI 环境变量回退值

PHP 8.3 支持在 INI 文件中为环境变量设置回退值：

; 如果 DB_HOST 环境变量未设置，使用 localhost 作为默认值
database.host = ${DB_HOST:-localhost}

PHP 8.3 新增函数

mb_str_pad() - 多字节字符串填充

// 填充多字节字符串到指定长度
echo mb_str_pad('中国', 6, '爱', STR_PAD_RIGHT) . "\n"; // 中国爱爱爱爱
echo mb_str_pad('中国', 6, '爱', STR_PAD_LEFT) . "\n";  // 爱爱爱爱中国
echo mb_str_pad('中国人', 6, '爱', STR_PAD_BOTH) . "\n"; // 爱中国人爱爱

str_increment() 和 str_decrement()

// 字符串递增
echo str_increment('a');   // 'b'
echo str_increment('z');   // 'aa'
echo str_increment('A9');  // 'B0'
echo str_increment('foo'); // 'fop'

// 字符串递减
echo str_decrement('b');   // 'a'
echo str_decrement('aa');  // 'z'
echo str_decrement('B0');  // 'A9'

stream_context_set_options()

// 设置流上下文选项
$context = stream_context_create();
stream_context_set_options($context, [
    'http' => [
        'method' => 'GET',
        'header' => 'Accept: application/json',
    ],
]);

DateTime 新方法

// 从 DateTime 创建 DateTimeImmutable
$dt = new DateTime('2024-01-01');
$immutable = DateTimeImmutable::createFromMutable($dt);

// IntlCalendar 新方法
$calendar = IntlCalendar::createInstance();
$calendar->setDate(2024, 0, 15);           // 设置日期
$calendar->setDateTime(2024, 0, 15, 10, 30, 0); // 设置日期时间

DOM 扩展新方法

$doc = new DOMDocument();
$doc->loadHTML('Hello
');
$element = $doc->getElementById('main');

// 获取所有属性名
$names = $element->getAttributeNames(); // ['class', 'id']

// 切换属性
$element->toggleAttribute('hidden'); // 添加 hidden 属性
$element->toggleAttribute('hidden'); // 移除 hidden 属性

// 检查包含关系
$parent = $doc->documentElement;
var_dump($parent->contains($element)); // true

// 获取根节点
$root = $element->getRootNode();

// 比较节点
var_dump($element->isEqualNode($element)); // true

命令行 Linter 改进

# PHP 8.3 支持同时检查多个文件
php -l file1.php file2.php file3.php

# 输出:
# No syntax errors detected in file1.php
# No syntax errors detected in file2.php
# No syntax errors detected in file3.php

弃用特性

get_class() 和 get_parent_class() 无参数调用

class MyClass {
    public function getName(): string {
        // ❌ PHP 8.3 已弃用
        return get_class();

        // ✅ 使用 $this 或 self
        return get_class($this);
        // 或
        return self::class;
    }

    public function getParentName(): string {
        // ❌ PHP 8.3 已弃用
        return get_parent_class();

        // ✅ 使用 $this 或 self
        return get_parent_class($this);
        // 或
        return parent::class;
    }
}

Assert 相关设置

// ❌ 以下 INI 设置已弃用
// assert.active
// assert.bail
// assert.callback
// assert.exception
// assert.warning

// ❌ assert_options() 函数已弃用
assert_options(ASSERT_ACTIVE, true);

// ✅ 使用 ini_set() 替代
ini_set('zend.assertions', 1);

MT_RAND_PHP 变体

// ❌ PHP 8.3 已弃用
mt_srand(1234, MT_RAND_PHP);

// ✅ 使用默认的 Mersenne Twister 实现
mt_srand(1234, MT_RAND_MT19937);

兼容性变化

空数组负索引行为变化

$arr = [];
$arr[-5] = 'a';
$arr[] = 'b';

var_dump($arr);
// PHP 8.3:    [-5 => 'a', -4 => 'b']
// PHP < 8.3: [-5 => 'a', 0 => 'b']

range() 函数行为变化

// PHP 8.3 更严格地处理参数类型
range('a', 'z');           // ✅ 正常
range(1, 10);              // ✅ 正常
range(1.5, 5.5);           // ✅ 正常
range('a', 1);             // ⚠️ PHP 8.3 会产生警告

SQLite3 默认错误模式

// PHP 8.3 中 SQLite3 默认使用异常模式
$db = new SQLite3(':memory:');
// 错误现在会抛出异常而不是返回 false

DateTime 异常类型细化

PHP 8.3 为 DateTime 相关操作引入了更具体的异常类型：

try {
    new DateTime('invalid date');
} catch (DateMalformedStringException $e) {
    // PHP 8.3 新增的具体异常类型
    echo $e->getMessage();
}

unserialize() 错误级别提升

// PHP 8.3 将 E_NOTICE 提升为 E_WARNING
// 反序列化时的错误现在产生警告而不是通知
$data = unserialize('invalid');

其他改进

gc_status() 返回更多信息

$status = gc_status();
// PHP 8.3 返回额外的垃圾回收信息
var_dump($status);
// 包含 running, protected, full 等新字段

类别名支持内置类

// PHP 8.3 允许为内置类创建别名
class_alias('stdClass', 'MyStdClass');
$obj = new MyStdClass();

OpenSSL EC 密钥生成

// 使用自定义参数生成 EC 密钥
$config = [
    'curve_name' => 'prime256v1',
    'private_key_type' => OPENSSL_KEYTYPE_EC,
];
$key = openssl_pkey_new($config);

总结

PHP 8.3 带来了许多实用的新特性和改进：

主要新特性：

类型化类常量
#[\Override] 属性
动态类常量访问
只读属性的深度克隆
json_validate() 函数
Random 扩展增强
mb_str_pad() 函数

需要注意的变化：

空数组负索引行为变化
get_class() 和 get_parent_class() 无参数调用已弃用
Assert 相关 INI 设置已弃用
SQLite3 默认使用异常模式
DateTime 异常类型细化

通过了解这些变化并遵循迁移建议，可以顺利地从 PHP 8.2 迁移到 PHP 8.3。

PHP Migrating 8.1 to 8.2

Mon, 01 Jul 2024 09:24:50 +0000

简介

PHP 8.2 引入了许多类型系统改进，包括只读类（Readonly Classes）、析取范式类型（DNF Types）、独立的 null、true、false 类型、敏感参数隐藏、新的 Random 扩展等。本文将介绍主要变化和如何从 PHP 8.1 迁移到 PHP 8.2。

参考资源

在线测试环境：https://onlinephp.io/
官方发布说明：https://www.php.net/releases/8.2/en.php
迁移指南：https://www.php.net/manual/en/migration82.php
更新详情：https://php.watch/versions/8.2

PHP 8.2 新特性

只读类（Readonly Classes）

PHP 8.2 允许将整个类声明为只读，类中的所有属性自动成为只读属性：

readonly class User {
    public function __construct(
        public string $username,
        public string $email,
    ) {}
}

$user = new User('john_doe', 'john@example.com');
echo $user->username; // john_doe

$user->email = 'new@example.com';
// Fatal error: Cannot modify readonly property User::$email

只读类的特性：

所有属性自动成为只读
不能有动态属性
所有属性必须有类型声明
子类也必须是只读的

析取范式类型（DNF Types）

析取范式（Disjunctive Normal Form）允许组合联合类型和交叉类型，交叉类型必须用括号分组：

// 接受同时实现 Countable 和 Iterator 的对象，或者 null
function process((Countable&Iterator)|null $item): int {
    return $item ? count($item) : 0;
}

// 更复杂的 DNF 类型示例
function handle(
    (HTMLRequest&RequestInterface)|APIRequest|null $request
): Response {
    // 处理请求
}

DNF 类型必须遵循特定格式：交叉类型用括号包裹，再与其他类型用 | 连接。

独立的 null、true、false 类型

PHP 8.2 允许将 null、true、false 作为独立的类型使用：

// 函数总是返回 false
function alwaysFalse(): false {
    return false;
}

// 函数总是返回 true
function alwaysTrue(): true {
    return true;
}

// 函数总是返回 null
function alwaysNull(): null {
    return null;
}

// 实际应用示例：失败时返回 false
function findUser(int $id): User|false {
    $user = // 查询数据库...
    return $user ?? false;
}

这比使用 bool 或 ?type 提供了更精确的类型信息。

Trait 中的常量

PHP 8.2 允许在 Trait 中定义常量：

trait NetworkTrait {
    public const TIMEOUT = 60;
    private const MAX_RETRIES = 3;

    public function getTimeout(): int {
        return self::TIMEOUT;
    }
}

class HttpClient {
    use NetworkTrait;

    public function connect(): void {
        echo "Timeout: " . self::TIMEOUT; // 60
    }
}

// 通过使用 Trait 的类访问常量
echo HttpClient::TIMEOUT; // 60

敏感参数隐藏（#[\SensitiveParameter]）

新的 #[\SensitiveParameter] 属性可以在堆栈跟踪中隐藏敏感数据：

function hashPassword(
    #[\SensitiveParameter] string $password
): string {
    debug_print_backtrace();
    return password_hash($password, PASSWORD_DEFAULT);
}

hashPassword('my_secret_password');
// PHP 8.1: #0 example.php(8): hashPassword('my_secret_password')
// PHP 8.2: #0 example.php(8): hashPassword(Object(SensitiveParameterValue))

这对于防止密码、API 密钥等敏感信息在错误日志中泄露非常有用。

新的 Random 扩展

PHP 8.2 重构了随机数生成，提供了面向对象的 API：

// 使用默认引擎
$randomizer = new \Random\Randomizer();

// 生成随机整数
echo $randomizer->getInt(1, 100);

// 生成随机字节
echo bin2hex($randomizer->getBytes(16));

// 随机打乱数组
$array = [1, 2, 3, 4, 5];
$shuffled = $randomizer->shuffleArray($array);

// 随机打乱字符串
$string = "Hello";
echo $randomizer->shuffleBytes($string);

// 使用特定引擎
$secure = new \Random\Randomizer(new \Random\Engine\Secure());
$mt = new \Random\Randomizer(new \Random\Engine\Mt19937(seed: 1234));

可用的引擎：

\Random\Engine\Secure - 加密安全的随机数
\Random\Engine\Mt19937 - Mersenne Twister 算法
\Random\Engine\PcgOneseq128XslRr64 - PCG 算法
\Random\Engine\Xoshiro256StarStar - Xoshiro256** 算法

#[\AllowDynamicProperties] 属性

由于动态属性已被弃用，如果仍需使用，可以用此属性标记类：

#[\AllowDynamicProperties]
class LegacyClass {
    public string $declared = 'value';
}

$obj = new LegacyClass();
$obj->undeclared = 'dynamic'; // 不会产生弃用警告

枚举中获取常量

PHP 8.2 允许在枚举表达式中获取常量：

enum Status: string {
    case Active = 'active';
    case Inactive = 'inactive';

    const DEFAULT = self::Active;
}

echo Status::DEFAULT->value; // active

PHP 8.2 新增函数

ini_parse_quantity()

解析 PHP INI 格式的数据大小值：

// 解析 INI 格式的容量值
echo ini_parse_quantity('256M');  // 268435456 (256 * 1024 * 1024)
echo ini_parse_quantity('1G');    // 1073741824
echo ini_parse_quantity('512K');  // 524288

memory_reset_peak_usage()

重置峰值内存使用量跟踪：

// 初始峰值
echo memory_get_peak_usage(); // 例如: 2097152

// 进行一些内存密集操作
$data = str_repeat('x', 1000000);
echo memory_get_peak_usage(); // 例如: 3145728

// 重置峰值
memory_reset_peak_usage();
unset($data);

echo memory_get_peak_usage(); // 重置后的新峰值

mysqli_execute_query()

简化 MySQLi 预处理语句的执行：

// PHP 8.2 之前
$stmt = $mysqli->prepare('SELECT * FROM users WHERE id = ?');
$stmt->bind_param('i', $id);
$stmt->execute();
$result = $stmt->get_result();

// PHP 8.2 - 使用 mysqli_execute_query()
$result = mysqli_execute_query(
    $mysqli,
    'SELECT * FROM users WHERE id = ?',
    [$id]
);

// 面向对象写法
$result = $mysqli->execute_query(
    'SELECT * FROM users WHERE id = ?',
    [$id]
);

curl_upkeep()

保持持久 HTTP 连接活跃：

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_exec($ch);

// 保持连接活跃
curl_upkeep($ch);

openssl_cipher_key_length()

获取 OpenSSL 加密算法所需的密钥长度：

echo openssl_cipher_key_length('aes-256-cbc'); // 32
echo openssl_cipher_key_length('aes-128-gcm'); // 16
echo openssl_cipher_key_length('des-ede3-cbc'); // 24

sodium_crypto_stream_xchacha20_xor_ic()

XChaCha20 加密函数，支持初始计数器：

$key = sodium_crypto_stream_xchacha20_keygen();
$nonce = random_bytes(SODIUM_CRYPTO_STREAM_XCHACHA20_NONCEBYTES);
$message = 'Hello, World!';

// 使用初始计数器加密
$encrypted = sodium_crypto_stream_xchacha20_xor_ic(
    $message,
    $nonce,
    1,  // 初始计数器
    $key
);

弃用特性

动态属性弃用

在未声明的类属性上进行读写操作已被弃用：

class User {
    public string $name;
}

$user = new User();
$user->name = 'John';        // ✅ 正常
$user->age = 25;             // ⚠️ Deprecated: Creation of dynamic property

// 解决方案 1：声明属性
class User {
    public string $name;
    public int $age;
}

// 解决方案 2：使用 #[AllowDynamicProperties]
#[\AllowDynamicProperties]
class User {
    public string $name;
}

// 解决方案 3：使用 __get/__set 魔术方法
class User {
    private array $data = [];

    public function __get(string $name): mixed {
        return $this->data[$name] ?? null;
    }

    public function __set(string $name, mixed $value): void {
        $this->data[$name] = $value;
    }
}

stdClass 和从 __get()/__set() 继承的类不受影响。

${var} 字符串插值弃用

旧的 ${var} 字符串插值语法已被弃用：

$name = 'PHP';

// ❌ 已弃用
echo "Hello ${name}";
// Deprecated: Using ${var} in strings is deprecated, use {$var} instead

// ❌ 变量变量也已弃用
$var = 'name';
echo "Hello ${$var}";
// Deprecated: Using ${expr} in strings is deprecated, use {${expr}} instead

// ✅ 推荐写法
echo "Hello {$name}";
echo "Hello {$$var}";

utf8_encode() 和 utf8_decode() 弃用

这两个函数已被弃用，因为它们只支持 Latin-1 编码：

// ❌ 已弃用
$encoded = utf8_encode($string);
$decoded = utf8_decode($string);

// ✅ 使用 mbstring
$encoded = mb_convert_encoding($string, 'UTF-8', 'ISO-8859-1');
$decoded = mb_convert_encoding($string, 'ISO-8859-1', 'UTF-8');

// ✅ 或使用 iconv
$encoded = iconv('ISO-8859-1', 'UTF-8', $string);
$decoded = iconv('UTF-8', 'ISO-8859-1', $string);

部分可调用模式弃用

一些可调用模式已被弃用：

// ❌ 已弃用的可调用模式
"self::method"
"parent::method"
"static::method"
["self", "method"]
["parent", "method"]
["static", "method"]
["Foo", "Bar::method"]
[new Foo, "Bar::method"]

// ✅ 使用一等可调用语法
$callable = $this->method(...);
$callable = self::method(...);
$callable = Foo::method(...);

Mbstring 编码弃用

以下 Mbstring 编码已被弃用：

BASE64
UUENCODE
HTML-ENTITIES
Quoted-Printable

// ❌ 已弃用
$encoded = mb_convert_encoding($data, 'BASE64');

// ✅ 使用专门的函数
$encoded = base64_encode($data);
$decoded = base64_decode($encoded);

// ✅ HTML 实体使用
$encoded = htmlentities($string, ENT_QUOTES, 'UTF-8');
$decoded = html_entity_decode($encoded, ENT_QUOTES, 'UTF-8');

兼容性变化

strtolower() 和 strtoupper() 不再受区域设置影响

setlocale(LC_ALL, 'tr_TR');

// PHP 8.1: 受区域设置影响
// PHP 8.2: 始终按 ASCII 规则处理
echo strtolower('I'); // 'i'（不再是土耳其语的 'ı'）
echo strtoupper('i'); // 'I'（不再是土耳其语的 'İ'）

// 需要区域敏感转换时使用 mbstring
echo mb_strtolower('I', 'tr_TR'); // 'ı'

str_split() 空字符串行为变化

// PHP 8.1: 返回 ['']
// PHP 8.2: 返回 []
$result = str_split('');
var_dump($result); // array(0) {}

ksort() SORT_REGULAR 行为变化

$arr = ['b' => 1, 'a' => 2, 10 => 3, 2 => 4];
ksort($arr, SORT_REGULAR);

// PHP 8.2 中排序更加一致
// 数字键和字符串键的比较规则更加明确

日期时间扩展变化

// DateTimeImmutable 和 DateTime 的行为更加一致
// DatePeriod 现在是可迭代的

$period = new DatePeriod(
    new DateTime('2024-01-01'),
    new DateInterval('P1D'),
    5
);

// 可以使用 foreach 遍历
foreach ($period as $date) {
    echo $date->format('Y-m-d');
}

其他改进

ReflectionMethod 和 ReflectionProperty 改进

// 检查方法是否可以作为静态方法调用
$reflection = new ReflectionMethod(MyClass::class, 'myMethod');
var_dump($reflection->isStatic());

// 检查属性是否是只读
$reflection = new ReflectionProperty(User::class, 'name');
var_dump($reflection->isReadOnly());

ZipArchive 新方法

$zip = new ZipArchive();
$zip->open('archive.zip', ZipArchive::CREATE);

// 获取文件流
$stream = $zip->getStreamIndex(0);
$stream = $zip->getStreamName('file.txt');

// 清除错误状态
$zip->clearError();

ODBC 和 PDO_ODBC 改进

连接字符串和凭证检查得到改进，支持更多的 ODBC 功能。

总结

PHP 8.2 带来了许多实用的新特性和改进：

主要新特性：

只读类
析取范式类型（DNF Types）
独立的 null、true、false 类型
Trait 中的常量
敏感参数隐藏
新的 Random 扩展

需要注意的变化：

动态属性已弃用
${var} 字符串插值已弃用
utf8_encode() 和 utf8_decode() 已弃用
strtolower() 和 strtoupper() 不再受区域设置影响
部分可调用模式已弃用

通过了解这些变化并遵循迁移建议，可以顺利地从 PHP 8.1 迁移到 PHP 8.2。

MongoDB 高手课

Wed, 19 Apr 2023 10:47:10 +0000

04 特色及优势

对象模型，快速响应业务变化：

多形性：同一个集合中可以包含不同字段（类型）的文档对象。
动态性：线上修改数据模式，修改是应用与数据库均无须下线。
数据治理：支持使用JSONSchema 来规范数据模式。在保证模式灵活动态的前提下，提供数据治理能力。

快速的开发：

只存储在一个存储区读写。
反范式、无关联的组织极大优化查询速度。
程序 API 自然，开发速度快。

原生的高可用：

Replica Set - 2 to 50 个成员，建议单数。
自恢复。
多中心容灾能力。
滚动服务，最小化服务终端。

横向扩展能力：

需要的时候无缝扩展。
应用全透明。
多种数据分布策略。
轻松支持 TB-PB 数量级。

06 基本操作

tar -xvf dump.tar.gz
mongorestore --uri="mongodb://root:root@10.130.0.12/?&authMechanism=SCRAM-SHA-1"

// 插入
db.fruit.insertOne({name: "apple"})
db.fruit.insertMany([
  {name: "apple"},
  {name: "pear"},
  {name: "orange"},
])
// 查询
db.customers.find({username: "fmiller", name: "Elizabeth Ray"})
db.customers.find({username: /^f/})
db.customers.find({$or: [{username: /^f/}, {name: /^E/}]})

a <> 1 {a: {$ne: 1}}
a > 1 {a: {$gt: 1}}
a >= 1 {a: {$gte: 1}}
a < 1 {a: {$lt: 1}}
a <= 1 {a: {$lte: 1}}
a=1 OR b=1 {$or: [{a: 1}, {b: 1}]}
a IS NULL {a: {$exists: false}}
a IS (1,2,3) {a: {$in: [1, 2, 3]}}

// 同时满足
{$eleMatch: {"city": "Rome", "country": "USA"}}

// 投影 projection
// like select
db.customers.find({username: /^f/}, {name: 0, email: 0})
db.customers.find({username: /^f/}, {_id: 1, name: 1})

// remove
db.customers.remove({username: "abrown"})

// update
db.customers.updateOne({username: "fmiller"}, {$set: {from: "China"}})
db.customers.updateMany({username: "fmiller"}, {$set: {from: "China"}})
// $set $unset
// $push $pushAll $pop 数组操作
// $pull $pullAll 如果匹配，从数组中删除相应的对象
// $addToSet 如果不存在则增加一个值到数组

// drop
db.fruit.drop()
show collections

db
db.dropDatabase()
show dbs

08 聚合查询

Aggregation Framework

Pipeline
Stage

pipeline = [stage1, stage2, ...]
db.<collection>.aggregate(
  pipeline,
  { option }
)

$match 过滤
$project 投影
$sort 排序
$group 分组
$skip $limit 结果限制
$lookup 左外连接

09 聚合查询实验

// 计算总合计
db.orders.aggregate([
    {
        $group: {
            _id: null,
            total: {$sum: "$total"}
        }
    }
])
// {
//     "_id": null,
//     "total": NumberDecimal("44019609")
// }

// 查询 2019 第一季度，已完成订单（completed）总金额（金额+运费）和订单总数
db.orders.aggregate([
    {
        $match: {
            status: "completed",
            orderDate: { $gte: ISODate("2019-01-01"), $lt: ISODate("2019-04-01") }
        }
    },
    {
        $group: {
            _id: null,
            total: { $sum: "$total" },
            shippingFee: { $sum: "$shippingFee" },
            count: { $sum: 1 }
        }
    },
    {
        $project: {
            grandTotal: { $add: ["$total", "$shippingFee"] },
            count: 1,
            _id: 0
        }
    }
])
// {
//     "count": 5875,
//     "grandTotal": NumberDecimal("2636376")
// }

10 复制集机制及原理

由3个以上具有投票权的节点组成：

1个主节点 PRIMARY：接收写入操作和选举时投票。
两个或多个从节点 SECONDARY：复制主节点上的新数据和选举时投票。

数据是如何复制的：

当一个修改操作，无论是插入、更新或删除，到达主节点时它对数据的操作将被记录下来(经过些必要的转换)，这些记录称为 oplog。
从节点通过在主节点上打开一个 tailable 游标不断获取新进入主节点的 oplog，并在自己的数据上回放，以此保持跟主节点的数据一致。

通过选举完成故障恢复：

具有投票权的节点之间两两互相发送心跳。
当5次心跳未收到时判断为节点失联。
如果失联的是主节点，从节点会发起选举，选出新的主节点。
如果失联的是从节点则不会产生新的选举。
选举基于RAFT一致性算法实现，选举成功的必要条件是大多数投票节点存活。
复制集中最多可以有50个节点，但具有投票权的节点最多7个。

影响选举的因素：

整个集群必须有大多数节点存活。
被选举为主节点的节点必须：
- 能够与多数节点建立连接
- 具有较新的 oplog
- 具有较高的优先级(如果有配置)

复制集节点有以下常见的选配项：

是否具有投票权（v 参数）：有则参与投票。
优先级（priority 参数）：优先级越高的节点越优先成为主节点。优先级为0的节点无法成为主节点。
隐藏（hidden 参数）：复制数据，但对应用不可见。隐藏节点可以具有投票仅，但优先级必须为0。
延迟（slaveDelay 参数）：复制 n 秒之前的数据，保持与主节点的时间差。

复制集注意事项：

关于硬件：
- 因为正常的复制集节点都有可能成为主节点，它们的地位是一样的，因此硬件配置上必须致；
- 为了保证节点不会同时岩机，各节点使用的硬件必须具有独立性。
关于软件：
- 复制集各节点软件版本必须一致，以避免出现不可预知的问题。
增加节点不会增加系统写性能！

11 搭建 MongoDB 复制集

mkdir -p runtime/data_db{1,2,3} && \
mkdir -p runtime/data_configdb{1,2,3}

hostname -f

rs.status()

12 全家桶

13 模型设计基础

Entity
Attribute
Relationship

概念模型 CDM -> 逻辑模型 LDM -> 物理模型 PDM 对象 -> 实体、属性、关系 -> 表结构、字段列表、主外建

14 JSON 文档模型设计

无模式的由来：可以省略无论建模的具体过程，物理模型可省。

设计原则：

性能 Performance
开发易用 Ease of Development

15 基础设计

集合、字段、基础形状 -> 引用及关联 -> 最终模式

业务需求及逻辑模型 –逻辑导向-> 基础建模 —> 集合、字段、基础形状

一个文档 16MB max.

内嵌为主。

16 工况细化

技术需求、读写比例、方式及数据 –技术导向-> 工况细化 —> 引用及关联

引用模式 $lookup：

db.contacts.aggregate([
  $lookup: {
    form: "groups",
    localField: "groups_ids",
    foreignField: "groups_id",
    as: "groups",
  }
])

使用引用方式：

内嵌文档太大
内嵌文档或数组元素频繁修改
内嵌文档数组元素持续增长且没有封顶

使用引用的设计：

没有主外键的检查
$lookup 只支持 left outer join
$lookup 的关系目标（from）不能是分片表

17 模式套用

经验和学习 –模式导向-> 套用设计模式 -> 优化的模型

时序数据，分桶设计：利用文档内嵌组，将一个时间段的数据聚合到一个文档里。大量减少文档数据量，大量减少索引占用空间。

18 设计模式集锦

大文档，很多字段，很多索引。列转行。列数据变化为数组。多语言多国家属性，类似字段需要建立很多索引。转化为数组，一个索引解决所有查询问题。

模型灵活了，如何管理文档不同版本？增加一个版本字段。schema_version。

统计网页点击流量。近似计算。if random(0,9)==0 increment by 10。

业绩排名、游戏排名等精确统计。消耗资源多，聚合计算时间长。用预聚合字段。模型中直接增加统计字段，每次更新数据时同时更新统计值。

19 写操作事务 writeConcern

write-concern | mongodb

{ w: , j: , wtimeout:  }

rs.status();
db.test.drop()
db.test.insert({count:2}, {writeConcern: {w: "majority"}})
db.test.insert({count:2}, {writeConcern: {w: 3}})
db.test.insert({count:2}, {writeConcern: {w: 1}})
// WriteResult({ "nInserted" : 1, "writeConcernError" : [ ] })

db.test.insert({count:2}, {writeConcern: {w: 4}})
// [Error] 100 - Not enough data-bearing nodes

db.test.find()

// 配置延迟节点，模拟网络延迟
conf=rs.conf()
// {
//     "_id": 3,
//     "host": "mongo3:27017",
//     "arbiterOnly": false,
//     "buildIndexes": true,
//     "hidden": false,
//     "priority": 1,
//     "tags": { },
//     "slaveDelay": NumberLong("0"),
//     "votes": 1
// }
conf.members[2].slaveDelay=5
// 没有选举权
conf.members[2].priority=0
rs.reconfig(conf)
// {
//     "_id": 3,
//     "host": "mongo3:27017",
//     "arbiterOnly": false,
//     "buildIndexes": true,
//     "hidden": false,
//     "priority": 0,
//     "tags": { },
//     "slaveDelay": NumberLong("5"),
//     "votes": 1
// }

db.test.insert({count:2}, {writeConcern: {w: 3}})
// Result Time 5s

// 3s 超时
db.test.insert({count:5}, {writeConcern: {w: 3, wtimeout:3000}})
// writeResult({
//         "nInserted" : 1,
//         "writeConcernError" : {
//                 "code" : 64,
//                 "codeName" : "WriteConcernFailed",
//                 "errmsg" : "waiting for replication timed out",
//                 "errInfo" : {
//                         "wtimeout" : true,
//                         "writeConcern" : {
//                                 "w" : 3,
//                                 "wtimeout" : 3000,
//                                 "provenance" : "clientSupplied"
//                         }
//                 }
//         }
// })

20 读操作事务 readPreference

配置：

mongodb://…/?replicaSet=rs&readPrefence=secondary
通过驱动API，MongoCollection.withReadPrefence(ReadPrefence readPref)
Mongo Shell: db.collection.find({}).readPref(“secondary”)

实验：

// 主节点
db.test.drop()
db.test.insert({count:2}, {writeConcern: {w: 3}})
db.test.find({})
// 1 line
db.test.find({}).readPref("secondary")
// 1 line

// 从节点 1、2
db.test.find({})
// 1 line
db.fsyncLock()
// now locked against writes, use db.fsyncUnlock() to unlock 锁住写入

// 主节点
db.test.insert({count:3})
db.test.find({})
// 2 line
db.test.find().readPref("secondary")
// 1 line

// 从节点 1、2
db.fsyncUnlock()
// 主节点
db.test.find().readPref("secondary")

21 读操作事务 readConcern

read-concern | mongodb

enableMajorityReadConcern: true

// 从节点 1、2
db.fsyncLock()
// 主节点
db.test.insert({count:3})
db.test.find().readConcern("local")
// 如果在一个写操作到达大多数节点前读取了这个写操作，然后因为系统故障该操作回滚了，则发生了脏读
// {readConcern: "majority"} 可以避免脏读
db.test.find().readConcern("majority")

majority 约为：Read Committed。

22 多文档事务

Atomocity 原子性
Consistency 一致性 writeConcern,readConcern
Isolation 隔离性 readConcern
Durability 持久性 Journal and Replication

实验启用事务后的隔离性：

db.tx.drop();
db.tx.insertMany([{x:1},{x:2}]);
var session = db.getMongo().startSession();
session.startTransaction();
var coll = session.getDatabase('test').getCollection('tx');
coll.updateOne({x:2}, {$set: {y:1}});
// {
//   acknowledged: true,
//   insertedId: null,
//   matchedCount: 1,
//   modifiedCount: 1,
//   upsertedCount: 0
// }
coll.find();
// [
//   { _id: ObjectId("64478074fcfac90fb90f1a65"), x: 1 },
//   { _id: ObjectId("64478074fcfac90fb90f1a66"), x: 2, y: 1 }
// ]
db.tx.find();
// [
//   { _id: ObjectId("64478074fcfac90fb90f1a65"), x: 1 },
//   { _id: ObjectId("64478074fcfac90fb90f1a66"), x: 2 }
// ]
session.commitTransaction();
db.tx.find();

实验可重复读 Repeatable Read：

db.tx.drop();
db.tx.insertMany([{x:1},{x:2}]);
var session = db.getMongo().startSession();
session.startTransaction({
  readConcern: {"level": "snapshot"},
  writeConcern: {"w": "majority"}
});
var coll = session.getDatabase('test').getCollection('tx');
coll.findOne({x: 1});
// 模拟事务之外的操作
db.tx.updateOne({x:1}, {$set: {y:1}});
db.tx.find();
// [
//   { _id: ObjectId("644782c3fcfac90fb90f1a69"), x: 1, y: 1 },
//   { _id: ObjectId("644782c3fcfac90fb90f1a6a"), x: 2 }
// ]
coll.findOne({x: 1});
// { _id: ObjectId("644782c3fcfac90fb90f1a69"), x: 1 }
session.abortTransaction();

实验写冲突：

db.tx.drop();
db.tx.insertMany([{x:1},{x:2}]);
// shell 1、2
var session = db.getMongo().startSession();
session.startTransaction({
  readConcern: {"level": "snapshot"},
  writeConcern: {"w": "majority"}
});
var coll = session.getDatabase('test').getCollection('tx');
// shell 1
coll.updateOne({x:1}, {$set: {y:1}});
// ok

// shell 2
coll.updateOne({x:1}, {$set: {y:1}});
// MongoServerError: WriteConflict error: this operation conflicted with another operation. Please retry your operation or multi-document transaction.
// session.abortTransaction();

事务默认 60s 内完成。
多文档事务中的读操作必须使用主节点读。

23 Change Stream

类似触发器。

触发方式：异步 | 同步（事务保证）
触发位置：回调事件 | 数据库触发器
触发次数：每个订阅事件的客户端 | 1次
故障恢复：从上此断点重新触发 | 事务回滚

基于 oplog 实现。被追踪的变更事件主要包括：

insert/update/delete
drop
rename
dropDatabase
invalidate：drop/rename/dropDatabase 将导致 invalidate 被触发，并关闭 chage stream

可重复读。未开启 majority readConcern 的集群无法使用 Change Stream。当集群无法满足 {w: “majority”} 时，不会触发 Change Stream。

可以使用集合管道的过滤步骤过滤事件。

25 分片集群机制及原理

路由节点 mongos
配置节点 mongod
数据节点 mongod

分片集群数据发布方式

基于范围查询性能好，数据分布可能不均匀
基于哈希发布均匀，范围查询效率低；日志、物联网
Zone 数据天然分区

25 分片集群设计

片键 shard key 文档中的一个字段
文档 doc
块 chunk
分片 shard
集群 cluster

片键：

取值基数范围要大
取值范围应尽可能均匀
对主要查询要具有定向能力

组合片键。{user_id:1, time:1}

27 分片集群搭建及扩容

# 1 配置域名解析
# 2 准备分片目录

# 3 创建第1个分片复制集 member1:27010 member3:27010 member5:27010
mongod --bind_ip_all --replSet shard1 --shardsvr --wiredTigerCacheSizeGB 1
# --shardsvr 标注为分片节点
# --wiredTigerCacheSizeGB 1 缓存大小
# 4 初始化分片复制集

# 5 创建 config server 复制集 member1:27019 member3:27019 member5:27019
mongod --bind_ip_all --replSet config --configsvr --wiredTigerCacheSizeGB 1
# --configsvr 标注为配置节点
# 6 创建 config server 复制集

# 7 搭建 mongos member1:27017
mongos --bind_ip_all --configdb config/member1:27019,member3:27019,member5:27019,
# 连接到 mongos 添加分片
sh.addShard("shard1/member1:27010,member3:27010,member5:27010")

# 8 创建分片表
# 连接到 mongos member1:27017
sh.enableSharding("foo");
sh.shardCollection("foo.bar", {_id: "hashed"});
sh.status();
# 插入测试数据
use foo
for(var i=0;1<10000;i++) {
  db.bar.insert({i:i))
}

# 9 创建第2个分片复制集  member2:27011 member4:27011 member6:27011
# 10 初始化第2个分片复制集
# 11 加入第2个分片
# 连接到 mongos 添加分片
sh.addShard("shard2/member2:27011,member4:27011,member6:27011")

28 监控最佳实践

MongoDB Ops Manager
Percona
程序脚本

如何获取监控数据：

db.serverStatus() 从上次开机到现在为止
db.isMaster()
monogostats
db.serverStatus().opcounters

29 备份与恢复

延迟节点备份
全量备份+Oplog增量，Oplog 幂等性支持重放
mongodump –oplog；不遗漏 dump 时的数据
mongorestore –oplogReplay

31 安全架构

db.createRole({
   role: "readWriteRole",
   privileges: [
      {
        resource: { db: "myDatabase", collection: "sample" },
        actions: [ "find", "insert", "update", "remove" ]
      }
   ],
   roles: [{
      role: 'read',
      db: 'sampledb',
   }]
})
db.createUser({
  user: 'sampleUser',
  pwd: 'pwd',
  roles: [{
      role: 'readWriteRole',
      db: 'admin',
   }]
})

32 安全加固实践

# 禁止脚本执行
--noscripting
# 必须鉴权
--auth

33 索引机制（一）

Index、Key、DataPage
Covered Query/FETCH
IXSCAN/COLLSCAN 索引扫描/集合扫描
Big O Notation 时间复杂度
Query Shape 查询的形状
Index Prefix 索引前缀
Selectivity 过滤器选择区别度大的
B-数结构

B-树和B+树都是常见的多路搜索树结构，常用于数据库索引和文件系统中。它们的主要区别在于如何存储和检索数据。

B-树是一种自平衡的搜索树，其中每个节点可以存储多个键和对应的值，并支持在O(log n)时间内进行搜索、插入和删除操作。B-树的每个节点都包含了一个子节点数组，可以用来搜索和遍历树。在B-树中，所有节点都可以存储键和值，而非仅仅是叶子节点。

B+树与B-树非常相似，但是只有叶节点包含了所有的键和值，而且所有叶节点都通过指针链接在一起。这意味着在B+树上进行查找只需要搜索一条从根节点到叶节点的路径，而在B-树中可能需要搜索多个节点。B+树的非叶子节点只包含键，而不包含值，这使得B+树在维护索引时更加高效。

因此，B+树比B-树更适用于存储和检索大量数据，尤其是数据库和文件系统中的索引。B+树的叶子节点形成了一个有序链表，可以方便地进行区间查找和遍历。而B-树则更适合内存较小的情况下，例如缓存。

34 索引机制（二）

.explain(true) 查看：

executionTimeMillis
totalDocsExamined
executionStages.docsExamined
executionStages.inputStage.stage

组合索引 ESR 原则，Equal(最前) Sort(中间) Range(最后)

db.member.createIndex({city:1}, {background: true})

36 性能诊断工具

mongostat 了解 MongoDB 运行状态的工具。

dirty 没有刷盘的比例 <5%
used
qrw 排队的请求
con 连接数量

mongotop 了解集合压力状态

mtools

41 应用场景及选型

优点：

横向扩展能力，数据量或并发量增加时候架构可以自动扩容
灵活模型，适合迭代开发，数据模型多变场景
JSON 数据结构，适合微服务/REST API

44 关系型数据库迁移

从基于关系型数据库应用迁移到 MongoDB 的理由：

高并发需求（数千 - 数十万 ops），关系型数据库不容易扩展
快速迭代 - 关系型模式太严谨
灵活的 JSON 模式
大数据量需求
地理位置查询
多数据中心跨地域部署

References

– EOF –

手把手教你落地 DDD

Wed, 01 Mar 2023 17:00:00 +0000

01 DDD 小传

DDD（Domain-Driven Design）由 Eric Evans 于 2003 年提出，本质是一套用于开发复杂软件的系统化方法学与思想，核心关注“领域建模”。它源于面向对象方法学与敏捷开发，可理解为“把面向对象做对”（OO Done right），并将建模、设计与落地实践更体系化。

传统面向对象在企业应用中常见问题是重技术轻业务、领域建模难以掌握、协作与沟通不足、难以适应频繁变化。DDD 通过模式、原则与实践（如通用语言、限界上下文、模型驱动设计等）促进业务与技术协作沉淀知识，并用“柔性设计/演进”避免过度设计、支持持续重构。

近年因数字化带来更高复杂度与变化，以及敏捷/DevOps 与 Spring Boot、微服务、整洁架构、事件驱动、CQRS 等生态成熟，DDD 才从“屠龙术”变成广泛可用的方法。

02 迭代一企业管理系统

企业为了满足管理诉求，希望员工每周在系统中填报自己在哪些项目上花了多少时间，也就是所谓的报工时。

需求	核心对象/范围	主要功能（CRUD/流程）	关键规则/约束	关键字段/记录
多租户	租户（企业）	管理多个租户（企业）	每个租户代表一个使用 SaaS 的企业	—
人员与组织管理	部门、员工	部门：增删改查；员工：增删改查；员工分配部门	员工只能从属于一个部门	部门层级示例：开发中心 → 开发组；职能部门（人事/财务等）
项目管理	客户、合同、项目	客户：增删改查；合同：增删改查 + 开始/结束；项目：增删改查 + 开始/结束	客户对应客户经理；合同对应销售；项目对应项目经理；合同下可有多个项目	合同/项目开始时间、结束时间等
人员分配	项目成员关系	为项目分配人员；人员退出项目	项目可多人；员工可同时参与多个项目；需记录投入比例	投入百分比（人-项目）
工时登记	工时（周报/日记录）	员工每周填报工时；查询；修改；填写备注	仅当员工已分配到项目后，才可在该项目报工时	日期、项目、投入时长、备注

03 事件风暴识别领域事件

领域事件是什么

**领域事件（Domain Event）**用来表达：在业务流程的某一步完成后，所引发并被业务关心的“结果”。

常见表达方式有一个很实用的习惯：

完成时
被动语态

在 DDD 的各种命名中，优先使用约定俗成的业务术语，因为这些词本身就承载着业务知识与共识。

领域事件的边界：两条关键提醒

在识别领域事件时，有两点特别容易踩坑：

不要把技术事件当成领域事件。领域事件强调的是 业务上发生了什么，而不是 系统内部做了什么。
查询功能不算领域事件。查询行为通常不会改变业务世界的状态，因此一般 不构成领域事件。领域事件应当满足一个直觉标准：
1. 对某样事物产生了影响
2. 该影响是业务要记录/追踪的
3. 或者它触发了对外通知（发消息给其他人或系统）

换句话说，领域事件通常对应“业务状态发生改变”或“业务需要对外告知”。

如何识别领域事件：先发散，再收敛

个人发散：参与者各自写出自己理解的领域事件（尽量不互相干扰）
集体收敛：一起讨论、对齐含义、合并同类项、澄清歧义

这种“先发散、后收敛、反复迭代”的方式，本质上就是一种结构化的头脑风暴：先把可能性铺开，再通过讨论把共识沉淀下来。

统一语言：事件风暴的隐性产出

在上述讨论过程中，其实已经在生成并强化统一语言（Ubiquitous Language）。统一语言的核心是：

业务人员和开发人员使用同一套词。
同一个词在不同人心里对应同一个概念。
语言一致意味着领域理解一致（语言是知识的载体）。

它不是某个阶段的文档，而是贯穿 DDD 全过程的基础设施。

事件风暴的精髓是“协作”

事件风暴表面上是在贴事件、理流程，但真正关键的价值在于：

让不同角色共同参与。
通过讨论对齐概念与边界。
在协作中形成统一语言与共同理解。

04 事件风暴识别命令和识别领域名词

命令是什么：从领域事件反推

命令 = 引发领域事件的操作。做法上可以理解为一条简单的逆向链路：

先有领域事件（结果）
再问：是谁做了什么，才让这个结果发生？

除了命令本身，事件风暴里往往还会顺手补齐两类“命令的上下文信息”：

执行者是谁？命令由谁发起/执行：可能是某个用户、某个岗位角色，也可能是系统内的某个领域对象在扮演某种角色，甚至与权限体系的角色有关。
执行命令前需要查询什么数据？为了执行该命令，需要先拿到哪些信息（用于校验、决策、填充表单、定位对象等）。

识别领域名词：从贴纸里提取“名词性概念”

这里的领域名词指：从命令、领域事件、执行者、查询数据中提取出来的名词性概念。举例理解：

命令：签订合同。被影响的核心名词：合同
领域事件：合同已签订。本质上是名词“合同”的状态发生变化，并被业务记录为一个重要结果。

领域规则如何保存：用“领域规则表”沉淀

领域规则是关键领域知识，必须可维护、可追溯。仅靠便利贴或图：

难长期保存
难版本化管理
难持续更新

更可行的方式是建立一个领域规则表：

将事件风暴阶段识别出的规则先记录进去
在后续领域建模中补充新规则
与领域模型放在一起，作为领域知识的核心资产共同维护

05 领域建模实践上

从事件风暴产出的 领域名词 出发做领域建模：先将名词 暂定为实体，再梳理实体间的 关联类型（1:1 / 1:N / M:N）；建模时持续做 抽象提炼 以发现 隐含实体、让模型更贴近业务本质；最后用注释与约束补齐业务知识，其中 约束必须落到代码或数据库 并纳入业务规则表。

06 领域建模实践下

通过引入 关联实体 将 多对多 关系拆成两个 一对多，并为实体补齐必要的 业务操作；当模型复杂时，可按 模块拆分 来提升可理解性。领域模型完成后，还要抓住两项落地 DDD 的关键实践：补齐 业务规则、建立 词汇表（统一语言），它们是确保模型可执行、团队认知一致的重点。

07 领域建模原理

DDD 的 领域模型 是对领域知识的 提炼抽象，同时兼顾 业务表达 与 技术落地 ；在 模型驱动设计 下要做到 领域模型 ↔ 业务需求一致、系统实现 ↔ 领域模型一致，从而确保 实现 ↔ 需求一致；而 统一语言 以领域模型与词汇表为基础，通过 持续协作 不断维护 模型、语言与实现 三者的 一致性。

08 数据库设计

数据库三范式（3 Normal Form）。1NF 字段原子性：

表中的每一列都必须是不可再分的原子值。
不允许在一个字段里存多个值、列表或重复组。

例：主键是(订单ID, 商品ID)，若订单日期只依赖订单ID，就不符合 2NF，应把订单信息拆到订单表。

2NF 消除对主键的部分依赖：

在满足 1NF 的基础上，要求非主属性必须完全依赖于整个主键。
主要针对联合主键的情况：不能只依赖主键的一部分。

例：主键是(订单ID, 商品ID)，若订单日期只依赖订单ID，就不符合 2NF，应把订单信息拆到订单表。

3NF 消除传递依赖

在满足 2NF 的基础上，要求非主属性不依赖于其他非主属性（即没有传递依赖）。
非主属性应当直接依赖主键。

例：员工ID -> 部门ID -> 部门名称，则部门名称是通过部门ID间接决定的，应拆出部门表存部门ID, 部门名称。

DDD 强调用 领域模型驱动数据库设计，以保证 业务、代码、数据一致：实体→表、属性→字段（按需求补充），并通过 词汇表/统一语言 规范命名；关系设计上，一对多用外键（云上常见 “虚拟外键”），多对多用关联表；相较“拍脑袋”式建模，这种方式更容易 与业务对齐、更符合范式，还能把 静态数据结构 与 动态业务逻辑 统一纳入同一套模型中。

09 分层架构

分层架构的原则是让不稳定的部分依赖稳定的部分：越靠内层越稳定、越靠外层越易变；其中领域层封装领域数据与规则，是系统核心，应用层作为门面把领域能力组织成粗粒度服务并处理事务、日志等横切关注点；外部交互由适配器层承担，主动适配器接收外部请求、被动适配器访问外部资源，二者只是在调用方向上不同，从而把技术细节隔离在外层，使应用层与领域层保持技术无关；数据访问上，仓库以聚合为单位（此处可暂按“一个实体一个仓库”理解），而 DAO 以表为单位；另设 common 层承载工具与框架，为各层提供支撑。

10 代码实现要“贫血”还是要“充血”

贫血模型（Anemic Domain Model，Fowler 2003）指领域对象 只有数据没有行为，违背面向对象原则；相对的富/充血模型（Rich Domain Model）强调领域对象应同时包含数据 + 行为，更贴近真正的面向对象（可理解为贫血更偏 面向过程、富模型更偏 面向对象），但企业实践中两者并非非黑即白，应结合多种范式；落到编码，核心要求是 代码与模型一致（发现模型问题要 及时改模型），并解决 层间依赖：将 DTO 移到应用层、用 依赖倒置 让适配器层依赖领域层，同时理解 领域模型 vs 设计模型（UML） 的区别，以便明确哪些和业务讨论、哪些仅在工程内部讨论，从而提升抽象分层下的沟通与效率。

11 代码实现创建领域对象、实现领域逻辑

实现领域逻辑时应使用能表达领域知识的命名，即 DDD 表意接口（Intention-Revealing Interfaces）；一旦违背，常见坏味道是 函数过长 与 注释过多，可用 抽取函数 重构解决。需区分 领域逻辑 与 应用逻辑，关键在于是否包含领域专家关心的 领域知识；领域逻辑应优先放入 领域对象，不适合放入对象的则放入 领域服务。复杂对象的创建推荐用 工厂（Factory），参数少可直接调用工厂，参数多可配合 Builder。模块划分有按性质（横切）与按耦合/业务（纵切）两种，建议采用 先横后竖 的策略。

– EOF –

正则表达式

Wed, 01 Mar 2023 15:31:15 +0000

00 01 元字符

正则表达式 —— 字符串的规则。

元字符就是指那些在正则表达式中具有特殊意义的专用字符。

特殊单字符
- . 任意字符（换行除外）
- \d 任意数字 \D 任意非数字
- \w A-Za-z0-9_ \W
- \s 空白符 \S
空白符
- \r 回车符
- \n 换行符
- \f 换页符
- \t 制表符
- \v 垂直制表符
范围
- | 或
- [abc] 多选一
- [a-z] 之间
- [^abc] 取反，不能是括号中的任意单个元素
量词
- * 0<=
- + 1<=
- ? 0或1
- {m} m
- {m,} m<=
- {m,n} m-n

02 量词与贪婪

贪婪(Greedy) *：匹配最长。在贪婪量词模式下，正则表达式会尽可能长地去匹配符合规则的字符串，且会回溯。

preg_match_all("/a*/i", "aaabb", $matches);
var_dump($matches);

非贪婪(Reluctant) +?：匹配最短。在非贪婪量词模式下，正则表达式会匹配尽可能短的字符串。

ENV：Python3

import re
re.findall(r'a*', 'aaabb') # 贪婪模式
# ['aaa', '', '', '']
re.findall(r'a*?', 'aaabb') # 非贪婪模式
# ['', 'a', '', 'a', '', 'a', '', '', '']

re.findall(r'".+"', '"the little cat" is a toy, it lokks "a little bad"') # 贪婪模式
# ['"the little cat" is a toy, it lokks "a little bad"']
re.findall(r'".+?"', '"the little cat" is a toy, it lokks "a little bad"') # 非贪婪模式
# ['"the little cat"', '"a little bad"']

独占模式(Possessive) ++：同贪婪一样匹配最长。不过在独占量词模式下，正则表达式尽可能长地去匹配字符串，一旦匹配不成功就会结束匹配而 不会回溯。

# 回溯示例：
import re
re.findall(r'xy{1,3}z', 'xyyz') # 回溯
# ['xyyz']
# 正则 xy{1,3} 会尽可能长地去匹配到 xyyz，无法匹配 z，向前回溯 xyy
# 正则 z 匹配到剩下字符串 z
re.findall(r'xy{1,3}?z', 'xyyz') # 非贪婪
# ['xyyz']
# 正则 xy{1,3} 会尽可能短地去匹配到 xy
# 正则 z 匹配到字符串 y，无法匹配，向前回溯
# 正则 xy{1,3} 会尽可能短地去匹配 xyy
# 正则 z 匹配到剩下字符串 z

# 独占模式示例：
# pip install regex -i https://mirrors.aliyun.com/pypi/simple/
import regex
regex.findall(r'xy{1,3}+z', 'xyyz') # 独占
# ['xyyz']
# 正则 xy{1,3}+ 会尽可能长地去匹配到 xyy 并占用
# 正则 z 匹配到字符串 z
regex.findall(r'xy{1,3}+yz', 'xyyz') # 独占
# []
# 正则 xy{1,3}+ 会尽可能长地去匹配到 xyy 并占用
# 正则 yz 无法匹配到剩下字符串 z

03 分组与引用

import regex
# 不保存分组 (?:正则)
regex.sub(r'(\d{4})-(?:\d{2})-(\d{2})', r"年：\1  日：\2", '2023-03-01')
# '年：2023  日：01'

# 去除重复连续单词
regex.sub(r'(\w+)(\s\1)+', r"\1", 'the little cat cat is in the hat hat hat, we like it.')
# 'the little cat is in the hat, we like it.'

04 匹配模式

指改变元字符匹配行为。

不区分大小写模式（Case-Insensitive）(?模式标识) (?i)。

import regex
regex.findall(r"(?i)cat", "cat Cat CAt")
# ['cat', 'Cat', 'CAt']

# https://regex101.com/r/3OUJda/1
# 二次重复时的大小写一致
((?i)cat) \1

点号通配模式（Dot All）(?s) 让英文的点 . 可以匹配上包括换行的任何字符。等价 [\s\S] [\d\D] [\w\W]。

# https://regex101.com/r/zXtwLv/1
# 匹配包括换行符
(?s).+

多行匹配模式（Multiline）(?m) 使 ^ 和 $ 能匹配上每行的开头或结尾。

# 分行匹配
(?m)^cat|dog$

注释模式（Comment）(?#)

(\w+)(?#word) \1(?#word repeat again)

05 断言 Assertion

对要匹配的文本的位置也有一定的要求。只用于匹配位置，而不是文本内容本身，这种结构就是断言。

边界（Boundary）

import re
# 单词边界 \b
# tom -> jerry, tomorrow 不受影响
re.sub(r'\btom\b', 'jerry', "tom asked me if I would go fishing with him tomorrow.")
# 'jerry asked me if I would go fishing with him tomorrow.'

# 行的开始结束
# \A \z 不受模式影响
# \A -> ^, \z -> $
re.sub(r'\Atom', 'jerry', "tom asked me if I would go fishing with him tomorrow.")

# 环视 左尖括号代表看左边，没有尖括号是看右边，感叹号是非的意思
# (?<=Y) 左边是Y
# (?
# (?=Y) 右边是Y
# (?!Y) 右边不是Y

re.findall(r'[1-9]\d{5}', "138001380002")
# ['138001', '380002']
re.findall(r'(?{5}(?!\d)', "138001380002")
# 左边不是数字、右边不是数字
# []
re.findall(r'(?{5}(?!\d)', "code138001code")
# 左边不是数字、右边不是数字
# ['138001']

# \b\w+\b -> (? (?<=\W)\w+(?=\W)
# https://regex101.com/r/PBEKxY/1

# (\w+)(\s+\b\1\b)+
# 单词，单词的左边是单词边界、可以有一个及以上空格，右边是单词边界
# 比 (\w+)(\s+\1)+ 更严谨 eg: the little cat cat2 is in the hat hat2

06 转义

转义字符 Escape Character 后面的字符，不是原来的意思了。

import re
re.findall(r'\\d', 'abc\\d123d\\')
# ['\\d']
re.findall('\\', 'a*b+c?\\d123d\\')
# bad escape (end of pattern) at position 0
re.findall('\\\\', 'a*b+c?\\d123d\\')
# ['\\', '\\']
# 字符串->正则表达式：字符串转义和正则转义
# \\\\ 字符串转义 \\
# \\ 正则转义 \
re.findall(r'\\', 'a*b+c?\\d123d\\')
# ['\\', '\\']
re.findall('\(\)\[]\{}', '()[]{}')
# ['()[]{}']
# 方括号和花括号的转义一般转义开括号就可以，但圆括号两个都需要转义

import re
re.escape('\d') # 反斜杠和字母d转义
# '\\\\d'
re.findall(re.escape('\d'), '\d')
# ['\\d']
re.escape('[+]')
# '\\[\\+\\]'
re.findall(re.escape('[+]'), '[+]')
# ['[+]']

import re
re.findall(r'[^ab]', '^ab')  # 转义前代表"非"
# ['^']
re.findall(r'[^cd]', '^ab')
# ['^', 'a', 'b']
re.findall(r'[\^ab]', '^ab')  # 转义后代表普通字符
# ['^', 'a', 'b']
re.findall(r'[a-c]', 'abc-')  # 中划线在中间，代表"范围"
# ['a', 'b', 'c']
re.findall(r'[a\-c]', 'abc-')  # 中划线在中间，转义后的
re.findall(r'[-ac]', 'abc-')  # 在开头，不需要转义
re.findall(r'[ac-]', 'abc-')  # 在结尾，不需要转义
# ['a', 'c', '-']
re.findall(r'[]ab]', ']ab')  # 右括号不转义，在首位
# [']', 'a', 'b']
re.findall(r'[a]b]', ']ab')  # 右括号不转义，不在首位
# []
re.findall(r'[a\]b]', ']ab')  # 转义后代表普通字符
# [']', 'a', 'b']
re.findall(r'[.*+?()]', '[.*+?()]')  # 单个长度的元字符在中括号里，可以不转义
# ['.', '*', '+', '?', '(', ')']
re.findall(r'[\d]', 'd12\\')  # \w，\d等在中括号中还是元字符的功能
# ['1', '2']

import re
re.findall('\n', '\\n\n\\')
# ['\n'] \n -> (\n) -> (\n)
re.findall('\\n', '\\n\n\\')
# ['\n'] \\n -> \n -> (\n)
re.findall('\\\n', '\\n\n\\')
# ['\n'] \\\n -> \n -> (\n)
re.escape('\n')
# '\\\n'
re.findall('\\\\n', '\\n\n\\')
# ['\\n'] \\\\n -> \\\n -> \(\n)
re.escape('\\n')
# '\\\\n'

07 流派及其特性

POSIX Portable Operating System Interface。不能使用 \d。
- BRE Basic Regular Expression 基本正则表达式。grep sed 花园问管家 {}()?|+ 要转义。
- ERE Extended Regular Expression 扩展正则表达式。egrep grep -E sed -E。
PCRE Perl Compatible Regular Expressions。可以使用 \d \w \s。grep -P sed -P。

grep --help | grep PATTERN
# PATTERN is, by default, a basic regular expression (BRE).
#   -E, --extended-regexp     PATTERN is an extended regular expression (ERE)
#   -F, --fixed-strings       PATTERN is a set of newline-separated fixed strings
#   -G, --basic-regexp        PATTERN is a basic regular expression (BRE)
#   -P, --perl-regexp         PATTERN is a Perl regular expression

Linux/Unix 工具与正则表达式的 POSIX 规范 | 余晟

08 处理 Unicode 文本

Unicode 相当于规定了字符对应的码值，这个码值得编码成字节的形式去传输和存储。最常见的编码方式是 UTF-8，另外还有 UTF-16，UTF-32 等。UTF-8 之所以能够流行起来，是因为其编码比较巧妙，采用的是变长的方法。也就是一个 Unicode 字符，在使用 UTF-8 编码表示时占用 1 到 4 个字节不等。最重要的是 Unicode 兼容 ASCII 编码，在表示纯英文时，并不会占用更多存储空间。而汉字呢，在 UTF-8 中，通常是用三个字节来表示。

# python2.7
import re
u'极客'.encode('utf-8')
# '\xe6\x9e\x81\xe5\xae\xa2'
u'时间'.encode('utf-8')
# '\xe6\x97\xb6\xe9\x97\xb4'
# 都含有 e6

re.search(r'[时间]', '极客') is not None
# True

re.compile(r'[时间]', re.DEBUG)
# in
#   literal 230
#   literal 151
#   literal 182
#   literal 233
#   literal 151
#   literal 180
# <_sre.SRE_Pattern object at 0x10ab44d78>

re.compile(r'[极客]', re.DEBUG)
# in
#   literal 230
#   literal 158
#   literal 129
#   literal 229
#   literal 174
#   literal 162
# <_sre.SRE_Pattern object at 0x10ab44e40>

re.compile(ur'[时间]', re.DEBUG)
# in
#   literal 26102
#   literal 38388
# <_sre.SRE_Pattern object at 0x10ac02710>

re.search(ur'[时间]', '时间') is not None
False

re.search(ur'[时间]', u'时间') is not None
True

# python2.7
import re
re.findall(r'^.$', '学')
# []
re.findall(r'^.$', u'学')
# [u'\u5b66']
re.findall(ur'^.$', u'学')
# [u'\u5b66']
print(unichr(0x5B66))
# 学

# python3
import re
re.findall(r'^.$', '学')
# ['学']
re.findall(r'(?a)^.$', '学')
# ['学']
# (?a) 表示启用 ASCII 模式
chr(0x5B66)
# '学'

// 可以匹配汉语 in PHP
\p{Han}

# python2.7
import re
re.findall(r'客{3}', '极客客客客')
# []
re.findall(ur'客{3}', '极客客客客')
# []
re.findall(r'客{3}', u'极客客客客')
# []
re.findall(ur'客{3}', u'极客客客客')
# [u'\u5ba2\u5ba2\u5ba2']
re.findall(r'(客){3}', '极客客客客')

# python3
re.findall(r'客{3}', '极客客客客')
# ['客客客']
# 在 Python3 中，不需要在正则表达式字符串前面添加 u 前缀，因为所有字符串都默认为 Unicode 字符串。

Script (Unicode) | wikipedia

09 编辑器中使用正则

竖向编辑：MacOS alt + 鼠标纵向滑动。

10 语言中用正则

校验文本内容：

import re
reg = re.compile(r'\A\d{4}-\d{2}-\d{2}\Z')  # 建议先编译，提高效率
reg.search('2020-06-01') is not None
# True
reg.match('2020-06-01') is not None  # 使用 match 时 \A 可省略，match 就是从头匹配
# True

reg = re.compile(r'\d{4}-\d{2}')
reg.findall('2020-05 2020-06')
# ['2020-05', '2020-06']

/^\d{4}-\d{2}-\d{2}$/.test("2020-06-01")
// true
var regex = new RegExp(/^\d{4}-\d{2}-\d{2}$/)
regex.test("2020-01-01")
// true
var regex = /^\d{4}-\d{2}-\d{2}$/
"2020-06-01".search(regex)
// 0

$regex = '/^\d{4}-\d{2}-\d{2}$/';
$ret = preg_match($regex, "2020-06-01");
var_dump($ret);
// int(1)

提取文本内容：

import re
# 没有子组时
reg = re.compile(r'\d{4}-\d{2}')
reg.findall('2020-05 2020-06')
# ['2020-05', '2020-06']

# 有子组时
reg = re.compile(r'(\d{4})-(\d{2})')
reg.findall('2020-05 2020-06')
[('2020', '05'), ('2020', '06')]

reg = re.compile(r'(\d{4})-(\d{2})')
for match in reg.finditer('2020-05 2020-06'):
    print('date: ', match[0])  # 整个正则匹配到的内容
    print('year: ', match[1])  # 第一个子组
    print('month:', match[2])  # 第二个子组
# date:  2020-05
# year:  2020
# month: 05
# date:  2020-06
# year:  2020
# month: 06

// 使用g模式，查找所有符合要求的内容
"2020-06 2020-07".match(/\d{4}-\d{2}/g)
// ['2020-06', '2020-07']

// 不使用g模式，找到第一个就会停下来
"2020-06 2020-07".match(/\d{4}-\d{2}/)
// ['2020-06', index: 0, input: '2020-06 2020-07', groups: undefined]

$regex = "/\d{4}-\d{2}/";
$str = "2020-05 2020-04";
$matchs = [];
preg_match_all($regex, $str, $matchs, PREG_SET_ORDER);
var_dump($matchs);
// array(2) {
//   [0] =>
//   array(1) {
//     [0] =>
//     string(7) "2020-05"
//   }
//   [1] =>
//   array(1) {
//     [0] =>
//     string(7) "2020-04"
//   }
// }

// PREG_PATTERN_ORDER: 结果排序为$matches[0]保存完整模式的所有匹配, $matches[1]保存第一个子组的所有匹配，以此类推。
// PREG_SET_ORDER: 结果排序为$matches[0]包含第一次匹配得到的所有匹配(包含子组)，$matches[1]是包含第二次匹配到的所有匹配(包含子组)的数组，以此类推。

替换文本内容：

reg = re.compile(r'(\d{2})-(\d{2})-(\d{4})')
reg.sub(r'\3年\1月\2日', '02-20-2020 05-21-2020')
# '2020年02月20日 2020年05月21日'

# 可以在替换中使用 \g<数字>，如果分组多于10个时避免歧义
reg.sub(r'\g<3>年\g<1>月\g<2>日', '02-20-2020 05-21-2020')
# '2020年02月20日 2020年05月21日'

# 返回替换次数
reg.subn(r'\3年\1月\2日', '02-20-2020 05-21-2020')
# ('2020年02月20日 2020年05月21日', 2)

// 使用g模式，替换所有的
"02-20-2020 05-21-2020".replace(/(\d{2})-(\d{2})-(\d{4})/g, "$3年$1月$2日")
// "2020年02月20日 2020年05月21日"

// 不使用 g 模式时，只替换一次
"02-20-2020 05-21-2020".replace(/(\d{2})-(\d{2})-(\d{4})/, "$3年$1月$2日")
// "2020年02月20日 05-21-2020"

$ret = preg_replace('/(\d{2})-(\d{2})-(\d{4})/', '\3年\1月\2日', "02-20-2020 05-21-2020");
var_dump($ret);
// string(35) "2020年02月20日 2020年05月21日"

切割文本内容：

reg = re.compile(r'\W+')
reg.split("apple, pear! orange; tea")
# ['apple', 'pear', 'orange', 'tea']

# 限制切割次数，比如切一刀，变成两部分
reg.split("apple, pear! orange; tea", 1)
# ['apple', 'pear! orange; tea']

"apple, pear! orange; tea".split(/\W+/)
// ["apple", "pear", "orange", "tea"]

// 传入第二个参数的情况
"apple, pear! orange; tea".split(/\W+/, 1)
// ["apple"]
"apple, pear! orange; tea".split(/\W+/, 2)
// ["apple", "pear"]
"apple, pear! orange; tea".split(/\W+/, 10)
// ["apple", "pear", "orange", "tea"]

$ret = preg_split('/\W+/', 'apple, pear! orange; tea');
var_dump($ret);
// array(4) {
//   [0] =>
//   string(5) "apple"
//   [1] =>
//   string(4) "pear"
//   [2] =>
//   string(6) "orange"
//   [3] =>
//   string(3) "tea"
// }
$ret = preg_split('/\W+/', 'apple, pear! orange; tea', 2);
var_dump($ret);
// array(2) {
//   [0] =>
//   string(5) "apple"
//   [1] =>
//   string(17) "pear! orange; tea"
// }

11 匹配原理以及优化原则

回溯不可怕，我们要尽量减少回溯后的判断

import re
x = '-' * 1000000 + 'abc'
timeit re.search('abc', x)

提前编译好正则。
尽量准确表示匹配范围：匹配引号里面的内容 .+? 改写为 [^"]+。
提取出公共部分：(abcd|abxy) => ab(cd|xy)，(^this|^that) => ^th(is|at)。
出现可能性大的放左边：\.(?:com|net)\b。
只在必要时才使用子组：把不需要保存子组的括号中加上 ?: 来表示只用于归组。
警惕嵌套的子组重复：(.*)* 匹配的次数会呈指数级增长，尽量不要写这样的正则。
避免不同分支重复匹配。

NFA 是以表达式为主导的，先看正则表达式，再看文本。而 DFA 则是以文本为主导的，先看文本，再看正则表达式。POSIX NFA 是指符合 POSIX 标准的 NFA 引擎，它会不断回溯，以确保找到最左侧最长匹配。

12 常见问题

import re
re.match(r'^(?:(?!\d\d)\w){6}$', '11abcd') # 不能匹配上
# 否定预测先行断言的语法"(?!)"来排除两个数字字符结尾的情况
# (?!) 表示匹配不满足某个条件的位置
re.match(r'^(?:\w(?!\d\d)){6}$', '11abcd') # 错误正则示范
# 
# (11) 回溯
# 1(1a) ok
# 11ab... ok

正负号、可二位小数、小数位末尾 0 无影响 Regulex：^[-+]?\d+(?:\.(?:\d){0,2}0*)?$
手机号码：1(?:3\d|4[5-9]|5[0-35-9]|6[2567]|7[0-8]|8\d|9[1389])\d{8}
身份证：[1-9]\d{14}(\d\d[0-9Xx])?
邮政编码：(?


中文字符：[\u4E00-\u9FFF] \p{Han}
邮箱：a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+


程语言的角度来理解正则

命令式编程的世界观是：程序是由若干行动指令组成的有序列表；
命令式编程的方法论是：用变量来存储数据，用语句来执行指令。
声明式编程的世界观是：程序是由若干目标任务组成的有序列表；
声明式编程的方法论是：用语法元素来描述任务，由解析引擎转化为指令并执行。

References

《精通正则表达式（第三版）》
《正则指引（第二版）》

– EOF –



Kubernetes 入门实战 Part3
Fri, 24 Feb 2023 17:24:14 +0000
24 PersistentVolume 数据持久化
PersistentVolume 属于集群的系统资源，是和 Node 平级的一种对象，Pod 对它没有管理权，只有使用权。
StorageClass 它抽象了特定类型的存储系统（比如 Ceph、NFS），在 PVC 和 PV 之间充当“协调人”的角色，帮助 PVC 找到合适的 PV。
# vim host-path-pv-pvc.yml
apiVersion: v1
kind: PersistentVolume
metadata:
  # 只有 10MB 容量的存储设备
  name: host-10m-pv
spec:
  # kubectl explain PersistentVolume.spec.storageClassName
  storageClassName:
    host-vol
    # kubectl explain PersistentVolume.spec.accessModes
  accessModes:
    # ReadWriteOnce：存储卷可读可写，但只能被一个节点上的 Pod 挂载。
    # ReadOnlyMany：存储卷只读不可写，可以被任意节点上的 Pod 多次挂载。
    # ReadWriteMany：存储卷可读可写，也可以被任意节点上的 Pod 多次挂载。
    - ReadWriteOnce
  capacity:
    #  Ki/Mi/Gi
    storage: 10Mi
  hostPath:
    path: /tmp/host-10m-pv/

---
# PVC 不表示实际的存储，而是一个“申请”或者“声明”
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: host-5m-pvc
spec:
  storageClassName: host-vol
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Mi
mkdir /tmp/host-10m-pv
kubectl apply -f host-path-pv-pvc.yml
kubectl get pv
# NAME          CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                 STORAGECLASS   REASON   AGE
# host-10m-pv   10Mi       RWO            Retain           Bound    default/host-5m-pvc   host-vol                4s
kubectl get pvc
# NAME          STATUS   VOLUME        CAPACITY   ACCESS MODES   STORAGECLASS   AGE
# host-5m-pvc   Bound    host-10m-pv   10Mi       RWO            host-vol       6s
# vim host-pvc-pod.yml
apiVersion: v1
kind: Pod
metadata:
  name: host-pvc-pod
spec:
  volumes:
    - name: host-pvc-vol
      persistentVolumeClaim:
        claimName: host-5m-pvc
  containers:
    - name: ngx-pvc-pod
      image: nginx:alpine
      ports:
        - containerPort: 80
      volumeMounts:
        - name: host-pvc-vol
          mountPath: /tmp
kubectl apply -f host-pvc-pod.yml
kubectl get pod -o wide
kubectl exec -it host-pvc-pod -- sh
cd /tmp && touch a.md
# check in worker node
/tmp/host-10m-pv/
25 NFS 网络共享存储
…


Kubernetes 入门实战 Part2
Wed, 22 Feb 2023 17:11:27 +0000
17 多节点的 Kubernetes 集群
在腾讯云 TencentOS Server 3.1 (TK4) 下测试：

master SA3.MEDIUM4 2 核 4GB 5Mbps
worker S5.SMALL2 1 核 2GB 1Mbps
worker S5.SMALL2 1 核 2GB 1Mbps

# 修改源 https://mirrors.cloud.tencent.com/
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.cloud.tencent.com/repo/centos7_base.repo
yum clean all
yum makecache

# install docker
yum remove docker \
            docker-client \
            docker-client-latest \
            docker-common \
            docker-latest \
            docker-latest-logrotate \
            docker-logrotate \
            docker-engine

yum install -y yum-utils

yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

systemctl start docker
docker -v
docker run hello-world
一些准备工作：
# 改主机名
vi /etc/hostname
# reboot
# 把 cgroup 的驱动程序改成 systemd
# 使用 Docker 作为 Kubernetes 的底层支持
cat <{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF

systemctl enable docker
systemctl daemon-reload
systemctl restart docker
docker version
# https://kubernetes.io/zh-cn/docs/setup/production-environment/container-runtimes/
# 转发 IPv4 并让 iptables 看到桥接流量
cat <overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

# check
lsmod | grep br_netfilter
lsmod | grep overlay

# 设置所需的 sysctl 参数，参数在重新启动后保持不变
cat <net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

# 应用 sysctl 参数而不重新启动
sudo sysctl --system

sysctl net.bridge.bridge-nf-call-iptables net.bridge.bridge-nf-call-ip6tables net.ipv4.ip_forward
# net.bridge.bridge-nf-call-iptables = 1
# net.bridge.bridge-nf-call-ip6tables = 1
# net.ipv4.ip_forward = 1
# 关闭 Linux 的 swap 分区
swapoff -a
sed -ri '/\sswap\s/s/^#?/#/' /etc/fstab
# https://developer.aliyun.com/mirror/kubernetes
cat < /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.cloud.tencent.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
EOF

yum clean all
yum makecache

# 将 SELinux 设置为 permissive 模式（相当于将其禁用）
setenforce 0
sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

# 新版本搞不定
# yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes --nogpgcheck

yum --showduplicate list kubelet
yum install -y kubelet-1.23.16-0 kubeadm-1.23.16-0 kubectl-1.23.16-0 --disableexcludes=kubernetes --nogpgcheck

systemctl enable --now kubelet

kubeadm version
kubectl version --output=yaml
kubelet --version
下载 Kubernetes 组件镜像：
# kubeadm config images list
kubeadm config images list --kubernetes-version v1.23.16
安装 Master 节点：
vim /etc/containerd/config.toml
#disabled_plugins = ["cri"]

systemctl enable containerd
systemctl restart containerd
systemctl status containerd

systemctl enable kubelet.service
systemctl restart kubelet
systemctl status kubelet

containerd config default > /etc/containerd/config.toml

yum install -y nc
nc 127.0.0.1 6443

kubeadm init -h
kubeadm reset -f
rm -rf ~/.kube/config

kubeadm init \
    --image-repository=registry.aliyuncs.com/google_containers \
    --pod-network-cidr=10.10.0.0/16 \
    --kubernetes-version=v1.23.16 \
    --v=9

# Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
#   https://kubernetes.io/docs/concepts/cluster-administration/addons/
# success
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

export KUBECONFIG=/etc/kubernetes/admin.conf
kubectl get node
# NAME     STATUS     ROLES                  AGE    VERSION
# master   NotReady   control-plane,master   2m4s   v1.23.16
# dubug
systemctl restart docker
systemctl restart kubelet
systemctl restart containerd
journalctl -xeu kubelet
crictr ps -a
crictl --runtime-endpoint unix:///var/run/containerd/containerd.sock ps -a | grep kube | grep -v pause

kubectl get pods -n kube-system
kubectl describe pods -n kube-system
# Flannel 网络插件 https://github.com/flannel-io/flannel/tree/master
# curl https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml --output kube-flannel.yml
#  net-conf.json: |
#     {
#       "Network": "10.10.0.0/16",
#       "Backend": {
#         "Type": "vxlan"
#       }
#     }
kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml
kubectl get node
# NAME     STATUS   ROLES                  AGE   VERSION
# master   Ready    control-plane,master   14h   v1.23.16
# show join command in control-plane
kubeadm token create --print-join-command
# work join; 云服务记得开放入站端口
telnet 172.21.0.5 6443
systemctl enable kubelet.service
kubeadm join 172.21.0.5:6443 --token xxx --discovery-token-ca-cert-hash sha256:xxx --v=9
# check in control-plane
kubectl get nodes
# NAME            STATUS   ROLES                  AGE     VERSION
# master          Ready    control-plane,master   14h     v1.23.16
# vm-0-9-centos   Ready                     3m27s   v1.23.16
# run nginx
kubectl run ngx --image=nginx:alpine
kubectl get pod -o wide
# NAME   READY   STATUS    RESTARTS   AGE   IP          NODE      NOMINATED NODE   READINESS GATES
# ngx    1/1     Running   0          52m   10.10.1.2   woker01              
18 Deployment 部署应用
“单一职责”和“对象组合”。既然 Pod 管理不了自己，那么我们就再创建一个新的对象，由它来管理 Pod，采用和 Job/CronJob 一样的形式——“对象套对象”。
kubectl api-resources

export out="--dry-run=client -o yaml"
kubectl create deploy ngx-dep --image=nginx:alpine $out > ngx-dep.yml
vim ngx-dep.yml
apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: ngx-dep
  name: ngx-dep
spec:
  # 定义了 Pod 的“期望数量”，Kubernetes 会自动维护 Pod 数量到正常水平
  replicas: 2
  # 定义了基于 labels 筛选 Pod 的规则，它必须与 template 里 Pod 的 labels 一致
  selector:
    matchLabels:
      app: ngx-dep
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      # 贴标签
      labels:
        app: ngx-dep
    spec:
      containers:
        - image: nginx:alpine
          name: nginx
          resources: {}
status: {}
Deployment 实际上并不“持有”Pod 对象，它只是帮助 Pod 对象能够有足够的副本数量运行。
通过标签这种设计，Kubernetes 就解除了 Deployment 和模板里 Pod 的强绑定，把组合关系变成了“弱引用”。
# replicas: 2
kubectl apply -f ngx-dep.yml

kubectl get deploy
# NAME      READY   UP-TO-DATE   AVAILABLE   AGE
# ngx-dep   2/2     2            2           57s
kubectl get pod
# NAME                      READY   STATUS    RESTARTS   AGE
# ngx-dep-bfbb5f64b-96scb   1/1     Running   0          3m20s
# ngx-dep-bfbb5f64b-qnzbh   1/1     Running   0          3m20s

READY：运行的 Pod 数量，当前数量/期望数量。
UP-TO-DATE：当前已经更新到最新状态的 Pod 数量。
AVAILABLE：不仅要求已经运行，还必须是健康状态，能够正常对外提供服务，它才是我们最关心的 Deployment 指标。
AGE：从创建到现在所经过的时间。

# 测试自启恢复
kubectl delete pod ngx-dep-bfbb5f64b-qnzbh
kubectl get pod
# NAME                      READY   STATUS    RESTARTS   AGE
# ngx-dep-bfbb5f64b-7n724   1/1     Running   0          33s
# ngx-dep-bfbb5f64b-96scb   1/1     Running   0          4m52s

# 测试伸缩
kubectl scale --replicas=5 deploy ngx-dep
kubectl get pod
# NAME                      READY   STATUS    RESTARTS   AGE
# ngx-dep-bfbb5f64b-7n724   1/1     Running   0          77s
# ngx-dep-bfbb5f64b-7xhbs   1/1     Running   0          7s
# ngx-dep-bfbb5f64b-96scb   1/1     Running   0          5m36s
# ngx-dep-bfbb5f64b-97qp5   1/1     Running   0          7s
# ngx-dep-bfbb5f64b-vjn4q   1/1     Running   0          7s
# 筛选标签 ==、!=、in、notin
kubectl get pod -l app=nginx
kubectl get pod -l 'app in (ngx, nginx, ngx-dep)'
19 DaemonSet 看门狗
在 Deployment 看来，Pod 的运行环境与功能是无关的，只要 Pod 的数量足够，应用程序应该会正常工作。
有些场景下，要在集群里的每个节点上都运行 Pod，也就是说 Pod 的数量与节点数量保持同步。防止在集群里漂移。
DaemonSet 的目标是在集群的每个节点上运行且仅运行一个 Pod。
kubectl api-resources
# export out="--dry-run=client -o yaml"
# kubectl create deploy redis-ds --image=redis:5-alpine $out
# kind modify DaemonSet, delete spec.replicas
# https://kubernetes.io/zh-cn/docs/concepts/workloads/controllers/daemonset/
# vim redis-ds.yml
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: redis-ds
  labels:
    app: redis-ds
spec:
  # 和 deplayment 比没有 replicas
  selector:
    matchLabels:
      name: redis-ds
  template:
    metadata:
      labels:
        name: redis-ds
    spec:
      containers:
        - image: redis:5-alpine
          name: redis
          ports:
            - containerPort: 6379
kubectl apply -f redis-ds.yml
kubectl get ds
# NAME       DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
# redis-ds   2         2         2       2            2                     30m
kubectl get pod -o wide
# 两个 worker 的场景
# NAME                      READY   STATUS    RESTARTS   AGE   IP           NODE      NOMINATED NODE   READINESS GATES
# redis-ds-9r96k            1/1     Running   0          2m52s   10.10.3.2    woker02              
# redis-ds-hdl28            1/1     Running   0          21m     10.10.1.11   woker01              
# Master 节点却被排除在外了
污点（taint）作用也是给节点“贴标签”。容忍度（toleration）Pod 能否“容忍”污点。
kubectl describe node master
# Taints:             node-role.kubernetes.io/master:NoSchedule
# 污点会拒绝 Pod 调度到本节点上运行
kubectl describe node woker01
# Taints:             
# - 出掉 master 污点
kubectl taint node master node-role.kubernetes.io/master:NoSchedule-
# NAME       DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
# redis-ds   3         3         3       3            3                     31m
# Pod 添加 tolerations
# kubectl explain ds.spec.template.spec.tolerations
# vim redis-ds-t.yml
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: redis-ds-t
  labels:
    app: redis-ds-t
spec:
  # 和 deplayment 比没有 replicas
  selector:
    matchLabels:
      name: redis-ds-t
  template:
    metadata:
      labels:
        name: redis-ds-t
    spec:
      containers:
        - image: redis:5-alpine
          name: redis
          ports:
            - containerPort: 6379
      # 容忍 node-role.kubernetes.io/master
      tolerations:
        - key: node-role.kubernetes.io/master
          effect: NoSchedule
          operator: Exists
kubectl apply -f redis-ds-t.yml
kubectl get ds
# NAME         DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
# redis-ds     2         2         2       2            2                     41m
# redis-ds-t   3         3         3       3            3                     6s
# 差别在 master
kubectl get pod -o wide
# NAME                      READY   STATUS    RESTARTS   AGE   IP           NODE      NOMINATED NODE   READINESS GATES
# redis-ds-9r96k            1/1     Running   0          23m   10.10.3.2    woker02              
# redis-ds-hdl28            1/1     Running   0          42m   10.10.1.11   woker01              
# redis-ds-t-4mptv          1/1     Running   0          80s   10.10.3.4    woker02              
# redis-ds-t-dpcl8          1/1     Running   0          80s   10.10.1.12   woker01              
# redis-ds-t-kdjmn          1/1     Running   0          80s   10.10.0.6    master               
https://kubernetes.io/zh-cn/docs/concepts/scheduling-eviction/taint-and-toleration/
静态 Pod：
ll -a /etc/kubernetes/manifests
# -rw------- 1 root root 2274 Feb 22 12:47 etcd.yaml
# -rw------- 1 root root 3358 Feb 22 12:47 kube-apiserver.yaml
# -rw------- 1 root root 2878 Feb 22 12:47 kube-controller-manager.yaml
# -rw------- 1 root root 1465 Feb 22 12:47 kube-scheduler.yaml
Kubernetes 的 4 个核心组件 apiserver、etcd、scheduler、controller-manager 原来都以静态 Pod 的形式存在的，这也是为什么它们能够先于 Kubernetes 集群启动的原因。
kubelet 会定期检查目录里的文件。
# flannel 就是一个 DaemonSet
kubectl get ns
kubectl get ds -n kube-flannel
# NAME              DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
# kube-flannel-ds   3         3         3       3            3                     3h54m
20 Service 服务发现
由 kube-proxy 控制的四层负载均衡，在 TCP/IP 协议栈上转发流量。
Pod 的生命周期很短暂，会不停地创建销毁，所以就需要用 Service 来实现负载均衡，它由 Kubernetes 分配固定的 IP 地址，能够屏蔽后端的 Pod 变化。
export out="--dry-run=client -o yaml"
kubectl expose deploy ngx-dep --port=80 --target-port=80 $ou

# vim ngx-svc.yml
apiVersion: v1
kind: Service
metadata:
  name: ngx-svc
spec:
  ports:
    - port: 80
      protocol: TCP
      targetPort: 80
  selector:
    app: ngx-dep
status:
  loadBalancer: {}

---
apiVersion: v1
kind: ConfigMap
metadata:
  name: ngx-conf
data:
  default.conf: |
    server {
      listen 80;
      location / {
        default_type text/plain;
        return 200
          'srv : $server_addr:$server_port\nhost: $hostname\nuri : $request_method $host $request_uri\ndate: $time_iso8601\n';
      }
    }

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ngx-dep
spec:
  replicas: 2
  selector:
    matchLabels:
      app: ngx-dep
  template:
    metadata:
      labels:
        app: ngx-dep
    spec:
      volumes:
        - name: ngx-conf-vol
          configMap:
            name: ngx-conf
      containers:
        - image: nginx:alpine
          name: nginx
          ports:
            - containerPort: 80
          volumeMounts:
            - mountPath: /etc/nginx/conf.d
              name: ngx-conf-vol
kubectl apply -f ngx-svc.yml
kubectl get svc
# NAME         TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)   AGE
# kubernetes   ClusterIP   10.96.0.1                443/TCP   5h10m
# ngx-svc      ClusterIP   10.109.131.132           80/TCP    35s
# 虚地址 10.109.131.132
kubectl describe svc ngx-svc
# Name:              ngx-svc
# Namespace:         default
# Labels:            
# Annotations:       
# Selector:          app=ngx-dep
# Type:              ClusterIP
# IP Family Policy:  SingleStack
# IP Families:       IPv4
# IP:                10.109.131.132
# IPs:               10.109.131.132
# Port:                80/TCP
# TargetPort:        80/TCP
# Endpoints:         10.10.1.13:80,10.10.3.5:80
# Session Affinity:  None
# Events:            
kubectl get pod -o wide
NAME                       READY   STATUS    RESTARTS   AGE    IP           NODE
ngx-dep-6796688696-cwm8f   1/1     Running   0          2m4s   10.10.3.5    woker02
ngx-dep-6796688696-khjnv   1/1     Running   0          2m2s   10.10.1.13   woker01
# same Endpoints

# 因为 Service、 Pod 的 IP 地址都是 Kubernetes 集群的内部网段
#   所以我们需要用 kubectl exec 进入到 Pod 内部
kubectl exec -it ngx-dep-6796688696-cwm8f -- sh
curl 10.109.131.132
# srv : 10.10.3.5:80
# host: ngx-dep-6796688696-cwm8f
# uri : GET 10.109.131.132 /
# date: 2023-02-22T10:09:49+00:00
curl 10.109.131.132
# srv : 10.10.1.13:80
# host: ngx-dep-6796688696-khjnv
# uri : GET 10.109.131.132 /
# date: 2023-02-22T10:09:50+00:00

# 测试恢复
kubectl delete pod ngx-dep-6796688696-khjnv
kubectl describe svc ngx-svc
# Endpoints:         10.10.1.14:80,10.10.3.5:80
# 之前是 10.10.1.13:80,10.10.3.5:80

# 测试扩容
kubectl scale --replicas=5 deploy ngx-dep
kubectl describe svc ngx-svc
# Endpoints:         10.10.1.14:80,10.10.1.15:80,10.10.3.5:80 + 2 more...
Service 对象的域名完全形式是 对象.名字空间.svc.cluster.local，但很多时候也可以省略后面的部分，直接写 对象.名字空间 甚至 对象名 就足够了，默认会使用对象所在的名字空间（比如这里就是 default）。
# Name:              ngx-svc
# Namespace:         default
kubectl exec -it ngx-dep-6796688696-cwm8f -- sh
curl ngx-svc
# srv : 10.10.3.5:80
# host: ngx-dep-6796688696-cwm8f
# uri : GET ngx-svc /
# date: 2023-02-22T10:19:25+00:00
curl ngx-svc.default
# srv : 10.10.3.6:80
# host: ngx-dep-6796688696-lpcfs
# uri : GET ngx-svc.default /
# date: 2023-02-22T10:19:41+00:00
curl ngx-svc.default.svc.cluster.local
# srv : 10.10.3.5:80
# host: ngx-dep-6796688696-cwm8f
# uri : GET ngx-svc.default.svc.cluster.local /
# date: 2023-02-22T10:20:04+00:00
Pod 分配了域名：IP 地址.名字空间.pod.cluster.local IP 地址 . 改成 -。
# kubectl explain svc.spec.type
# vim ngx-svc.yml
  ...
  type: NodePort
kubectl apply -f ngx-svc.yml
kubectl get svc
# NAME         TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
# kubernetes   ClusterIP   10.96.0.1                443/TCP        5h56m
# ngx-svc      NodePort    10.109.131.132           80:30916/TCP   46m
# Service 的默认类型是“ClusterIP”，只能在集群内部访问，
#   如果改成“NodePort”，就会在节点上开启一个随机端口号，让外界也能够访问内部的服务。
curl localhost:30916
# srv : 10.10.1.15:80
# host: ngx-dep-6796688696-l6skl
# uri : GET localhost /
# date: 2023-02-22T10:48:32+00:00

21 Ingress 流量总管
Service 本身是没有服务能力的，它只是一些 iptables 规则，真正配置、应用这些规则的实际上是节点里的 kube-proxy 组件。
Ingress 也只是一些 HTTP 路由规则的集合，相当于一份静态的描述文件，真正要把这些规则在集群里实施运行，还需要有另外一个东西，这就是 Ingress Controller，它的作用就相当于 Service 的 kube-proxy，能够读取、应用 Ingress 规则，处理、调度流量。
Ingress Class 是插在 Ingress 和 Ingress Controller 中间，作为流量规则和控制器的协调人，解除了 Ingress 和 Ingress Controller 的强绑定关系。
Kubernetes 用户可以转向管理 Ingress Class，用它来定义不同的业务逻辑分组，简化 Ingress 规则的复杂度。
export out="--dry-run=client -o yaml"
kubectl create ing ngx-ing --rule="ngx.test/=ngx-svc:80" --class=ngx-ink $out
# vim ingress.yml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  creationTimestamp: null
  name: ngx-ing
spec:
  ingressClassName: ngx-ink
  rules:
    - host: ngx.test
      http:
        # 路径的匹配方式
        paths:
          - backend:
              service:
                name: ngx-svc
                port:
                  number: 80
            path: /
            # 精确匹配（Exact）或前缀匹配（Prefix）
            pathType: Exact
status:
  loadBalancer: {}

---
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: ngx-ink
spec:
  controller: nginx.org/ingress-controller
kubectl apply -f ingress.yml
# NAME      CONTROLLER                     PARAMETERS   AGE
# ngx-ink   nginx.org/ingress-controller          15s
kubectl get ing
# NAME      CLASS     HOSTS      ADDRESS   PORTS   AGE
# ngx-ing   ngx-ink   ngx.test             80      84s
kubectl describe ing ngx-ing
# Name:             ngx-ing
# Labels:           
# Namespace:        default
# Address:
# Default backend:  default-http-backend:80 ()
# Rules:
#   Host        Path  Backends
#   ----        ----  --------
#   ngx.test
#               /   ngx-svc:80 (10.10.1.14:80,10.10.1.15:80)
# Annotations:  
# Events:       
在 Kubernetes 里使用 Ingress Controller：
https://docs.nginx.com/nginx-ingress-controller/installation/installation-with-manifests/
git clone https://github.com/nginxinc/kubernetes-ingress.git --branch v3.0.2
cd kubernetes-ingress/deployments

# Configure RBAC
# 为Ingress控制器创建一个命名空间和一个服务账户
kubectl apply -f common/ns-and-sa.yaml
# 为服务账户创建一个集群角色和集群角色绑定
kubectl apply -f rbac/rbac.yaml

# Create Common Resources
# 为NGINX的默认服务器创建一个带有TLS证书和密钥的秘密
kubectl apply -f common/default-server-secret.yaml
# 创建一个 config map，用于定制NGINX配置。
kubectl apply -f common/nginx-config.yaml
# 创建一个IngressClass资源
kubectl apply -f common/ingress-class.yaml

# Create Custom Resources
# kubectl apply -f common/crds/
vim deployment/nginx-ingress.yaml
# args add:
# -enable-custom-resources=false

# Run the Ingress Controller
kubectl apply -f deployment/nginx-ingress.yaml

# check
kubectl get pods --namespace=nginx-ingress
# NAME                             READY   STATUS    RESTARTS   AGE
# nginx-ingress-5f98f8f5f9-nnkv7   1/1     Running   0          3m14s

# Get Access to the Ingress Controller
kubectl create -f service/nodeport.yaml
kubectl get service -n nginx-ingress
# NAME            TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
# nginx-ingress   NodePort   10.111.210.52           80:31754/TCP,443:30188/TCP   5s
# debug
kubectl get IngressClass
kubectl get ing -n nginx-ingress
kubectl get deploy -n nginx-ingress
kubectl get pod -n nginx-ingress -o wide

kubectl describe service -n nginx-ingress -o wide
kubectl describe pod -n nginx-ingress
# 命令kubectl port-forward，它可以直接把本地的端口映射到 Kubernetes 集群的某个 Pod 里
kubectl port-forward -n nginx-ingress nginx-ingress-5f98f8f5f9-nnkv7 8080:80 &

22 玩转 Kubernetes 2
Kubernetes 部署 WordPress：

# vim wp-maria.yml
apiVersion: v1
kind: ConfigMap
metadata:
  name: maria-cm
data:
  DATABASE: "db"
  USER: "wp"
  PASSWORD: "123"
  ROOT_PASSWORD: "123"

---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: maria-dep
  name: maria-dep
spec:
  replicas: 1
  selector:
    matchLabels:
      app: maria-dep
  template:
    metadata:
      labels:
        app: maria-dep
    spec:
      containers:
        - image: mariadb:10
          name: mariadb
          ports:
            - containerPort: 3306
          envFrom:
            - prefix: "MARIADB_"
              configMapRef:
                name: maria-cm

---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: maria-dep
  name: maria-svc
spec:
  ports:
    - port: 3306
      protocol: TCP
      targetPort: 3306
  selector:
    app: maria-dep
kubectl apply -f wp-maria.yml
kubectl get pod
kubectl get deploy
kubectl get svc
# vim wp-app.yml
apiVersion: v1
kind: ConfigMap
metadata:
  name: wp-cm
data:
  # DNS HOST
  HOST: "maria-svc"
  USER: "wp"
  PASSWORD: "123"
  NAME: "db"

---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: wp-dep
  name: wp-dep
spec:
  replicas: 2
  selector:
    matchLabels:
      app: wp-dep
  template:
    metadata:
      labels:
        app: wp-dep
    spec:
      containers:
        - image: wordpress:5
          name: wordpress
          ports:
            - containerPort: 80
          envFrom:
            - prefix: "WORDPRESS_DB_"
              configMapRef:
                name: wp-cm

---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: wp-dep
  name: wp-svc
spec:
  ports:
    - name: http80
      port: 80
      protocol: TCP
      targetPort: 80
      # 指定端口
      nodePort: 30088
  selector:
    app: wp-dep
  # NodePort
  type: NodePort
kubectl apply -f wp-app.yml
kubectl get pod
kubectl get deploy
kubectl get svc

kubectl port-forward service/wp-svc 80:80 --address 0.0.0.0
# vim wp-ing.yml
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: wp-ink
spec:
  controller: nginx.org/ingress-controller

---
# kubectl create ing wp-ing --rule="wp.test/=wp-svc:80" --class=wp-ink $out
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: wp-ing
spec:
  ingressClassName: wp-ink
  rules:
    - host: wp.test
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: wp-svc
                port:
                  number: 80
# vim wp-kic-dep.yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wp-kic-dep
  namespace: nginx-ingress
spec:
  replicas: 1
  selector:
    matchLabels:
      app: wp-kic-dep
  template:
    metadata:
      labels:
        app: wp-kic-dep
    spec:
      # kubectl explain Deployment.spec.template.spec.serviceAccountName
      serviceAccountName: nginx-ingress
      # kubectl explain Deployment.spec.template.spec.hostNetwork
      hostNetwork: true
      containers:
        - image: nginx/nginx-ingress:3.0.2
          imagePullPolicy: IfNotPresent
          name: nginx-ingress
          ports:
            - name: http
              containerPort: 80
            - name: https
              containerPort: 443
            - name: readiness-port
              containerPort: 8081
            - name: prometheus
              containerPort: 9113
          readinessProbe:
            httpGet:
              path: /nginx-ready
              port: readiness-port
            periodSeconds: 1
          securityContext:
            allowPrivilegeEscalation: true
            runAsUser: 101 #nginx
            runAsNonRoot: true
            capabilities:
              drop:
                - ALL
              add:
                - NET_BIND_SERVICE
          env:
            - name: POD_NAMESPACE
              valueFrom:
                fieldRef:
                  fieldPath: metadata.namespace
            - name: POD_NAME
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
          args:
            # 默认是 nginx
            - -ingress-class=wp-ink
            - -enable-custom-resources=false
            - -nginx-configmaps=$(POD_NAMESPACE)/nginx-config
            - -default-server-tls-secret=$(POD_NAMESPACE)/default-server-secret

---
apiVersion: v1
kind: Service
metadata:
  name: wp-kic-svc
  namespace: nginx-ingress

spec:
  ports:
    - port: 80
      protocol: TCP
      targetPort: 80
      nodePort: 30080

  selector:
    app: wp-kic-dep
  type: NodePort
kubectl apply -f wp-ing.yml -f wp-kic-dep.yml

kubectl get ing
kubectl get ingressclass
kubectl get pod -n=nginx-ingress
kubectl describe pod -n=nginx-ingress
kubectl get deploy -n=nginx-ingress
kubectl get svc -n=nginx-ingress
# 在服务器上
kubectl get pod -n=nginx-ingress -o=wide
# NAME                          READY   STATUS    RESTARTS   AGE   IP           NODE
# wp-kic-dep-68579bc688-d64zs   1/1     Running   0          10m   172.21.0.9   woker01
curl 172.21.0.9 -H "HOST: wp.test"
# 在服务器外
kubectl port-forward service/wp-kic-svc -n=nginx-ingress 80:80 --address 0.0.0.0

vim /etc/hosts
[master ip] wp.test
# 游览器访问 wp.test

23 中级篇实操总结
# DaemonSet 模板生成
kubectl create deploy redis-ds --image=redis:5-alpine $out \
  | sed 's/Deployment/DaemonSet/g' - \
  | sed -e '/replicas/d' -
References

chronolaw/k8s_study | GitHub
nginx-ingress-controller Installation with Manifests | nginx.com

– EOF –



Kubernetes 入门实战 Part1
Wed, 15 Feb 2023 14:46:38 +0000
01 初识 Docker
https://docs.docker.com/get-started/overview/
curl -fsSL https://get.docker.com | sudo sh
# sudo usermod -aG docker $USER
# newgrp docker
dockerd-rootless-setuptool.sh install

docker version
docker info
docker ps
docker pull busybox
# show all images
docker images
02 被隔离的进程
# 拉取轻量级 Alpine Linux 镜像
docker pull alpine
# 以交互模式运行容器并进入 shell
docker run -it alpine sh
# 查看容器内的操作系统信息
cat /etc/os-release
Docker 实现资源隔离的三种核心技术：

namespace：隔离进程、网络、文件系统等资源视图
cgroup：限制和监控资源使用（CPU、内存、磁盘 I/O 等）
chroot/pivot_root：改变进程的根目录，实现文件系统隔离

03 容器化的应用
Build once, Run anywhere.
应用程序不再直接和操作系统打交道，而是封装成镜像，再交给容器环境去运行。
# remove image
docker rmi busybox
# 开启一个交互式操作的 Shell
docker run -it busybox
# 在后台运行
docker run -d busybox
# 为容器起一个名字
docker run -d --name xxx busybox
# 不保存容器，只要运行完毕就自动清除
docker run --rm busybox echo "hello docker"

docker stop xxx
# remove container
docker rm xxx

# show all container
docker ps -a
docker exec xxx echo "hello docker"
05 镜像仓库

https://github.com/docker-library/official-images
https://hub.docker.com/u/library

用户名/应用名:标签 官方镜像用户名是 library。

slim 经过精简的
fat 包含了较多的辅助工具
rc 候选版本，release candidate

docker build -t
docker tag ngx-app chronolaw/ngx-app:1.0
docker push chronolaw/ngx-app:1.0
save 和 load 这两个镜像归档命令：
docker save ngx-app:latest -o ngx.tar
docker load -i ngx.tar
06 打破次元壁
docker run -d --rm --name ubu phusion/baseimage:jammy-1.0.1
echo "hello" > a.txt
# a.txt 拷贝到容器 tmp
docker cp a.txt ubu:/tmp
docker exec -it ubu bash
# 考出容器
docker cp ubu:/tmp/a.txt ./b.txt
容器和主机共享本地目录：
# --mount
# -v /tmp:/tmp:ro 只读
docker run -d --rm -v /tmp:/tmp --name ubu phusion/baseimage:jammy-1.0.1
docker exec -it ubu bash
docker pull python:alpine
docker run -it --rm -v `pwd`:/tmp python:alpine sh
网络模式：null host bridge
# host
docker run -d --rm --net=host --name=ng nginx:alpine
docker exec ng ip addr
docker inspect ng | grep IPAddress
docker stop ng
# bridge 默认模式
docker run -d --rm --name=ng nginx:alpine
docker inspect ng | grep IPAddress
# "IPAddress": "172.17.0.3"
docker run -d --rm --name=rd redis
docker inspect rd | grep IPAddress
# "IPAddress": "172.17.0.4"
分配服务端口号
docker run -d -p 80:80 --rm nginx:alpine
docker run -d -p 8080:80 --rm nginx:alpine
# 分别“映射”到了两个容器里的 80 端口
07 玩转 Docker
Container Image Registry
https://registry.hub.docker.com/_/registry/
docker run -d -p 5000:5000 registry
# 使用 docker tag 命令给镜像打标签再上传
docker tag nginx:alpine 127.0.0.1:5000/nginx:alpine
docker push 127.0.0.1:5000/nginx:alpine
# 本次重新拉取测试
docker rmi 127.0.0.1:5000/nginx:alpine
docker pull 127.0.0.1:5000/nginx:alpine
https://docs.docker.com/registry/spec/api/
# Listing Repositories
curl 127.1:5000/v2/_catalog
# {"repositories":["nginx"]}
curl 127.1:5000/v2/nginx/tags/list
# {"name":"nginx","tags":["alpine"]}
registry 默认会把镜像存储在 Docker 内部目录 /var/lib/registry。
搭建 WordPress：
docker run -d --rm \
    --env MARIADB_DATABASE=db \
    --env MARIADB_USER=wp \
    --env MARIADB_PASSWORD=123 \
    --env MARIADB_ROOT_PASSWORD=123 \
    --name mariadb \
    mariadb:10
# 进入 mariadb
docker exec -it mariadb mysql -uwp -p123
# show mariadb ip
docker inspect mariadb | grep IPAddress
# "IPAddress": "172.17.0.2"

docker run -d --rm \
    --env WORDPRESS_DB_HOST=172.17.0.2 \
    --env WORDPRESS_DB_USER=wp \
    --env WORDPRESS_DB_PASSWORD=123 \
    --env WORDPRESS_DB_NAME=db \
    --name wp \
    wordpress:5
docker inspect wp | grep IPAddress
# "IPAddress": "172.17.0.4"
vim wp.conf

server {
  listen 80;
  default_type text/html;
  location / {
      proxy_http_version 1.1;
      proxy_set_header Host $host;
      # wordpress server
      proxy_pass http://172.17.0.4;
  }
}
# 感觉可以直接用 wordpress 的 80，无需再代理一次
docker run -d --rm \
    -p 80:80 \
    -v `pwd`/wp.conf:/etc/nginx/conf.d/default.conf \
    --name ng \
    nginx:alpine
# show logs
docker logs mariadb
docker logs ng
docker logs wp
08 入门篇总结
构建自己的镜像：
https://github.com/chronolaw/k8s_study/blob/master/ch1/Dockerfile
ARG IMAGE_BASE="nginx"
ARG IMAGE_TAG="1.21-alpine"

FROM ${IMAGE_BASE}:${IMAGE_TAG}

ENV PATH=$PATH:/tmp
ENV DEBUG=OFF

COPY ./default.conf /etc/nginx/conf.d/

RUN cd /usr/share/nginx/html \
    && echo "hello nginx" > a.txt

EXPOSE 8081 8082 8083

WORKDIR /etc/nginx
docker build -t ngx-app:1.0 .
docker run -it --rm ngx-app:1.0 sh
docker save ngx-app:1.0 -o ngx.tar
docker load -i ngx.tar
09 Kubernetes 环境
Kubernetes 就是一个 Production-Grade Container Orchestration 生产级别的容器编排平台和集群管理系统。
minikube quickly sets up a local Kubernetes cluster on macOS, Linux, and Windows.
brew install minikube

minikube version
# minikube version: v1.37.0
# commit: 65318f4cfff9c12cc87ec9eb8f4cdd57b25047f3

# 统一实验环境
minikube start
# 查看状态
minikube status
# type: Control Plane
# host: Running
# kubelet: Running
# apiserver: Running
# kubeconfig: Configured
minikube node list
# minikube 192.168.49.2

# 登录到这个节点上
minikube ssh
uname -a
# Linux minikube 6.17.8-orbstack-00308-g8f9c941121b1 #1 SMP PREEMPT Thu Nov 20 09:34:02 UTC 2025 aarch64 aarch64 aarch64 GNU/Linux
ip add
# minikube 管理 Kubernetes 集群环境
# kubectl 操作实际的 Kubernetes 功能
# install kubectl
minikube kubectl

minikube kubectl -- version
# Client Version: v1.34.0
# Kustomize Version: v5.7.1
# Server Version: v1.34.0
alias kubectl="minikube kubectl --"
kubectl version

# 启动一个镜像
kubectl run ngx --image=nginx:alpine

# like docker ps
kubectl get pod
# NAME   READY   STATUS              RESTARTS   AGE
# ngx    0/1     ContainerCreating   0          7s
10 Kubernetes 工作机制
Kubernetes 架构基于流行的“控制面 Control Plane / 数据面 Data Plane”设计。集群由多个“节点”（Node）组成，底层环境支持物理机或虚拟机。
按照功能划分，集群节点主要分为两类：负责“大脑”工作的 Master 节点（控制面），用于执行管理和调度任务；以及负责“体力”工作的 Worker 节点（数据面），用于运行具体的业务应用。

kubectl get node
# NAME       STATUS   ROLES           AGE   VERSION
# minikube   Ready    control-plane   11m   v1.34.0

# 查看 master Component pod
kubectl get pod -n kube-system
# NAME                               READY   STATUS    RESTARTS   AGE
# coredns-66bc5c9577-6c27s           1/1     Running   0          11m
# etcd-minikube                      1/1     Running   0          11m
# kube-apiserver-minikube            1/1     Running   0          11m
# kube-controller-manager-minikube   1/1     Running   0          11m
# kube-proxy-9v5wf                   1/1     Running   0          11m
# kube-scheduler-minikube            1/1     Running   0          11m
# storage-provisioner                1/1     Running   0          11m

# worker node
minikube ssh
# show kube-proxy
docker ps | grep kube-proxy
# show kubelet, not exist docker
ps -ef | grep kubelet
# show addons list
minikube addons list

minikube dashboard
# 🎉  Opening http://127.0.0.1:50733/api/v1/namespaces/kubernetes-dashboard/services/http:kubernetes-dashboard:/proxy/ in your default browser...

11 YAML
YAML 在语法上是 JSON 的超集，常被用作 Kubernetes 的配置文件格式。
其次，我们需要理解两种思维模式：Shell 脚本和 Dockerfile 是典型的 “命令式”，它告诉机器“第一步做什么，第二步做什么”；而 Kubernetes 推崇 “声明式”，它只告诉机器“我想要什么样的结果”，具体的步骤由系统自己完成。
最后，Kubernetes 的核心组件 apiserver 借鉴了 HTTP 协议中“资源”的概念，使用了标准的 RESTful 风格。在 K8s 的体系里，所有被管理的内容（如 Pod, Service）都被抽象成了 “API 对象” 来进行操作。
# 查看 kubectl api-service 支持的所有对象
kubectl api-resources

# 显示出详细的命令执行过程
kubectl get pod --v=9
# 自带的 API 文档 https://kubernetes.io/docs/reference/kubernetes-api/
kubectl explain pod
kubectl explain pod.metadata

# 命令式
kubectl run ngx --image=nginx:alpine
# 转换为 YAML 声名式
kubectl run ngx --image=nginx:alpine --dry-run=client -o yaml > ngx-pod.yml
kubectl apply -f ngx-pod.yml
kubectl delete -f ngx-pod.yml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: ngx
  name: ngx
spec:
  containers:
  - image: nginx:alpine
    name: ngx
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}
12 Pod
既然 Docker 容器提倡“一个容器只跑一个进程”，那么当我们需要多个紧密协作的进程（多应用联合运行）共同工作时，我们不能破坏单容器单进程的隔离原则（不破坏容器隔离），所以我们需要在容器之上引入一个更高层级的抽象对象（收纳舱/Pod），让这些容器在共享网络和存储的同时，依然保持镜像层面的独立。

kubectl apply -f ngx-pod.yml
kubectl logs ngx
kubectl get pod
kubectl describe pod ngx

# cp file to pod
echo 'aaa' > a.txt
kubectl cp a.txt ngx:/tmp

# exec need --
kubectl exec -it ngx -- sh
cat /tmp/a.txt
13 Job CronJob 离线业务
单一职责 意味着每个容器应当只运行一个核心进程。避免“大而全”的巨型容器，保持容器功能的单一和纯粹，才能让它们像乐高积木一样被灵活复用和独立升级。
组合优于继承 意味着应该通过“组合”多个独立的容器（Pod 模式）来构建复杂的应用，而不是通过“继承”基础镜像并在其上层层叠加所有功能（巨型镜像）。这种松耦合的方式，允许应用在运行时通过 Sidecar 等模式灵活协作，而不是被固化在同一个镜像文件里。
kubectl create job echo-job --image=busybox --dry-run=client -o yaml > echo-job.yml
# 告诉 k8s 我想创建一个名为 echo-job 的任务（Job）。
# --dry-run=client 告诉 kubectl，“你假装执行一下创建命令，检查一下语法，但是千万不要真的把请求发给 Kubernetes API Server，也不要真的在集群里创建这个 Job”
vim echo-job.yml
apiVersion: batch/v1
kind: Job
metadata:
  creationTimestamp: null
  name: echo-job
spec:
  template:
    metadata:
      creationTimestamp: null
    spec:
      containers:
      - image: busybox
        name: echo-job
        resources: {}
        # 补充输出
        command: ["echo", "hello world"]
        # -----
      restartPolicy: Never
status: {}
kubectl apply -f echo-job.yml
kubectl get job
# NAME       COMPLETIONS   DURATION   AGE
# echo-job   1/1           16s        33s
kubectl get pod
# NAME             READY   STATUS      RESTARTS   AGE
# echo-job-59sgn   0/1     Completed   0          68s
kubectl logs echo-job-59sgn
# hello world
apiVersion: batch/v1
kind: Job
metadata:
  creationTimestamp: null
  name: sleep-job
spec:
  # 设置 Pod 运行的超时时间
  activeDeadlineSeconds: 60
  # 设置 Pod 的失败重试次数
  backoffLimit: 2
  # Job 完成需要运行多少个 Pod，默认是 1
  completions: 4
  # 它与 completions 相关，表示允许并发运行的 Pod 数量，避免过多占用资源
  parallelism: 2

  template:
    metadata:
      creationTimestamp: null
    spec:
      containers:
        - image: busybox
          name: echo-job
          resources: {}
          # 随机休眠
          command:
            - sh
            - -c
            - sleep $(($RANDOM % 10 + 1)) && echo done
      restartPolicy: Never
status: {}
kubectl apply -f sleep-job.yaml

kubectl get pod -w
# NAME              READY   STATUS      RESTARTS   AGE
# sleep-job-92m4d   0/1     Completed   0          30s
# sleep-job-g8pmj   0/1     Completed   0          15s
# sleep-job-tsncl   0/1     Completed   0          30s
# sleep-job-x4qlp   0/1     Completed   0          15s
# cronjob
kubectl create cj echo-cj --image=busybox --schedule="*/1 * * * *" --dry-run=client -o yaml > echo-cj.yaml
apiVersion: batch/v1
kind: CronJob
metadata:
  creationTimestamp: null
  name: echo-cj
spec:
  jobTemplate:
    metadata:
      creationTimestamp: null
      name: echo-cj
    spec:
      template:
        metadata:
          creationTimestamp: null
        spec:
          containers:
            - image: busybox
              name: echo-cj
              resources: {}
              # 补充输出
              command: ["/bin/echo"]
              args: ["hello", "world"]
          restartPolicy: OnFailure
  schedule: "*/1 * * * *"
status: {}
kubectl apply -f echo-cj.yaml
kubectl get cj
# NAME      SCHEDULE      SUSPEND   ACTIVE   LAST SCHEDULE   AGE
# echo-cj   */1 * * * *   False     1        5s              8s
kubectl get pod
# NAME                     READY   STATUS      RESTARTS   AGE
# echo-cj-27942326-qng4j   0/1     Completed   0          93s
# echo-cj-27942327-vlrvs   0/1     Completed   0          33s
14 ConfigMap Secret 管理配置信息
kubectl create cm info --from-literal=name=zhao --dry-run=client -o yaml > cm.yml
kubectl apply -f cm.yml
kubectl get cm
kubectl describe cm info
kubectl create secret generic user --from-literal=name=root --dry-run=client -o yaml > secret.yml

# -n 去掉字符串里隐含的换行符
echo -n "root" | base64
kubectl apply -f secret.yml
kubectl get secret
kubectl describe secret user
kubectl explain pod.spec.containers.env.valueFrom
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: ngx
  name: ngx
spec:
  containers:
    - image: nginx:alpine
      name: ngx
      resources: {}
      env:
        - name: NAME
          valueFrom:
            configMapKeyRef:
              name: info
              key: name
        - name: SNAME
          valueFrom:
            secretKeyRef:
              name: user
              key: name
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}
kubectl apply -f env-pod.yml
kubectl exec -it ngx -- sh

echo $NAME $SNAME
# 以 Volume 的方式使用 ConfigMap/Secret
apiVersion: v1
kind: Pod
metadata:
  name: vol-pod
spec:
  # Volume 属于 Pod 与 containers 同级
  volumes:
    - name: cm-vol
      configMap:
        name: info
    - name: sec-vol
      secret:
        secretName: user
  containers:
    # 挂载到容器里的某个路径下
    - volumeMounts:
        - mountPath: /tmp/cm-items
          name: cm-vol
        - mountPath: /tmp/sec-items
          name: sec-vol
      image: nginx:alpine
      name: ngx
      resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}
vim vol-pod.yml
kubectl apply -f vol-pod.yml
kubectl get pod
kubectl exec -it vol-pod -- sh

cat /tmp/cm-items/name
cat /tmp/sec-items/name
# ConfigMap 和 Secret 都变成了目录的形式，而它们里面的 Key-Value 变成了一个个的文件，而文件名就是 Key。
15 玩转 Kubernetes

搭建 WordPress 环境：
# vim mariadb-pod.yml
apiVersion: v1
kind: ConfigMap
metadata:
  name: maria-cm
data:
  DATABASE: "db"
  USER: "wp"
  PASSWORD: "123"
  ROOT_PASSWORD: "123"

---
apiVersion: v1
kind: Pod
metadata:
  name: maria-pod
  labels:
    app: wordpress
    role: database
spec:
  containers:
    - image: mariadb:10
      name: maria
      imagePullPolicy: IfNotPresent
      ports:
        - containerPort: 3306
      envFrom:
        - prefix: "MARIADB_"
          configMapRef:
            name: maria-cm
kubectl apply -f mariadb-pod.yml
# 获取 IP 地址需要加上参数 -o wide
kubectl get pod -o wide
# NAME        READY   STATUS    RESTARTS   AGE   IP           NODE       NOMINATED NODE   READINESS GATES
# maria-pod   1/1     Running   0          64s   172.17.0.5   minikube              
# vim wp-pod.yml
apiVersion: v1
kind: ConfigMap
metadata:
  name: wp-cm
data:
  # MariaDB Pod 的 IP
  HOST: "172.17.0.5"
  USER: "wp"
  PASSWORD: "123"
  NAME: "db"

---
apiVersion: v1
kind: Pod
metadata:
  name: wp-pod
  labels:
    app: wordpress
    role: website
spec:
  containers:
    - image: wordpress:5
      name: wp-pod
      imagePullPolicy: IfNotPresent
      ports:
        - containerPort: 80
      envFrom:
        - prefix: "WORDPRESS_DB_"
          configMapRef:
            name: wp-cm
kubectl apply -f wp-pod.yml
kubectl get pod -o wide
# NAME        READY   STATUS    RESTARTS   AGE     IP           NODE       NOMINATED NODE   READINESS GATES
# maria-pod   1/1     Running   0          160m    172.17.0.5   minikube              
# wp-pod      1/1     Running   0          2m47s   172.17.0.6   minikube              
# 本地的 “8080” 映射到 WordPress Pod 的“80”
kubectl port-forward wp-pod 8080:80 &
# Forwarding from 127.0.0.1:8080 -> 80
# Forwarding from [::1]:8080 -> 80
# fg
16 初级篇总结
minikube version
minikube status
minikube start --kubernetes-version=v1.23.3
minikube node list

kubectl version
kubectl run ngx --image=nginx:alpine

# apiserver 等核心组件是在 kube-system 名字空间
kubectl get pod -n kube-system

kubectl api-resources
kubectl explain pod.metadata

export out="--dry-run=client -o yaml"
kubectl run ngx --image=nginx:alpine $out > pod.yml

kubectl apply -f ngx-pod.yml
kubectl get pod
kubectl logs ngx-pod
kubectl exec -it ngx-pod -- sh
kubectl delete -f ngx-pod

kubectl create job echo-job --image=busybox $out
kubectl apply -f job.yml
kubectl get job
kubectl get pod
kubectl logs echo-job-l52l7

kubectl create cj echo-cj --image=busybox --schedule="* * * * *" $out
kubectl apply -f cronjob.yml
kubectl get cj
kubectl get pod

kubectl create cm info --from-literal=k=v $out
kubectl get cm
kubectl describe cm info

kubectl create secret generic user --from-literal=name=root $out
kubectl get secret
kubectl describe secret user

echo cm9vdA== | base64 -d
References

chronolaw/k8s_study | GitHub

– EOF –



Go 语言第一课
Wed, 01 Feb 2023 11:44:27 +0000
02 设计哲学
设计哲学之于编程语言，就好比一个人的价值观之于这个人的行为。

简单：Go 生产力的源泉。
显式：Go 希望开发人员 明确知道自己在做什么；显式的基于值比较的错误处理方案。
组合：类型嵌入(Type Embedding)。
并发：面向多核、原生支持并发、用户层轻量级线程 goroutine。
面向工程：将解决工程问题作为 Go 的 设计原则之一，这些问题包括:程序构建慢、依赖管理失控、代码难于理 解、跨语言构建难等。

03 配好环境

https://go.dev/doc/devel/release
https://golang.google.cn/dl/

安装多个 Go 版本
go get golang.org/dl/go1.15.13
go1.15.13 download
go1.15.13 version
配置 Go
go env
go help environment
04 Go 程序的结构

import "fmt" 一行中 fmt 代表的是包的导入路径(Import)，它表示的是标准库下的 fmt 目录，整个 import 声明语句的含义是导入标准库 fmt 目录下的包
fmt.Println 函数调用一行中的 fmt 代表的则是包名。
通常导入路径的最后一个分段名与包名是相同的，这也很容易让人误解 import 声明语句中的 fmt 指的是包名，其实并不是这样的。

gofmt main.go
Go module
go mod init
go mod tidy
05 Go 项目的布局标准
loccount 工具
https://github.com/golang/go
tree -LF 1 .
06 解决包依赖管理
GOPATH -> Vendor -> Go Module
GOPATH
go env

GOPATH="/Users/v_yfanzhao/go"

go get github.com/sirupsen/logrus
vendor

Go 项目必须放在 GOPATH 环境变量配置的路径下，庞大的 vendor 目录需要提交到代码仓库，不仅占用代码仓库空间，减慢仓库下载和更新的速度， 而且还会干扰代码评审，对实施代码统计等开发者效能工具也有比较大影响。
你还需要手工管理 vendor 下面的 Go 依赖包，包括项目依赖包的分析、版本的记 录、依赖包获取和存放，等等，最让开发者头疼的就是这一点。

Go Module
Go Module 与 go.mod 是一一对应的。go.mod 文件所在的顶层目录也被称为 module 的根目录，module 根目录以及它子目录 下的所有 Go 包均归属于这个 Go Module，这个 module 也被称为 main module。
package main

import "github.com/sirupsen/logrus"

func main() {
 logrus.Println("hello, go module mode")
}
go mod init
go mod tidy
module go-lesson-one

go 1.17

require github.com/sirupsen/logrus v1.9.0

require golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect
major.minor.patch
Go 的语义导入版本机制：将包主版本号引入到包导入路径中。v0、v1 时不加入路径。
因此甚至可以同时依赖一个包的两个不兼容版本：
import (
  "github.com/sirupsen/logrus"
  logv2 "github.com/sirupsen/logrus/v2"
)
Go 会在该项目依赖项的所有版本中，选出符合项目整体要求的“最小版本”。这与 PHP Composer 最新最大 (Latest Greatest) 版本 相反。
07 Go Module 操作
go list -m all

go list -m -versions github.com/sirupsen/logrus

# 指定版本 升降级
go get github.com/sirupsen/logrus@v1.7.0

# 指定版本 升降级
go mod edit -require=github.com/sirupsen/logrus@v1.7.0
go mod tidy
使用 vendor 机制
go mod vendor

go build -mod=verdor
# 顶层目录下存在 vendor 目录，那么 go build 默认也会优先基于 vendor 构建，除非：
go build -mod=mod
08 Go 程序的执行次序
可执行程序的 main 包必须定义 main 函数，否则 Go 编译器会报错。
除了 main 包外，其他包也可以拥有自己的名为 main 的函数 或方法。
init 函数
除了前面讲过的 main.main 函数之外，Go 语言还有一个特殊函数，它就是用于进行包初始化的 init 函数了。main 函数之前，常量和变量初 始化之后。每个 init 函数在整个 Go 程序生命周期内仅会被执行一次。Go 包可以拥有不止一个 init 函数。
Go 在进行包初始化的过程中，会采用“深度优先”的原则，递归初始化各个包的 依赖包。
package main
|- import pkg1
    |- import pkg2
        |- const
        |- var
        |- init()
    |- const
    |- var
    |- init()
|- const
|- var
|- init()
|- main()
init 函数的用途

重置包级变量值。被用于检查包级变量的初始状态。
实现对包级变量的复杂初始化。
在 init 函数中实现“注册模式”。通过在 init 函数中注册自己的实现的模式，就有效降低了 Go 包对外的直接 暴露，尤其是包级变量的暴露，从而避免了外部通过包级变量对包状态的改动。

09 构建一个 Web 服务
package main

import (
 "net/http"
)

func main() {
 http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  w.Write([]byte("Hello World"))
 })
 http.ListenAndServe(":8888", nil)
}
curl localhost:8888
Hello World

https://github.com/imzyf/go-bookstore

10 变量声明
var a int = 10
// 将变量名放在了类型的前面
// 修饰关键字 变量名 类型 初值

// 省略类型信息的声明
var b = 12
// 显式赋予变量初值
var b = int32(13)
// 声明多个
var a, b, c = 12, 'A', "hello"

// 短变量声明
a := 12
b := 'A'
c := "hello"
// 声明多个
a, b, c := 12, 'A', "hello"
Go 语言的两类变量

包级变量 (package varible)
局部变量 (local varible)

包级变量的声明形式
包级变量只能使用带有 var 关键字的变量声明形式，不能使用短变量声明形式，但在形式细节上可以有一定灵活度。
var b int32 = 17 // 显式指定类型
var f float32 = 3.14 // 显式指定类型

var a = 13 // 使用默认类型
var b = int32(17) // 显式指定类型
var f = float32(3.14) // 显式指定类型

var a int32
var f float64
// 声明聚类
var (
    netGo bool
    netCgo bool
)

var (
    aLongTimeAgo = time.Unix(1, 0)
    noDeadline = time.Time{}
    noCancel = (chan struct{})(nil)
)

// 就近原则
// 尽可能在靠近第一次使用变量的位置声明这个变量
局部变量的声明形式
// 延迟初始化的局部变量
var err error

// 显式初始化的局部变量
a := 17
f := float32(3.14)
s := []byte("hello, gopher!")
// 尽量在分支控制时使用短变量声明形式
11 代码块 Block 与作用域 Scope
// 变量遮蔽
var a = 11
func foo(n int) {
    a := 1
    a += n
}
func main() {
    fmt.Println("a =", a) // 11
    foo(5)
    fmt.Println("after calling foo, a =", a) // 11
}

宇宙代码块(Universe Block)
包代码块(Package Block)
文件代码块(File Block)
分支控制语句隐式代码块
switch/select 的子句隐式代码块

一个标识符的作用域就是指：这个标识符在被声明后可以被有效使用的源码区域。
导出标识符：

声明在包代码块中
它名字第一个字符是一个大写的 Unicode 字符


https://github.com/imzyf/go-lesson-one/blob/main/cmd/chapter11/main.go

12 数值类型
整型
Go 采用补码(2’s complement)作为整型的比特位编码方法。Go 的补码是通过原码逐位取反后再加 1 得到的。
unit8  1 0 0 0 0 0 0 1 = 129
int8   1 0 0 0 0 0 0 1 = -127

0 1 1 1 1 1 1 1     127
1 0 0 0 0 0 0 0     取反
1 0 0 0 0 0 0 1     +1    -127
整型的溢出问题

https://github.com/imzyf/go-lesson-one/blob/main/cmd/chapter12/main.go

这个问题最容易发生在循环语句的结束条件判断中，因为这也是经常使用整型变量的地方。
浮点型
IEEE 754

符号位Sign  阶码Exponent  尾数Maintissa

  
      
          \bit 位\
          符号位
          阶码
          阶码偏移值
          尾数
      
  
  
      
          单精度 float32
          1
          8
          127
          23
      
      
          双精度 float64
          1
          11
          1023
          52
      
  

eg:129.8125
步骤一:我们要把这个浮点数值的整数部分和小数部分，分别转换为二进制形式(后缀 d 表示十进制数，后缀 b 表示二进制数):

整数部分:139d => 10001011b;

小数部分:0.8125d => 0.1101b(十进制小数转换为二进制可采用“乘 2 取整”的竖式计算)。
0.8125 * 2 = 1.625 …… 1
0.625 * 2 = 1.25   …… 1
0.25 * 2 = 0.5     …… 0
0.5 * 2 = 1        …… 1

139.8125d -> 10001011.1101b
步骤二:移动小数点，直到整数部分仅有一个 1。

10001011.1101b -> 1.00010111101b

小数点向左移了 7 位，这样 指数就为 `7`，尾数为 `00010111101b`。
步骤三:计算阶码。对于 float32 的单精度浮点数而言：
阶码 = 指数 + 偏移值
偏移值的计算公式为 2^(e-1)-1，其中 e 为阶码部分的 bit 位数，这里为 8，于是单精度浮点数的阶码偏移 值就为 2^(8-1)-1 = 127。

阶码 = `7` + 127 = 134d = `10000110b`。
步骤四:将符号位、阶码和尾数填到各自位置，得到最终浮点数的二进制表示

符号位 0
阶码 10000110
尾数 00010111101 不足 23 位补零 `0_0010111101_00_0000000000`
139.8125 -> 0_10000110_00010111101_000000000000

Go Float32bit() result not expected | stackoverflow

复数型
矢量计算。
创建自定义的数值类型
type MyInt int32

var m int = 5
var n int32 = 6
var a MyInt = m // error
var a MyInt = n // error

var a = MyInt(m) // ok
var a = MyInt(n) // ok
MyInt 类型的底层类型是 int32，所以它的数值性质与 int32 完全相同，但它 们仍然是完全不同的两种类型。
类型别名(Type Alias)
type MyInt = int32

var n int32 = 6
var a MyInt = n
通过类型别名语法定义的新类型与原类型别无二致，可以完全相互替代。
13 字符串类型
why-what-how
非原生字符串：

不是原生类型，编译器不会对它进行类型校验，导致类型安全性差;
字符串操作时要时刻考虑结尾的 \0，防止缓冲区溢出;
以字符数组形式定义的“字符串”，它的值是可变的，在并发场景中需要考虑同步问题;
获取一个字符串的长度代价较大，通常是 O(n) 时间复杂度;
C 语言没有内置对非 ASCII 字符(如中文字符)的支持。

string 类型的数据是不可变的，提高了字符串的并发安全性和存储利用率（同一个字符串值分配同一块存储）。
var s string = "hello"
s[0] = 'k' // cannot assign to s[0] (value of type byte)
s = "gopher" // ok
没有结尾 \0，而且获取长度的时间复杂度是常数时间，消除了获取字符串长度的开销。
反引号原生支持“所见即所得”的原始字符串，大大降低构造多行字符串时的心智负担。
对非 ASCII 字符提供原生支持，消除了源码在不同环境下显示乱码的可能。Unicode 字符是以 UTF-8 编码格式存储在内存。
通过单引号括起的字符字面值：
https://github.com/imzyf/go-lesson-one/blob/main/cmd/chapter13/main.go
UTF-8 编码解决的是 Unicode 码点值在计算机中如何存储和表示(位模式)的问题。UTF-8 方案使用变长度字节，从 1 个到 4 个不等。
一个 rune 存储一个 unicode 码点或 utf-32 的四字节编码；从字节视角，string 对应的底层存储存放的是 utf8 编码。
Go 字符串类型的内部标示
// StringHeader 是一个 string 的运行时表示
// string 类型其实是一个“描述符”
type StringHeader struct {
  // 一个指向底层存储的指针
  Data uintptr
  // 字符串的长度
  Len int
}
直接将 string 类型通过函数或方法参数传入也不会带来太多的开销。因为传入的仅仅是一个“描述符”，而不是真正的字符串数据。
Go 字符串类型的常见操作
下标操作；下标操作，我们获取的是字符串中特定下标上的字节，而不是字符。
字符迭代：

or 迭代，字节视角的迭代
字符串中 Unicode 字符的码点值，以及该字符在字符串中的偏移值（字节视角）

字符串连接；+ += strings.Builder strings.Join fmt.Sprintf。
字符串比较；= =、!= 、>=、<=、> 和 <。
字符串转换；string -> []rune []byte
14 常量

支持无类型常量
支持隐式自动转型
可用于实现枚举

type myInt int
// 无类型常量(Untyped Constant)
const n = 13

func main() {
  var a myInt = 5
  // 隐式转型
  fmt.Println(a + n)
}

// 无类型常量 + 隐式转型：使得在 Go 这样的具有强类型系统的语言，在处理表达式混合数据类型运算的时候具有比较大的灵活性，代码编写也得到了一定程度的简化。
Go 的 const 语法提供了“隐式重复前一个非空表达式”的机制。
const (
  Apple, Banana = iota, iota + 10 // 0, 10 (iota = 0)
  Strawberry, Grape // 1, 11 (iota = 1)
  Pear, Watermelon // 2, 12 (iota = 2)
)
const (
  _ = iota // 略过 iota = 0
  IPV6_V6ONLY // 1
  SOMAXCONN // 2
  SO_ERROR // 3
)
15 数组与切片
数组是一个固定长度的、由同构类型元素组成的连续序列。不仅是逻辑上的连续序列，而且在实际内存分配时也占据着一整块内存。
切片不定长同构数据类型。切片可以看成是数组的“描述符”（句柄），为数组打开了一个访问与修改的“窗口”。
// 切片
type slice struct {
  array unsafe.Pointer // 指向底层数组的指针
  len int // 切片的长度，即切片中当前元素的个数
  cap int // 底层数组的长度，也是切片的最大容量，cap 值永远大于等于 len 值
}
var sl1 []int // 是声明，未初始化，是nil值，底层没有分配内存空间
var sl2 = []int{} // 初始化了，不是nil值，底层分配了内存空间，有地址。
16 map 类型
一组无序的键值对。
map[key_type]value_type
key 的类型必须支持“==”和“!=”两种比较操作符。
References

The Go Playground

– EOF —



回顾 2022
Sat, 31 Dec 2022 20:16:41 +0000

犯错的人不会沉浸在错误里，而是继续战斗。 —— 管泽元 S12 总决赛 DRX vs SKT 2:2

– EOF –


PHP Migrating 8.0 to 8.1
Wed, 21 Dec 2022 18:25:49 +0000
简介
PHP 8.1 引入了许多重要的新特性，包括枚举（Enums）、只读属性（Readonly Properties）、一等可调用语法（First-class Callable Syntax）、Fibers、交叉类型（Intersection Types）等。本文将介绍主要变化和如何从 PHP 8.0 迁移到 PHP 8.1。
参考资源

在线测试环境：https://onlinephp.io/
官方发布说明：https://www.php.net/releases/8.1/en.php
迁移指南：https://www.php.net/manual/en/migration81.php
更新详情：https://php.watch/versions/8.1

PHP 8.1 新特性
枚举（Enums）
PHP 8.1 原生支持枚举类型，取代了之前使用类常量的方式：
// 纯枚举（Pure Enum）
enum Status {
    case Draft;
    case Published;
    case Archived;
}

// 回退枚举（Backed Enum）- 带有标量值
enum Status: string {
    case Draft = 'draft';
    case Published = 'published';
    case Archived = 'archived';
}

// 使用枚举作为类型提示
class BlogPost {
    public function __construct(
        public Status $status = Status::Draft
    ) {}
}

$post = new BlogPost();
echo $post->status->value; // 'draft'

// 枚举可以有方法
enum Color: string {
    case Red = '#FF0000';
    case Green = '#00FF00';
    case Blue = '#0000FF';

    public function label(): string {
        return match($this) {
            self::Red => '红色',
            self::Green => '绿色',
            self::Blue => '蓝色',
        };
    }
}

echo Color::Red->label(); // '红色'

// 从值获取枚举
$status = Status::from('draft');     // Status::Draft
$status = Status::tryFrom('invalid'); // null（不会抛出异常）
枚举的特性：

枚举可以实现接口
枚举可以使用 trait
枚举不能被实例化（new Status() 是非法的）
枚举 case 是单例

只读属性（Readonly Properties）
属性可以标记为 readonly，只能初始化一次：
class User {
    public readonly string $id;
    public readonly string $name;

    public function __construct(string $id, string $name) {
        $this->id = $id;
        $this->name = $name;
    }
}

$user = new User('123', 'John');
echo $user->id; // '123'

$user->id = '456';
// Fatal error: Cannot modify readonly property User::$id

// 结合构造函数提升使用
class Product {
    public function __construct(
        public readonly string $sku,
        public readonly float $price,
    ) {}
}
只读属性的特性：

只能初始化一次，初始化后不可修改
必须有类型声明
不能有默认值（除非在构造函数中设置）
可以在构造函数或声明时初始化

一等可调用语法（First-class Callable Syntax）
使用 ... 语法创建闭包，替代 Closure::fromCallable()：
// 函数转闭包
$strlen = strlen(...);
echo $strlen('hello'); // 5

// 等同于
$strlen = Closure::fromCallable('strlen');

// 方法转闭包
class Calculator {
    public function add(int $a, int $b): int {
        return $a + $b;
    }

    public static function multiply(int $a, int $b): int {
        return $a * $b;
    }

    public function __invoke(int $x): int {
        return $x * 2;
    }
}

$calc = new Calculator();

// 实例方法
$addFn = $calc->add(...);
echo $addFn(3, 5); // 8

// 静态方法
$multiplyFn = Calculator::multiply(...);
echo $multiplyFn(3, 4); // 12

// __invoke 方法
$invokeFn = $calc(...);
echo $invokeFn(10); // 20

// 在数组函数中使用
$words = ['apple', 'banana', 'cherry'];
$lengths = array_map(strlen(...), $words); // [5, 6, 6]
Fibers（纤程）
Fibers 是轻量级的协程，允许暂停和恢复代码执行：
$fiber = new Fiber(function(): void {
    echo "1. Fiber 开始\n";
    $value = Fiber::suspend('暂停值');
    echo "3. Fiber 恢复，收到: $value\n";
});

echo "0. 主程序开始\n";
$suspended = $fiber->start();  // 启动 Fiber
echo "2. 主程序收到: $suspended\n";
$fiber->resume('恢复值');      // 恢复 Fiber
echo "4. 主程序结束\n";

// 输出:
// 0. 主程序开始
// 1. Fiber 开始
// 2. 主程序收到: 暂停值
// 3. Fiber 恢复，收到: 恢复值
// 4. 主程序结束
Fibers 主要用于异步框架（如 ReactPHP、Amp），普通应用开发较少直接使用。
交叉类型（Intersection Types）
使用 & 运算符要求参数同时满足多个类型：
// 参数必须同时实现 Iterator 和 Countable
function processItems(Iterator&Countable $items): int {
    foreach ($items as $item) {
        // 处理项目
    }
    return count($items);
}

// ArrayIterator 同时实现了这两个接口
$items = new ArrayIterator([1, 2, 3]);
echo processItems($items); // 3

// 更复杂的示例
interface Loggable {
    public function log(): void;
}

interface Serializable {
    public function serialize(): string;
}

function store(Loggable&Serializable $object): void {
    $object->log();
    $data = $object->serialize();
    // 存储数据
}
never 返回类型
表示函数永远不会返回（总是抛出异常或终止程序）：
function redirect(string $url): never {
    header("Location: $url");
    exit();
}

function throwError(string $message): never {
    throw new RuntimeException($message);
}

// 静态分析工具可以检测 never 之后的死代码
redirect('/home');
echo "这行代码永远不会执行"; // IDE 会标记为死代码
final 类常量
类常量可以标记为 final，防止子类覆盖：
class ParentClass {
    final public const VERSION = '1.0';
    public const NAME = 'Parent';
}

class ChildClass extends ParentClass {
    // ❌ Fatal error: Cannot override final constant
    public const VERSION = '2.0';

    // ✅ 可以覆盖非 final 常量
    public const NAME = 'Child';
}
初始化器中的 new 表达式
可以在默认参数、属性默认值和常量中使用 new 表达式：
// 默认参数
class Logger {
    public function __construct(
        private Formatter $formatter = new DefaultFormatter(),
    ) {}
}

// 属性默认值
class Config {
    public DateTimeImmutable $createdAt = new DateTimeImmutable();
}

// 属性（PHP 8.0 的属性也支持）
#[Attribute]
class Route {
    public function __construct(
        public string $path,
        public array $methods = ['GET'],
    ) {}
}

class Controller {
    #[Route('/users', methods: ['GET', 'POST'])]
    public function users() {}
}
字符串键数组解包
现在可以对字符串键数组使用扩展运算符：
$array1 = ['a' => 1, 'b' => 2];
$array2 = ['c' => 3, 'd' => 4];

// PHP 8.1 之前：只能用于数字键数组
// PHP 8.1：支持字符串键
$merged = [...$array1, ...$array2];
// ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4]

// 后面的值会覆盖前面的
$array3 = ['a' => 'override'];
$result = [...$array1, ...$array3];
// ['a' => 'override', 'b' => 2]
显式八进制表示法
新增 0o 前缀表示八进制数：
// 传统八进制表示法（仍然有效）
$permissions = 0755;

// PHP 8.1 新的显式表示法
$permissions = 0o755;

// 两者等价
var_dump(0o16);  // int(14)
var_dump(016);   // int(14)

// 0o 更清晰，避免与数字 0 开头的误解
PHP 8.1 新增函数
array_is_list()
检查数组是否为列表（连续的从 0 开始的整数键）：
// 是列表
array_is_list([]);                    // true
array_is_list(['a', 'b', 'c']);       // true
array_is_list([0 => 'a', 1 => 'b']);  // true

// 不是列表
array_is_list([1 => 'a', 2 => 'b']);  // false（不从 0 开始）
array_is_list(['a' => 1, 'b' => 2]);  // false（字符串键）
array_is_list([0 => 'a', 2 => 'b']);  // false（不连续）
fsync() 和 fdatasync()
强制将文件数据写入磁盘：
$file = fopen('data.txt', 'w');
fwrite($file, 'important data');

// fsync: 同步文件数据和元数据
fsync($file);

// fdatasync: 只同步文件数据（更快，不包括元数据）
fdatasync($file);

fclose($file);
Sodium XChaCha20 函数
新增 XChaCha20 加密函数：
// 生成密钥
$key = sodium_crypto_stream_xchacha20_keygen();

// XChaCha20 加密
$nonce = random_bytes(SODIUM_CRYPTO_STREAM_XCHACHA20_NONCEBYTES);
$encrypted = sodium_crypto_stream_xchacha20_xor($message, $nonce, $key);
新的哈希算法
支持 xxHash 和 MurmurHash3：
// xxHash（非常快的非加密哈希）
echo hash('xxh3', 'data');
echo hash('xxh64', 'data');
echo hash('xxh128', 'data');

// MurmurHash3
echo hash('murmur3a', 'data');
echo hash('murmur3c', 'data');
echo hash('murmur3f', 'data');
枚举相关函数
enum Status: string {
    case Active = 'active';
    case Inactive = 'inactive';
}

// 获取所有 case
$cases = Status::cases();
// [Status::Active, Status::Inactive]

// 回退枚举的额外方法
$status = Status::from('active');      // Status::Active
$status = Status::tryFrom('unknown');  // null
弃用特性
向非可空参数传递 null
向内置函数的非可空参数传递 null 已被弃用：
// ❌ PHP 8.1 弃用警告
strlen(null);
str_contains(null, 'test');
trim(null);

// ✅ 修复方法
strlen($value ?? '');
str_contains($value ?? '', 'test');
trim($value ?? '');
Serializable 接口弃用
Serializable 接口已被弃用，使用 __serialize() 和 __unserialize() 替代：
// ❌ 已弃用
class OldWay implements Serializable {
    public function serialize(): string {
        return serialize($this->data);
    }
    public function unserialize(string $data): void {
        $this->data = unserialize($data);
    }
}

// ✅ 推荐方式
class NewWay {
    public function __serialize(): array {
        return ['data' => $this->data];
    }
    public function __unserialize(array $data): void {
        $this->data = $data['data'];
    }
}
隐式浮点数转整数弃用
非整数浮点数隐式转换为整数时会产生弃用警告：
// ❌ 弃用警告
$arr = [];
$arr[3.14] = 'value'; // 3.14 会被转为 3

// ✅ 显式转换
$arr[(int)3.14] = 'value';
日期函数弃用
// ❌ 已弃用
strftime('%Y-%m-%d', time());
gmstrftime('%Y-%m-%d', time());
strptime('2024-01-01', '%Y-%m-%d');
date_sunrise($timestamp);
date_sunset($timestamp);

// ✅ 替代方案
// 使用 IntlDateFormatter
$formatter = new IntlDateFormatter(
    'zh_CN',
    IntlDateFormatter::FULL,
    IntlDateFormatter::NONE
);
echo $formatter->format(time());

// 或使用 DateTime
$date = new DateTime();
echo $date->format('Y-m-d');
mhash*() 函数弃用
// ❌ 已弃用
mhash(MHASH_MD5, 'data');
mhash_keygen_s2k(MHASH_SHA1, 'password', 'salt', 16);

// ✅ 使用 hash() 函数
hash('md5', 'data');
hash_pbkdf2('sha1', 'password', 'salt', 1000, 16);
PDO::FETCH_SERIALIZE 弃用
// ❌ 已弃用
$stmt->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_SERIALIZE, MyClass::class);

// ✅ 使用 __serialize()/__unserialize() 魔术方法
auto_detect_line_endings INI 弃用
// ❌ 已弃用
ini_set('auto_detect_line_endings', true);

// ✅ 手动处理行结束符
$content = str_replace(["\r\n", "\r"], "\n", $content);
兼容性变化
资源类型迁移为对象
多个扩展的资源类型被迁移为对象：
// finfo
$finfo = finfo_open(FILEINFO_MIME);
var_dump($finfo); // PHP 8.0: resource, PHP 8.1: finfo object

// FTP
$ftp = ftp_connect('ftp.example.com');
var_dump($ftp); // FTP\Connection object

// IMAP
$imap = imap_open('{imap.example.com:993/imap/ssl}', 'user', 'pass');
var_dump($imap); // IMAP\Connection object

// LDAP
$ldap = ldap_connect('ldap.example.com');
var_dump($ldap); // LDAP\Connection object

// PostgreSQL
$pg = pg_connect('host=localhost dbname=test');
var_dump($pg); // PgSql\Connection object
继承方法中的静态变量
继承方法中的静态变量现在与父类共享：
class A {
    public static function counter() {
        static $i = 0;
        return ++$i;
    }
}
class B extends A {}

var_dump(A::counter()); // int(1)
var_dump(A::counter()); // int(2)
var_dump(B::counter());
// PHP 8.0: int(1)（B 有自己的计数器）
// PHP 8.1: int(3)（B 共享 A 的计数器）
HTML 实体函数默认处理单引号
// PHP 8.0: 默认 ENT_COMPAT，不转义单引号
// PHP 8.1: 默认 ENT_QUOTES | ENT_SUBSTITUTE

$str = "It's a \"test\"";
echo htmlspecialchars($str);
// PHP 8.0: It's a "test"
// PHP 8.1: It's a "test"
性能改进
PHP 8.1 带来了显著的性能提升：

Symfony Demo: 提升约 23%
WordPress: 提升约 3.5%
继承缓存优化
快速类名解析
内置函数优化
ARM64 JIT 后端支持

总结
PHP 8.1 带来了许多实用的新特性和改进：
主要新特性：

枚举（Enums）
只读属性（Readonly Properties）
一等可调用语法
Fibers（纤程）
交叉类型（Intersection Types）
never 返回类型
final 类常量
初始化器中的 new 表达式
字符串键数组解包

需要注意的变化：

向非可空参数传递 null 已弃用
Serializable 接口已弃用
隐式浮点数转整数已弃用
多个资源类型迁移为对象
继承方法中的静态变量行为变化
日期相关函数弃用

通过了解这些变化并遵循迁移建议，可以顺利地从 PHP 8.0 迁移到 PHP 8.1。



PHP Migrating 7.4 to 8.0
Wed, 14 Dec 2022 16:40:03 +0000

实验环境：https://onlinephp.io/
https://www.php.net/releases/8.0/en.php
https://www.php.net/manual/en/migration80.php
https://php.watch/versions/8.0
https://github.com/symfony/polyfill/tree/1.x/src/Php80


PHP 8.0 contains many new features and optimizations including named arguments, union types, attributes, constructor property promotion, match expression, nullsafe operator, JIT, and improvements in the type system, error handling, and consistency.

New Features 8.0
// Named Parameters 命名参数
// https://www.php.net/manual/zh/functions.arguments.php#functions.named-arguments
// array_fill(int $start_index, int $count, mixed $value): array
var_dump(array_fill(value: 50, count: 3, start_index: 0));
// PHP80 [50, 50, 50]
// 注解（Attributes）
// https://www.php.net/manual/zh/language.attributes.php
// 定义注解 -> 使用注解 -> （通过反射）提取注释
// 注意以后用词：Attributes 注解，Properties 属性
#[\Attribute]
class JsonSerialize {
    public function __construct(public ?string $fieldName = null) {
        var_dump("JsonSerialize:$fieldName");
    }
}
class VersionedObject {
    #[JsonSerialize('json-foobar')]
    protected string $myValue = '';
}
$object = new VersionedObject();
$reflection = new ReflectionObject($object);
foreach ($reflection->getProperties() as $reflectionProp) {
    foreach ($reflectionProp->getAttributes(JsonSerialize::class) as $jsonSerializeAttr) {
        var_dump($jsonSerializeAttr->getName());
        var_dump($jsonSerializeAttr->getArguments());
        var_dump($jsonSerializeAttr->getTarget());
        var_dump($jsonSerializeAttr->isRepeated());
        var_dump($jsonSerializeAttr->newInstance());
    }
}
// string(13) "JsonSerialize"
//
// array(1) {
//   [0]=>
//   string(11) "json-foobar"
// }
//
// int(8) Attribute::TARGET_PROPERTY
//
// bool(false)
//
// string(25) "JsonSerialize:json-foobar"
// object(JsonSerialize)#5 (1) {
//   ["fieldName"]=>
//   string(11) "json-foobar"
// }
// 构造器属性提升 Constructor Property Promotion
// 当构造器参数带访问控制（visibility modifier）时，PHP 会同时把它当作对象属性和构造器参数，并赋值到属性
class Point {
    public function __construct(protected int $x, protected int $y = 0) {}
}
var_dump(new Point(2,4));
// object(Point)#1 (2) {
//   ["x":protected]=>
//   int(2)
//   ["y":protected]=>
//   int(4)
// }
class Point2 {
    protected int $x;
    protected int $y;
    public function __construct(protected int $x, protected int $y = 0) {}
}
// 此类中已经定义了具有相同名称的字段
// Fatal error: Cannot redeclare Point::$x
// Union types 联合类型
// ?T is same T|null
//
// - 类型只能出现一次 int|string|INT 否则报错
// - 使用 mixed 会报错
// - bool 与 false or true 不能混用
// - object 与 class 不能混用
// - iterable 与 array Traversable 不能混用
// - 使用 self、parent 或 static 都会导致错误
public function parse_value(string|int|float): string|null {}
// match 表达式
// https://www.php.net/manual/en/control-structures.match.php
// match 表达式必须是详尽，则会抛出 UnhandledMatchError。
echo match (8.0) {
    '8.0' => "Oh no!",
    8.0 => "This matches",
};
// This matches
// Nullsafe Operator
$result = $repository?->getUser(5)?->name;
// Is equivalent to the following code block:
if (is_null($repository)) {
    $result = null;
} else {
    $user = $repository->getUser(5);
    if (is_null($user)) {
        $result = null;
    } else {
        $result = $user->name;
    }
}
// Argument Unpacking
echo str_replace(...[
    'replace' => 'Iron Man',
    'search' => 'Inevitable',
    'subject' => 'I am Inevitable',
]);
// Named Parameters with Variadic Parameters
function test($a, $b, ...$args) {
    var_dump($args);
}
test(28, 15, june: 6, september: 15, january: "01");
// array(3) {
//     ["june"]=> int(6)
//     ["september"]=> int(15)
//     ["january"]=> string(2) "01"
// }
// JIT Just-In-Time Compilation
// php -i | grep -i opcache
// php -d opcache.enable_cli=1 -d opcache.jit_buffer_size=256M -d opcache.jit=tracing -i | grep -i jit

// opcache.enable=1
// opcache.enable_cli=1
// opcache.jit_buffer_size=256M

<?php
function fibonacci($n) {
    if ($n < 2) return $n;
    return fibonacci($n - 1) + fibonacci($n - 2);
}

$start = microtime(true);

fibonacci(42);

$end = microtime(true);
echo "Time taken: " . ($end - $start) . " seconds\n";

// php -d opcache.enable_cli=1 -d opcache.jit_buffer_size=256M -d opcache.jit=tracing test.php
// The WeakMap class has been added, accepts objects as keys, similar SplObjectStorage
// https://www.php.net/manual/en/class.weakmap.php
// https://www.php.net/manual/en/class.splobjectstorage.php
// final class WeakMap implements ArrayAccess, Countable, IteratorAggregate
$wm = new WeakMap();
$o = new StdClass;
class A {
    public function __destruct() {
        echo "Dead!\n";
    }
}
$wm[$o] = new A;
var_dump(count($wm));
// int(1)
unset($o);
// Dead!
// 销毁
var_dump(count($wm));
// int(0)

// 对比 SplObjectStorage
$wm = new SplObjectStorage();
$o = new StdClass;
class A {
    public function __destruct() {
        echo "Dead!\n";
    }
}
$wm[$o] = new A;
var_dump(count($wm));
// int(1)
unset($o);
// 未销毁
var_dump(count($wm));
// int(1)
// 只要类型兼容，现在可以将任意数量的函数参数替换为可变参数 variadic argument
class A {
    public function method(int $many, string $parameters, $here) {}
}
class B extends A {
    public function method(...$everything) {}
}
// OK
class C extends A {
    public function method(int ...$everything) {}
}
// Fatal error: Declaration of C::method(int ...$everything)
// static 后期静态绑定，现在可以用作返回类型
class Test {
    public function create(): static {
        return new static();
    }
}
// get_class($obj) === $obj::class
class Test {}
$obj = new Test;
var_dump($obj::class);
var_dump(get_class($obj));
// new instanceof 可以与任意表达式一起使用
// new (expression)(...$args)
// $obj instanceof (expression)
class A{};
class B{};
new (1>2 ? "A" : "B")();
// 新增 Stringable 接口。如果 class 定义了 __toString()，则自动实现了此接口
// Traits can define abstract private methods
trait T {
    abstract private function a();
}
// Throw 可以作为一个表达式 as an expression
$value = $config['path'] ?? throw new InvalidArgumentException('path required');
$fn = fn() => throw new Exception('Exception in arrow function');
// 参数列表中现在允许使用可选的尾随逗号
function functionWithLongSignature(
    Type1 $parameter1,
    Type2 $parameter2, // <-- This comma is now allowed.
) {}
// 允许 catch (Exception) 无需存储到变量
try {}
catch (Exception) {}
// 在父类上声明的私有方法不再对子类的方法强制执行任何继承规则（私有构造函数除外）
class ParentClass {
    private function method1() {}
    private function method2() {}
    private static function method3() {}
}
abstract class ChildClass extends ParentClass {
    public abstract function method1();
    public static function method2() {}
    public function method3() {}
}
// OK
// New string functions
str_contains('Foobar', 'Foo'); // true
str_starts_with('PHP 8', 'PHP'); // true
str_ends_with('Version8', '8'); // true
Backward Incompatible Changes 8.0
// 字符串与数字比较
// 0 == "not-a-number" is false
// 将数字转换为字符串，并使用字符串比较
var_dump(0 == "foo");
var_dump(42 == "42foo");
var_dump(0 == "");
// PHP80           PHP74
// bool(false)     true
// bool(false)     true
// bool(false)     true

var_dump("" < 0);
var_dump("" < -1);
var_dump("a" < 0);
var_dump("b" < -1);
var_dump("ab" > 0);
// PHP80           PHP74
// bool(true)      false
// bool(true)      false
// bool(false)     false
// bool(false)     false
// bool(true)      false
// is_callable() 在检查具有 classname 的 non-static 方法时将 false（必须检查对象实例）
class Test {
    public function method1() {}
}
var_dump(is_callable([Test::class, 'method1']));
var_dump(is_callable([new Test, 'method1']));
// PHP80           PHP74
// bool(false)     true
// bool(true)      true
// __autoload() function has been removed
// 删除了对 object 使用 array_key_exists() 的能力。isset() or property_exists() may be used instead
// isset($arr['key']) → false（当值为 null）- 只能在 null 安全时检查，无法区分 null 与 不存在
// array_key_exists('key', $arr) → true（即使值为 null）- 可以区分存在但值为 null 的情况
– EOF –


PHP Migrating to 7.2 7.3 7.4
Mon, 12 Dec 2022 20:51:51 +0000

实验环境：https://onlinephp.io/

PHP7.1 to PHP7.2

https://www.php.net/manual/en/migration72.php
https://php.watch/versions/7.2


Argon2 password hashing support, class constant visibility, object type, and many more.

New Features 7.2
// 新的 object 类型
// 可用于逆变（contravariant）参数输入和协变（covariant）返回任何对象类型
// https://www.php.net/manual/zh/language.oop5.variance.php
// 协变使子类比父类方法能返回更具体的类型；逆变使子类比父类方法参数类型能接受更模糊的类型
function test(object $obj): object
{
    return new SplQueue();
}
test(new StdClass());
// 抽象类可以重写被继承的抽象类的抽象方法
abstract class A
{
    abstract function test(string $s);
}
abstract class B extends A
{
    // overridden - 仍然保持参数的逆变和返回的逆变
    abstract function test($s): int;
}
// 重写方法和接口实现的参数类型可以省略
// 仍然是符合LSP，这种参数类型是逆变
interface A
{
    public function test(array $input);
}
class B implements A
{
    // type omitted for $input
    public function test($input){
        return $input;
    }
}
var_dump((new B())->test(1));
// PHP72 int(1)
//
// PHP71 Fatal error: Declaration of B::test($input) must be compatible with A::test(array $input)
Backward incompatible changes 7.2
// 防止 number_format() 返回负零
var_dump(number_format(-0.01));
// PHP72 string(1) "0"
//
// PHP71 string(2) "-0"
// 转换对象和数组中的数字键
$arr = [0 => 1];
$obj = (object) $arr;
var_dump($obj);
var_dump($obj->{'0'}, // 新写法
    $obj->{0} // 新写法
);
// PHP72 object(stdClass)#1 (1) {
//   ["0"]=>
//   int(1)
// }
// int(1)
// int(1)
//
// PHP71 object(stdClass)#1 (1) {
//   [0]=>
//   int(1)
// }
// Notice: Undefined property: stdClass::$0


$obj = new class {
    public function __construct()
    {
        $this->{1} = "value";
    }
};
$arr = (array) $obj;
var_dump($arr);
var_dump($arr["1"]); // 整数 或者 字符串整数 含义相同
var_dump($arr[1]); // PHP71
var_dump($arr[0]);
// PHP72 array(1) {
//   [1]=>
//   string(2) "my"
// }
//
// PHP71 无法取整型字符串 key
// array(1) {
//   ["1"]=>
//   string(2) "my"
// }
// Notice: Undefined offset: 1
// Notice: Undefined offset: 1
// Notice: Undefined offset: 0

$a = [1.3 => "v1", 1.4 => "v2"];
var_dump($a);
// ALL array key float 会被转换为 int
// array(1) {
//   [1]=>
//   string(2) "v2"
// }
// get_class() 函数不再接受 null
var_dump(get_class(null));
// PHP72
// Warning: get_class() expects parameter 1 to be object
// bool(false)
//
// PHP71
// Warning: get_class() called without object from outside a class
// bool(false)
//
// PHP80
// Fatal error: Uncaught TypeError: get_class(): Argument #1 ($object) must be of type object, null given
// 计算非可数类型（non-countable）时发出警告
var_dump(
    count(null), // NULL is not countable
    count(1), // integers are not countable
    count('abc'), // strings are not countable
    count(new stdclass) // objects not implementing the Countable interface are not countable
);
// PHP72
// Warning: count(): Parameter must be an array or an object that implements Countable
//
// PHP71
// 无 Warning
//
// PHP80
// Fatal error: Uncaught TypeError: count(): Argument #1 ($value) must be of type Countable|array
// 调用未定义的常量，现在会抛出一个 E_WARNING 错误（之前版本中为 E_NOTICE)）
// PHP8 将不会转化成他们自身的字符串，同时抛出 Error 异常
var_dump(MY_CONST);
// PHP72
// Warning: Use of undefined constant MY_CONST - assumed 'MY_CONST'
// string(8) "MY_CONST"
//
// PHP71
// Notice: Use of undefined constant MY_CONST
// string(8) "MY_CONST"
//
// PHP80
// Fatal error: Uncaught Error: Undefined constant "MY_CONST"
// bcmod 任意精度数字取模，添加新增参数 scale
var_dump(bcmod("4", "3.5"));
// PHP72
// string(1) "0"
//
// PHP71
// string(1) "1"
var_dump(bcmod("4", "3.5", 1));
// PHP72
// string(3) "0.5"
//
// PHP71
// Warning: bcmod() expects exactly 2 parameters, 3 given
// json_decode associative 允许为 null
// 当为 true 时，JSON 对象将返回关联 array；当为 false 时，JSON 对象将返回 object。
// 当为 null 时，JSON 对象将返回关联 array 或 object，这取决于是否在 flags 中设置 JSON_OBJECT_AS_ARRAY
// https://www.php.net/manual/zh/function.json-decode.php
$json = '{"a":1,"b":2}';
var_dump(json_decode($json, null, 512, JSON_OBJECT_AS_ARRAY));
// PHP72
// array(2) {
//   ["a"]=>
//   int(1)
//   ["b"]=>
//   int(2)
// }
//
// PHP71
// object(stdClass)#1 (2) {
//   ["a"]=>
//   int(1)
//   ["b"]=>
//   int(2)
// }
PHP7.2 to PHP7.3

https://www.php.net/manual/en/migration72.php
https://php.watch/versions/7.3


Heredoc/nowdoc syntax improvements and a bunch of legacy code deprecations.

New Features 7.3
// Heredoc Nowdoc 不再需要后跟分号或换行符
// 结束标记可以缩进，结束时所引用的标识符必须在该行的第一列
$values = [<<<END
a
  b
    c
END, 'd e f'];
var_dump($values);
// PHP73 array(2) {
//   [0]=>
//   string(13) "a
//   b
//     c"
//   [1]=>
//   string(5) "d e f"
// }
//
// PHP72 Parse error: syntax error, unexpected end of file

echo <<      a
     b
    c
    END;
// PHP73
//   a
//  b
// c
//
// PHP72 Parse error: syntax error, unexpected end of file, expecting variable (T_VARIABLE) or heredoc end (T_END_HEREDOC) or ${ (T_DOLLAR_OPEN_CURLY_BRACES) or {$ (T_CURLY_OPEN)

echo <<<END
  a
 b
c
   END;
// PHP73 Parse error: Invalid body indentation level
// 数组解构支持引用赋值
$arr = [[1], [1]];
[&$a, $b] = $arr;
$a[] = 2;
$b[] = 3;
var_dump($arr);
// PHP73 array(2) {
//   [0]=>
//   &array(2) {
//     [0]=>
//     int(1)
//     [1]=>
//     int(2)
//   }
//   [1]=>
//   array(1) {
//     [0]=>
//     int(1)
//   }
// }
//
// PHP72 Fatal error: [] and list() assignments cannot be by reference
// 允许将 literals 作为第一个操作数，always false
var_dump(true instanceof stdClass);
// PHP73 bool(false)
//
// PHP72 Fatal error: instanceof expects an object instance, constant given
// 调用中允许尾随逗号
function my($v) {
    echo "php-{$v}";
}
my(73,);
// PHP73 php-73
//
// PHP72 Parse error: syntax error, unexpected ')'
New Functions 7.3
// Gets the first key of an array
array_key_first(array $array): int|string|null
// Gets the last key of an array
array_key_last(array $array): int|string|null
// Get the system's high resolution time
// [seconds, nanoseconds] int（64 位平台）或 float（32 位平台）
hrtime(bool $as_number = false): array|int|float|false
// 验证变量的内容是否为 countable 值
// return is_array($value) || $value instanceof Countable || $value instanceof ResourceBundle || $value instanceof SimpleXmlElement;
is_countable(mixed $value): bool
Backward Incompatible Changes 7.3
// Continue Targeting Switch 问题警告
$foo = 0;
while ($foo < 10) {
    switch ($foo) {
      case "baz":
         continue;
   }
   $foo++;
}
// PHP73 Warning: "continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"?
// PHP72 ok
// $obj["123"] 类型的数组访问，其中 $obj 实现 ArrayAccess 且 "123" 是整数字符串文字将不再导致隐式转换为整数
// 数组的行为不会受到任何影响，它们继续将整数字符串键隐式转换为整数
class A implements \ArrayAccess
{
    public function offsetExists($offset)
    {
    }
    public function offsetGet($offset)
    {
        var_dump($offset);
    }
    public function offsetSet($offset, $value)
    {
    }
    public function offsetUnset($offset)
    {
    }
}
$a = new A();
$a["123"];
// PHP73 string(3) "123"
// PHP72 int(123)
PHP7.3 to PHP7.4

https://www.php.net/manual/en/migration74.php
https://php.watch/versions/7.4


PHP 7.4, the final release in the PHP 7.x series. PHP 7.4 brings typed properties, underscore numeric separator, and other minor improvements to PHP.

New Features 7.4
// Typed properties
class User {
    public int $id; // 会强制要求 $user->id 只能为 int 类型，访问前必须进行处理化，?int 也要进行初始化
}
// 箭头函数 Arrow functions
$factor = 10;
$nums = array_map(fn($n) => $n * $factor, [1, 2, 3, 4]);
// 有限的 Limited 返回类型协变和参数类型逆变
class A {}
class B extends A {}
class Producer {
    public function method(): A {}
}
class ChildProducer extends Producer {
    public function method(): B {}
}
// PHP74 ok
// PHP73 Fatal error: Declaration of ChildProducer::method(): B must be compatible with Producer::method(): A
// 空合并赋值运算符
$array['key1'] ??= 1;
// is roughly equivalent to
if (!isset($array['key2'])) {
    $array['key2'] = 2;
}
var_dump($array);
// array(2) {
//   ["key1"]=>
//   int(1)
//   ["key2"]=>
//   int(2)
// }
// Unpacking inside arrays
// 可以平替 array_merge
$parts = ['apple', 'pear'];
$fruits = ['orange', ...$parts, 'watermelon'];
var_dump($fruits);
// array(4) {
//   [0]=>
//   string(6) "orange"
//   [1]=>
//   string(5) "apple"
//   [2]=>
//   string(4) "pear"
//   [3]=>
//   string(10) "watermelon"
// }
// 数字文字分隔符
6.674_083e-11; // float
299_792_458;   // decimal
0xCAFE_F00D;   // hexadecimal
0b0101_1111;   // binary

var_dump((int)"1_123");
// int(1)
// WeakReference 类
// https://www.php.net/manual/zh/class.weakreference.php
$obj = new stdClass;
$weakref = WeakReference::create($obj);
var_dump($weakref->get());
unset($obj);
var_dump($weakref->get());
// object(stdClass)#1 (0) {
// }
// NULL
Backward Incompatible Changes 7.4
// 以数组形式访问非数组，将会抛出 notic
// null, bool, int, float or resource
$i = 12;
$i["a"];
// PHP74 Notice: Trying to access array offset on value of type int
// PHP73 ok
// PHP80 Warning: Trying to access array offset on value of type int
Deprecated Features 7.4
// 嵌套的三元运算必须明确地使用括号来指示运算的顺序
var_dump(1 ? 2 : 3 ? 4 : 5);
// PHP74 Deprecated: Unparenthesized `a ? b : c ? d : e` is deprecated. Use either `(a ? b : c) ? d : e` or `a ? b : (c ? d : e)`
// PHP73 int(4)
– EOF –



PHP Migrating to 7.0 7.1
Mon, 28 Nov 2022 10:36:34 +0000

实验环境：https://onlinephp.io/
Polyfill https://github.com/symfony/polyfill/tree/main/src

PHP7.0 to PHP7.1

https://www.php.net/manual/en/migration71.php

7.1 New Features
// Nullable types 可为空类型
function test(?string $name): ?string
// Void 函数
function swap(&$left, &$right) : void
// 获取一个 void 方法的返回值会得到 null，并且不会产生任何警告
// 对称数组解构
$data = [
    [1, 'Tom'],
    [2, 'Fred'],
];
[$id, $name] = $data[0];
// 赋值部分
[, $name1] = $data[1];

foreach ($data as [$id, $name]) {
    // logic here with $id and $name
}

function swap(&$a, &$b): void
{
    [$a, $b] = [$b, $a];
}
// list 支持键名
$data = [
    ["id" => 1, "name" => 'Tom'],
    ["id" => 2, "name" => 'Fred'],
];
foreach ($data as ["name" => $name, "id" => $id]) {
    // logic here with $id and $name
}
// 类常量支持可见性
class ConstDemo
{
    public const PUBLIC_CONST_A = 1;
}
// iterable 伪类（与 callable 类似）
interface Traversable extends iterable {
    // 这个接口没有任何方法，它的作用仅仅是作为所有可遍历类的基本接口
    // Traversable as part of either Iterator or IteratorAggregate，不能直接实现
}

function iterator(iterable $iter)
{
    foreach ($iter as $val) {
        // ...
    }
}
// 多异常捕获处理，可以通过管道字符(|)来实现多个异常的捕获
try {
    // some code
} catch (FirstException | SecondException $e) {
    // handle first and second exceptions
}
// 支持为负的字符串偏移量，一个负数的偏移量会被理解为一个从字符串结尾开始的偏移量
// 所有支持偏移量的字符串操作函数，都支持接受负数作为偏移量
// 中文操作要小心
var_dump("abcdef"[-2]); // e
var_dump(strpos("aabbcc", "b")); // 2
var_dump(strpos("aabbcc", "b", -3)); // 3
// 新增 Closure::fromCallable()，将 callable 转为一个 Closure 对象
// public static Closure::fromCallable(callable $callback): Closure
class Test
{
    public function exposeFunction()
    {
        return Closure::fromCallable([$this, 'privateFunction']);
    }
    private function privateFunction($param)
    {
        var_dump($param);
    }
}

$privFunc = (new Test)->exposeFunction();
$privFunc('some value');
// string(10) "some value"
7.1 New Functions
// 否为可迭代
is_iterable()
7.1 Backward Incompatible Changes
// 当传递参数过少时将抛出错误
function test($param){}
test();
/*
PHP71
Fatal error: Uncaught ArgumentCountError: Too few arguments to function test()

PHP70
Warning: Missing argument 1 for test()
*/
// 禁止动态调用作用域自检函数
// $func() or array_map('extract', ...)
// function array_map($callback, array $array, array ...$arrays): array
(function () {
    $func = 'func_num_args';
    $func();
})();
/*
PHP71
Warning: Cannot call func_num_args() dynamically
*/
// 以下名称不能用于命名 class, interface, trait
// - void
// - iterable
// 数字字符串转换 遵循科学记数法
var_dump(intval('1e5'));
var_dump(is_numeric('1e5'));
var_dump(is_numeric('e'));
// PHP71             PHP70
// int(100000)       int(1)
// bool(true)        bool(true)
// bool(false)       bool(false)
// call_user_func() 不再支持对传址的函数的调用
error_reporting(E_ALL);
function increment(&$var)
{
    $var++;
}

$a = 0;
call_user_func('increment', $a); // ...expected to be a reference, value given
call_user_func_array('increment', [&$a]); // 1
$increment = 'increment';
$increment($a); // 2
// 字符串不再支持空索引运算符
$str = "";
$str[] = "abc";
var_dump($str);
// PHP71 Fatal error: Uncaught Error: [] operator not supported for strings
// PHP70 array(1) {
//   [0]=>
//   string(3) "abc"
// }

$a = "";
$a[0] = "hello world";
var_dump($a);
// PHP71 string(1) "h"
// PHP70 array(1) {
//   [0]=>
//   string(11) "hello world"
// }
// 通过空字符串上的字符串索引访问赋值
$str = '';
$str[10] = 'foo';
var_dump($str);
// PHP71 string(11) "          f"
// PHP70 array(1) {
//   [10]=>
//   string(3) "foo"
// }
// 当通过引用赋值引用它们自动创建这些元素时，数组中元素的顺序已更改。
$array = [];
$array['a'] = &$array['b'];
$array['b'] = 1;
var_dump($array);
// PHP71 array(2) {
//   ["b"]=>
//   &int(1)
//   ["a"]=>
//   &int(1)
// }
// PHP70 array(2) {
//   ["a"]=>
//   &int(1)
//   ["b"]=>
//   &int(1)
// }
// 词法绑定变量不能重用名称，以下都将 fatal error
$f = function () use ($_SERVER) {}; // any superglobals
$f = function () use ($this) {};
$f = function ($param) use ($param) {};
// 禁止 "return;" 对于已经在编译时键入的返回值
function test(int $i): array
{
    $i += 1;
    return;
}
// PHP Compile Error A function with return type must return a value
var_dump('1b' + 'something');
// PHP71
// Notice: A non well formed numeric value encountered
// Warning: A non-numeric value encountered
// int(1)
// PHP70 int(1)
PHP5.6 to PHP7.0

https://www.php.net/manual/en/migration70.php

Backward incompatible changes
// 错误和异常处理相关的变更
// set_exception_handler() 不再保证收到的一定是 Exception 对象
function handler(Exception $e) { ... }
set_exception_handler('handler');

// 兼容 PHP 5 和 7
function handler($e) { ... }

// 仅支持 PHP 7
function handler(Throwable $e) { ... }

// 当内部构造器失败的时候，总是抛出异常
// 间接调用的表达式的新旧解析顺序
// 现在严格遵循从左到右的顺序来解析
// 表达式               PHP 5 的解析方式           PHP 7 的解析方式
$$foo['bar']['baz']    ${$foo['bar']['baz']}    ($$foo)['bar']['baz']
$foo->$bar['baz']      $foo->{$bar['baz']}      ($foo->$bar)['baz']
// foreach 通过值遍历时，操作的值为数组的副本
$array = [0];
foreach ($array as $val) {
    var_dump($val);
    $array[1] = 1;
}
// int(0)

// foreach通过引用遍历时，有更好的迭代特性
$array = [0];
foreach ($array as &$val) {
    var_dump($val);
    $array[1] = 1;
}
// PHP 7.0
// int(0)
// int(1)

// PHP 5.6
// int(0)
// call_user_method() and call_user_method_array() 被移除。
// 应该使用 call_user_func() 和 call_user_func_array()
// 在函数中检视参数值会返回 当前 的值
function foo($x) {
    $x++;
    var_dump(func_get_arg(0));
}
foo(1);
// int(2) PHP 7.0
// int(1) PHP 5.6
7.0 New Features
// 标量类型声明
// 返回值类型声明
function arraysSum(array ...$arrays): array
{
    return array_map(function(array $array): int {
        return array_sum($array);
    }, $arrays);
}
// null 合并运算符，对 isset() 的简化
$username = $_GET['user'] ?? 'nobody';

// 太空船操作符（组合比较符）
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1
// 通过 define() 定义 常量数组
define('ANIMALS', [
    'dog',
    'cat',
    'bird'
]);
// 匿名类 用来替代一些“用后即焚”的完整类定义
$app = new Application;
$app->setLogger(new class implements Logger {
    public function log(string $msg) {
        echo $msg;
    }
});
// Unicode codepoint 转译语法
// 这接受一个以 16 进制形式的 Unicode codepoint
echo "\u{9999}"; // 香
// Closure::call() 新方法，简化绑定一个方法到对象上闭包并调用它
// PHP 7 之前版本的代码
$getXCB = function() {return $this->x;};
// function bindTo($newThis, $newScope = 'static') { }
// $newScope 将闭包关联到的类作用域
$getX = $getXCB->bindTo(new A, A::class); // 中间层闭包
echo $getX();

// PHP 7+ 及更高版本的代码
$getX = function() {return $this->x;};
echo $getX->call(new A);
// 生成器委托 yield from
function gen()
{
    yield 1;
    yield 2;

    yield from gen2();
}
function gen2()
{
    yield 3;
    yield 4;
}
foreach (gen() as $val)
{
    echo $val, PHP_EOL;
}
// 1
// 2
// 3
// 4
// 柯里化
function add($a) {
  return function($b) use ($a) {
    return $a + $b;
  };
}
$result = add(10)(15);
var_dump($result); // int 25
Deprecated features in PHP 7.0.x
// 构造函数（方法名和类名一样）将被弃用，并在将来移除
class Foo {
    function foo() {
        echo 'I am the constructor';
    }
}
// PHP 7.0: Deprecated: Methods with the same name as their class will not be constructors in a future version of PHP
// PHP 5.6: OK
Other Changes
// 放宽了保留词限制，以前不能用 'new'、'private' 和 'for'
Project::new('Project Name')->private()->for('purpose here')->with('username here');
// class 关键词不能用于常量名，否则会和类名解析语法冲突（ClassName::class）
New Global Constants
PHP_INT_MIN
– EOF –


Docker Code Snippet
Thu, 17 Nov 2022 10:09:26 +0000
Dockerfile
ARG 构建参数
ARG <参数名>[=<默认值>]
该默认值可以在构建命令 docker build 中用 –build-arg <参数名>=<值> 来覆盖。
ARG LARADOCK_PHP_VERSION
ARG BASE_IMAGE_TAG_PREFIX=latest
FROM laradock/workspace:${BASE_IMAGE_TAG_PREFIX}-${LARADOCK_PHP_VERSION}

LABEL maintainer="Mahmoud Zalt <mahmoud@zalt.me>"

# ARG 指令有生效范围，如果在 FROM 指令之前指定，那么只能用于 FROM 指令中。
# 在 FROM 之后须再次指定 ARG
ARG LARADOCK_PHP_VERSION
COPY vs. ADD
能用 COPY 就用 COPY，只有在 ADD 独有功能确实需要时才使用 ADD。
只有在确实需要 ADD 的额外功能（自动解压本地归档文件、从远程 URL 获取资源）时才使用 ADD。
RUN vs. CMD vs. ENTRYPOINT
RUN 在 镜像构建时执行 并生成新层；CMD/ENTRYPOINT 在 容器启动时执行。

RUN 安装依赖、编译源码。
ENTRYPOINT 用来定义 始终要执行 的主命令。
CMD 用来提供 默认参数，也可在缺少 ENTRYPOINT 时充当默认命令。

...

ENTRYPOINT [ "/scripts/app/entrypoint.sh" ]
CMD "/scripts/fpm/start-php-fpm.sh"

ENTRYPOINT 以 exec 形式 (JSON 数组) 指定：容器启动时一定会先执行 /scripts/app/entrypoint.sh，它就是 PID 1。可被 docker run 的 –entrypoint 覆盖。
CMD 以 shell 形式 (单字符串) 指定默认命令：缺省情况下，Docker 会把它当作 /bin/sh -c "/scripts/fpm/start-php-fpm.sh" 并把这一整串 作为参数 传给 ENTRYPOINT。可被 docker run 后面参数覆盖。

/scripts/app/entrypoint.sh /bin/sh -c "/scripts/fpm/start-php-fpm.sh"
LABEL vs. ARG vs. ENV
LABEL 写入镜像 元数据。ARG 仅在 构建阶段 可用；ENV 在 构建后续层 和 运行时 都可用，并会出现在最终镜像中。


Laradock 学习笔记
Wed, 09 Nov 2022 22:24:01 +0000
Laradock 简介
Laradock 是一个基于 Docker 的完整 PHP 开发环境，专为 PHP 开发者（特别是 Laravel 开发者）设计。它提供了一套预配置的 Docker 容器，包含开发中常用的服务，如 Nginx、MySQL、Redis、PHP-FPM 等。
主要优势

开箱即用：预配置的开发环境，无需繁琐设置
一致性：确保开发、测试和生产环境的一致性
灵活性：支持多种 PHP 版本和扩展
模块化：可以根据需要启用或禁用特定服务
跨平台：在 Windows、macOS 和 Linux 上表现一致

基本架构
Laradock 采用模块化设计，每个服务都运行在独立的容器中，通过 Docker 网络连接：

Workspace：包含开发工具的容器
PHP-FPM：PHP 解释器
Nginx/Apache：Web 服务器
MySQL/PostgreSQL/MongoDB：数据库
Redis/Memcached：缓存
其他辅助服务（邮件服务器、消息队列等）

Dockerfile
DEBIAN_FRONTEND
ENV DEBIAN_FRONTEND=noninteractive
DEBIAN_FRONTEND 环境变量用于告知操作系统应该从哪儿获得用户输入。
设置为 “noninteractive” 可以实现自动安装而无需用户交互，对于 CI/CD 流程和 Docker 构建特别有用。这在运行 apt-get 命令时尤为重要，因为它会自动选择默认选项并以最快速度完成构建。
最佳实践是在 RUN 命令中设置该变量，而不是使用 ENV 进行全局设置，因为全局设置会影响容器运行时的交互体验：
RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y ...
基于角色的用户配置
# 创建非 root 用户防止文件在宿主机上创建时具有 root 权限
ARG PUID=1000
ENV PUID ${PUID}
ARG PGID=1000
ENV PGID ${PGID}

RUN set -xe; \
    groupadd -g ${PGID} laradock && \
    useradd -l -u ${PUID} -g laradock -m laradock -G docker_env && \
    usermod -p "*" laradock -s /bin/bash
这段配置创建了一个非 root 用户 laradock，解决了容器和宿主机之间文件权限问题：

可配置的 UID/GID：通过 ARG 和 ENV 指令使用户 ID 和组 ID 可配置
权限一致性：将容器内用户的 UID/GID 与宿主机用户匹配，确保文件权限一致
改善开发体验：设置 bash 作为默认 shell，并且不需要密码

实际使用中，可以通过 .env 文件配置这些值：
PUID=1000
PGID=1000
通过 id -u 和 id -g 命令可以获取当前用户的 UID 和 GID。
PHP 扩展安装示例
Swoole 安装
Swoole 是一个高性能的 PHP 异步网络通信引擎。安装 Swoole 时，可以使用 PECL：
# php7.1
echo '' | pecl -q install --configureoptions 'enable-openssl="yes" enable-mysqlnd="yes" enable-swoole-curl="yes"' swoole-4.5.11;
这个命令通过 PECL 安装 Swoole 4.5.11，并启用了 OpenSSL、MySQL Native Driver 和 cURL 支持。安装后可以通过以下命令验证 OpenSSL 支持：
php -r "new swoole_server('0.0.0.0', 443, SWOOLE_PROCESS, SWOOLE_SOCK_TCP | SWOOLE_SSL);"
如果没有错误输出，说明 OpenSSL 支持已正确启用。
PHP 版本智能检测
RUN if [ $(php -r "echo PHP_MAJOR_VERSION;") = "8" ] || { [ $(php -r "echo PHP_MAJOR_VERSION;") = "7" ] && { [ $(php -r "echo PHP_MINOR_VERSION;") = "4" ] || [ $(php -r "echo PHP_MINOR_VERSION;") = "3" ] ;} ;}; then \
    # PHP 8.x 或 PHP 7.3/7.4 的配置
    pecl install xdebug-3.1.6; \
else \
    if [ $(php -r "echo PHP_MAJOR_VERSION;") = "5" ]; then \
        # PHP 5.x 的配置
        pecl install xdebug-2.5.5; \
    else \
        # 其他 PHP 7.x 版本的配置
        if [ $(php -r "echo PHP_MINOR_VERSION;") = "0" ]; then \
            pecl install xdebug-2.9.0; \
        else \
            pecl install xdebug-2.9.8; \
        fi \
    fi \
fi
Laradock 的 Dockerfile 中大量使用 PHP 版本检测，确保安装与当前 PHP 版本兼容的扩展和工具：

使用 php -r 内联执行 PHP 命令获取版本信息
通过嵌套条件语句处理不同的 PHP 版本需求
支持多种 PHP 版本（从 5.x 到 8.x）使用同一个 Dockerfile

这种方法使得一个 Dockerfile 可以适应多个 PHP 版本，极大简化了维护工作。
Composer 双版本安装
# 更新 composer
ARG COMPOSER_VERSION=2
ENV COMPOSER_VERSION ${COMPOSER_VERSION}

RUN set -eux; \
    if [ "$COMPOSER_VERSION" = "1" ] || [ "$COMPOSER_VERSION" = "2" ] || [ "$COMPOSER_VERSION" = "2.2" ]; then \
        composer self-update --${COMPOSER_VERSION}; \
    else \
        composer self-update ${COMPOSER_VERSION}; \
    fi
Laradock 支持灵活选择 Composer 版本：

允许通过环境变量切换 Composer 1.x、2.x 或特定版本
适应不同项目的兼容性需求
方便在旧项目和新项目之间切换

实用场景：某些旧项目可能与 Composer 2.x 不兼容，而新项目需要更新的 Composer 功能。
docker-compose.yml 配置技巧
主机名解析
extra_hosts:
  - "dockerhost:${DOCKER_HOST_IP}"
这个配置会在容器的 /etc/hosts 文件中添加一条记录：
10.0.75.1 dockerhost
这样，容器内的应用可以通过 dockerhost 域名访问宿主机，无需使用动态 IP 地址。
模块化服务架构
Laradock 的 docker-compose.yml 文件采用高度模块化的设计：
services:
  workspace:
    build:
      context: ./workspace
      args:
        - PHP_VERSION=${PHP_VERSION}
    volumes:
      - ${APP_CODE_PATH_HOST}:${APP_CODE_PATH_CONTAINER}
    networks:
      - frontend
      - backend

  php-fpm:
    build:
      context: ./php-fpm
      args:
        - PHP_VERSION=${PHP_VERSION}
    volumes:
      - ${APP_CODE_PATH_HOST}:${APP_CODE_PATH_CONTAINER}
    depends_on:
      - workspace
    networks:
      - backend
主要特点：

每个服务独立配置：可以只启动需要的服务
明确的依赖关系：使用 depends_on 确保正确的启动顺序
统一的环境变量：从 .env 文件加载配置

网络配置
networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
Laradock 采用前后端分离的网络设计：

前端网络：连接 Web 服务器和负载均衡器
后端网络：连接应用服务（PHP-FPM）和数据库
安全隔离：数据库等服务不直接暴露给前端

这种设计增强了安全性，防止外部直接访问敏感服务。
卷管理策略
volumes:
  mysql:
    driver: ${VOLUMES_DRIVER}
  redis:
    driver: ${VOLUMES_DRIVER}
  postgres:
    driver: ${VOLUMES_DRIVER}
Laradock 使用命名卷而非绑定挂载来提高性能和可移植性：

集中式数据路径：使用 ${DATA_PATH_HOST} 管理所有持久化数据
可配置驱动：支持本地存储或网络存储
性能优化：命名卷在某些平台（特别是 Windows 和 macOS）上性能更好

实际使用示例：
# 查看卷列表
docker volume ls

# 备份数据卷
docker run --rm -v laradock_mysql:/source -v $(pwd):/backup alpine tar -czvf /backup/mysql_backup.tar.gz -C /source .
资源限制配置
php-fpm:
  ulimits:
    nproc: 65535
    nofile:
      soft: 20000
      hard: 40000
  mem_limit: 1024m
Laradock 支持为服务配置资源限制：

进程数限制：控制可创建的进程数
文件描述符限制：影响并发连接能力
内存限制：防止单个容器消耗过多资源

这些设置对于生产环境特别重要，可以防止单个服务耗尽系统资源。
端口映射策略
mysql:
  ports:
    - "${MYSQL_PORT}:3306"
Laradock 采用可配置的端口映射策略：

所有端口都可配置：通过环境变量定义外部端口
避免默认暴露端口：增强安全性
灵活处理端口冲突：可以在不同项目使用不同端口

端口冲突是多项目开发中常见的问题，这种设计可以轻松避免。
PHP 扩展管理
常用开发扩展
Xdebug
ARG INSTALL_XDEBUG=false

RUN if [ ${INSTALL_XDEBUG} = true ]; then \
  # 安装 Xdebug 并配置
  pecl install xdebug && \
  docker-php-ext-enable xdebug \
fi
Xdebug 是 PHP 的调试和分析工具。在 Laradock 中，可以通过环境变量控制是否安装：
WORKSPACE_INSTALL_XDEBUG=true
PHP_FPM_INSTALL_XDEBUG=true
实际使用配置（php.ini）：
[xdebug]
xdebug.mode=debug
xdebug.client_host=host.docker.internal
xdebug.client_port=9003
xdebug.start_with_request=yes
PCOV
PCOV 是一个轻量级代码覆盖率驱动，比 Xdebug 更快：

专注于代码覆盖率分析
与 PHPUnit 完全兼容
性能影响比 Xdebug 小

在 Laravel 项目中使用示例：
php -dpcov.enabled=1 vendor/bin/phpunit --coverage-html coverage
Taint
Taint 是由 PHP 核心开发者鸟哥（惠新宸）开发的 PHP 扩展，用于检测 XSS 代码：

自动检测可能的 XSS 漏洞
低运行时开销
适合在开发环境中使用

数据库相关扩展
OCI8
ARG INSTALL_OCI8=false
ARG ORACLE_INSTANT_CLIENT_MIRROR=https://github.com/the-paulus/oracle-instantclient/raw/master/
ARG ORACLE_INSTANT_CLIENT_ARCH=x86_64
ARG ORACLE_INSTANT_CLIENT_MAJOR=18
ARG ORACLE_INSTANT_CLIENT_MINOR=3

RUN if [ ${INSTALL_OCI8} = true ]; then \
    # 安装 Oracle Instantclient 和 PHP OCI8 扩展
    ...
fi
OCI8 用于连接 Oracle 数据库，通过 Oracle Call Interface 提供完整的功能：

支持 Oracle 的所有数据类型
处理大型对象（LOB）
支持绑定变量和存储过程

示例代码：
$conn = oci_connect('username', 'password', 'localhost/XE');
$stmt = oci_parse($conn, 'SELECT * FROM employees');
oci_execute($stmt);
while ($row = oci_fetch_array($stmt, OCI_ASSOC+OCI_RETURN_NULLS)) {
    var_dump($row);
}
Redis
Laradock 支持两种 Redis 扩展：

PhpRedis：C 扩展，性能更好
Predis：纯 PHP 实现，更灵活

PhpRedis 安装示例：
ARG INSTALL_PHPREDIS=false

RUN if [ ${INSTALL_PHPREDIS} = true ]; then \
    pecl install redis && \
    docker-php-ext-enable redis \
fi
性能优化扩展
OPcache
OPcache 通过将 PHP 脚本预编译的字节码存储在共享内存中来提高性能，减少加载和解析的开销：
[opcache]
opcache.enable=1
opcache.memory_consumption=128
opcache.interned_strings_buffer=8
opcache.max_accelerated_files=4000
opcache.validate_timestamps=0
opcache.save_comments=1
opcache.fast_shutdown=0
在生产环境中，可以设置 validate_timestamps=0 来防止 OPcache 检查文件变化，进一步提高性能。
APCu
APCu 是一个用户数据缓存系统，可以在 PHP 进程中存储 key-value 数据：
apcu_store('my_key', 'my_value', 3600); // 存储数据，过期时间为 1 小时
$value = apcu_fetch('my_key'); // 读取数据
与 OPcache 不同，APCu 专注于用户数据缓存，而非代码缓存。
实用工具与配置
软件源和镜像
# 将应用源从 deb.debian.org 更改为阿里云源
sed -i 's/deb.debian.org/mirrors.tuna.tsinghua.edu.cn/' /etc/apt/sources.list && \
sed -i 's/security.debian.org/mirrors.tuna.tsinghua.edu.cn/' /etc/apt/sources.list && \
sed -i 's/security-cdn.debian.org/mirrors.tuna.tsinghua.edu.cn/' /etc/apt/sources.list \
在国内环境使用 Laradock 时，配置国内镜像源可以大幅提升构建速度：

系统源：使用 TUNA 或阿里云源
Composer：配置 Packagist 中国镜像
NPM：配置淘宝 NPM 镜像

可以在 .env 文件中设置：
WORKSPACE_NPM_REGISTRY=https://registry.npm.taobao.org/
WORKSPACE_COMPOSER_REPO_PACKAGIST=https://mirrors.aliyun.com/composer/
Node.js 配置
ARG INSTALL_NODE=false
ARG NODE_VERSION=node
ARG INSTALL_NPM_GULP=false
ARG INSTALL_NPM_BOWER=false
ARG INSTALL_NPM_VUE_CLI=false
ARG INSTALL_NPM_ANGULAR_CLI=false
ARG NPM_REGISTRY

RUN if [ ${INSTALL_NODE} = true ]; then \
    # 安装 nvm 和 Node.js
    ...
fi
Laradock 的 Node.js 配置非常灵活：

使用 NVM 管理 Node.js 版本
支持配置 NPM 镜像源
可选安装常用前端工具（Vue CLI、Angular CLI 等）
支持 Yarn 和 PNPM 等现代包管理器

使用案例：
WORKSPACE_INSTALL_NODE=true
WORKSPACE_NODE_VERSION=16
WORKSPACE_NPM_REGISTRY=https://registry.npm.taobao.org/
WORKSPACE_INSTALL_NPM_VUE_CLI=true
常用命令工具
update-alternatives
update-alternatives 用于管理 Linux 系统中的命令替代版本：
# 设置默认 PHP 版本
update-alternatives --set php /usr/bin/php7.4
Laradock 使用这个命令管理多个 PHP 版本。
docker-php-ext-disable
# 禁用不需要的扩展（不需要重新编译）
docker-php-ext-disable xdebug pcov
Laradock 特有的实用脚本，允许：

在生产环境中禁用性能密集型扩展
保留扩展文件但不加载，避免重新编译
需要时快速重新启用扩展

这对于开发/生产环境切换非常有用，可以保持相同的镜像但有不同的扩展启用状态。
常用操作指南
基本使用流程
# 克隆 Laradock 仓库
git clone https://github.com/laradock/laradock.git

# 复制环境配置文件
cp .env.example .env

# 编辑配置文件，设置项目路径等
vim .env

# 构建并启动容器
docker compose up -d nginx mysql redis
常用维护命令
# 构建特定服务
docker compose build workspace php-fpm

# 进入容器
docker compose exec workspace bash

# 查看日志
docker compose logs nginx

# 停止所有容器
docker compose down
故障排除


端口冲突：修改 .env 文件中的端口映射
NGINX_HOST_HTTP_PORT=8080
MYSQL_PORT=33060


权限问题：确保 PUID/PGID 设置正确
PUID=$(id -u)
PGID=$(id -g)


内存不足：增加 Docker 分配的资源，或减少启用的服务
docker compose up -d nginx php-fpm mysql


高级功能
多项目环境
Laradock 支持同时运行多个项目：
.
├── laradock/
│   ├── docker-compose.yml
│   └── .env
├── project1/
├── project2/
└── project3/
配置示例：
APP_CODE_PATH_HOST=../:/var/www
NGINX_SITES_PATH=./nginx/sites/
然后为每个项目创建 Nginx 配置文件：
# ./nginx/sites/project1.conf
server {
    server_name project1.test;
    root /var/www/project1/public;
    # ...
}
多架构支持
# 支持 ARM 和 x86 架构
FROM --platform=${TARGETPLATFORM} php:${PHP_VERSION}-fpm-alpine

ARG TARGETPLATFORM
ARG BUILDPLATFORM
Laradock 现代版本支持：

使用 Docker BuildKit 进行多架构构建
在 ARM 设备（M1/M2 Mac、树莓派）上本地开发
通过 GitHub Actions 实现跨平台自动构建

使用多架构镜像的命令：
# 显示支持的架构
docker manifest inspect laradock/workspace:latest

# 构建多架构镜像
docker buildx build --platform linux/amd64,linux/arm64 -t myname/myapp:latest .
CI/CD 集成
Laradock 可以与各种 CI/CD 工具集成：
# .gitlab-ci.yml 示例
stages:
  - build
  - test
  - deploy

build:
  stage: build
  script:
    - cd laradock
    - docker compose build php-fpm workspace

test:
  stage: test
  script:
    - cd laradock
    - docker compose up -d php-fpm mysql
    - docker compose exec workspace php artisan test
可以使用 Docker Compose 的 --profile 参数为不同环境创建配置：
# 开发环境
docker compose --profile dev up -d

# 测试环境
docker compose --profile test up -d
最佳实践
优化构建速度


使用 BuildKit：
DOCKER_BUILDKIT=1 docker compose build


创建层缓存：
# 先复制依赖文件，安装依赖，然后再复制应用代码
COPY composer.json composer.lock ./
RUN composer install --no-scripts --no-autoloader
COPY . .
RUN composer dump-autoload --optimize


多阶段构建：
FROM php:7.4-fpm AS builder
# 安装构建依赖...

FROM php:7.4-fpm
# 只复制需要的文件
COPY --from=builder /var/www/vendor /var/www/vendor


安全最佳实践


避免使用 root 用户：
USER laradock


限制容器能力：
security_opt:
  - no-new-privileges:true


使用健康检查：
healthcheck:
  test: ["CMD", "php", "-v"]
  interval: 30s
  timeout: 10s
  retries: 3


定期更新基础镜像：
docker compose pull
docker compose build --pull


References

Laradock 官方文档
Laradock GitHub 仓库
Docker 官方文档
PHP 官方文档
Laradock - A PHP Developer’s best friend. | dev.to
如何优化 Docker 镜像构建
Docker Compose 参考




Git Code Snippet
Sat, 01 Oct 2022 10:00:00 +0000
建立独立的分支
当想在项目中使用一个独立分支进行项目文档的管理时，或者当我们想要发布一个软件的开源版本但又不希望将软件的版本历史暴露给外界时，都可以使用以下的方法建立一个独立分支：
git help checkout
# git checkout --orphan <new-branch> <start-point>
修改提交时间
# 指定本次提交时间
git commit -m "fix..." --date=`date -R`
git commit -m "fix..." --date="$(date -R)"
git commit -m "fix..." --date="Tue, 11 Jun 2019 17:50:50 +0800"

# 修改上次提交时间
git commit --amend --date=`date -R`
# 风险操作。会修改 history hash.
忽略文件权限修改
# Git 默认会记录文件权限的修改，可关闭
git config core.filemode false
git status 中文文件名乱码
git config --global core.quotepath false
当 core.quotepath 设置为 false 时，Git 将不会对路径名进行 quoting，这意味着路径名中的特殊字符将不被转义。

Git 中文显示问题解决

工作区中删除未跟踪的文件
# 查看文档
git help clean
git clean -h
# git clean [-d] [-f] [-i] [-n] [-q] [-e <pattern>] [-x | -X] [--] [<pathspec>...]

# 【查看】有哪些文件将被删除
git clean -n

# 【查看】删除 Git【忽略】的文件与文件夹
git clean -Xn

# 【查看】删除【src 路径下】下的【未跟踪】文件以及文件夹
git clean -d -- src

# 如果想执行删除 -n 替换为 -f，注意风险。

Git 清除未跟踪文件 | github.io


MySQL 实战 45 讲 Part1
Sun, 14 Aug 2022 15:53:16 +0000

MySQL 实战 45 讲 | 林晓斌

01 | 基础架构：一条 SQL 查询语句是如何执行的？

连接器：跟客户端建立连接、获取权限、维持和管理连接。
SHOW PROCESSLIST;

137462239  db  10.135.4.7:41261  db  Query  0  starting  show processlist
-- 一个空闲连接
137462293  db  10.130.128.1:47174  db  Sleep  24
-- 客户端如果太长时间没动静，连接器就会自动将它断开
select @@wait_timeout;
show variables like 'wait_timeout';
-- 28800 8h
通过执行 mysql_reset_connection 来重新初始化连接资源，这是个接口函数，不是一个 SQL 语句。
查询缓存：不建议使用。在一个表上有更新的时候，跟这个表有关的查询缓存都会失效。
select @@query_cache_type;
-- OFF

sysvar_query_cache_type | mysql

分析器：词法分析、语法分析。进行分词和验证语法规则。解析器和预处理器。

解析器处理语法和解析查询，生成一课对应的解析树。
预处理器进一步检查解析树的合法。比如: 数据表和数据列是否存在，别名是否有歧义等。如果通过则生成新的解析树，再提交给优化器。

优化器：决定使用哪个索引，决定各个表的连接顺序。
执行器：有没有执行查询的权限，操作引擎，返回结果。执行器调用的次数（rows_examined）与引擎总共扫描行数可能是不等的，后文有例子。
读写、存取数据在 engine 引擎层，连接、鉴权、计算在 server 服务层。
连接的长短是由客户端来决定的，MySQL 服务端不会主动断开连接，除非到了 waiting_timeout 所设置的时间。
查询一个没用 k 列的表 1054 - Unknown column 'k' in 'field list' 是在哪阶段报错的？

答案是：分析器。分析器在词法分析阶段，需要知道 SQL 中的每个字段代表什么意思，所以在这个阶段就可以判断表中存不存在 k 这一列。
不是执行器的原因：有人说在执行器时才打开表获取数据，但是表的字段不是数据，是事先定义好的，所以可以直接读取的，不需要打开表。

02 | 日志系统：一条 SQL 更新语句是如何执行的？
WAL 的全称是 Write-Ahead Logging，先写日志，再写磁盘。

redo log 是 InnoDB 引擎特有的；binlog 是 MySQL 的 Server 层实现的，所有引擎都可以使用
redo log 是物理日志，记录的是“在某个数据页上做了什么修改”；binlog 是逻辑日志，记录的是这个语句的原始逻辑，比如“给 ID=2 这一行的 c 字段加 1”。
redo log 是循环写的，空间固定会用完；binlog 是可以追加写入的。“追加写”是指 binlog 文件写到一定大小后会切换到下一个，并不会覆盖以前的日志。


物理：InnoDB 存储引擎提供接口给执行器调用（操作数据），数据库的数据是存在磁盘上的（或者说硬盘上），那么 redo log 记录存储引擎修改硬盘上的数据的操作就叫做物理操作；物理日志就只有“我”自己能用，别人没有共享我的“物理格式”。
逻辑：binlog 归档日志，有两种模式 1 statement 记录 SQL；2 row 格式记录两条数据，数据修改前的样子，数据修改后的样子。记录的是一种逻辑上的变化 。逻辑日志可以给别的数据库，别的引擎使用，已经大家都讲得通这个“逻辑”。


把 binlog 夹在 redo log 中间，就是为了保证如果 redo 提交前的任何失败，都会带来回滚，binlog 的写入也应该不会成功，只有这样，才能保证两个一致。

如果提交了 binlog，提交事务接口崩溃了，恢复时 redo log 有日志记录，binlog 有日志记录，一致，直接自动提交事务，事务完成确认数据修改成功。
如果提交 binlog 前就崩了，redo log 是 prepare 阶段，binlog 没有记录不一致，事务回滚，事务执行失败。

redo log 负责事务、crash-safe；binlog 负责归档恢复。redo log 是物理的，binlog 是逻辑的。
redo log 是顺序写，数据文件是随机写。
MySQL 的记录是以“页”为单位存取的，默认大小 16K。也就是说，你要访问磁盘中一个记录，不会只读这个记录，而会把它所在的 16K 数据一起读入内存。
-- 每个 binlog 文件的大小
SELECT @@max_binlog_size / 1024 / 1024;
-- 256.00000000

-- 一页数据大小
SELECT @@innodb_page_size / 1024;
-- 16.0000
redo log 和 binlog 都可以用于表示事务的提交状态，而两阶段提交就是让这两个状态保持逻辑上的一致。
-- 保证 crash-safe 能力；每次事务的 redo log 都直接持久化到磁盘
select @@innodb_flush_log_at_trx_commit;
-- 2

-- 每次事务的 binlog 都持久化到磁盘
select @@sync_binlog;
-- 0

SELECT @@binlog_format;
-- STATEMENT 是记 SQL 语句，但是有风险比如时间函数
-- ROW 记录行的内容，记两条，更新前和更新后都有

彻底搞懂三大 MySQL 日志，Redo Log、Undo Log、Bin Log
彻底搞懂 mysql 日志系统 binlog,redolog,undolog

03 | 事务隔离：为什么你改了我还看不见？
脏读（dirty read）读到其他事务未提交的数据，仅发生在读未提交的的隔离级别下：
-- session1 当数据库中一个事务A正在修改一个数据但是还未提交或者回滚
BEGIN;
SELECT k FROM T1 WHERE id=1;
-- 1
UPDATE T1 SET k=2 WHERE id=1;

-- session2
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
SELECT k FROM T1 WHERE id=1;
-- 2 session2 出现脏读
不可重复读（non-repeatable read）前后读取的记录内容不一致，发生在读未提交、读提交的隔离级别：
-- session1 在一个事务A中多次操作数据，在事务操作过程中(未最终提交)
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
BEGIN;
SELECT k FROM T1 WHERE id=1;
-- 1

-- session2 修改改值
UPDATE T1 SET k=2 WHERE id=1;

-- session1
SELECT k FROM T1 WHERE id=1;
-- 2 session1 出现不可重复读
幻读（phantom read）前后读取的记录数量不一致，发生在读未提交、读提交的隔离级别，InnoDB RR 不发生幻读：
-- session1 获取当前行数量
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
BEGIN;
SELECT * FROM T1 WHERE k=1;
-- 1

-- session2 插入一行数
INSERT INTO T1 (k) VALUES (1);

-- session1
SELECT count(*) FROM T1;
-- 2
-- session1 表数据
BEGIN;
SELECT * FROM T1;
-- id,k 1,1 只有一行数据

-- session2 更新 id 主键
UPDATE T1 SET id=5 WHERE id=1;

-- session1
SELECT * FROM T1;
-- id,k 1,1
UPDATE T1 SET id=id+1;
-- ok
SELECT * FROM T1;
-- 竟然看到了两行 1,1 6,1
-- 1,1 MVCC 保证了 1,1 的存在
-- 因为主键的 UPDATE 在 MySQL 里是以 insert+delete 方式执行的。这个 6 和 1 在 MySQL 看来已经不是同一行数据了，1 的 delete version 是在事务 1 的可见范围，所以才能看得到。如果是非主键就只用一行，就是下面的例子.
-- 这个例子不能被归类为幻读，只不过是当前最新读带来的问题。
-- session1 获取 id=1 的 k
BEGIN;
SELECT k FROM T1;
-- 1 一行数据

-- session2 更新
UPDATE T1 SET k=2;

-- session1
SELECT k FROM T1;
-- 1
UPDATE T1 SET k=k+1;
-- ok
SELECT k FROM T1;
-- 3

关于幻读，可重复读的真实用例是什么？| zhihu

不可重复读和幻读区别：由于在 InnoDB RR 下模拟不出幻读的场景，退回到 RC 隔离级别的话就容易把幻读和不可重复读搞混淆。理论上 RR 级别是无法解决幻读的问题, 但是由于 InnoDB 引擎的 RR 级别还使用了 MVCC，所以也就避免了幻读的出现。
后文有讲到 FOR UPDATE 下的幻读。
事务隔离级别：

读未提交（READ UNCOMMITTED）一个事务还没提交时，它做的变更就能被别的事务看到。直接返回记录上的最新值，没有视图概念。
读提交（READ COMMITTED）一个事务提交之后，它做的变更才会被其他事务看到。这个视图是在每个 SQL 语句开始执行的时候创建的。
可重复读（REPEATABLE READ）一个事务执行过程中看到的数据，总是跟这个事务在启动时看到的数据是一致的 read-view。当然在可重复读隔离级别下，未提交变更对其他事务也是不可见的。这个视图是在事务启动时（第一个 SQL 执行时）创建的，整个事务存在期间都用这个视图。
串行化（SERIALIZABLE）对于同一行记录，“写”会加“写锁”，“读”会加“读锁”。当出现读写锁冲突的时候，后访问的事务必须等前一个事务执行完成，才能继续执行。用加锁的方式来避免并行访问。

show variables like '%tx_isolation%';
show variables like 'transaction_isolation';
-- tx_isolation  REPEATABLE-READ

select @@tx_isolation;
-- REPEATABLE-READ

SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-- 修改 session 事务隔离级别

SET TRANSACTION Statement | mysql

多版本并发控制（MVCC）
set autocommit=0，这个命令会将这个线程的自动提交关掉。
-- 持续时间超过 60s 的事务
select * from information_schema.innodb_trx where TIME_TO_SEC(timediff(now(),trx_started))>60;
commit work and chain;
-- 等价于 commit; begin;
如何避免长事务对业务的影响？

确认是否使用了 set autocommit=0，如果没有，则可以使用 set autocommit=1 来避免长事务对业务的影响。
确认是否有不必要的只读事务。有些框架会习惯不管什么语句先用 begin/commit 框起来。
业务连接数据库的时候，根据业务本身的预估，通过 SET MAX_EXECUTION_TIME 命令，来控制每个语句执行的最长时间，避免单个语句意外执行太长时间。
监控 information_schema.Innodb_trx 表，设置长事务阈值。
开发测试阶段输出所用 general_log，分析日志提前发现问题。

04 | 深入浅出索引（上）

哈希表：这种结构适用于只有等值查询的场景。
有序数组：有序数组在等值查询和范围查询场景中的性能就都非常优秀。但有序数组索引只适用于静态存储引擎
搜索树：平衡二叉树是 O(log(N)) 的查询复杂度；N 叉树，以 InnoDB 整数字段索引为例，这个 N 差不多是 1200。


MySQL 默认一个节点的长度为 16K，一个整数（bigint）字段索引的长度为 8B，另外每个索引还跟着 6B 的指向其子树的指针；所以 16K/14B ≈ 1170

innodb B+树主键索引的叶子节点存的是什么：
回复 1：

InnoDB 磁盘管理的最小单位就是“页”，也就是说无论是叶子节点、非叶子节点和行数据，都是存放在页当中。页组成结构有头部数据、主体数据和尾部数据。头部数据主要存的是页相关数据，例如上一页、下一页、当前页号等。是一个双向链表结构。主体数据主要关注索引和数据的存储，也就是我们常说的索引和数据的存储位置。主体数据当中有一个“User Records”的概念，用来存储索引和数据，是一个单链表结构。
User Records 根据节点的不同，User Records 又分为四种不同类型：主键索引树叶子节点和非叶子节点，二级索引树叶子节点和非叶子节点。
有了页和 User Records 的认识，其实说叶子节点存的是页是一种笼统的回答，基于我的理解，我认为叶子节点（主键索引树叶子节点）存放的是行数据更为贴切。

回复 2：

B+树的叶子节点是 page（页），一个页里面可以存多个行。 B+树的结点跟 innoDB 的“页”都属于一种抽象逻辑概念。如果你要问“存”的是什么？我觉得回答行数据没毛病。因为存的不可能是“页”。这一逻辑概念，只能说这个叶结点大小等于 innoDB 里设置的页大小，或者说这个叶结点其实就是“页”。但存的是什么？那当然是数据，什么数据？当然是表中的行数据。

索引类型分为主键索引和非主键索引。

主键索引也被称为聚簇索引（clustered index）
非主键索引也被称为二级索引（secondary index）

基于非主键索引的查询需要多扫描一棵索引树，也就是主键索引树，也就是回表操作。
自增主键的意义：

性能方面：每次插入一条新记录，都是追加操作，都不涉及到挪动其他记录，也不会触发叶子节点的分裂（页分裂）。
存储空间方面：主键长度越小，普通索引的叶子节点就越小，普通索引占用的空间也就越小。

有没有什么场景适合用业务字段直接做主键的呢？

只有一个索引
该索引必须是唯一索引

即典型的 KV 场景。
非聚集索引上为啥叶子节点的 value 为什么不是地址，这样可以直接定位到整条数据，而不用再次对整棵树进行查询？
这个叫作“堆组织表”，MyISAM 就是这样的，各有利弊。你想一下如果修改了数据的位置的情况，InnoDB 这种模式是不是就方便些。主键索引页分裂的场景，就可能会导致主键记录的地址发生变化，这时候需要更新每一个索引上面对主键记录地址的引用。
05 | 深入浅出索引（下）
覆盖索引：在查询里索引已经覆盖了查询需要的列。覆盖索引可以减少树的搜索次数，显著提升查询性能，是一个常用的性能优化手段。
select * from T where k between 3 and 5;
表中 k 的值是：1，2，3，5，6，7。引擎内部使用覆盖索引在索引 k 上其实读了三个记录（第一次 3，第二次 3 的下一个 5，第三次 5 的下一个 6 不满足 ），但是对于 MySQL 的 Server 层来说，它只是找引擎拿到了两条记录，因此 MySQL 认为扫描行数是 2。这就是引擎实际扫描条数不等于 MySQL explain 语句中的 rows 字段的原因。
最左前缀原则：B+树这种索引结构，可以利用索引的“最左前缀”，来定位记录。
第一原则是，如果通过调整顺序，可以少维护一个索引，那么这个顺序往往就是需要优先考虑采用的。
如果需要常查人的名字与年龄。可以建立索引 (name,age) 与 (age)，而不是 (age,name) 与 (age)，考虑的原则就是空间。
索引下推优化（index condition pushdown)：
联合索引（name,age）为例，名字第一个字是张，而且年龄是 10 岁的所有男孩：
select * from tuser where name like '张%' and age=10 and ismale=1;
这个语句在搜索索引树的时候，只能用 “张”。

在 MySQL 5.6 之前，只能从符合 ‘张%’ 开始一个个回表。到主键索引上找出数据行，再对比字段值。
而 MySQL 5.6 引入的索引下推优化（index condition pushdown)，可以在索引遍历过程中，对索引中包含的字段先做判断，直接过滤掉不满足条件的记录，减少回表次数。


InnoDB 在（name,age）索引内部就判断了 age 是否等于 10，对于不等于 10 的记录，直接判断并跳过。
联合索引中是按索引列的顺序，来排序的。（name,age）先排 name 列的值，再排 age 列的值。
在满足语句需求的情况下，尽量少地访问资源是数据库设计的重要原则之一。
06 | 全局锁和表锁：给表加个字段怎么有这么多阻碍？
全局锁：
-- 加全局读锁 FTWRL，整个库处于只读状态；做全库逻辑备份
FLUSH TABLES WITH READ LOCK;

-- 插入一行数据

SHOW PROCESSLIST;
-- Waiting for global read lock

-- 释放锁
UNLOCK TABLES;
但是让整库都只读，听上去就很危险：

如果你在主库上备份，那么在备份期间都不能执行更新，业务基本上就得停摆。
如果你在从库上备份，那么备份期间从库不能执行主库同步过来的 binlog，会导致主从延迟。

在可重复读隔离级别下开启一个事务，来确保拿到一致性视图。mysqldump 使用参数 -single-transaction 就是如此执行的。而由于 MVCC 的支持，这个过程中数据是可以正常更新的。
有了可重复读的事务隔离级别却还需要 FTWRL 的原因是：引擎不都支持这个事务隔离级别。
既然要全库只读，为什么不使用 set global readonly=true 的方式

在有些系统中，readonly 的值会被用来做其他逻辑，比如用来判断一个库是主库还是备库。修改 global 变量的方式影响面更大。
在异常处理机制上有差异。如果执行 FTWRL 命令之后由于客户端发生异常断开，那么 MySQL 会自动释放这个全局锁，整个库回到可以正常更新的状态。而将
整个库设置为 readonly 之后，如果客户端发生异常，则数据库就会一直保持 readonly 状态，这样会导致整个库长时间处于不可写状态，风险较高。

表级锁：
第一类表锁：lock-tables | mysql
LOCK TABLES T1 READ, T2 WRITE;
-- 其他线程 写 T1、读写 T2 的语句都会被阻塞
-- 当前线程也只能执行 读 T1、读写 T2 的操作，其他表都不能访问

-- 当前线程读 T2
-- Waiting for table metadata lock

-- 当前线程读 T3
-- 1100 - Table 'T3' was not locked with LOCK TABLES
-- 查看表锁
SHOW OPEN TABLES WHERE In_use > 0;
第二类 MDL（metadata lock)：
MDL 不需要显式使用：

当对一个表做增删改查操作的时候，加 MDL 读锁。读锁之间不互斥，因此你可以有多个线程同时对一张表增删改查。共享锁。
当要对表做结构变更操作的时候，加 MDL 写锁。读写锁之间、写锁之间是互斥的，用来保证变更表结构操作的安全性。如果有两个线程要同时给一个表加字段，其中一个要等另一个执行完才能开始执行。排他锁。

给一个小表加个字段，导致整个库挂了：
-- session1
SET autocommit = 0;
-- 关闭自动提交

BEGIN;
-- 开启使用

SELECT * FROM T;
-- 查询 T 表，一切 ok
-- 获取 MDL 读锁 ok，因为在事务中，查询结束后没有释放读锁。

-- 事务中的 MDL 锁，在语句执行开始时申请，但是语句结束后并不会马上释放，而会等到整个事务提交后再释放。

SELECT * FROM information_schema.innodb_trx;
-- 查询事务有个 RUNNING
-- session2
SELECT * FROM T;
-- 查询 T 表，一切 ok
-- 获取 MDL 读锁 ok，查询结束后释放读锁。
-- session3
ALTER TABLE `T` ADD COLUMN `c2` varchar(255) NULL;
-- 修改字段，卡住
-- blocked 原因：是因为 session1 的 MDL 读锁还没有释放，而 session3 需要 MDL 写锁，因此只能被阻塞。

SHOW OPEN TABLES WHERE In_use > 0;
-- In_use 1
-- session4
SELECT * FROM T;
-- 查询 T 表，卡住
-- blocked 原因：对表的增删改查操作都需要先申请 MDL 读锁，都被 session3 阻塞。

这里自己想了一个问题：session4 卡住后，session1 COMMIT 后，session4 的 SELECT 执行结果是否有 session3 的新列呢？
从结果上看是没有的。开始以为是事务级别，但是调整为 READ UNCOMMITTED，session4 仍然没有新列。后来了解到 online DDL 意识到应该有关系。测试后得出 session3 在获取写锁后，在做 DDL 前会释放写锁加读锁，这时 session4 就可以执行了，但是这时 DDL 还没有执行，所以 session4 的执行结果没有新列。
如果 session3 执行语句是：
ALTER TABLE `T` ADD COLUMN `c2` varchar(255) NULL, LOCK=EXCLUSIVE;
-- NONE：允许并发查询和DML操作；
-- SHARED：允许并发查询，但不允许DML操作；
-- DEFAULT：允许尽可能多的并发查询或DML操作(或两者都允许)，没指定LOCK选项默认就为DEFAULT；
-- EXCLUSIVE：不允许并发查询和DML操作。
EXCLUSIVE 时写锁会一直持有，一直等到 DDL 完毕 session4 才开始执行，所以 session4 的执行结果有新列。
衍生问题：session3 如果没有 LOCK=EXCLUSIVE，session4 查询前 BEGIN; 开启事务那结果是如何呢？实验结果：session1 提交后，session3 session4 依然阻塞。
衍生问题：session3 添加 LOCK=EXCLUSIVE，session4 查询前 BEGIN; 开启事务那结果是如何呢？实验结果：ssession1 提交后，session3 session4 正常结束。
分析猜测 session3 阻塞的原因是：session1 提交后释放了读锁，session3 session4 拿到读锁，session3 DDL 操作完成后又要拿写锁，但是 session4 的读锁未释放，所以 session3 阻塞。那 session4 为啥阻塞呢？session4 可以获取读锁就应该可以执行完毕，遗留问题。
如何安全地给小表加字段？

解决长事务，事务不提交，就会一直占着 MDL 锁。
在 ALTER TABLE 语句里面设定等待时间，如果在这个指定的等待时间里面能够拿到 MDL 写锁最好，拿不到也不要阻塞后面的业务语句，先放弃。

ALTER TABLE tbl_name NOWAIT add column ...
ALTER TABLE tbl_name WAIT N add column ...
实测：MySQL 5.7.30 不支持。腾讯云 MySQL 5.7.18-txsql-log 支持。

支持 NOWAIT 语法 | cloud.tencent

07 | 行锁功过：怎么减少行锁对性能的影响？
在 InnoDB 事务中，行锁是在需要的时候才加上的，但并不是不需要了就立刻释放，而是要等到事务结束时才释放。这个就是两阶段锁协议。
如果事务中需要锁多个行，要把最可能造成锁冲突、最可能影响并发度的锁尽量往后放。
举例：

从顾客 A 账户余额中扣除电影票价；UPDATE
给影院 B 的账户余额增加这张电影票价；UPDATE 最容易发送锁等待的地方
记录一条交易日志。INSERT

以 3、1、2 顺序执行可以最大程度地减少了事务之间的锁等待，提升了并发度。
当并发系统中不同线程出现循环资源依赖，涉及的线程都在等待别的线程释放资源时，就会导致这几个线程都进入无限等待的状态，称为死锁。

上图 session1 在等 session2 id=2 的锁，session2 在等 session1 id=1 的锁，进入死锁状态。
-- 所等待超时时间 s
SELECT @@innodb_lock_wait_timeout;
-- 7200 2h

-- 死锁检测，发现死锁后，主动回滚死锁链条中的某一个事务
SELECT @@innodb_deadlock_detect;
-- 1213 - Deadlock found when trying to get lock; try restarting transaction
主动死锁检测在发生死锁的时候，是能够快速发现并进行处理的，但是它也是有额外负担的：
每当一个事务被锁的时候，就要看看它所依赖的线程有没有被别人锁住，如此循环，最后判断是否出现了循环等待，也就是死锁。
每个新来的被堵住的线程，都要判断会不会由于自己的加入导致了死锁，这是一个时间复杂度是 O(n)的操作。假设有 1000 个并发线程要同时更新同一行，那么死锁检测操作就是 100 万这个量级的。这期间要消耗大量的 CPU 资源。即：热点行更新导致的性能问题。
可以通过尝试将热点数据拆分多行进行处理，提高并发处理。
08 | 事务到底是隔离的还是不隔离的？
begin/start transaction 命令并不是一个事务的起点，在执行到它们之后的第一个操作 InnoDB 表的语句，事务才真正启动。如果你想要马上启动一个事务：
START TRANSACTION WITH CONSISTENT SNAPSHOT;
有两个“视图”的概念：

一个是 view。它是一个用查询语句定义的虚拟表，在调用的时候执行查询语句并生成结果。创建视图的语法是 create view …，而它的查询方法与表一样。
另一个是 InnoDB 在实现 MVCC 时用到的一致性读视图，即 consistent read view，用于支持 RC（Read Committed，读提交）和 RR（Repeatable Read，可重复读）隔离级别的实现。

在可重复读隔离级别下，事务在启动的时候就“拍了个快照”。注意，这个快照是基于整库的。
InnoDB 里面每个事务有一个唯一的事务 ID，叫作 transaction id。它是在事务开始的时候向 InnoDB 的事务系统申请的，是按申请顺序严格递增的。




Shell Code Snippet
Thu, 28 Jul 2022 11:51:46 +0000
Package Management
Find Packages with pkgs.org
pkgs.org is a Linux package search website that helps you find software packages for various Linux distributions.
# Check installed package versions (Red Hat/CentOS)
rpm -qa | grep docker
Process Management
Run Commands in Background
# Run in background (will stop when terminal closes)
cmd &

# Run in background (continues after terminal closes)
nohup cmd &
Control Background Jobs

Ctrl + Z - Pause the current foreground job and move it to background
jobs - List all background jobs (jobs -l shows PIDs)
fg - Bring the most recent background job to foreground
fg %N - Bring job number N to foreground
bg - Resume the most recent job in the background
bg %N - Resume job number N in the background

Using fg Command
# Restore the most recent background job
fg

# Restore a specific job by number
fg 1

# Restore using % syntax
fg %2

# Restore by process name
fg %vim

# List all background jobs
jobs
DNS Operations
Lookup CNAME Records
CNAME (Canonical Name) records map one domain name to another, commonly used for subdomains or third-party hosted services.
# Using dig
dig example.com cname
# Output: example.com. 300 IN CNAME target-domain.com.

# Using host command
host -t CNAME example.com
# Output: example.com is an alias for target-domain.com.

# Using nslookup
nslookup -type=CNAME example.com
# Output: example.com canonical name = target-domain.com.

# Check multiple domains at once
dig +short CNAME www.example.com blog.example.com

# See full DNS lookup path
dig +trace example.com
File System Operations
Find Large Files
# Find and display the 3 largest files/folders in current directory
du -sh ./* | sort -rh | head -3

# Find files larger than 100MB
find . -type f -size +100M

# Find large files and show human-readable sizes
find . -type f -size +50M -exec du -h {} \; | sort -rh
Dealing with Deleted Files That Still Use Space
When you delete a file but the disk space isn’t freed, it’s usually because a process is still using the file.
# Find deleted files still in use
lsof | grep deleted

# Clear file content without deleting the file
echo "" > /var/log/large_logfile.log
# Or more safely:
truncate -s 0 /var/log/large_logfile.log
Search Text in Files Recursively


The Set Builtin
Bash 脚本 set 命令教程


# Search for text in all files in current directory and subdirectories
grep -r "search text" .

# Limit search to specific file types
grep -r "search text" --include="*.php" .

# Show line numbers in results
grep -rn "search text" .

# Case-insensitive search
grep -ri "search text" .
鉴别自己是否真的使用了代理来登陆服务器
root@ubuntu:~# who
root     pts/2        2017-05-13 18:13 (xxx.xxx.xxx.xxx)
Script Safety with set
The set command controls shell behavior and can make scripts safer.
#!/usr/bin/env bash

# Stop script if any command fails
set -o errexit  # Same as set -e

# Treat unset variables as errors
set -o nounset  # Same as set -u

# Make pipeline fail if any command in it fails
set -o pipefail

# Print commands before execution (useful for debugging)
set -o xtrace   # Same as set -x

# Common combined safety settings
set -euxo pipefail
Error Handling Patterns
# Stop if command fails
command || exit 1

# With error message
command || { echo "Command failed"; exit 1; }

# Using if statement
if ! command; then
  echo "Command failed"
  exit 1
fi

# Other way
command
if [ "$?" -ne 0 ]; then echo "command failed"; exit 1; fi

# Execute second command only if first succeeds
command1 && command2
Navigation Shortcuts
Using CDPATH
CDPATH creates shortcuts for the cd command by checking multiple locations.
# Add directories to CDPATH
export CDPATH=.:/etc:~/projects

# Now you can directly cd to subdirectories of those paths
cd project1    # Changes to ~/projects/project1
cd mail        # Changes to /etc/mail

# Unset CDPATH (useful in scripts for predictability)
unset CDPATH
System Configuration
Set Timezone in Ubuntu
# Interactive timezone selection
sudo dpkg-reconfigure tzdata

# Set timezone directly
sudo timedatectl set-timezone Asia/Shanghai

# Restart logging service (may be needed for cron)
sudo systemctl restart rsyslog
# Or
/etc/init.d/rsyslog restart
Open PDF Files from Terminal
# Open PDF without loading file explorer
evince document.pdf

# Alternative PDF viewers
xpdf document.pdf
okular document.pdf
References

setting timezone from terminal - Ask Ubuntu
cron - How do you set the timezone for crontab? - Ask Ubuntu
Ubuntu 命令行打开 PDF 文件 - bigmarco 的专栏
Linux 文件删除，但是 df 之后磁盘空间没有释放 | cnblogs
How to lookup CNAME records | nslookup.io
Linux 命令后台运行

– EOF –



回顾 2021
Fri, 31 Dec 2021 20:16:41 +0000
直到对的人来 · 追星族乐队

我想跟他说：那家餐厅太美了，我一定要和你去一次。但是那个菜其实很一般的，那个老板娘戴的耳环特别漂亮。

– EOF –


PHP 安装 gRPC
Wed, 13 Oct 2021 15:48:41 +0000
ENV
cat /etc/redhat-release

CentOS Linux release 7.2 (Final)

uname -a
Linux xxx-xxx 3.10.107-1-tlinux2_kvm_guest-0052 #1 SMP Wed Jan 15 18:42:19 CST 2020 x86_64 x86_64 x86_64 GNU/Linux
PECL
pecl install grpc
如果遇到：
Connection to `ssl://pecl.php.net:443′ failed:
参考：
PHP Swoft 框架环境配置 | ZYF.IM
Build
通用手动安装 PECL 扩展
For this to work, you’ll need to have root access to your server, and you’ll most probably need developer tools installed as well.

https://pecl.php.net/

# 创建临时目录
mkdir /tmp/download/ && cd /tmp/download/
# 下载
wget http://pecl.php.net/get/[extension].tgz
# 解压
tar -xvf [extension].tgz
cd [extension]
# 配置
phpize
# 查看参数
./configure --help
# 设置参考 以实际情况为准
./configure --enable-[extension]
# 编译
make && make test
# 安装
make install
# 查看 ini 路径
php --ini
# 开启
vi [php-ini].ini
extension=[extension].so
gcc is currently not installed
yum install gcc

...already installed and latest version...

gcc

...gcc is currently not installed.

yum reinstall gcc
# 重新安装后解决
GrpcLb::TokenAndClientStatsAttribute::ToString() const
原因：gcc 版本过低。


PHP __invoke 使用
Tue, 20 Jul 2021 14:58:33 +0000
why they are magic? Because they are magically called by PHP when specific actions happen.
The __invoke() method is called when a script tries to call an object as a function.
php
class CallableClass
{
    public function __invoke($x)
    {
        var_dump($x);
    }
}
$obj = new CallableClass;
$obj(5);
var_dump(is_callable($obj));
int(5)
bool(true)
使用明显的操作方法初始化
例如，当我们有一个提供者时，就会发生这种情况。
aws-sdk-php/src/Endpoint/PatternEndpointProvider.php
public function __invoke(array $args = [])
{
    $service = isset($args['service']) ? $args['service'] : '';
    $region = isset($args['region']) ? $args['region'] : '';
    $keys = ["{$region}/{$service}", "{$region}/*", "*/{$service}", "*/*"];

    foreach ($keys as $key) {
        if (isset($this->patterns[$key])) {
            return $this->expand(
                $this->patterns[$key],
                isset($args['scheme']) ? $args['scheme'] : 'https',
                $service,
                $region
            );
        }
    }

    return null;
}
它使用 invoke 使用一些参数提供端点。我们如何使用这个类？
public function testReturnsNullWhenUnresolved()
{
    $e = new PatternEndpointProvider(['foo' => ['rules' => []]]);
    $this->assertNull($e(['service' => 'foo', 'region' => 'bar']));
}
尝试使用单动作控制器？
控制器应该大而广泛？他们不应该。我们应该有瘦控制器和胖服务。
在这里，invoke 可以帮助我们，因为我们可以定义一个只处理单个动作的控制器，并在其上放置单个 invoke 方法。
这也有助于我们实现单一职责原则，即 SOLID 中的 S，这是前五个面向对象设计 (OOD) 原则的首字母缩写词。

A class should have one and only one reason to change, meaning that a class should have only one job.

在 Laravel 中的例子：Single Action Controllers | laravel：
php

namespace App\Http\Controllers;

use App\User;
use App\Http\Controllers\Controller;

class ShowProfile extends Controller
{
    /**
     * Show the profile for the given user.
     *
     * @param  int  $id
     * @return View
     */
    public function __invoke($id)
    {
        return view('user.profile', ['user' => User::findOrFail($id)]);
    }
}
然后，在注册路由时，我们不需要指定方法名称。只有类名。
php
Route::get('user/{id}', 'ShowProfile');
This way we can have Single Action Controllers.
实现回调函数 by GPT
class Sorter
{
    public function __invoke($a, $b)
    {
        return $a <=> $b; // 比较函数
    }
}

$numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5];
usort($numbers, new Sorter());
print_r($numbers); // 输出排序后的数组
实现函数式编程 by GPT
class Adder
{
    private $value;

    public function __construct($value)
    {
        $this->value = $value;
    }

    public function __invoke($x)
    {
        return $this->value + $x;
    }
}

$add5 = new Adder(5);
$result = $add5(3); // 结果为 8
References

PHP invoke: is anybody using it? | medium
__invoke() | php

– EOF –



PHP strict_types 严格模式
Mon, 19 Jul 2021 19:58:26 +0000

严格模式的声明 必须 放在文件的顶部。
严格模式不仅作用于函数参数的类型声明，也作用于函数的返回值类型。

声明 PHP 文件作为严格模式的一个好事是，实际上只适用于当前文件。这确保了这个文件是严格类型，但是他没有影响到整个项目中的其他文件。这允许你一步一步的迁移非严格模式的代码。
使用提示类型没有 strict_types 可能导致微妙的错误。
严格类型之前，int $x 意味着 $x must have a value coercible to an int。

a float (example: 13.1459 -> 13)
a bool (example: true -> 1)
a null (example: null -> 0)
a string with leading digits (example: “15 Trees” -> 15)

设置严格模式后，you tell the engine that int $x means $x must only be an int proper, no type coercion allowed。
谁给更关心 strict_type 这行？is more for the reader than for the writer. Why? Bacause it will explicitly tell the reader:
The types in this current scope are treated strictly.
对比
php
function add(int $a, int $b): int
{
  return $a + $b;
}

var_dump(add(1.0, 2.0));
运行输出 int(3)。
php
declare(strict_types=1);
function add(int $a, int $b): int
{
  return $a + $b;
}

var_dump(add(1.0, 2.0));
运行输出：
PHP Fatal error:  Uncaught TypeError: Argument 1 passed to add() must be of the type int, float given, ...
声明位置
必须在脚本最前。不能写在脚本的中间，如下写法是错误的：
php
function add(int $a, int $b): int
{
  return $a + $b;
}
declare(strict_types=1);

var_dump(add(1.0, 2.0));
运行后报错：
PHP Fatal error:  strict_types declaration must be the very first statement in the script in ...
不得使用 block mode 进行声明：
php
declare(strict_types=1) {
  var_dump(1);
}
运行后报错：
PHP Fatal error:  strict_types declaration must not use block mode in ...
多文件场景
例子 1
A.php
php
// 严格模式
declare(strict_types=1);
function add(int $a, int $b): int
{
  return $a + $b;
}
B.php
php
// 非严格模式
require 'A.php';
// 违反了 A 的定义
var_dump(add(1.0, 2.0));
运行
php B.php

int(3)
例子 2
A.php
php
// 非严格模式
function add(int $a, int $b): int
{
  return $a + $b;
}
B.php
php
// 严格模式
declare(strict_types=1);
require 'A.php';
// 违反了 A 的定义
var_dump(add(1.0, 2.0));
运行
php B.php

PHP Fatal error:  Uncaught TypeError: Argument 1 passed to add() must be of the type int, float given, called in ...
小结

函数定义时的严格模式，行为并不会出现什么不同。
函数执行时的，严格模式会出现差异。
declare(strict_types=1); 的声明本身在 A.php 文件中完成。被 B.php 文件 require，而 B.php 并没有定义严格模式，那么执行 require 的 B.php 文件不会变成严格模式。

总结
只有在写 declare 的文件的执行部分才会执行严格模式，该文件中调用的其它函数（其它文件中的函数）也会被影响。
若果想完全使用严格模式，比较简单的方法是在所有 php 文件都写上 declare(strict_types=1);。
工具
推荐自动格式化工具：symplify/easy-coding-standard。
References

关于 declare(strict_types=1) 的有效范围 | segmentfault
Strict Types in PHP | medium
Scalar type declarations | php
Strict typing | php

– EOF –



Git and GitHub Secrets
Mon, 12 Jul 2021 10:40:15 +0000
记住密码
Git 记住密码配置后，不用每次 pull、push 都需要输入密码：
git config --global credential.helper store
会在 cat ~/.gitconfig 看到：
[credential]
    helper = store
快速检出上一个分支
git checkout -
提交空改动
git commit -m "empty commit" --allow-empty
在如下几种情况下是有意义：

标记一批工作或一个新功能的开始。
记录你对项目进行了跟代码无关的改动。
跟使用你仓库的其他人交流。
作为仓库的第一次提交，因为第一次提交日后是不能被 rebase 的：git commit -m "init repo" --allow-empty。

更直观的 status
git status -sb
更直观的 log
git log --all --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an %ae>%Creset' --abbrev-commit --date=relative
提交信息查询
找到其中和搜索条件相匹配的最近的一条。query （区别大小写）是你想要搜索的词语。
git show :/query
分支合并
显示所有已经合并到你当前分支的分支列表：
git branch --merged
相反地：
git branch --no-merged
.gitconfig
打开编辑：
vim ~/.gitconfig
命令修改：
git config --global alias.co 'checkout'
git config --global alias.ac 'add -A . && commit'
git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an %ae>%Creset' --abbrev-commit"
GitHub
整行高亮
多行高亮也可以，比如用 #L53-L60 选择范围，或者按住 shift 键，然后再点击选择的两行。
https://github.com/rails/rails/blob/master/activemodel/lib/active_model.rb#L53-L60
用 commit 信息关闭 issue
如果某个提交修复了一个 Issue，当提交到 master 分支时，提交信息里可以使用 fix/fixes/fixed , close/closes/closed 或者 resolve/resolves/resolved 等关键词，后面再跟上 Issue 号，这样就会关闭这个 Issue。
git commit -m "Fix screwup, fixes #12"
链接其他仓库的 Issue
如果你想引用到同一个仓库中的一个 Issue，只需使用井号 # 加上 Issue 号，这样就会自动创建到此 Issue 的链接。
要链接到其他仓库的 Issue，就使用 user_name/repo_name#ISSUE_NUMBER 的方式，例如 tiimgreen/toc#12。
Reference

Git and GitHub Secrets | speakerdeck
More Git and GitHub Secrets | speakerdeck

– EOF –



设计模式之美 Part2
Sat, 06 Feb 2021 11:00:41 +0000
11
领域驱动设计（Domain Driven Design，简称 DDD）。
什么是基于贫血模型的传统开发模式？
UserEntity 和 UserRepository 组成了数据访问层，UserBo 和 UserService 组成了业务逻辑层，UserVo 和 UserController 在这里属于接口层。
Service 层的数据和业务逻辑，被分割为 BO 和 Service 两个类中。像 UserBo 这样，只包含数据，不包含业务逻辑的类，就叫作贫血模型（Anemic Domain Model）。
这种贫血模型将数据与操作分离，破坏了面向对象的封装特性，是一种典型的面向过程的编程风格。
什么是基于充血模型的 DDD 开发模式？
领域驱动设计，即 DDD，主要是用来指导如何解耦业务系统，划分业务模块，定义业务领域模型及其交互。
基于贫血模型的传统的开发模式，重 Service 轻 BO；基于充血模型的 DDD 开发模式，轻 Service 重 Domain。
为什么基于贫血模型的传统开发模式如此受欢迎？

系统业务可能都比较简单，简单到就是基于 SQL 的 CRUD 操作
充血模型的设计要比贫血模型更加有难度。我们从一开始就要设计好针对数据要暴露哪些操作，定义哪些业务逻辑。而不是像贫血模型那样，我们只需要定义数据，之后有什么功能开发需求，我们就在 Service 层定义什么操作，不需要事先做太多设计。
思维已固化，转型有成本。

什么项目应该考虑使用基于充血模型的 DDD 开发模式？
适合业务复杂的系统开发。比如，包含各种利息计算模型、还款模型等复杂业务的金融系统。
两种不同的开发模式会导致不同的开发流程。基于充血模型的 DDD 开发模式的开发流程，在应对复杂业务系统的开发的时候更加有优势。
DDD 这种开发模式下，我们需要事先理清楚所有的业务，定义领域模型所包含的属性和方法。领域模型相当于可复用的业务中间层。新功能需求的开发，都基于之前定义好的这些领域模型来完成。
12
一个虚拟钱包系统
充值、提现、支付、查询余额、查询交易流水。甚至还有冻结、透支、转赠等。
整个钱包系统一部分单纯跟应用内的虚拟钱包账户打交道，另一部分单纯跟银行账户打交道。我们基于这样一个业务划分，给系统解耦，将整个钱包系统拆分为两个子系统：虚拟钱包系统和三方支付系统。

不保证数据的强一致性，只实现数据的最终一致性。
public class VirtualWalletService {
  // 通过构造函数或者 IOC 框架注入
  private VirtualWalletRepository walletRepo;
  private VirtualWalletTransactionRepository transactionRepo;

  public VirtualWallet getVirtualWallet(Long walletId ) {
    VirtualWalletEntity walletEntity = walletRepo.getWalletEntity(walletId);
    VirtualWallet wallet = convert(walletEntity);
    return wallet;
  }

  public BigDecimal getBalance(Long walletId) {
    return virtualWalletRepo.getBalance(walletId);
  }

  public void debit(Long walletId, BigDecimal amount) {
    VirtualWalletEntity walletEntity = walletRepo.getWalletEntity(walletId);

    // 贫血型
    // BigDecimal balance = walletEntity.getBalance();
    // if (balance.compareTo(amount) < 0) {
    //   throw new NoSufficientBalanceException(...);
    // }
    // walletRepo.updateBalance(walletId, balance.subtract(amount));

    // DDD
    VirtualWallet wallet = convert(walletEntity);
    wallet.debit(amount);
    walletRepo.updateBalance(walletId, wallet.balance());
  }

  public void credit(Long walletId, BigDecimal amount) {
    VirtualWalletEntity walletEntity = walletRepo.getWalletEntity(walletId);

    // 贫血型
    // BigDecimal balance = walletEntity.getBalance();
    // walletRepo.updateBalance(walletId, balance.add(amount));

    // DDD
    VirtualWallet wallet = convert(walletEntity);
    wallet.credit(amount);
    walletRepo.updateBalance(walletId, wallet.balance());
  }

  public void transfer(Long fromWalletId, Long toWalletId, BigDecimal amount) {
    VirtualWalletTransactionEntity transactionEntity = new VirtualWalletTransactionEntity();
    transactionEntity.setAmount(amount);
    transactionEntity.setCreateTime(System.currentTimeMillis());
    transactionEntity.setFromWalletId(fromWalletId);
    transactionEntity.setToWalletId(toWalletId);
    transactionEntity.setStatus(Status.TO_BE_EXECUTED);
    Long transactionId = transactionRepo.saveTransaction(transactionEntity);
    try {
      debit(fromWalletId, amount);
      credit(toWalletId, amount);
    } catch (InsufficientBalanceException e) {
      transactionRepo.updateStatus(transactionId, Status.CLOSED);
      // ...rethrow exception e...
    } catch (Exception e) {
      transactionRepo.updateStatus(transactionId, Status.FAILED);
      // ...rethrow exception e...
    }
    transactionRepo.updateStatus(transactionId, Status.EXECUTED);
  }
}
领域模型 VirtualWallet 类很单薄，包含的业务逻辑很简单。相对于原来的贫血模型的设计思路，这种充血模型的设计思路，貌似并没有太大优势。这也是大部分业务系统都使用基于贫血模型开发的原因。不过，如果虚拟钱包系统需要支持更复杂的业务逻辑，那充血模型的优势就显现出来了。比如，我们要支持透支一定额度和冻结部分余额的功能。这个时候，我们重新来看一下 VirtualWallet 类的实现代码。
public class VirtualWallet {
  private Long id;
  private Long createTime = System.currentTimeMillis();
  private BigDecimal balance = BigDecimal.ZERO;
  private boolean isAllowedOverdraft = true;
  private BigDecimal overdraftAmount = BigDecimal.ZERO;
  private BigDecimal frozenAmount = BigDecimal.ZERO;

  public VirtualWallet(Long preAllocatedId) {
    this.id = preAllocatedId;
  }

  public BigDecimal balance() {
    return this.balance;
  }

  public BigDecimal getAvaliableBalance() {
    BigDecimal totalAvaliableBalance = this.balance.subtract(this.frozenAmount);
    if (isAllowedOverdraft) {
      totalAvaliableBalance += this.overdraftAmount;
    }
    return totalAvaliableBalance;
  }

  public void debit(BigDecimal amount) {}
  public void credit(BigDecimal amount) {}

  public void freeze(BigDecimal amount) { ... }
  public void unfreeze(BigDecimal amount) { ...}
  public void increaseOverdraftAmount(BigDecimal amount) { ... }
  public void decreaseOverdraftAmount(BigDecimal amount) { ... }
  public void closeOverdraft() { ... }
  public void openOverdraft() { ... }
}
如果功能继续演进，我们可以增加更加细化的冻结策略、透支策略、支持钱包账号（VirtualWallet id 字段）自动生成的逻辑（不是通过构造函数经外部传入 ID，而是通过分布式 ID 生成算法来自动生成 ID）等等。
辩证思考与灵活应用
两种代码设计与实现中，并没有完全将 Service 类去掉，这是为什么？或者说，Service 类在这种情况下担当的职责是什么？哪些功能逻辑会放到 Service 类中？

Service 类负责与 Repository 交流。获取数据库中的数据，转化成领域模型 VirtualWallet，然后由领域模型 VirtualWallet 来完成业务逻辑，最后调用 Repository 类的方法，将数据存回数据库。之所以让 VirtualWalletService 类与 Repository 打交道，而不是让领域模型 VirtualWallet 与 Repository 打交道，那是因为我们想保持领域模型的独立性，不与任何其他层的代码（Repository 层的代码）或开发框架（比如 Spring、MyBatis）耦合在一起，将流程性的代码逻辑（比如从 DB 中取数据、映射数据）与领域模型的业务逻辑解耦，让领域模型更加可复用。
Service 类负责跨领域模型的业务聚合功能。VirtualWalletService 类中的 transfer() 转账函数会涉及两个钱包的操作，因此这部分业务逻辑无法放到 VirtualWallet 类中，所以，我们暂且把转账业务放到 VirtualWalletService 类中了。当然，虽然功能演进，使得转账业务变得复杂起来之后，我们也可以将转账业务抽取出来，设计成一个独立的领域模型。
Service 类负责一些非功能性及与三方系统交互的工作。比如幂等、事务、发邮件、发消息、记录日志、调用其他系统的 RPC 接口等，都可以放到 Service 类中。

小结
基于充血模型的 DDD 开发模式跟基于贫血模型的传统开发模式相比，主要区别在 Service 层。在基于充血模型的开发模式下，我们将部分原来在 Service 类中的业务逻辑移动到了一个充血的 Domain 领域模型中，让 Service 类的实现依赖这个 Domain 类。
在基于充血模型的 DDD 开发模式下，Service 类并不会完全移除，而是负责一些不适合放在 Domain 类中的功能。比如，负责与 Repository 层打交道、跨领域模型的业务聚合功能、幂等事务等非功能性的工作。
基于充血模型的 DDD 开发模式跟基于贫血模型的传统开发模式相比，Controller 层和 Repository 层的代码基本上相同。这是因为，Repository 层的 Entity 生命周期有限，Controller 层的 VO 只是单纯作为一种 DTO。两部分的业务逻辑都不会太复杂。业务逻辑主要集中在 Service 层。所以，Repository 层和 Controller 层继续沿用贫血模型的设计思路是没有问题的。
遗留问题：Entity 与 Domain 的转换应该放在哪里？
13 如何对接口鉴权这样一个功能开发做面向对象分析？
面向对象分析（OOA）、面向对象设计（OOD）、面向对象编程（OOP），是面向对象开发的三个主要环节。
我们需要通过沟通、挖掘、分析、假设、梳理，搞清楚具体的需求有哪些，哪些是现在要做的，哪些是未来可能要做的，哪些是不用考虑做的。

加密之后的密码及 AppID，可能被 重放攻击。

调用方将请求接口的 URL 跟 AppID、密码拼接在一起，然后进行加密，生成一个 token。

这样的设计仍然存在重放攻击的风险。
为了解决这个问题，我们可以进一步优化 token 生成算法，引入一个随机变量，让每次接口请求生成的 token 都不一样。
微服务端在收到这些数据之后，会验证当前时间戳跟传递过来的时间戳，是否在一定的时间窗口内（比如一分钟）。

14

把 URL、AppID、密码、时间戳拼接为一个字符串；
对字符串通过加密算法加密生成 token；
将 token、AppID、时间戳拼接到 URL 中，形成新的 URL；
解析 URL，得到 token、AppID、时间戳等信息；
从存储中取出 AppID 和对应的密码；
根据时间戳判断 token 是否过期失效；
验证两个 token 是否匹配；

1、2、6、7 都是跟 token 有关，负责 token 的生成、验证；3、4 都是在处理 URL，负责 URL 的拼接、解析；5 是操作 AppID 和密码，负责从存储中读取 AppID 和密码。AuthToken、Url、CredentialStorage。
15



设计模式之美 Part1
Fri, 05 Feb 2021 11:00:41 +0000
00
KISS 原则（Keep It Simple and Stupid），这个原则理解起来很简单，一看貌似就懂了，那我问你，怎样的代码才算是足够简单呢？怎样才算不够简单需要优化呢？
“Talk is cheap, show me the code.”
01
为什么要学习设计模式：应对面试中的设计模式相关问题；告别写被人吐槽的烂代码；提高复杂代码的设计和开发能力；让读源码、学框架事半功倍；为你的职场发展做铺垫。
02
灵活性（flexibility）、可扩展性（extensibility）、可维护性（maintainability）、可读性（readability）、可理解性（understandability）、易修改性（changeability）、可复用（reusability）、可测试性（testability）、模块化（modularity）、高内聚低耦合（high cohesion loose coupling）、高效（high effciency）、高性能（highperformance）、安全性（security）、兼容性（compatibility）、易用性（usability）、整洁（clean）、清晰（clarity）、简单（simple）、直接（straightforward）、少即是多（less code is more）、文档详尽（well-documented）、分层清晰（well-layered）、正确性（correctness、bug free）、健壮性（robustness）、鲁棒性（robustness）、可用性（reliability）、可伸缩性（scalability）、稳定性（stability）、优雅（elegant）、好（good）、坏（bad）
我们并不能通过单一的维度去评价一段代码写的好坏。比如，即使一段代码的可扩展性很好，但可读性很差，那我们也不能说这段代码质量高。
如果用数字来量化代码的可读性的话，它应该是一个连续的区间值，而非 0、1 这样的离散值。
代码质量的评价有很强的主观性。
有些词语过于笼统、抽象，比较偏向对于整体的描述，比如优雅、好、坏、整洁、清晰等；有些过于细节、偏重方法论，比如模块化、高内聚低耦合、文档详尽、分层清晰等；有些可能并不仅仅局限于编码，跟架构设计等也有关系，比如可伸缩性、可用性、稳定性等。
可维护性（maintainability）
破坏原有代码设计、不引入新的 bug 的情况下，能够快速地修改或者添加代码。与之相反，修改或者添加代码需要冒着极大的引入新 bug 的风险，并且需要花费很长的时间才能完成。
码分层清晰、模块化好、高内聚低耦合、遵从基于接口而非实现编程的设计原则等等，那就可能意味着代码易维护。
可读性（readability）
“任何傻瓜都会编写计算机能理解的代码。好的程序员能够编写人能够理解的代码。”
是否符合编码规范、命名是否达意、注释是否详尽、函数是否长短合适、模块划分是否清晰、是否符合高内聚低耦合等等。
code review 是一个很好的测验代码可读性的手段。如果你的同事可以轻松地读懂你写的代码，那说明你的代码可读性很好；如果同事在读你的代码时，有很多疑问，那就说明你的代码可读性有待提高了。
可扩展性（extensibility）
我们在不修改或少量修改原有代码的情况下，通过扩展的方式添加新的功能代码。说直白点就是，代码预留了一些功能扩展点，你可以把新功能代码，直接插到扩展点上，而不需要因为要添加一个功能而大动干戈，改动大量的原始代码。
“对修改关闭，对扩展开放”。
灵活性（flexibility）
如果一段代码易扩展、易复用或者易用，我们都可以称这段代码写得比较灵活。

当我们添加一个新的功能代码的时候，原有的代码已经预留好了扩展点，我们不需要修改原有的代码，只要在扩展点上添加新的代码即可。这个时候，我们除了可以说代码易扩展，还可以说代码写得好灵活。
当我们要实现一个功能的时候，发现原有代码中，已经抽象出了很多底层可以复用的模块、类等代码，我们可以拿来直接使用。这个时候，我们除了可以说代码易复用之外，还可以说代码写得好灵活。
当我们使用某组接口的时候，如果这组接口可以应对各种使用场景，满足各种不同的需求，我们除了可以说接口易用之外，还可以说这个接口设计得好灵活或者代码写得好灵活。

简洁性（simplicity）
尽量保持代码简单。代码简单、逻辑清晰，也就意味着易读、易维护。我们在编写代码的时候，往往也会把简单、清晰放到首位。
KISS 原则，思从深而行从简，真正的高手能云淡风轻地用最简单的方法解决最复杂的问题。这也是一个编程老手跟编程新手的本质区别之一。
可复用性（reusability）
尽量减少重复代码的编写，复用已有的代码。
当讲到面向对象特性的时候，我们会讲到继承、多态存在的目的之一，就是为了提高代码的可复用性；当讲到设计原则的时候，我们会讲到单一职责原则也跟代码的可复用性相关；当讲到重构技巧的时候，我们会讲到解耦、高内聚、模块化等都能提高代码的可复用性。可见，可复用性也是一个非常重要的代码评价标准，是很多设计原则、思想、模式等所要达到的最终效果。
DRY（Don’t Repeat Yourself）设计原则。
可测试性（testability）
代码可测试性的好坏，能从侧面上非常准确地反应代码质量的好坏。代码的可测试性差，比较难写单元测试，那基本上就能说明代码设计得有问题。
03
面向对象

面向对象的四大特性：封装、抽象、继承、多态面
向对象编程与面向过程编程的区别和联系
面向对象分析、面向对象设计、面向对象编程
接口和抽象类的区别以及各自的应用场景
基于接口而非实现编程的设计思想
多用组合少用继承的设计思想
面向过程的贫血模型和面向对象的充血模型

设计原则
指导我们代码设计的一些经验总结。

SOLID 原则 SRP 单一职责原则
SOLID 原则 OCP 开闭原则
SOLID 原则 SP 里式替换原则
SOLID 原则 ISP 接口隔离原则
SOLID 原则 DIP 依赖倒置原则
DRY 原则、KISS 原则、YAGNI 原则、LOD 法则

设计模式
针对软件开发中经常遇到的一些设计问题，总结出来的一套解决方案或者设计思路。
大部分设计模式要解决的都是代码的可扩展性问题。

创建型 常用的有：单例模式、工厂模式（工厂方法和抽象工厂）、建造者模式。不常用的有：原型模式。
结构型 常用的有：代理模式、桥接模式、装饰者模式、适配器模式。不常用的有：门面模式、组合模式、享元模式。
行为型 常用的有：观察者模式、模板模式、策略模式、职责链模式、迭代器模式、状态模式。不常用的有：访问者模式、备忘录模式、命令模式、解释器模式、中介模式。

编程规范
主要解决的是代码的可读性问题。
代码重构
在软件开发中，只要软件在不停地迭代，就没有一劳永逸的设计。
在开发初期，除非特别必须，我们一定不要过度设计，应用复杂的设计模式。而是当代码出现问题的时候，我们再针对问题，应用原则和模式进行重构。这样就能有效避免前期的过度设计。

重构的目的（why）、对象（what）、时机（when）、方法（how）；
保证重构不出错的技术手段：单元测试和代码的可测试性；
两种不同规模的重构：大重构（大规模高层次）和小重构（小规模低层次）。

五者联系
面向对象编程因为其具有丰富的特性（封装、抽象、继承、多态），可以实现很多复杂的设计思路，是很多设计原则、设计模式等编码实现的基础。
设计原则是指导我们代码设计的一些经验总结，对于某些场景下，是否应该应用某种设计模式，具有指导意义。比如，“开闭原则”是很多设计模式（策略、模板等）的指导原则。
设计模式是针对软件开发中经常遇到的一些设计问题，总结出来的一套解决方案或者设计思路。应用设计模式的主要目的是提高代码的可扩展性。从抽象程度上来讲，设计原则比设计模式更抽象。设计模式更加具体、更加可执行。
编程规范主要解决的是代码的可读性问题。编码规范相对于设计原则、设计模式，更加具体、更加偏重代码细节、更加能落地。持续的小重构依赖的理论基础主要就是编程规范。
重构作为保持代码质量不下降的有效手段，利用的就是面向对象、设计原则、设计模式、编码规范这些理论。

04
面向对象编程是一种编程范式或编程风格。它以类或对象作为组织代码的基本单元，并将封装、抽象、继承、多态四个特性，作为代码设计和实现的基石。
05
封装（Encapsulation）
封装也叫作信息隐藏或者数据访问保护。类通过暴露有限的访问接口，授权外部仅能通过类提供的方式来访问内部信息或者数据。
封装特性存在的意义，一方面是保护数据不被随意修改，提高代码的可维护性；另一方面是仅暴露有限的必要接口，提高类的易用性。
抽象（Abstraction）
抽象可以通过接口类或者抽象类来实现，但也并不需要特殊的语法机制来支持。
抽象存在的意义，一方面是提高代码的可扩展性、维护性，修改实现不需要改变定义，减少代码的改动范围；另一方面，它也是处理复杂系统的有效手段，能有效地过滤掉不必要关注的信息。
提供“函数”这一非常基础的语法机制，就可以实现抽象特性、所以，它没有很强的“特异性”，有时候并不被看作面向对象编程的特性之一。
在定义（或者叫命名）类的方法的时候，也要有抽象思维，不要在方法定义中，暴露太多的实现细节，以保证在某个时间点需要改变方法的实现逻辑的时候，不用去修改其定义。getPictureUrl 好于 getAliyunPictureUrl。
继承（Inheritance）
继承是用来表示类之间的 is-a 关系。继承主要是用来解决代码复用的问题。
多用组合少用继承。
多态（Polymorphism）
多态是指子类可以替换父类，在实际的代码运行过程中，调用子类的方法实现。
多态这种特性也需要编程语言提供特殊的语法机制来实现，比如继承、接口类、duck-typing。多态可以提高代码的扩展性和复用性，是很多设计模式、设计原则、编程技巧的代码实现基础。
只要两个类具有相同的方法，就可以实现多态，并不要求两个类之间有任何关系，这就是所谓的 duck-typing，是一些动态语言所特有的语法机制。
06
相较于面向对象编程以类为组织代码的基本单元，面向过程编程则是以过程（或方法）作为组织代码的基本单元。它最主要的特点就是数据和方法相分离。相较于面向对象编程语言，面向过程编程语言最大的特点就是不支持丰富的面向对象编程特性，比如继承、多态、封装。
面向对象编程相比面向过程编程有哪些优势？

对于大规模复杂程序的开发，程序的处理流程并非单一的一条主线，而是错综复杂的网状结构。
面向对象编程比起面向过程编程，更能应对这种复杂类型的程序开发。面向对象编程相比面向过程编程，具有更加丰富的特性（封装、抽象、继承、多态）。利用这些特性编写出来的代码，更加易扩展、易复用、易维护。
从编程语言跟机器打交道的方式的演进规律中，我们可以总结出：面向对象编程语言比起面向过程编程语言，更加人性化、更加高级、更加智能。

07
滥用 getter、setter 方法
尽管 getter 方法相对 setter 方法要安全些，但是如果返回的是集合容器（比如例子中的 List 容器），也要防范集合内部数据被修改的危险。
public class ShoppingCart {
    // ... 省略其他代码...
    public List<ShoppingCartItem> getItems() {
        return Collections.unmodifiableList(this.items);
    }
}
public class UnmodifiableList<E> extends UnmodifiableCollection<E> implements List<E> {
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }
    public void clear() {
        throw new UnsupportedOperationException();
    }
    // ... 省略其他代码...
}
滥用全局变量和全局方法
Constants 类、Utils 类的设计尽量能做到职责单一，定义一些细化的小类。
静态成员变量归属于类上的数据，被所有的实例化对象所共享，也相当于一定程度上的全局变量。
静态方法将方法与数据分离，破坏了封装特性，是典型的面向过程风格。
只包含静态方法不包含任何属性的 Utils 类，是彻彻底底的面向过程的编程风格。要尽量避免滥用，不要不加思考地随意去定义 Utils 类。
定义数据和方法分离的类
Controller 层负责暴露接口给前端调用，Service 层负责核心业务逻辑，Repository 层负责数据读写。
而在每一层中，我们又会定义相应的 VO（View Object）、BO（Business Object）、Entity。一般情况下，VO、BO、Entity 中只会定义数据，不会定义方法，所有操作这些数据的业务逻辑都定义在对应的 Controller 类、Service 类、Repository 类中。这就是典型的面向过程的编程风格。

实际上，这种开发模式叫作基于 贫血模型的开发模式，也是我们现在非常常用的一种 Web 项目的开发模式。看到这里，你内心里应该有很多疑惑吧？既然这种开发模式明显违背面向对象的编程风格，为什么大部分 Web 项目都是基于这种开发模式来开发呢？

在面向对象编程中，为什么容易写出面向过程风格的代码？
面向过程编程风格恰恰符合人的这种流程化思维方式。而面向对象编程风格正好相反。它是一种自底向上的思考方式。
它不是先去按照执行流程来分解任务，而是将任务翻译成一个一个的小的模块（也就是类），设计类之间的交互，最后按照流程将类组装起来，完成整个任务。
在面向对象编程中，类的设计还是挺需要技巧，挺需要一定设计经验的。你要去思考如何封装合适的数据和方法到一个类里，如何设计类之间的关系，如何设计类之间的交互等等诸多设计问题。
面向过程编程及面向过程编程语言就真的无用武之地了吗？
如果我们开发的是微小程序，或者是一个数据处理相关的代码，以算法为主，数据为辅，那脚本式的面向过程的编程风格就更适合一些。
08
抽象类和接口的语法特性
抽象类不允许被实例化，只能被继承。它可以包含属性和方法。方法既可以包含代码实现，也可以不包含代码实现。不包含代码实现的方法叫作抽象方法。子类继承抽象类，必须实现抽象类中的所有抽象方法。接口不能包含属性，只能声明方法，方法不能包含代码实现。类实现接口的时候，必须实现接口中声明的所有方法。
抽象类和接口存在的意义
抽象类是对成员变量和方法的抽象，是一种 is-a 关系，是为了解决代码复用问题。接口仅仅是对方法的抽象，是一种 has-a 关系，表示具有某一组行为特性，是为了解决解耦问题，隔离接口和具体的实现，提高代码的扩展性。
从类的继承层次上来看，抽象类是一种自下而上的设计思路，先有子类的代码重复，然后再抽象成上层的父类（也就是抽象类）。而接口正好相反，它是一种自上而下的设计思路。
09
“Program to an interface, not animplementation”。“基于抽象而非实现编程”。
越抽象、越顶层、越脱离具体某一实现的设计，越能提高代码的灵活性，越能应对未来的需求变化。好的代码设计，不仅能应对当下的需求，而且在将来需求发生变化的时候，仍然能够在不破坏原有代码设计的情况下灵活应对。
“细节是魔鬼”。

函数的命名不能暴露任何实现细节。
封装具体的实现细节。
为实现类定义抽象的接口。

抽象意识、封装意识、接口意识。
10
继承层次过深、过复杂，也会影响到代码的可维护性。
鸟 -> 会飞、不会飞、会叫、不会叫、会下蛋、不会下蛋。
利用组合（composition）、接口、委托（delegation 解决。
// 接口
public interface Flyable {
  void fly();
}

// 提高复用性
public class FlyAbility implements Flyable {
  @Override
  public void fly() {
    //...
  }
}

public class Sparrow implements Flyable {
  // 组合
  private FlyAbility flyAbility = new FlyAbility();
  @Override
  public void fly() {
    // 委托
    flyAbility.fly();
  }
}
继承改写成组合意味着要做更细粒度的类的拆分。这也就意味着，我们要定义更多的类和接口。类和接口的增多也就或多或少地增加代码的复杂程度和维护成本。
组合并不完美，继承也不是一无是处。
如果类之间的继承结构稳定，层次比较浅，关系不复杂，我们就可以大胆地使用继承。反之，我们就尽量使用组合来替代继承。除此之外，还有一些设计模式、特殊的应用场景，会固定使用继承（模板模式（template pattern））或者组合（装饰者模式（decoratorpattern）、策略模式（strategy pattern）、组合模式（composite pattern））。
– EOF –



MySQL Code Snippet
Fri, 29 Jan 2021 18:08:00 +0000
Tips SQL
-- 追踪优化器 Trace 功能
--  optimizer_trace_enabled=1
--  optimizer_trace_file=optimizer_trace.log
SELECT @@optimizer_trace;
SET optimizer_trace = 'enabled=on';
-- ;
SET optimizer_trace = 'enabled=off';
select * from INFORMATION_SCHEMA.OPTIMIZER_TRACE;

-- 查看优化后的 SQL
-- 在联表查询时比较有效果
EXPLAIN <你的 SQL>;
SHOW WARNINGS;

-- 查看处理
SHOW PROCESSLIST;

-- 查看结构
DESC user;
SHOW COLUMNS FROM user;
DESCRIBE user;
视图更新
CREATE OR REPLACE VIEW 视图名 AS SELECT[...] FROM [...]
字符集转换
LEFT JOIN code_value b ON a.cost_type = CONVERT ( b.`code` USING utf8mb4 ) COLLATE utf8mb4_unicode_ci
Function
-- https://www.w3schools.com/sql/func_mysql_find_in_set.asp
select FIND_IN_SET('bb', 'aa,bb,cc');
select FIND_IN_SET(null, '0');

-- COALESCE 函数用于返回参数列表中第一个非 NULL 值。如果所有参数都为 NULL，则返回 NULL
COALESCE ( `code_value`.`name`, '' ) AS cost_type_name,
ON vs USING
MySQL ON vs USING? | stackoverflow
删除重复数据
DELETE
FROM
  student
WHERE
  id NOT IN (
  SELECT
    id
FROM
  ( SELECT MIN( id ) AS id FROM student GROUP BY `name` ) tmp)
要多加一层 tmp 包装，否则会遇到：1093 - You can't specify target table 'student' for update in FROM clause
备份表
-- 创建同结构备份表
create table zzz_my_table_220727 like my_table;
-- 将需要数据写入备份表
insert into zzz_my_table_220727 select * from my_table ORDER BY id desc LIMIT 1000;
-- 情况原表
truncate table my_table;
SQL AND OR 执行优先级
select id from table01 where condition1 or condition2 and condition3;

-- 等价于：
select id from table01 where condition1 or (condition2 and condition3);
-- 而非：
select id from table01 where (condition1 or condition2) and condition3;
and 级别高于 or。相当于可以把 and 看成 乘号 *，把 or 看成 加号 +。
事务
//对读取的记录加共享锁
select ... lock in share mode;

-- //对读取的记录加独占锁
select ... for update;
References

编程小技巧（3）：查看优化后的 SQL

– EOF –



PHP 月份加减问题
Wed, 27 Jan 2021 18:18:24 +0000
看现象
var_dump(date("Y-m-d", strtotime("+1 month", strtotime("2020-07-31"))));
// string(10) "2020-08-31" 符合预期

var_dump(date("Y-m-d", strtotime("+1 month", strtotime("2020-05-31"))));
// string(10) "2020-07-01" 不符合预期，预期 2020-06-30

var_dump(date("Y-m-d", strtotime("-1 month", strtotime("2020-02-29"))));
// string(10) "2020-01-29" 符合预期

var_dump(date("Y-m-d", strtotime("-1 month", strtotime("2020-03-31"))));
// string(10) "2020-03-02" 不符合预期，预期 2020-02-29


// Carbon\Carbon
Carbon::parse("2020-07-31")->addMonth()->toDateString();
// "2020-08-31"
Carbon::parse("2020-05-31")->addMonth()->toDateString();
// "2020-07-01"
Carbon::parse("2020-02-29")->subMonth()->toDateString();
// "2020-01-29"
Carbon::parse("2020-03-31")->subMonth()->toDateString();
// "2020-03-02"

// 结果与 strtotime 一致。
原因
var_dump(date("Y-m-d", strtotime("+1 month", strtotime("2020-05-31"))));
// string(10) "2020-07-01"
date 内部的处理逻辑：

2020-05-31 做 +1 month 也就是 2020-06-31。
再做日期规范化，因为没有 06-31，所以 06-31 就等于了 07-01。

var_dump(date("Y-m-d", strtotime("2020-06-31")));
// string(10) "2017-07-01"

var_dump(date("Y-m-d", strtotime("next month", strtotime("2017-01-31"))));
// string(10) "2017-03-03"

var_dump(date("Y-m-d", strtotime("last month", strtotime("2017-03-31"))));
// string(10) "2017-03-03"
解决方案
var_dump(date("Y-m-d", strtotime("last day of -1 month", strtotime("2017-03-31"))));
// string(10) "2017-02-28"

var_dump(date("Y-m-d", strtotime("first day of +1 month", strtotime("2017-08-31"))));
// string(10) "2017-09-01"

// 但要注意短语的含义：
var_dump(date("Y-m-d", strtotime("last day of -1 month", strtotime("2017-03-01"))));
// string(10) "2017-02-28"
如果使用 Carbon\Carbon 可以用 subMonthNoOverflow 与 addMonthNoOverflow 防止进位：


回顾 2020
Thu, 31 Dec 2020 20:00:00 +0000
过年就在石家庄
lwl 走学
肺炎在家办公
PR 剪辑
表情包制作
自己染发剪发
– EOF –


MySQL 空格问题
Sat, 28 Nov 2020 11:11:59 +0000
看现象
创建一个测试数据库表，插入测试数据：
CREATE TABLE `blank_space` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `uid` varchar(10) COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
  `desc` varchar(10) COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uniq_key` (`uid`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

INSERT INTO `blank_space`(`id`, `uid`, `desc`) VALUES (1, 'abc ', '末尾1个');
INSERT INTO `blank_space`(`id`, `uid`, `desc`) VALUES (2, ' abc', '开头1个');
INSERT INTO `blank_space`(`id`, `uid`, `desc`) VALUES (3, '  abc', '开头2个');

  
      
          id
          uid
          desc
      
  
  
      
          1
          abc_
          末尾 1 个
      
      
          2
          _abc
          开头 1 个
      
      
          3
          __abc
          开头 2 个
      
  


uid 实际上没有 _，这样写是为了看到空格。

执行操作：
SELECT * FROM blank_space WHERE uid = 'abc';

SELECT * FROM blank_space WHERE uid = 'abc ';

SELECT * FROM blank_space WHERE uid = 'abc   ';
都可以查询出：

  
      
          id
          uid
          desc
      
  
  
      
          1
          abc_
          末尾 1 个
      
  

执行操作：
INSERT INTO `blank_space`(`uid`, `desc`) VALUES ('abc', '无空格');
-- 1062 - Duplicate entry 'abc' for key 'uniq_key', Time: 0.322000s

INSERT INTO `blank_space`(`uid`, `desc`) VALUES ('abc  ', '末位两个');
-- 1062 - Duplicate entry 'abc' for key 'uniq_key', Time: 0.322000s
原因
MySQL 校对规则属于 PADSPACE，会忽略尾部空格。针对的是 varchar char text 等文本类的数据类型。此为 SQL 标准化行为。无需要设置也无法改变。
解决方案
SELECT * FROM blank_space WHERE uid = BINARY 'abc';
-- 0 records

SELECT * FROM blank_space WHERE uid = BINARY 'abc ';
-- 1 records

SELECT * FROM blank_space WHERE uid = BINARY 'abc   ';
-- 0 records


SELECT * FROM blank_space WHERE uid like 'abc';
-- 0 records

SELECT * FROM blank_space WHERE uid like 'abc ';
-- 1 records

SELECT * FROM blank_space WHERE uid like 'abc   ';
-- 0 records

BINARY 不是函数，是类型转换运算符，它用来强制它后面的字符串为一个二进制字符串，可以理解成精确匹配。

约束攻击
需要在非严格模式下。
SET sql_mode = '';

CREATE TABLE `blank_space_attack` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `uid` varchar(10) COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
  `pwd` varchar(10) COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

INSERT INTO `blank_space_attack`(`id`, `uid`, `pwd`) VALUES (1, 'admin', '123');
INSERT INTO `blank_space_attack`(`id`, `uid`, `pwd`) VALUES (2, 'tim', '234');
攻击：
INSERT INTO `blank_space_attack`(`uid`, `pwd`) VALUES ('admin      1', 'easy');
结果：

select * from blank_space_attack where uid = "admin" and pwd = "easy";

  
      
          id
          uid
          desc
      
  
  
      
          3
          admin_____
          easy
      
  

限制条件

服务端没有对用户名长度进行限制。如果服务端限制了用户名长度就不能导致数据库截断，也就没有利用条件。
登陆验证的 SQL 语句必须是用户名和密码一起验证。如果是验证流程是先根据用户名查找出对应的密码，然后再比对密码的话，那么也不能进行利用。因为当使用 admin 为用户名来查询密码的话，数据库此时就会返回两条记录，而一般取第一条则是目标用户的记录，那么你传输的密码肯定是和目标用户密码匹配不上的。
验证成功后返回的必须是用户传递进来的用户名，而不是从数据库取出的用户名。因为当我们以用户 admin 和密码 easy 登陆时，其实数据库返回的是我们自己的用户信息，而我们的用户名其实是 admin_____，如果此后的业务逻辑以该用户名为准，那么就不能达到越权的目的了。

References

SQL 约束攻击 | v0n
记一次数据库空格问题 | iluoy
Mysql 查询条件中字符串尾部有空格也能匹配上的问题 | xjnotxj

– EOF –



Composer 文档笔记
Wed, 28 Oct 2020 11:36:27 +0000
Basic usage

https://getcomposer.org/doc/01-basic-usage.md

# get a list of your locally available platform packages.
# php | ext- | lib-
composer show --platform
Libraries

https://getcomposer.org/doc/02-libraries.md

Light-weight distribution packages 轻量级分发包。使用 .gitattributes 来防止不需要的文件使 zip 分发包膨胀。
// .gitattributes
/demo export-ignore
phpunit.xml.dist export-ignore
/.github/ export-ignore
通过检查手动生成的压缩文件进行测试：
git archive branchName --format zip -o file.zip
Command-line interface / Commands

https://getcomposer.org/doc/03-cli.md

As Composer uses symfony/console you can call commands by short name if it’s not ambiguous.
composer dump
# calls
composer dump-autoload
Bash Completions
composer completion bash > completion.bash
Global Options:

--profile 显示计时和内存使用信息

install / i:
php composer.phar install
如果当前目录中有 composer.lock 文件，会使用其中的确切版本而不是重新解析。这确保了每个人使用的依赖版本相同。
如果没有 composer.lock 文件，Composer 会在解析依赖后创建一个。
常用选项：

--prefer-install: 指定安装方式，可选 source 或 dist
--no-dev: 跳过安装 require-dev 中列出的包
--optimize-autoloader (-o): 优化自动加载器，建议在生产环境使用
--classmap-authoritative (-a): 仅从 classmap 自动加载类，隐式启用 --optimize-autoloader

update / u / upgrade:
php composer.phar update
更新所有依赖到最新版本（根据 composer.json 的约束）并更新 composer.lock 文件。
常用选项：

--prefer-stable: 优先使用稳定版本
--prefer-lowest: 尝试回退到最低匹配的版本
--with-dependencies: 同时更新依赖的依赖项

require / r:
php composer.phar require vendor/package:version
添加新的依赖包并更新 composer.json 文件。
remove / rm / uninstall:
php composer.phar remove vendor/package
移除包并更新 composer.json 文件。
dump-autoload / dumpautoload:
php composer.phar dump-autoload
更新自动加载器，不安装或更新任何包。在添加新类时很有用。
选项：

-o, --optimize: 生成优化的 autoloader
--classmap-authoritative (-a): 仅从 classmap 自动加载
--no-dev: 不生成开发环境的 autoloader

global:
php composer.phar global require vendor/package
全局安装包，存储在 COMPOSER_HOME 目录。
search:
php composer.phar search keyword
搜索包。
self-update / selfupdate:
php composer.phar self-update
更新 Composer 到最新版本。
Composer 支持多种环境变量来控制其行为：

COMPOSER_HOME: 指定 Composer 主目录位置
COMPOSER_CACHE_DIR: 更改 Composer 缓存目录
COMPOSER_MEMORY_LIMIT: 设置 PHP 内存限制
COMPOSER_PROCESS_TIMEOUT: 设置命令执行超时时间（默认 300 秒）
COMPOSER_NO_INTERACTION: 禁用交互模式
COMPOSER_NO_DEV: 等同于 --no-dev 选项
COMPOSER_VENDOR_DIR: 更改安装依赖的目录

The composer.json schema

https://getcomposer.org/doc/04-schema.md

composer.json 文件是 Composer 项目的核心配置文件，用于定义包的基本信息和依赖关系。以下是主要字段的说明：
基本字段

name: 包名称，格式为 vendor/project，例如 monolog/monolog。必须小写，可包含短横线、下划线或点号。
description: 包的简短描述，通常为一行。
version: 包的版本号，格式如 1.0.0 或 v1.0.0。一般建议省略，由 VCS 标签推断。
type: 包类型，默认为 library。其他可选值包括 project、metapackage 和 composer-plugin。
keywords: 关键词数组，用于搜索和过滤。
homepage: 项目网站的 URL。
readme: 自述文件的相对路径，默认为 README.md。
time: 版本发布日期，格式为 YYYY-MM-DD 或 YYYY-MM-DD HH:MM:SS。
license: 包的许可证，可以是字符串或字符串数组。

作者与支持

authors: 包作者数组，每个作者为一个对象，包含 name、email、homepage 和 role 字段。
support: 提供支持的各种信息，如 email、issues、forum、wiki 等。
funding: 用于赞助包作者的 URL 数组。

依赖管理

require: 运行时必需的依赖包映射表（包名到版本约束）。
require-dev: 开发环境需要的依赖包映射表，仅对根包有效。
conflict: 与当前包冲突的包。
replace: 由当前包替换的包。
provide: 当前包提供的包（接口实现等）。
suggest: 推荐安装的包，仅起信息提示作用。

自动加载配置

autoload: 定义项目自动加载规则，支持 psr-4、psr-0、classmap 和 files。
autoload-dev: 开发环境的额外自动加载规则，仅对根包有效。

其他高级配置

repositories: 定义额外的包来源，仅对根包有效。
minimum-stability: 默认包稳定性过滤级别，仅对根包有效。
prefer-stable: 是否优先使用稳定版本，仅对根包有效。
config: 各种配置选项，仅对根包有效。
scripts: 在安装过程中各个阶段执行的脚本钩子，仅对根包有效。
extra: 供脚本使用的任意额外数据。
bin: 应作为二进制文件安装的文件集合。

示例：
{
    "name": "monolog/monolog",
    "description": "Logging library",
    "keywords": ["logging", "psr-3"],
    "homepage": "https://github.com/Seldaek/monolog",
    "license": "MIT",
    "authors": [
        {
            "name": "Jordi Boggiano",
            "email": "j.boggiano@seld.be",
            "homepage": "https://seld.be"
        }
    ],
    "require": {
        "php": ">=5.3.0",
        "psr/log": "~1.0"
    },
    "autoload": {
        "psr-4": {"Monolog\\": "src/Monolog"}
    }
}
Repositories

https://getcomposer.org/doc/05-repositories.md

仓库是包的来源，Composer 会在所有配置的仓库中查找项目所需的包。本节介绍仓库的概念和类型。
仓库类型
1. Composer 仓库
使用单个 packages.json 文件包含所有包元数据的仓库类型，这也是 Packagist 使用的类型。
{
    "repositories": [
        {
            "type": "composer",
            "url": "https://example.org"
        }
    ]
}
2. VCS 仓库
版本控制系统（Version Control System）仓库，支持从 git、svn、fossil 或 hg 仓库安装包。
{
    "repositories": [
        {
            "type": "vcs",
            "url": "https://github.com/username/repository"
        }
    ],
    "require": {
        "vendor/package": "dev-branch-name"
    }
}
使用 VCS 仓库的主要场景包括：

维护第三方库的自己的分支
使用私有仓库
需要直接从版本控制系统获取代码

3. Package 仓库
针对不支持 Composer 的项目，可以手动定义包的信息。
{
    "repositories": [
        {
            "type": "package",
            "package": {
                "name": "smarty/smarty",
                "version": "3.1.7",
                "dist": {
                    "url": "https://www.smarty.net/files/Smarty-3.1.7.zip",
                    "type": "zip"
                }
            }
        }
    ]
}
自托管仓库选项
当需要保持包私有或为项目创建独立生态系统时，可以选择自托管仓库：


Private Packagist：提供私有包托管和镜像功能的托管或自托管应用。


Satis：轻量级的静态 Composer 仓库生成器，适合小型团队。


Artifact 仓库：使用包含 ZIP 或 TAR 归档文件的文件夹作为包源。
{
    "repositories": [
        {
            "type": "artifact",
            "url": "path/to/directory/with/zips/"
        }
    ]
}


Path 仓库：直接依赖本地目录，对于单体仓库特别有用。
{
    "repositories": [
        {
            "type": "path",
            "url": "../../packages/my-package"
        }
    ]
}


禁用 Packagist.org
默认情况下，Composer 会使用 Packagist.org 作为包源。如需禁用：
{
    "repositories": [
        {
            "packagist.org": false
        }
    ]
}
或通过全局配置：
php composer.phar config -g repo.packagist false
Config

https://getcomposer.org/doc/06-config.md

Composer 配置选项可以通过 composer.json 中的 config 字段设置。以下是一些常用的配置项：
基本配置选项


process-timeout: 进程执行超时时间（秒），默认 300（5分钟）。
{
    "config": {
        "process-timeout": 900
    }
}


allow-plugins: 控制哪些 Composer 插件可以执行代码（Composer 2.2.0+）。
{
    "config": {
        "allow-plugins": {
            "vendor/plugin-name": true,
            "another-vendor/*": true
        }
    }
}


preferred-install: 首选安装方式，可为 source、dist 或 auto。
{
    "config": {
        "preferred-install": {
            "vendor/*": "source",
            "*": "dist"
        }
    }
}


仓库与认证


github-protocols: 克隆 GitHub 仓库使用的协议列表，默认 ["https", "ssh", "git"]。


github-oauth: GitHub OAuth 令牌列表。


gitlab-oauth/gitlab-token: GitLab OAuth 令牌或私有令牌列表。


http-basic: HTTP 基本认证信息。
{
    "config": {
        "http-basic": {
            "example.org": {
                "username": "username",
                "password": "password"
            }
        }
    }
}


目录与缓存

vendor-dir: 安装依赖的目录，默认为 vendor。
bin-dir: 二进制文件链接目录，默认为 vendor/bin。
cache-dir: 缓存目录。
cache-files-ttl: 缓存文件的存活时间（秒），默认 15552000（6个月）。
cache-files-maxsize: 缓存可使用的最大空间，默认 “300MiB”。

自动加载相关

optimize-autoloader: 始终优化自动加载器，默认 false。
prepend-autoloader: 是否将 Composer 自动加载器前置到已存在的自动加载器，默认 true。
classmap-authoritative: 设为 true 时，自动加载器只会从 classmap 加载类，默认 false。
apcu-autoloader: 是否使用 APCu 缓存查找的类，默认 false。

安全与其他

platform-check: 平台检查级别，默认 php-only，可设为 true 或 false。
secure-http: 是否只允许通过 HTTPS 下载包，默认 true。
discard-changes: 处理脏更新的方式，默认 false，可设为 true 或 stash。
sort-packages: 添加新包时是否按名称排序，默认 false。

全局配置
某些配置可通过命令行全局设置：
php composer.phar config -g repo.packagist false
php composer.phar config -g process-timeout 900
Runtime Composer utilities

https://getcomposer.org/doc/07-runtime.md

Composer 除了安装和管理依赖外，还提供了一些运行时实用工具。如果需要依赖特定版本的这些功能，可以通过 composer-runtime-api 包实现。
自动加载
最常用的运行时工具是自动加载器，在所有 Composer 版本中可用。
require __DIR__ . '/vendor/autoload.php';

// 现在可以使用项目的依赖了
$log = new Monolog\Logger('name');
已安装版本信息
Composer 2.0 引入了 Composer\InstalledVersions 类，提供了检查已安装包的静态方法。
检查包是否存在
\Composer\InstalledVersions::isInstalled('vendor/package'); // 返回布尔值
\Composer\InstalledVersions::isInstalled('psr/log-implementation'); // 检查虚拟包
从 Composer 2.1 开始，还可以检查包是否通过 require-dev 安装：
\Composer\InstalledVersions::isInstalled('vendor/package', false); // 仅检查 require 中的包
检查包版本
use Composer\Semver\VersionParser;

// 检查包是否满足版本约束
\Composer\InstalledVersions::satisfies(new VersionParser, 'vendor/package', '2.0.*');

// 获取包的版本号
$version = \Composer\InstalledVersions::getVersion('vendor/package'); // 标准化版本 (如 1.2.3.0)
$prettyVersion = \Composer\InstalledVersions::getPrettyVersion('vendor/package'); // 原始版本 (如 v1.2.3)
获取包的安装路径
// 获取包安装的绝对路径
$path = \Composer\InstalledVersions::getInstallPath('vendor/package');
查找指定类型的已安装包
// 获取所有类型为 'foo-plugin' 的已安装包
$packages = \Composer\InstalledVersions::getInstalledPackagesByType('foo-plugin');
平台检查
Composer 2.0 引入了 vendor/composer/platform_check.php 文件，会在包含自动加载器时自动执行。它会验证当前 PHP 环境是否满足平台要求，如 PHP 版本和扩展。
默认情况下，只检查 PHP 版本（php-only）。可以通过 platform-check 配置选项修改行为：
{
    "config": {
        "platform-check": true  // 也检查 PHP 扩展
    }
}
如果要禁用此安全检查：
{
    "config": {
        "platform-check": false
    }
}
二进制文件中的自动加载器路径
Composer 2.2 引入了全局变量 $_composer_autoload_path，它在运行 Composer 安装的二进制文件时设置。
二进制文件中的 bin-dir 路径
Composer 2.2.2 引入了全局变量 $_composer_bin_dir，它在运行 Composer 安装的二进制文件时设置。



Composer vendor 提交至 Git
Mon, 10 Aug 2020 14:24:47 +0000
应该将 vendor 提交到 Git 吗
一般建议是 不。vendor 目录应添加到 .gitignore。
最佳实践是让所有开发人员使用 Composer 来安装依赖项。类似地，构建服务器、CI、部署工具等都应该作为项目启动的一部分来运行 Composer。
虽然在某些环境下这样做很诱人，但也会导致一些问题：

大型 VCS 存储库的大小和更新代码时的差异。
在你自己的 VCS 复制你所有依赖的历史。
将通过 git 安装的依赖项添加到 git repo 中将显示为 submodules。这是有问题的，因为它们不是真正的 submodules，您将会遇到问题。

如果你真的觉得你必须这样做，你有几个选择：

限制自己安装带标记的版本（没有 dev 版本），这样就只能安装压缩版，并避免与 git submodules 有关的问题。
Use --prefer-dist or set preferred-install to dist in your config.
Remove the .git directory of every dependency after the installation, then you can add them to your git repo. You can do that with rm -rf vendor/\*\*/.git in ZSH or find vendor/ -type d -name ".git" -exec rm -rf {} \; in Bash. 但这意味着您必须在运行 composer 更新之前从磁盘中删除这些依赖项。
Add a .gitignore rule /vendor/**/.git to ignore all the vendor .git folders. 这种方法不需要在运行编写器更新之前从磁盘删除依赖项。

我的做法

问题解决了，但是不确信做法是否正确。

因为网络环境与部署的原因，在生产环境下是将 vendor 目录提交到 git 中的。使用过程中确实出现了，部分类库成为了 submodules，无法把真实的代码提交进 git。
可尝试执行：
git rm rf --cache vendor
git add .
git commit -m "add vendor"
References

Should I commit the dependencies in my vendor directory? | getcomposer

– EOF –



配置 Laradock PhpStorm Xdubug
Tue, 26 May 2020 09:45:15 +0000
最近在学习 Yii2 的源码，为了方便调试所以研究下 Laradock + PhpStorm + Xdubug 的配置。
环境

macOS
Laradock v10.0

请保证 Laradock 是最新的版本，可以减少不必要的麻烦。也推荐使用我精简过的项目 imzyf/my-dock | github。

配置 Laradock
vim .env

WORKSPACE_INSTALL_XDEBUG=true
PHP_FPM_INSTALL_XDEBUG=true
重新编译 php-fpm 和 workspace 容器：
docker-compose build php-fpm workspace
配置 PhpStorm
配置 Docker
Preferences > Build, Execution, Deploymnent > Docker

配置 PHP
Preferences > Languages & Frameworks > PHP，PHP CLI Interpreter 点 ...

点击 +，选择 From Docker, Vagrant…

Debugger 可以显示出 Xdebug。
配置 Servers
Preferences > Languages & Frameworks > PHP > Servers

注意：Name 必须填写 Laradock 中的 PHP_IDE_CONFIG 也就就是 laradock。
配置 Xdebug
Preferences > Languages & Frameworks > PHP > Debug。点击 Validate，填写。

run > Edit Configurations，添加 PHP Remote Debug。IDE key 为 PHPSTORM。

配置 Chrome
下载插件 Xdebug helper，右键图标 配置。

enjoy

开启 debug，然后访问页面。

芜湖起飞。
References

Laradock 使用 PhpStorm Debug 代码 | learnku
Set Debugger Using Xdebug With PHPStorm & Laradock | medium

– EOF –



PHP float 精度
Sat, 09 May 2020 17:32:34 +0000
实例 1
$a = 1.1;
var_dump(gettype($a)); // string(6) "double"
var_dump($a); // float(1.1)
实例 2
$a = "123456789.1100110011";
$a = (float) $a;
var_dump($a); // float(123456789.11001)
var_dump(sprintf('%.11f', $a)); // string(21) "123456789.11001099646"

$b = 123456789.11001;
var_dump($b); // float(123456789.11001)
var_dump(sprintf('%.11f', $b)); // string(21) "123456789.11000999808"

$c = '123456789.1100110011';
$c = (float) $c;
var_dump($c); // float(123456789.11001)
$c = (string) $c;
var_dump($c); // string(15) "123456789.11001"
$c = (float) $c;
var_dump($c); // float(123456789.11001)
var_dump(sprintf('%.11f', $c)); // string(21) "123456789.11000999808"


var_dump($a === $b); // bool(false) - 说明 $a 还是携带着 float 的精度
var_dump($b === $c); // bool(true)
实例 3
// # 1
var_dump(120085 === 1200.85 * 100); // bool(false)

// # 2
var_dump(120085 == 1200.85 * 100); // bool(false)

// # 3
var_dump(120081 == 1200.81 * 100); // bool(true)

// # 4
var_dump(120085 - 1200.85 * 100); // float(1.4551915228367E-11)
实例 4
$a = 0.1;
$b = 0.9;
$c = 1;

var_dump(($a + $b) == $c); // bool(true)
var_dump(($c - $b) == $a); // bool(false)

var_dump(sprintf('%.20f', $a + $b)); // string(22) "1.00000000000000000000"
var_dump(sprintf('%.20f', $c - $b)); // string(22) "0.09999999999999997780"

var_dump((0.5 - 0.25) === 0.25); // bool(true) 0.5 二进制 0.1，0.25 二进制 0.01
var_dump((0.25 + 0.25) === 0.5); // bool(true)
实例 5
$n = 19.99;
dump($n * 100); // 1999.0
dump((int) ($n * 100)); // 1998 !!!
dump((string) ($n * 100)); // "1999"
dump((int) (string) ($n * 100)); // 1999
dump(round($n * 100)); // 1999.0 !!!
dump((int) round($n * 100)); // 1999
分析
看文档：


IDE Snippet
Tue, 28 Apr 2020 10:43:39 +0000
PhpStorm
PhpStorm 使用经验 | ZYF.IM
Cursor
备份扩展
cursor --list-extensions > cursor_extensions.txt
xargs -L 1 cursor --install-extension < cursor_extensions.txt
VSCode
配置文件

~/Library/Application\ Support/Cursor/User/settings.json
~/Library/Application\ Support/Cursor/User/keybindings.json

编辑 settings.json
command + , 右上角点击 Open Settings(JSON)。
{
  "terminal.integrated.fontSize": 14,
  "window.zoomLevel": 1.4,
  "editor.fontSize": 14,
  "editor.wordWrapColumn": 300,
  "editor.renderWhitespace": "all",
}
VIM
常用

全选（高亮显示）：按 esc 后，然后 ggvG 或者 ggVG
全部复制：按 esc 后，然后 ggyG
全部删除：按 esc 后，然后 dG

粘贴到终端 vim 缩进错乱

stackoverflow

在 vim 中粘贴前先输入：
:set paste
原因：在终端的 vim 中没有相应的程序来处理这个从其他应用复制粘贴的过程，所以 vim 通过插入键盘输入的 buffer 来模拟这个粘贴的过程，这个时候 vim 会以为这是用户输入的。


PHP GD 入门使用
Thu, 16 Apr 2020 17:24:37 +0000
GD 安装、配置
考虑到功能需要使用字体库、图像格式 jpeg\png 所以先安装相关库。
字体库 FreeType 2
https://www.freetype.org/
# 在临时目录进行操作
cd /tmp

# https://download.savannah.gnu.org/releases/freetype/
wget http://download.savannah.gnu.org/releases/freetype/freetype-2.10.1.tar.gz

tar zxvf freetype-2.10.1.tar.gz

cd freetype-2.10.1

./configure --prefix=/usr/local/freetype && make && make install
图像格式 jpeg
cd /tmp

# http://www.ijg.org/
wget http://www.ijg.org/files/jpegsrc.v9d.tar.gz

tar zxvf jpegsrc.v9.tar.gz

cd jpeg-9/

./configure --prefix=/usr/local/jpeg && make && make install
图像格式 png
cd /tmp

# http://www.libpng.org/pub/png/libpng.html
wget https://download.sourceforge.net/libpng/libpng-1.6.37.tar.gz --no-check-certificate

tar zxvf libpng-1.6.37.tar.gz

cd libpng-1.6.37

./configure --prefix=/usr/local/libpng && make && make install
安装 GD

背景：服务器 php 7.1 通过编译自行安装的。
# 到 php 源码 dir
cd {php-source-dir}/ext/gd/

# 生成 configure 文件
{php-dir}/bin/phpize

# 查看可用参数
./configure --help

# 设置参数
./configure --with-php-config={php-dir}/bin/php-config --with-jpeg-dir=/usr/local/jpeg --with-png-dir=/usr/local/libpng --with-freetype-dir=/usr/local/freetype --enable-gd-native-ttf

make && make install

vim {php-dir}/lib/php.ini

# 最底下增加一行
extension=gd.so

service php-fpm reload

# 检查
php -r "var_dump(gd_info());"
编译前一定要记得 make clean 清除上次的编译内容，尤其是已经编译安装过的。
实例
$pic = imagecreate($maxWidth, $maxHeight);
//定义颜色
$black = imagecolorallocate($pic, 0, 0, 0);
$white = imagecolorallocate($pic, 255, 255, 255);

// 白底
imagefill($pic, 0, 0, $white);

// 打水印
imagettftext($pic, $fontSize, 30, $x, $y, $lightGrey, $fontFile, $mark);

imagejpeg($pic, $resultPath, 100);
imagedestroy($pic);
文字右对齐：
// https://php.golaravel.com/function.imagettfbbox.html
$bbox = imagettfbbox($fontSize, 0, $fontFile, $text);

$offset = $colWidth - $bbox[2] - 50;

imagettftext($pic, $fontSize, 0, $x + $offset, $y, $_color, $fontFile, $text);
遇到的报错
Call to undefined function imagettftext()
出现此问题应该就是 FreeType 没有装好，可参考上面的步骤。
References

php 中文手册 | golaravel
PHP Fatal error: Call to undefined function imagettftext() | stackoverflow

– EOF –



PHP Code Snippet
Wed, 15 Apr 2020 18:03:44 +0000
PHP Sandbox

Online PHP editor | 3v4l.org
PHP Sandbox | onlinephp.io

PHP.net

Supported Versions | PHP.net
Unsupported Branches | PHP.net

References

PHP News, Articles, Upcoming Changes, and more | PHP.Watch
brew tap shivammathur/php
brew tap shivammathur/extensions

PHP CLI
# 查看 PHP 编译时的参数
php -r "phpinfo();" | grep configure

# in source code
./configure --help
./configure --help | grep openssl

# 查看 .ini 配置文件路径
php --ini
php -r "phpinfo();" | grep "Configuration File"

# 查看 Modules
php -m

# 显示 PHP 信息
php -i
php -i | grep -E "Loaded Configuration|Scan this dir"

php -r "echo ini_get('memory_limit');"
php -r "phpinfo();" | grep memory

# 显示扩展配置
php --ri gd

# 检查扩展是否存在
php --re decimal

# 交互式运行模式。具有函数、常量、类名、变量、静态方法调用和类常量的 `tab` 补全功能
# http://php.net/manual/en/features.commandline.interactive.php
php -a

# 检查 PHP-FPM 配置文件语法
php-fpm -tt

# check openssl
php -r "print_r(openssl_get_cert_locations());"
Snippets
// 临时设置最大内存占用
ini_set('memory_limit', '1024M');
// 设置脚本最大执行时间为 0 永不过期
set_time_limit(0);
Composer
aliyun repo
阿里云 Composer 全量镜像
composer config -g repo.packagist composer https://mirrors.aliyun.com/composer/
    "config": {
        "disable-tls": true,
        "gitlab-domains": [],
        "optimize-autoloader": true,
        "preferred-install": {
            "*": "dist"
        }
        "secure-http": false,
        "sort-packages": true,
    },
    "repositories": [
        {
            "type": "cvs",
            "url": "..."
        },
        {
            "type": "composer",
            "url": "https://mirrors.tencent.com/composer/"
        },
        {
            "type": "composer",
            "url": "https://mirrors.aliyun.com/composer/"
        },
        {
            "type": "composer",
            "url": "https://asset-packagist.org"
        }
    ]
忽略 php 版本限制
这个是错误做法，这样会造成库安装的版本错误。不应该使用。
composer require hellogerard/jobby --ignore-platform-reqs
推荐做法：
which composer
# /usr/local/bin/composer

# {正确的 PHP 版本}/bin/php /usr/local/bin/composer require hellogerard/jobby
# 如果内存不够，可以设置为不限制
/usr/local/opt/php@7.1/bin/php -d memory_limit=-1 /usr/local/bin/composer update -vvv

# 若项目之前已通过其他源安装，则需要更新 composer.lock 文件
composer update --lock
PHPStan
class Foo {
   public const WHEELER = [
      'car' => 4,
      'bike' => 2,
   ];
}
/**
 * @param key-of $type
 * @param value-of $wheels
 */
function repair(string $type, int $wheels): void
{
    // $type is 'bike'|'car'
    // $wheels is 2|4
}
repair("bus", 2);
// Parameter #1 $type of function repair expects 'bike'|'car', 'bus' given.
Links

Managing Multiple PHP versions via the ondrej/php PPA
update-alternatives(1) — Linux manual page

– EOF –



【PRCC2019 全套入门教程】笔记
Fri, 13 Mar 2020 22:25:25 +0000

u1s1 本教程质量一般，推荐看看 李兴兴 老师的教程。

用视频记录生活越来越普及，年初旅行也拍了些素材，想着自己也当个 up 主。先来学学 PR。【PR】Premiere Pro CC 2019 全套入门教程 | bilibili 是我在 B 站看的第一套教学视频，坦白说内容不多，有不少重复的东西，但是这样适合完全零基础的同学。

课代表来收我的课后作业：【交作业】PR CC 2019 全套入门教程 课后作业 | 菲菲与帆 。
我的一条 VLOG：【VLOG】#01 新年之旅 成都 第一日 | 菲菲与帆 欢迎来一键三连。
 
01-基础流程
1、窗口乱了后：【窗口-工作区-编辑&重置为保存的布局】alt + shift + 0
2、【文字工具】加字幕
3、修改字体：【窗口-基础图形】选择编辑
4、【剃刀】剪切多余素材
5、本素材图片来自 http://unsample.net/
02-转场效果
1、选择素材点击左键拖拽到【左下窗口】 右下的文件夹可以快速新建文件夹，方便素材分类
2、时序新建时，选择 HDV 720
3、ctrl + d 添加转场效果
4、【左下窗口】（项目窗口）选择【效果】视频过渡，可以切换效果
5、点击时序上的过渡，【左上窗口】选择【效果控件】，可以编辑转场效果的持续时间、对齐等
03&04-视频转场特效&音频特效
1、【左上窗口】选择【效果控件】，可以编辑视频效果、过渡效果
2、视频效果，可以点击秒表的图标添加关键帧
3、新建时查看、修改【暂存盘】位置
4、【编辑-首选项-时间轴】可以修改：静止图片默认持续时间等，
已经导入的素材无效
5、【时序窗口】计时器可以点击编辑，输入 500 会跳到第 5 秒的位置
6、音频过渡，结尾声音淡出
05&06-视频剪辑&音画对应
1、【左上窗口】点击 i 标记入点，点击 o 标记出点
2、【左上窗口】窗口右下角的 + 是按钮编辑器
3、【左上窗口】标记完成后可以点击 插入 或者 覆盖
4、【节目窗口】点击 m 可以标记
5、【节目窗口】窗口右下角的 +，添加转到下一个标记
6、转到下一个标记配合在时序上的标，踩点视频
07&08-简单动画&素材嵌套
1、【左上窗口】效果控件，可以修改素材位置、缩放
2、【左上窗口】效果控件，点击小秒表可以添加关键帧动画
3、导出素材前可以修改静止图片默认持续时间
4、创建多个时序，再创建一个 master 时序，作为主时序
5、时序拖入时序时，注意点击前面的 V1 A1，否则可能只有视频或音频
6、【时序窗口】时序取消链接，可以删除音频轨
7、按 alt 键拖拽可以快速复制
09&10&11-自定义转场&视频效果&变形和扭曲
1、使用 PS 制作灰度图，新建 颜色模式 灰度，图片要和视频尺寸一致
2、在线图片编辑 https://www.uupoop.com/
3、图片使用 tiff 格式，原因不懂
4、视频过渡 擦除 渐变擦除，然后可以选择自己制作的图片
5、从【效果】可以选择后向上拖入【效果控件】
6、fx 可以开启或关闭效果，还有 清除、复制、粘贴
7、【项目窗口】新建 调整图层，可以给视频加一个整体的效果
8、要善于使用标记定位
9、视频效果：变形、扭曲
12-模板的下载和使用
1、.mogrt 模板
2、导入方法 1：【图形】安装动态图形模板
3、导入方法 2：【窗口】基础图形，游览，右下角加号
4、导入方法 3：将模板文件复制到
Mac：username/Library/Application Support/Adobe/Common/motion Graphics Template/
Win：root://Users/Username/AppData/Roaming/Adobe/Common/Motion Graphics Templates
5、【基础图形】编辑，可以修改模板内容
6、按 enter 键，可以渲染视频
13-标准模板的使用
1、.prproj 模板
2、【视图】显示标尺、显示参考线，方便对齐
14&15-倒计数器及色彩调节&传统与图形字幕
1、【项目窗口】新建 通用倒计时片头，就是到 2 就没了
2、【向前选择轨道工具】ctrl + a
3、视频效果 扭曲 球面化
4、视频效果 扭曲 偏移
5、视频效果 杂色与颗粒 杂色
6、【文件】新建 字幕 开放式字幕
– EOF –



回顾 2019
Tue, 31 Dec 2019 23:00:00 +0000
新裤子 · 夏日终曲
2019 年的第一天从三亚开始，在 第一市场海鲜市场 买了海味，然后直接到旁边的 林姐香味海鲜 加工，迟到了超级好吃的香辣蟹。飞回北京就是滑雪团建，年后双双得到了最佳合作奖，感谢我们每周的火锅，让大家多了些感情。
– EOF –
年后买了烤箱烹饪技术再次升级，烤鸡翅、披萨、蛋挞甚至烤鱼，都已不在话下。受 shilei 推荐也喜欢玩德州扑克。看 B 站 UP 主自驾游，疯狂迷恋上了房车一段时间，还去看了一次房山的房车展（够远的），应该会结下不解之缘。
3 月 29 日公司 7 周年，第一次庆祝公司周年，吃蛋糕前大家合了张影。这张照片我挺感动的，说不好具体的原因，可能是因为大家的笑容吧。清明小假在奥森玩了个露营，是真的有点冷。涛爷来北京面试，转头就成了科大博士，给劲儿。
4 月中的一个双休日和爸妈南下，和比比定了亲 🎉🎉🎉。
5 月乐队的夏天，是今年开过最好的综艺，刺猬、新裤子很棒。
2019 年过去了，我很怀念它。


Lonicera Framework
Thu, 19 Dec 2019 16:46:06 +0000
项目代码：imzyf/lonicera | GitHub

【PHP 核心技术与最佳实践】第二版 第 6 章 读书笔记

Lonicera Framework - Every French soldier carries a marshal’s baton in his knapsack.
MVC
MVC 模式的目的是实现一种动态的程序设计，使后续对程序的修改和扩展简化，并且使程序某一部分的重复利用成为可能。
Lonicera 0.1
bootstrap
index.php 单一入口模式。
启动 PHP 内置 Web 服务器：
php -S localhost:7070
路由器层
更偏向于使用 PATH_INFO 方式来访问。
从传统 URL 参数模式的访问地址进行解析，提取里面的 group、controller、action、param 4 个参数，随后交给 bootstrap 进行 dispatch 处理。
数据模型
用 PDO 来实现连接数据库。

ORM Object Relational Mapping 对象与数据库的映射叫作对象关系映射
PO Persistent Object 把一个数据库中的表的一行记录对应的对象称为持久对象
BO Business Object 业务对象 把业务逻辑封装为一个对象
VO Value Object 值对象 界面显示的数据对象
DTO Data Transfer Object 用在热呵呵需要数据传输的地方
DAO Data Access Object 指代 Active Record 模式中的数据对象

传统的 ORM 模式提倡数据对象和负责持久化的代码的分开，但是这并没有坚持数据操作的工作量。还有一种 ORM 模式叫作 Active Record。在 Active Record 中，模型层集成了 ORM 的功能，他们及代表实体，包含因为业务逻辑，又是数据对象，并负责把自己存储到数据库中。
Active Record 模式中的数据对象不再是 PO 对象，而是 DAO。
一系列的数据库操作组合起来，称之为 Service。Service 向下负责与数据库打交道，向上负责接收页面传递的参数以及数据的传输。理论上应该对 DAO 进项抽象到一个 Service 中。
视图层
PHP MVC 中的显示层开始朝着轻量化、API 化发展了。
增强一个类通常途径：

使用 __call __set __get 等魔术方法
使用反射
使用 trait
使用继承和组合

初步改进
spl_autoload_register 统一加载文件。
Lonicera 0.2
引入异常机制
同时设置 set_error_handler 和 set_exception_handler。PHP 同时存在错误和异常两个互不包含的概念。
拦截器与插件
dispatch 中处理。使用正则匹配、call_user_func。
Request 增强与安全防御
包装 $_REQUEST。
Lonicera 0.3
Composer 类加载机制
PSR-4。
Model 增强
illuminata/database。
控制反转与依赖注入
Inversion of Control IoC，Dependency Injection DI。

谁控制谁？IoC 容器控制了对象。
控制什么？主要控制了外部资源获取（不只是对象创建，还包括比如文件等）。

传统应用程序是：由我们自己在对象中主动控制去直接获取依赖对象，而反转则是：由容器来帮忙创建及注入依赖对象。由于是容器帮我们查找及注入依赖对象，对象只是被动接受依赖对象，所以是反转。

哪些方面反转了？依赖对象的获取被反转了。

在我们使用 UserOrder 对象的时候，不再需要手动去创建 User 对象和 Order 对象了，而是直接问 IoC 容器去要 UserOrder 对象，IoC 容器会负责查找 UserOrder 的依赖并替我们创建 User 对象和 Order 对象，并管理它们。也就是说和我们打交道的是 IoC 容器。
依赖注入，是组件之间依赖关系由容器在运行期决定形象来说，即由容器动态地将某个依赖关系注入到组件之中。依赖注入的目的并非是为软件系统带来更多功能，而是为了提高组件重用的效率，并为系统搭建一个灵活、可扩展的平台。
通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

谁依赖于谁？当然是应用程序依赖于 IoC 容器。
为什么需要依赖？应用程序需要 IoC 容器来提供对象需要的外部资源。
谁注入谁？IoC 容器注入应用程序某个对象，应用程序依赖的对象。
注入了什么？注入某个对象所需要的外部资源(包括对象、资源、常量数据)。

IoC 和 DI 是两个相辅相成的概念，IoC 的实现是使用了 DI，而 DI 的目的是为了实现 IoC。实际上，它们是同一个概念的不同角度描述。
为什么要这么做，这么做有什么意义呢？依赖注入帮我们降低了创建对象的成本，使得对象之间松耦合。
composer 通过 composer.json 来管理第三方依赖，从这个角度讲，composer 就是一个 IoC 容器。
PSR-11 Psr\Contanier\ContainerInterface。
DB SQL
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '' COMMENT '名字',
  `age` int(10) unsigned NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

SET FOREIGN_KEY_CHECKS = 1;
– EOF –



Git 提交 message 规范
Tue, 04 Jun 2019 14:07:46 +0000
commit message 应该清晰明了，说明本次提交的目的。基本公式：
(): 

完整公式：
(): 




type
用于说明 commit 的类别，只允许使用下面 7 个标识。

feat：新功能（feature）
fix：修补 bug
docs：文档（documentation）
style：格式（不影响代码运行的变动）
refactor：重构（即不是新增功能，也不是修改 bug 的代码变动）
test：增加测试
chore：构建过程或辅助工具的变动

scope
用于说明 commit 影响的范围，比如数据层、控制层、视图层等等，视项目不同而不同。
subject
是 commit 目的的简短描述，不超过 50 个字符。

以动词开头，使用第一人称现在时，比如 change，而不是 changed 或 changes
第一个字母小写
结尾不加句号 .

cli 工具
commitizen cli
commitizen/cz-cli 使用它提供的 git cz 命令替代我们的 git commit 命令，帮助我们生成符合规范的 commit message。
除此之外，我们还需要为 commitizen 指定一个 Adapter 比如：commitizen/cz-conventional-changelog（一个符合 Angular 团队规范的 preset）使得 commitizen 按照我们指定的规范帮助我们生成 commit message。
全局安装（首选）：
npm install -g commitizen cz-conventional-changelog
echo '{ "path": "cz-conventional-changelog" }' > ~/.czrc
项目级安装（首选）：
npm install -D commitizen cz-conventional-changelog
package.json 中配置：
"script": {
   ...,
   "commit": "git-cz",
},
"config": {
   "commitizen": {
      "path": "node_modules/cz-conventional-changelog"
   }
}
如果全局安装过 commitizen，那么在对应的项目中执行 git cz or npm run commit 都可以。
自定义规范
也许 Angular 的那套规范我们不习惯，那么可以通过指定 Adapter leonardoanalista/cz-customizable 指定一套符合自己团队的规范。
校验 message
可以通过 conventional-changelog/commitlint 校验 commit message。同时可以配合使用 typicode/husky 🐶 Git hooks made easy。
生成 CHANGELOG
conventional-changelog/standard-version 🏆 自动化版本和更新日志生成。
还看到一个有意思的库 📦🚀 semantic-release 待研究。
References

你可能会忽略的 Git 提交规范 - juejin
优雅的提交你的 Git Commit Message - juejin
Commit message 和 Change log 编写指南 - ruanyifeng
AngularJS Git Commit Message Conventions - google docs

– EOF –



最左前缀原理与相关优化
Sat, 25 May 2019 11:05:46 +0000
MySQL 中的索引可以以一定顺序引用多个列，这种索引叫做联合索引，一般的，一个联合索引是一个有序元组 ，其中各个元素均为数据表的一列。另外，单列索引可以看成联合索引元素数为 1 的特例。
我们在 Employees Sample Database 中实验，MySQL 版本 5.7。

以 employees.titles 为例，查看其索引：
SHOW INDEX FROM employees.titles;

+--------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| Table  | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment |
+--------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| titles |          0 | PRIMARY  |            1 | emp_no      | A         |      301292 |     NULL | NULL   |      | BTREE      |         |               |
| titles |          0 | PRIMARY  |            2 | title       | A         |      442605 |     NULL | NULL   |      | BTREE      |         |               |
| titles |          0 | PRIMARY  |            3 | from_date   | A         |      442605 |     NULL | NULL   |      | BTREE      |         |               |
+--------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
全列匹配
EXPLAIN SELECT * FROM employees.titles
WHERE
 emp_no = '10009'
 AND title = 'Senior Engineer'
 AND from_date = '1995-02-18';

+----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------+
| id | select_type | table  | partitions | type  | possible_keys | key     | key_len | ref               | rows | filtered | Extra |
+----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------+
|  1 | SIMPLE      | titles | NULL       | const | PRIMARY       | PRIMARY | 159     | const,const,const |    1 |   100.00 | NULL  |
+----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------+
当按照索引中所有列进行精确匹配（这里精确匹配指 = 或 IN 匹配）时，索引可以被用到。
这里有一点需要注意，理论上索引对顺序是敏感的，但是由于 MySQL 的 查询优化器会自动调整 where 子句的条件顺序 以使用适合的索引，例如我们将 where 中的条件顺序颠倒：
EXPLAIN SELECT * FROM employees.titles
WHERE
 from_date = '1995-02-18'
 AND emp_no IN ( '10009' )
 AND title = 'Senior Engineer';

+----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------+
| id | select_type | table  | partitions | type  | possible_keys | key     | key_len | ref               | rows | filtered | Extra |
+----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------+
|  1 | SIMPLE      | titles | NULL       | const | PRIMARY       | PRIMARY | 159     | const,const,const |    1 |   100.00 | NULL  |
+----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------+
和上面是一样的。
最左前缀匹配
EXPLAIN SELECT * FROM employees.titles
WHERE
 emp_no = '10009';

+----+-------------+--------+------------+------+---------------+---------+---------+-------+------+----------+-------+
| id | select_type | table  | partitions | type | possible_keys | key     | key_len | ref   | rows | filtered | Extra |
+----+-------------+--------+------------+------+---------------+---------+---------+-------+------+----------+-------+
|  1 | SIMPLE      | titles | NULL       | ref  | PRIMARY       | PRIMARY | 4       | const |    3 |   100.00 | NULL  |
+----+-------------+--------+------------+------+---------------+---------+---------+-------+------+----------+-------+
当查询条件精确匹配索引的 左边连续一个或几个列 时，如  或 ，所以可以被用到，但是只能用到一部分，即条件所组成的最左前缀。
上面的查询从分析结果看用到了 PRIMARY 索引，但是 key_len 为 4，说明只用到了索引的第一列前缀。
中间某个条件未提供
查询条件用到了索引中列的精确匹配，但是中间某个条件未提供。
EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10009' AND from_date='1995-02-18';

+----+-------------+--------+------------+------+---------------+---------+---------+-------+------+----------+-------------+
| id | select_type | table  | partitions | type | possible_keys | key     | key_len | ref   | rows | filtered | Extra       |
+----+-------------+--------+------------+------+---------------+---------+---------+-------+------+----------+-------------+
|  1 | SIMPLE      | titles | NULL       | ref  | PRIMARY       | PRIMARY | 4       | const |    1 |    10.00 | Using where |
+----+-------------+--------+------------+------+---------------+---------+---------+-------+------+----------+-------------+
此时索引使用情况和情况二相同，因为 title 未提供，所以查询只用到了索引的第一列，而后面的 from_date 虽然也在索引中，但是由于 title 不存在而无法和左前缀连接，因此需要对结果进行扫描过滤 from_date（这里由于 emp_no 唯一，所以不存在扫描）。
如果想让 from_date 也使用索引而不是 where 过滤，可以增加一个 辅助索引 ，此时上面的查询会使用这个索引。
除此之外，还可以使用一种称之为 隔离列 的优化方法，将 emp_no 与 from_date 之间的 坑 填上。
首先我们看下 title 有几种不同的值：
SELECT DISTINCT(title) FROM employees.titles;
只有 7 种。在这种成为 坑 的列值比较少的情况下，可以考虑用 IN 来填补这个 坑 从而形成最左前缀：
EXPLAIN SELECT * FROM employees.titles
WHERE emp_no='10009'
AND title IN ('Senior Engineer', 'Staff', 'Engineer', 'Senior Staff', 'Assistant Engineer', 'Technique Leader', 'Manager')
AND from_date='1995-02-18';

+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
| id | select_type | table  | partitions | type  | possible_keys | key     | key_len | ref  | rows | filtered | Extra       |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | titles | NULL       | range | PRIMARY       | PRIMARY | 159     | NULL |    7 |   100.00 | Using where |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
这次 key_len 为 159，说明索引被用全了，但是从 type 和 rows 看出 IN 实际上执行了一个 range 查询，这里检查了 7 个 key。看下两种查询的性能比较：
SET profiling = 1;
SELECT * FROM...  -- 1
SELECT * FROM... -- 2
SHOW PROFILES;

| Query_ID | Duration   | Query   |
+----------+------------+---------+
|        1 | 0.00083950 | SELECT * ..|
|        2 | 0.00063700 | SELECT * ..|
“填坑” 后性能提升了一点。如果经过 emp_no 筛选后余下很多数据，则后者性能优势会更加明显。当然，如果 title 的值很多，用填坑就不合适了，必须建立辅助索引。（笔者：多次测试后发现是有快有慢，可能是数据的原因，效果并不明显）
查询条件没有指定索引第一列
EXPLAIN SELECT * FROM employees.titles WHERE from_date='1995-02-18';

+----+-------------+--------+------------+------+---------------+------+---------+------+--------+----------+-------------+
| id | select_type | table  | partitions | type | possible_keys | key  | key_len | ref  | rows   | filtered | Extra       |
+----+-------------+--------+------------+------+---------------+------+---------+------+--------+----------+-------------+
|  1 | SIMPLE      | titles | NULL       | ALL  | NULL          | NULL | NULL    | NULL | 442605 |    10.00 | Using where |
+----+-------------+--------+------------+------+---------------+------+---------+------+--------+----------+-------------+
由于不是最左前缀，索引这样的查询显然用不到索引。
匹配某列的前缀字符串
EXPLAIN SELECT * FROM employees.titles WHERE emp_no=10009 AND title LIKE 'Senior%';

+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
| id | select_type | table  | partitions | type  | possible_keys | key     | key_len | ref  | rows | filtered | Extra       |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | titles | NULL       | range | PRIMARY       | PRIMARY | 156     | NULL |    1 |   100.00 | Using where |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
此时可以用到索引，如果通配符 % 不出现在开头，则可以用到索引，但根据具体情况不同可能只会用其中一个前缀。
范围查询
EXPLAIN SELECT * FROM employees.titles WHERE emp_no < '10010' and title = 'Senior Engineer';

+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
| id | select_type | table  | partitions | type  | possible_keys | key     | key_len | ref  | rows | filtered | Extra       |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | titles | NULL       | range | PRIMARY       | PRIMARY | 4       | NULL |   14 |    10.00 | Using where |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
范围列可以用到索引（必须是最左前缀），但是范围列后面的列无法用到索引。同时，索引最多用于一个范围列，因此如果查询条件中有两个范围列则无法全用到索引。
EXPLAIN SELECT * FROM employees.titles
WHERE emp_no < '10010'
AND title = 'Senior Engineer'
AND from_date BETWEEN '1986-01-01' AND '1986-12-31';

+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
| id | select_type | table  | partitions | type  | possible_keys | key     | key_len | ref  | rows | filtered | Extra       |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | titles | NULL       | range | PRIMARY       | PRIMARY | 4       | NULL |   14 |     1.11 | Using where |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
可以看到索引对第二个范围索引无能为力。这里特别要说明 MySQL 一个有意思的地方，那就是仅用 explain 可能无法区分 范围索引 和 多值匹配，因为在 type 中这两者都显示为 range。
同时，用了 between 并不意味着就是范围查询，例如下面的查询：
EXPLAIN SELECT * FROM employees.titles
WHERE emp_no BETWEEN '10001' AND '10010'
AND title='Senior Engineer'
AND from_date BETWEEN '1986-01-01' AND '1986-12-31';

+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
| id | select_type | table  | partitions | type  | possible_keys | key     | key_len | ref  | rows | filtered | Extra       |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | titles | NULL       | range | PRIMARY       | PRIMARY | 159     | NULL |   15 |     1.11 | Using where |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
看起来是用了两个范围查询，但作用于 emp_no 上的 BETWEEN 实际上相当于 IN，也就是说 emp_no 实际是多值精确匹配。可以看到这个查询用到了索引全部三个列。因此在 MySQL 中要谨慎地区分多值匹配和范围匹配，否则会对 MySQL 的行为产生困惑。
还有个值得注意的事情：
EXPLAIN SELECT * FROM employees.titles where emp_no > 10000 AND emp_no < 10011 AND title='Senior Engineer' AND from_date BETWEEN '1986-01-01' AND '1986-12-31';

+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
| id | select_type | table  | partitions | type  | possible_keys | key     | key_len | ref  | rows | filtered | Extra       |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | titles | NULL       | range | PRIMARY       | PRIMARY | 4       | NULL |   15 |     1.11 | Using where |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+

EXPLAIN SELECT * FROM employees.titles where emp_no >= 10001 and emp_no <= 10010 AND title='Senior Engineer' AND from_date BETWEEN '1986-01-01' AND '1986-12-31';

+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
| id | select_type | table  | partitions | type  | possible_keys | key     | key_len | ref  | rows | filtered | Extra       |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | titles | NULL       | range | PRIMARY       | PRIMARY | 159     | NULL |   15 |     1.11 | Using where |
+----+-------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+

疑问：= 影响 范围索引 还是 多值匹配？

查询条件中含有函数或表达式
很不幸，如果查询条件中含有函数或表达式，则 MySQL 不会为这列使用索引（虽然某些在数学意义上可以使用）。例如：
EXPLAIN SELECT * FROM employees.titles WHERE emp_no='10009' AND left(title, 6)='Senior';

+----+-------------+--------+------------+------+---------------+---------+---------+-------+------+----------+-------------+
| id | select_type | table  | partitions | type | possible_keys | key     | key_len | ref   | rows | filtered | Extra       |
+----+-------------+--------+------------+------+---------------+---------+---------+-------+------+----------+-------------+
|  1 | SIMPLE      | titles | NULL       | ref  | PRIMARY       | PRIMARY | 4       | const |    3 |   100.00 | Using where |
+----+-------------+--------+------------+------+---------------+---------+---------+-------+------+----------+-------------+
虽然这个查询和情况五中功能相同，但是由于使用了函数 left，则无法为 title 列应用索引，而情况五中用 LIKE 则可以。
EXPLAIN SELECT * FROM employees.titles WHERE emp_no - 1 = 10000;

+----+-------------+--------+------------+------+---------------+------+---------+------+--------+----------+-------------+
| id | select_type | table  | partitions | type | possible_keys | key  | key_len | ref  | rows   | filtered | Extra       |
+----+-------------+--------+------------+------+---------------+------+---------+------+--------+----------+-------------+
|  1 | SIMPLE      | titles | NULL       | ALL  | NULL          | NULL | NULL    | NULL | 442605 |   100.00 | Using where |
+----+-------------+--------+------------+------+---------------+------+---------+------+--------+----------+-------------+
显然这个查询等价于查询 emp_no 为 10001 的函数，但是由于查询条件是一个表达式，MySQL 无法为其使用索引。看来 MySQL 还没有智能到自动优化常量表达式的程度，因此在写查询语句时尽量避免表达式出现在查询中，而是先手工私下代数运算，转换为无表达式的查询语句。
References

MySQL 索引背后的数据结构及算法原理
13.7.5.30 SHOW PROFILE Syntax

– EOF –



归并排序
Thu, 23 May 2019 14:44:40 +0000
归并排序（英语：Merge sort，或 mergesort），是创建在归并操作上的一种有效的排序算法，效率为 O(nlogn)。1945 年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。


采用分治法：

分割：递归地把当前序列平均分割成两半。
集成：在保持元素顺序的同时将上一步得到的子序列集成到一起（归并）。

归并操作（merge），也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。
<?php

function mergeSort($arr)
{
    $len = count($arr);
    if ($len <= 1) {
        return $arr;
    } // 递归结束条件, 到达这步的时候, 数组就只剩下一个元素了, 也就是分离了数组

    $mid = $len / 2;
    $left = array_slice($arr, 0, $mid); // 拆分数组0-mid这部分给左边left
    $right = array_slice($arr, $mid); // 拆分数组mid-末尾这部分给右边right
    $left = mergeSort($left); // 左边拆分完后开始递归合并往上走
    $right = mergeSort($right); // 右边拆分完毕开始递归往上走

    $arr = merge($left, $right); // 合并两个数组,继续递归
    return $arr;
}

// merge函数将指定的两个有序数组(arrA, arr)合并并且排序
function merge($arrA, $arrB)
{
    $arrC = array();
    while (count($arrA) && count($arrB)) {
        // 这里不断的判断哪个值小, 就将小的值给到arrC, 但是到最后肯定要剩下几个值,
        // 不是剩下arrA里面的就是剩下arrB里面的而且这几个有序的值, 肯定比arrC里面所有的值都大所以使用
        $arrC[] = $arrA[0] < $arrB[0] ? array_shift($arrA) : array_shift($arrB);
    }

    return array_merge($arrC, $arrA, $arrB);
}

$startTime = microtime(1);

$arr = range(1, 1000);
shuffle($arr);
echo 'before sort: ', implode(', ', $arr), "\n";
$sortArr = mergeSort($arr);
echo 'after sort: ', implode(', ', $sortArr), "\n";

echo 'use time: ', microtime(1) - $startTime, "s\n";
假设被排序的数列中有 N 个数。遍历一趟的时间复杂度是 O(N)，需要遍历多少次呢？


Laravel 中 composer 加载流程
Sun, 28 Apr 2019 19:21:12 +0000
启动

Laravel 5.8

文章以 Laravel 学习。入口文件 public/index.php：
// Register The Auto Loader
require __DIR__.'/../vendor/autoload.php';
autoload.php 不负责具体功能逻辑，只做了两件事：初始化自动加载类、注册自动加载类。
autoload_real.php 中的类名为 ComposerAutoloaderInit... 这可能是为防止与用户自定义类名跟这个类重复冲突，加上了哈希值。
其实还有一个做法我们更加熟悉，是定义一个命名空间。这里为什么不定义一个命名空间呢？一种理解：命名空间一般都是为了复用，而这个类只需要运行一次即可，以后也不会用得到，用哈希值更加合适。

autoload_real.php
autoload.php 主要调用了 getLoader()：
public static function getLoader()
{
    // 单例模式，自动加载类只能有一个 1
    if (null !== self::$loader) {
        return self::$loader;
    }

    // 获得自动加载核心类对象 2
    spl_autoload_register(array('ComposerAutoloaderInit76e88f0b305cd64c7c84b90b278c31db', 'loadClassLoader'), true, true);
    self::$loader = $loader = new \Composer\Autoload\ClassLoader();
    spl_autoload_unregister(array('ComposerAutoloaderInit76e88f0b305cd64c7c84b90b278c31db', 'loadClassLoader'));

    // 初始化自动加载核心类对象 3
    $useStaticLoader = PHP_VERSION_ID >= 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded());
    if ($useStaticLoader) {
        require_once __DIR__ . '/autoload_static.php';

        call_user_func(\Composer\Autoload\ComposerStaticInit76e88f0b305cd64c7c84b90b278c31db::getInitializer($loader));
    } else {
        $map = require __DIR__ . '/autoload_namespaces.php';
        foreach ($map as $namespace => $path) {
            $loader->set($namespace, $path);
        }

        $map = require __DIR__ . '/autoload_psr4.php';
        foreach ($map as $namespace => $path) {
            $loader->setPsr4($namespace, $path);
        }

        $classMap = require __DIR__ . '/autoload_classmap.php';
        if ($classMap) {
            $loader->addClassMap($classMap);
        }
    }

    // 注册自动加载核心类对象 4
    $loader->register(true);

    // 自动加载全局函数 5
    if ($useStaticLoader) {
        $includeFiles = Composer\Autoload\ComposerStaticInit76e88f0b305cd64c7c84b90b278c31db::$files;
    } else {
        $includeFiles = require __DIR__ . '/autoload_files.php';
    }
    foreach ($includeFiles as $fileIdentifier => $file) {
        composerRequire76e88f0b305cd64c7c84b90b278c31db($fileIdentifier, $file);
    }

    return $loader;
}
单例模式 1
if (null !== self::$loader) {
    return self::$loader;
}
构造 ClassLoader 核心类 2
spl_autoload_register(array('ComposerAutoloaderInit76e88f0b305cd64c7c84b90b278c31db', 'loadClassLoader'), true, true);
self::$loader = $loader = new \Composer\Autoload\ClassLoader();
spl_autoload_unregister(array('ComposerAutoloaderInit76e88f0b305cd64c7c84b90b278c31db', 'loadClassLoader'));
public static function loadClassLoader($class)
{
    if ('Composer\Autoload\ClassLoader' === $class) {
        require __DIR__ . '/ClassLoader.php';
    }
}
composer 先向 PHP 自动加载机制注册了一个函数，这个函数 require 了 ClassLoader 文件。成功 new 出该文件中核心类 ClassLoader() 后，又销毁了该函数。
为什么不直接 require？原因是：怕有的用户也定义了个 \Composer\Autoload\ClassLoader 命名空间，导致自动加载错误文件。
那为什么不跟引导类一样用个哈希值呢？原因是：这个类是可以复用的，框架允许用户使用这个类。
初始化核心类对象 3
对自动加载类的初始化，主要是给自动加载核心类初始化顶级命名空间映射。初始化的方法有两种：

使用 autoload_static 进行静态初始化
调用核心类接口初始化

autoload_static 静态初始化
静态初始化只支持 PHP 5.6 以上版本、不支持 HHVM 虚拟机、不存在 Zend-encoded file。
autoload_static.php
php

// autoload_static.php @generated by Composer

namespace Composer\Autoload;

// hash 防止冲突
class ComposerStaticInit76e88f0b305cd64c7c84b90b278c31db
{
    public static $files = array (...);
    public static $prefixLengthsPsr4 = array (...);
    public static $prefixDirsPsr4 = array (...);
    public static $fallbackDirsPsr4 = array (...);
    public static $prefixesPsr0 = array (...);
    public static $classMap = array array (...);

    public static function getInitializer(ClassLoader $loader)
    {
        return \Closure::bind(function () use ($loader) {
            $loader->prefixLengthsPsr4 = ComposerStaticInit76e88f0b305cd64c7c84b90b278c31db::$prefixLengthsPsr4;
            $loader->prefixDirsPsr4 = ComposerStaticInit76e88f0b305cd64c7c84b90b278c31db::$prefixDirsPsr4;
            $loader->fallbackDirsPsr4 = ComposerStaticInit76e88f0b305cd64c7c84b90b278c31db::$fallbackDirsPsr4;
            $loader->prefixesPsr0 = ComposerStaticInit76e88f0b305cd64c7c84b90b278c31db::$prefixesPsr0;
            $loader->classMap = ComposerStaticInit76e88f0b305cd64c7c84b90b278c31db::$classMap;

        }, null, ClassLoader::class);
    }
}
这个静态初始化类的核心就是 getInitializer() 函数，它将自己类中的顶级命名空间映射给了 ClassLoader 类。
值得注意的是这个函数返回的是一个匿名函数，为什么呢？原因就是 ClassLoader 中的 prefixLengthsPsr4 、prefixDirsPsr4 等等方法都是 private 的。普通的函数没办法给类的 private 成员变量赋值。利用匿名函数的绑定功能就可以将把匿名函数转为 ClassLoader 类的成员函数。
关于匿名函数的 绑定功能。
接下来就是 顶级命名空间 初始化的关键了。
classMap
public static $classMap = array (
    'App\\Api\\Middleware\\DeviceRecord' => __DIR__ . '/../..' . '/app/Api/Middleware/DeviceRecord.php',
    'App\\Api\\Middleware\\HeaderCheck' => __DIR__ . '/../..' . '/app/Api/Middleware/HeaderCheck.php',
    ...
)
直接命名空间全名与目录的映射，没有顶级命名空间。简单粗暴，也导致这个数组相当的大。
PSR0 顶级命名空间映射
public static $prefixesPsr0 = array (
    'P' =>
    array (
        'Prophecy\\' =>
        array (
            0 => __DIR__ . '/..' . '/phpspec/prophecy/src',
        ),
        'Parsedown' =>
        array (
            0 => __DIR__ . '/..' . '/erusev/parsedown',
        ),
    ),
    ...
);
为了快速找到顶级命名空间，这里使用命名空间第一个字母作为前缀索引。这个映射的用法比较明显，假如我们有 Parsedown/example 这样的命名空间，首先通过首字母 P，找到：
'P' => array (...)
这个数组，然后就会遍历这个数组来和 Parsedown/example 比较，发现第一个 Prophecy 不符合，第二个 Parsedown 符合，然后得到了映射目录（映射目录可能不止一个）：
0 => __DIR__ . '/..' . '/erusev/parsedown',
接着遍历这个数组，尝试 __DIR__ . '/..' . '/erusev/parsedown/Parsedown/example.php' 是否存在，如果不存在接着遍历数组（这个例子数组只有一个元素），如果数组遍历完都没有，就会加载失败。
PSR4 标准顶级命名空间映射
public static $prefixLengthsPsr4 = array (
    'p' =>
    array (
        'phpDocumentor\\Reflection\\' => 25,
    ),
    'Z' =>
    array (
        'Zend\\Diactoros\\' => 15,
    ),
    ...
);

public static $prefixDirsPsr4 = array (
    'phpDocumentor\\Reflection\\' =>
    array (
        0 => __DIR__ . '/..' . '/phpdocumentor/reflection-common/src',
        1 => __DIR__ . '/..' . '/phpdocumentor/reflection-docblock/src',
        2 => __DIR__ . '/..' . '/phpdocumentor/type-resolver/src',
    ),
    'Zend\\Diactoros\\' =>
    array (
        0 => __DIR__ . '/..' . '/zendframework/zend-diactoros/src',
    ),
    ...
);
PSR4 标准 顶级命名空间 映射用了两个数组，第一个和 PSR0 一样用命名空间第一个字母作为前缀索引，然后是 顶级命名空间，但是最终并不是文件路径，而是 顶级命名空间 的长度。为什么呢？因为 PSR4 的文件目录更加灵活，更加简洁。
PSR0 中 顶级命名空间 目录 直接加 到命名空间前面就可以得到路径：
                                        ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
Parsedown/example => __DIR__ . '/..' . '/erusev/parsedown/Parsedown/example.php
                                                         ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
而 PSR4 却是用顶级命名空间目录 替换 顶级命名空间，所以获得顶级命名空间的 长度 很重要：
                                        ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
Parsedown/example => __DIR__ . '/..' . '/erusev/parsedown/example.php
                                                ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
举例：假如我们找 Symfony\\Polyfill\\Mbstring\\example 这个类，和 PSR0 一样通过前缀索引和字符串匹配我们得到了:
'Symfony\\Polyfill\\Mbstring\\' => 26,
这条记录，键是顶级命名空间，值是命名空间的长度。拿到顶级命名空间后去 $prefixDirsPsr4 获取它的映射目录数组（注意映射目录可能不止一条）：
'Symfony\\Polyfill\\Mbstring\\' =>
array (
    0 => __DIR__ . '/..' . '/symfony/polyfill-mbstring',
),
将 Symfony\\Polyfill\\Mbstring\\example 前 26 个字母替换为 __DIR__ . '/..' . '/symfony/polyfill-mbstring 也就是：
__DIR__ . '/..' . '/symfony/polyfill-mbstring/example.php
先验证磁盘上这个文件是否存在，如果不存在接着遍历。如果遍历后没有找到，则加载失败。
自动加载核心类 ClassLoader 的静态初始化完成！

其实还有 $fallbackDirsPsr4，暂未研究

调用接口初始化
如果 PHP 版本低于 5.6 或者使用 HHVM 虚拟机环境或者存在 zend_loader_file_encoded，那么就要使用核心类的接口进行初始化。

/*
PSR0 取出命名空间的第一个字母作为索引，一个索引对应多个顶级命名空间，一个顶级命名空间对应多个目录路径，具体形式可以查看上面的 autoload_static 的 $prefixesPsr0。

如果没有顶级命名空间，就只存储一个路径名，以便在后面尝试加载。
*/
$map = require __DIR__ . '/autoload_namespaces.php';
foreach ($map as $namespace => $path) {
    $loader->set($namespace, $path);
}

/*
PSR4 如果没有顶级命名空间，就直接保存目录。
如果有命名空间的话，要保证顶级命名空间最后是 \，然后分别保存
( 前缀 -> 顶级命名空间，顶级命名空间 -> 顶级命名空间长度 )
( 顶级命名空间 -> 目录 )

这两个映射数组。具体形式可以查看上面我们讲的 autoload_static 的 prefixLengthsPsr4、$prefixDirsPsr4 。
*/
$map = require __DIR__ . '/autoload_psr4.php';
foreach ($map as $namespace => $path) {
    $loader->setPsr4($namespace, $path);
}

/*
整个命名空间与目录之间的映射
*/
$classMap = require __DIR__ . '/autoload_classmap.php';
if ($classMap) {
    $loader->addClassMap($classMap);
}
注册核心类对象 4
Composer 自动加载功能的启动与初始化，经过启动与初始化，自动加载核心类对象已经获得了顶级命名空间与相应目录的映射，换句话说，如果有命名空间 App\Console\Kernel，我们已经知道了 App\ 对应的目录，接下来我们就要解决下面的就是 \Console\Kernel 这一段。
/**
 * Registers this instance as an autoloader.
 *
 * @param bool $prepend Whether to prepend the autoloader or not
*/
public function register($prepend = false)
{
    spl_autoload_register(array($this, 'loadClass'), true, $prepend);
}
一行代码实现自动加载。核心在 ClassLoader 的 loadClass() 函数上，这个函数负责按照 PSR 标准将顶层命名空间以下的内容转为对应的目录，也就是上面所说的将 App\Console\Kernel 中 Console\Kernel 这一段转为目录。
自动加载全局函数 5
Composer 不止可以自动加载命名空间，还可以加载全局函数。就是把全局函数写到特定的文件里面去，在程序运行前挨个 require 就行了。
if ($useStaticLoader) {
    // 静态初始化
    $includeFiles = Composer\Autoload\ComposerStaticInit76e88f0b305cd64c7c84b90b278c31db::$files;
} else {
    // 普通初始化
    $includeFiles = require __DIR__ . '/autoload_files.php';
}
foreach ($includeFiles as $fileIdentifier => $file) {
    composerRequire76e88f0b305cd64c7c84b90b278c31db($fileIdentifier, $file);
}
function composerRequire76e88f0b305cd64c7c84b90b278c31db($fileIdentifier, $file)
{
    if (empty($GLOBALS['__composer_autoload_files'][$fileIdentifier])) {
        require $file;

        $GLOBALS['__composer_autoload_files'][$fileIdentifier] = true;
    }
}
问题 1
为什么不直接 require $includeFiles 里面的每个文件名，而要用类外面的函数 composerRequire... ？

避免和用户定义函数冲突
防止有人在全局函数所在的文件写 $this 或者 self

假如 $includeFiles 有个 app/helper.php 文件，这个 helper.php 文件的函数外有一行代码： $this->foo()，如果引导类在 getLoader() 函数直接 require($file)，那么引导类就会运行这句代码，调用自己的 foo() 函数，这显然是错的。
事实上 helper.php 就不应该出现 $this 或 self 这样的代码，这样写一般都是用户写错了的，一旦这样的事情发生：

第一种情况：引导类恰好有 foo() 函数，那么就会莫名其妙执行了引导类的 foo()。
第二种情况：引导类没有 foo() 函数，但是却甩出来引导类没有 foo() 方法这样的错误提示，用户不知道自己哪里错了。把 require 语句放到 引导类的外面，遇到 $this 或者 self ，程序就会告诉用户根本没有类， $this 或 self 无效，错误信息更加明朗。

问题 2
为什么要用 hash 作为 $fileIdentifier？
这个变量是用来控制全局函数只被 require 一次的，那为什么不用 require_once 呢？事实上 require_once 比 require 效率低很多，使用全局变量 $GLOBALS 这样控制加载会更快。猜测另一个原因应该是 require_once 对相对路径的支持并不理想，所以 composer 尽量少用 require_once。
运行
ClassLoader 将 loadClass() 函数注册到 PHP SPL 中的 spl_autoload_register() 里面去。这样，每当 PHP 遇到一个不认识的命名空间的时候，PHP 会自动调用注册到 spl_autoload_register() 里面的函数堆栈，运行其中的每个函数，直到找到命名空间对应的文件。
/**
 * Loads the given class or interface.
 *
 * @param  string    $class The name of the class
    * @return bool|null True if loaded, null otherwise
    */
public function loadClass($class)
{
    if ($file = $this->findFile($class)) {
        includeFile($file); // include $file; Prevents access to $this/self from included files.

        return true;
    }
}

/**
 * Finds the path to the file where the class is defined.
 *
 * @param string $class The name of the class
    *
    * @return string|false The path if found, false otherwise
    */
public function findFile($class)
{
    // class map lookup
    if (isset($this->classMap[$class])) {
        return $this->classMap[$class];
    }

    // classMapAuthoritative 关闭搜索未在类映射中注册的类的 prefix and fallback directories。- 不清楚干啥的 暂没研究
    if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
        return false;
    }

    // 如果启用扩展名，则使用 APCu 前缀来缓存已找到/未找到的类。 - 不清楚干啥的 暂没研究
    if (null !== $this->apcuPrefix) {
        $file = apcu_fetch($this->apcuPrefix.$class, $hit);
        if ($hit) {
            return $file;
        }
    }

    $file = $this->findFileWithExtension($class, '.php');

    // Search for Hack files if we are running on HHVM
    if (false === $file && defined('HHVM_VERSION')) {
        $file = $this->findFileWithExtension($class, '.hh');
    }

    if (null !== $this->apcuPrefix) {
        apcu_add($this->apcuPrefix.$class, $file);
    }

    if (false === $file) {
        // Remember that this class does not exist.
        $this->missingClasses[$class] = true;
    }

    return $file;
}
loadClass() 主要调用 findFile() 函数。findFile() 在解析命名空间的时候主要分为两部分：

classMap 直接看命名空间是否在映射数组
findFileWithExtension() 包含了 PSR0、PSR4

如果我们在代码中写 'phpDocumentor\Reflection\example，PHP 会通过 SPL 调用 loadClass -> findFile -> findFileWithExtension。

首先默认用 .php 后缀名调用 findFileWithExtension 函数里，利用 PSR4 标准尝试解析目录文件，如果文件不存在则继续用 PSR0 标准解析
如果解析出来的目录文件仍然不存在，但是环境是 HHVM 虚拟机，继续用后缀名 .hh 再次调用 findFileWithExtension 函数，如果不存在，说明此命名空间无法加载，放到 classMap 中设为 false，以便以后更快地加载

PSR4
对于 phpDocumentor\Reflection\example，当尝试利用 PSR4 标准映射目录时，步骤如下：
// $class: phpDocumentor\Reflection\example

// PSR-4 lookup
$logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
// $logicalPathPsr4: phpDocumentor/Reflection/example.php(hh)`

$first = $class[0];
// $first: p

if (isset($this->prefixLengthsPsr4[$first])) {
    /* 'p' =>
    array (
        'phpDocumentor\\Reflection\\' => 25,
    ),
    */
    $subPath = $class;
    // $subPath: phpDocumentor\Reflection\example
    while (false !== $lastPos = strrpos($subPath, '\\')) {
        // $lastPos 13
        $subPath = substr($subPath, 0, $lastPos);
        $search = $subPath.'\\';
        if (isset($this->prefixDirsPsr4[$search])) {
            // search phpDocumentor\\Reflection\\
            // $lastPos 25

            /* 'phpDocumentor\\Reflection\\' =>
                array (
                    0 => __DIR__ . '/..' . '/phpdocumentor/reflection-common/src',
                    1 => __DIR__ . '/..' . '/phpdocumentor/reflection-docblock/src',
                    2 => __DIR__ . '/..' . '/phpdocumentor/type-resolver/src',
                ),
            */
            $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
            // $pathEnd /example.php(hh)

            foreach ($this->prefixDirsPsr4[$search] as $dir) {
                // 遍历 3 个
                if (file_exists($file = $dir . $pathEnd)) {
                    // $file __DIR__ . '/..' . /phpdocumentor/type-resolver/src/example.php(hh)`
                    return $file;
                }
            }
        }
    }
}
PSR0
如果 PSR4 标准加载失败，则要进行 PSR0 标准加载。对于 phpDocumentor\Reflection\example，当尝试利用 PSR0 标准映射目录时，步骤如下：
// $class: phpDocumentor\Reflection\example

// PSR-0 lookup
if (false !== $pos = strrpos($class, '\\')) {
    // namespaced class name
    $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
        . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
} else {
    // PEAR-like class name
    $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
}

// $logicalPathPsr0: phpDocumentor/Reflection/example.php(hh)`
if (isset($this->prefixesPsr0[$first])) {
    foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
        /* 'P' =>
        array (
            'Prophecy\\' =>
            array (
                0 => __DIR__ . '/..' . '/phpspec/prophecy/src',
            ),
            'Parsedown' =>
            array (
                0 => __DIR__ . '/..' . '/erusev/parsedown',
            ),
        ), */
        if (0 === strpos($class, $prefix)) {
            foreach ($dirs as $dir) {
                if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
                    // $file __DIR__ . '/..' . '/phpspec/prophecy/src' . phpDocumentor/Reflection/example.php(hh)
                    return $file;
                }
            }
        }
    }
}
Q&A
个人一些疑问：
防止用户自定义与 ClassLoader 命名空间冲突
spl_autoload_register(array('ComposerAutoloaderInit76e88f0b305cd64c7c84b90b278c31db', 'loadClassLoader'), true, true);
self::$loader = $loader = new \Composer\Autoload\ClassLoader();
spl_autoload_unregister(array('ComposerAutoloaderInit76e88f0b305cd64c7c84b90b278c31db', 'loadClassLoader'));
为什么这样可以解决：与用户也定义了个 \Composer\Autoload\ClassLoader 命名空间，导致自动加载错误文件。
与第四个参数 $prepend true 有关吗？
composer StaticLoader 有什么优势
composer 在加载类和加载全局方法时，都有两种方式。
$useStaticLoader = PHP_VERSION_ID >= 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded());
以 $useStaticLoader 的值进行选择，为什么一定分两种，静态方法是有什么优势吗？
References

PHP Composer - 初始化源码分析

– EOF –



寻找数组中轴索引
Wed, 06 Mar 2019 14:00:00 +0000
将 pivot 索引定义为：左边的数字之和等于索引右边的数字之和。
Input:
nums = [1, 7, 3, 6, 5, 6]
Output: 3
Explanation:
1 + 7 + 3 = 5 + 6

Input:
nums = [1, 2, 3]
Output: -1
Explanation:
There is no index that satisfies the conditions in the problem statement.

Note:

The length of nums will be in the range [0, 10000].
Each element nums[i] will be an integer in the range [-1000, 1000].

关键点

动态规划
数组的和 - 中轴数 = 中轴数左边数组的和 * 2

解答
func findPivot(_ array: [Int]) -> Int {
    // 数组和
    let sum = array.reduce(0, +)
    // 左侧数组和
    var leftSum = 0
    for (key, value) in array.enumerated() {
        if sum - value == leftSum * 2 {
            return key
        }
        leftSum += value
    }
    return -1
}

let array = [1, 7, 3, 6, 5, 6]
search(array) // 3
References

找到数组中左右两边的和相等的 pivot 的下标 Find Pivot Index

– EOF –


m 进制转 n 进制
Sat, 02 Mar 2019 14:00:00 +0000
思路

m 进制 -> 十进制 -> n 进制
利用柯里化生成函数（炫技 🐶）


m 进制 -> 十进制
// carry 范围值: 2-36
// origin 范围值: 0-9 [ascii 48-58], A-Z [65-90], a-z [97-122]
func carryToDecimalism(_ carry: Int) -> (_ origin: String) -> Int {
    return { origin in
        // 得到字符串对应的 ascii 码
        let asciis = origin.uppercased().unicodeScalars.map { Int($0.value) }
        // 累加每一位
        let result = asciis.reversed().enumerated().map { (index, ascii) -> Int in
            var standard: Int
            if 65 <= ascii && ascii <= 90 {
                standard = ascii - 65 + 10
            } else {
                standard = ascii - 48
            }
            return standard * Int(pow(Double(carry), Double(index)))
        }.reduce(0, +)
        return result
    }
}

let 十六进制转十进制 = carryToDecimalism(16)
print(十六进制转十进制("1a")) // 26

let 二进制转十进制 = carryToDecimalism(2)
print(二进制转十进制("110")) // 6
十进制 -> n 进制
func decimalismToCarry(_ carry: Int) -> (_ origin: Int) -> String {
    return { origin in
        var result = [Int]()
        var remain = origin
        while remain > 0 {
            result.append(remain % carry)
            remain /= carry
        }
        if carry <= 10 {
            return result.reversed().map(String.init).joined()
        } else {
            return result.reversed().map { i -> String in
                return i < 10 ? String(i) : String(UnicodeScalar(i + 55)!)
            }.joined()
        }
    }
}

let 十进制转二进制 = decimalismToCarry(2)
print(十进制转二进制(26)) // "11010"
References

ASCII 码对照表

– EOF –


超长阶乘的计算
Fri, 01 Mar 2019 14:00:00 +0000
打印 n! 的结果（1 <= n <= 100）。注意：当 n > 20 时 64 位的 Int 将无法直接存储结果。
思路

将大数字用 数组 形式表示。比如 987 使用 [9,8,7] 代替。
每一位乘以 n，再进行进位操作，得到新数组。

let nums = [9, 8, 7]
let tmpNums = nums.map { $0 * 2 } // [18, 16, 14]

// 遍历 tmpNums 每一个数字，进行进制操作

[18, 16, 14] -> [18, 17, 4] -> [19, 7, 4] -> [1, 9, 7, 4]

print(tmpNums.map(String.init).joined()) // 1974
解答项目
func extraLongFactorials(n: Int) -> Void {
    guard n > 0 else {
        return
    }
    // 结果数组
    var result: [Int] = [1]
    for index in 1...n {
        // 数组翻转 从低位开始每一位乘以本次的数字
        let tmpNums = result.reversed().map { $0 * index }
        // 进位数
        var carryNum = 0
        // 重置结果
        result = []
        tmpNums.forEach {
            // 每一位加上上一位的进的数
            let tmpNum = $0 + carryNum
            // 向下一位进制的数
            carryNum = tmpNum / 10
            // 本位实际剩下的数 插入结果
            result.append(tmpNum % 10)
        }
        // 处理剩余进位数 进位数是可能大于 100
        while carryNum > 0 {
            // 逐渐插入进制
            result.append(carryNum % 10)
            carryNum /= 10
        }
        // 翻转回数组
        result = result.reversed()
    }
    // 连接字符串
    print(result.map(String.init).joined())
}
References

Extra Long Factorials | HackerRank
Swift 3 calculate factorial number. Result becomes too high?

– EOF –


【Swifter - Swift 开发者必备 Tips】笔记
Fri, 15 Feb 2019 17:00:00 +0000
再读王巍的《Swifter - Swift 开发者必备 Tips》，看看有什么新收获。
柯里化（Currying）
柯里化是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。这个词自己是第一次见到。
自己的理解是：把接受多个参数的函数变换为先接受一个参数，然后返回一个函数，这个函数再接受其他参数。
两个细节：

只有一个参数，并且这个参数是该函数的第一个参数。必须按照参数的定义顺序来调用柯里化函数。
柯里化函数的函数体只会执行一次，只会在调用完最后一个参数的时候执行柯里化函数体。


/// 一个数加 x 的函数
func addTo(_ adder: Int) -> (Int) -> Int {
    return { adder + $0 }
}
// +2
let addTwo = addTo(2)
let result = addTwo(6) // 8

// +10
let addTen = addTo(10)
addTen(6) // 16
柯里化是一种量产相似方法的好办法，可以通过柯里化一个方法模板来避免写出很多重复代码，也方便了今后维护。
书中还提到了一个封装 Selector 的例子，但是没懂，欢迎指教。
Reference:

Swift 函数柯里化介绍及使用场景

将 protocol 的方法声明为 mutating
protocol 不仅可以被 class 类型实现，也适用于 struct 和 enum。因为这个原因，就要考虑定义的方法是否应该使用 mutating 来修饰。在 protocol 中使用 mutating 修饰的方法，对于 class 的实现是完全透明的。
多元组（Tuple）
Python 中有见过类似用法。
/// 交互数据
func swapMe<T>(_ a: inout T, _ b: inout T) {
    (a, b) = (b, a)
}

var a = 10
var b = 20
swapMe(&a, &b) // a: 20  b: 10
/// 可读的返回值
let rect = CGRect(x: 0, y: 0, width: 100, height: 100)
let (slice, remainder) = rect.divided(atDistance: 20, from: .minYEdge)

// slice {x 0 y 0 w 100 h 20}
// remainder {x 0 y 20 w 100 h 80}
@autoclosure 和 ??
@autoclosure 做的事情就是把一句表达式自动的封装成一个闭包（closure）。这样有时候在语法上看起来就会非常漂亮。
func logIfTrue(_ predicate: @autoclosure () -> Bool) {
    if predicate() {
        print("True")
    }
}

logIfTrue(2 > 1)
// 而不是 logIfTrue { 2 > 1 }
Swift 把 2 > 1 这个表达式自动转换为 () -> Bool。
Swift 中 ?? 定义为：
func ??<T>(optional: T?, defaultValue: @autoclosure () -> T?) -> T?

func ??<T>(optional: T?, defaultValue: @autoclosure () -> T) -> T
/// 猜测 ?? 的实现
func ??<T>(optional: T?, defaultValue: @autoclosure() -> T) -> T {
    switch optional {
    case .some(let value):
        return value
    default:
        return defaultValue()
    }
}
使用 @autoclosure 来修饰默认值看起来有些画蛇添足，但是如果默认值是通过一系列复杂计算得到话，在 optional 不为 nil 的情况下就会造成浪费。@autoclosure 将计算推迟到 optional 为 nil。
@escaping
func doWork(block: () -> Void) {
    block()
}

doWork {
    print("work")
}
这里默认了一个隐藏假设：参数中 block 的内容会在 doWork 返回之前就完成了，也就是说，对于 block 的调用是同步行为。
func doWorkAsync(block: @escaping () -> ()) {
    DispatchQueue.main.async {
        block()
    }
}
@escaping 表明这个闭包是会 逃逸 出该方法。
class S {
    var foo = "foo"

    func method1() {
        doWork {
            print(foo)
        }
        foo = "method1"
    }
    func method2() {
        doWorkAsync {
            print(self.foo)
        }
        foo = "method2"
    }
    func method3() {
        foo = "method4"
        doWorkAsync { [weak self] in
            print(self?.foo ?? "nil")
        }
        foo = "method3"
    }
}

S().method1()  // foo - 同步
S().method2()  // method2 - 由于强引用
S().method3()  // nil - 已经释放
Optional Chaining
let playClosure = { (child: Child) -> Void in
    child.pet?.toy?.play()
}
这里 Void 是不合理的，因为真正的结果是一个 Optional 的结果，所以应该为 Void?。
let playClosure = { (child: Child) -> Void? in
    child.pet?.toy?.play()
}

// 判断方法是否调用成功：
if let result = playClosure {
    print("happy")
} else {
    print("can't play")
}



回顾 2018
Mon, 31 Dec 2018 21:00:00 +0000

重新翻阅的自己工作邮件的发件箱，回顾一年工作。新年伊始自己还是在开发 P 项目的 iOS App，开始写 Q&A 功能。一些不算太难的 tableView 布局的需求，对我来说，都是头大的问题。
这段时期招聘时的面试，竟成为我学习 App 开发的一扇小窗。
年前收到了奖金还是挺开心的。leader 新年寄语：

要发声，要当主力
当有好的想法时，要学会说服别人
要有耐心，Yifan 需要时间的沉淀

前两点意思差不多，这段时间思想上困扰我的是：自己对自己的定位是一个初级工程师，认为会的东西、经验不多，见识少，我尊重比我年长的工程师的想法与观点，也相信他们是经过长远思考过的。这个思维设定，我觉得没有什么问题。但是也许有人忽略了 责任，对方案负责，对项目负责。开发方案一再重建性修改，接口结构没有规范。
2017 的总结说胜利属于伏地魔，本想苟着发育，这时发现：苟是苟不住的，这个世界 需要英雄 carry。
后来我感觉应该将公司看做一个舞台，舞台上有灯光、音效就要利用，展示自己、锻炼自己，即使是出糗，那就整理整理再来一次，who care? 成长是最重要的。
Course 模块是前工程师用 Objective-C 写的，离职后一直没有再维护，过年期间自己重构了所有 Objective-C 的代码，项目完全转为了一个纯 Swift 项目。使用 Realm 作为数据本地化方案，选择的原因也很朴素，GitHub 哪个星多我就优先选用什么。
后来参考 Jack Feng - 6ag 的几个 Swift 开源项目，新创建了 P 项目的工具 App，也对主项目结构做了重新的整理，在这里再次特别感谢。
西安运营部的成立，加多了 C 项目的后台需求，难以都顾及项目两头。使用 laravel-admin 搭建新后台，也开始使用 Docker 部署项目，感觉从此离不开 Docker 了，像极了遇到 Git 时的感觉。
C 项目主站的前端是在服务端渲染，非常传统的模式，多个工程师转手也是十分混乱。参考了 白俊遥 工程的博客、laravel 项目，修改了项目结构，添加了 gulp 工具制定了工作流，虽然没有实现前后端的完全分离，但终究是向现代化前端走出了一步。
转眼就到了年中调薪，公司不含糊，薪水涨到了我满意的值。这对我很关键，调整的不单单是我的薪水，也调整了我的心态。因为当时我认为没有强的工程师、甚至归我负责，却拿着比我还高的薪水。现在总算是有了一个平衡。
不断向 C 项目投入更多的资源，项目 指标 的要求越来越多。比如：优化了项目、优化了查询，到底优化了多少，怎么量化？这些在之前一直不被重视，改好了就都算叫优化了。项目中出现的问题错误，都要查找真实具体的原因，而不是说一个可能的什么原因，就当解答的了。我一开始也很难适应这些，但心里是认同的。
C 项目数据源重新整理，终于摸到了一次算法的边。“你觉的算法没用，是因为你不会。” 数据标记、正确率、召回率、特征词提取、文本相似度、词条打分、背包算法…… 一段最让人回忆的开发经历，与业务开发完全不同的模式。
C 项目衍生出新项目 G，我一个人做，一次实践 Laravel 框架的机会。
再次和 Z 哥合作了一个 App 项目，私活做的真是的太累了，极不推荐。其实这段时期工作上并没有在做 iOS，因为这个项目没让自己 iOS 的技能凉下来，为后面回归 iOS 项目保持了状态。
参加了年度的 Swift 大会，在群里简单了很多大佬、看过博客的工程师，没想到他们都很乐意加微信。也发现他们相互都认识，这就是圈子吧。
2018 是世界杯年，我不懂球就是看个热闹，最开心的是公司有活动基金，我拉着不少新同事们吃喝了不少。冬季后发展成了和同事的每周的火锅，真挺快乐的。
买了心心念的 Switch 叫的闪送，上午下单一会后，就像收外卖一样收了机子。荒野之息是好玩，呃… 男主竟然叫林克不是塞尔达，你敢想？
因为 MSI 的胜利开始关注 RNG LPL。这年 LPL 后面的比赛我基本都看了，中午还会看 dys 的直播实况。洲际赛 RW 救世主真是精彩，“当没人相信你的时候，你自己相信了自己，并且赢得了胜利，这便是成为英雄的道路。” 登峰造極 2018 我们是冠军。
永利*暴雷崩盘，损失不少，派出所报案。家里，多年的期房要发钥匙了，感恩父母。一次团建向比比求婚成功。
这年最后一天是在三亚，吃到了棒棒的早晨，去了蜈支洲岛，感受了乘风破浪，遇到了一个有趣的东北司机，参加了酒店的晚会，看了喝酒赢到的电影。
2018 Happy Ending.

做了一个梦 我们 iG 拿冠军了 啊哈哈哈…
我说是不是假的 确实是个梦吧，
但是就是当时虽然在做 但是特别开心。
所以我们尽量就是自己努力一下，
然后每个人发挥好一点的话，
我觉得真的有可能 也可以拿冠军的。

– EOF –



二分查找 Binary Search
Mon, 10 Dec 2018 14:00:00 +0000
快速从一个数组中查找一个元素。
Linear Search 线性查找
func linearSearch<T: Equatable>(_ a: [T], _ key: T) -> Int? {
    for i in 0 ..< a.count {
        if a[i] == key {
            return i
        }
    }
    return nil
}
线性查找在最坏情况：遍历了整个数组，但没有找到合适的元素。平均要遍历一半的元素性能为 O(n)，而二分查找的效率为 O(log n)，也就是说一个有 1,000,000 元素的数组只需要 20 步就可以找到想要的元素 log_2(1,000,000) = 19.9。
但是二分查找要求数组必须是排好序。
二分查找步骤：

将数组分为两半。
判断想要找的元素是在左边数组还是右边，这也是数组需要排好顺序的原因。
如果要的元素在左边，就将左边的数组分成更小的两部分，并判断要的元素在哪部分。
重复步骤直到找到想要的元素。如果数组不能进一步查分，就说明要找的元素不在数组中。

divide-and-conquer
The code
func binarySearch<T: Comparable>(_ a: [T], key: T, range: Range<Int>) -> Int? {
    if range.lowerBound >= range.upperBound {
        // If we get here, then the search key is not present in the array.
        return nil

    } else {
        // Calculate where to split the array.
        let midIndex = range.lowerBound + (range.upperBound - range.lowerBound) / 2

        // Is the search key in the left half?
        if a[midIndex] > key {
            return binarySearch(a, key: key, range: range.lowerBound ..< midIndex)

        // Is the search key in the right half?
        // 这里 + 1 的原因是排除 midIndex 中间值
        } else if a[midIndex] < key {
            return binarySearch(a, key: key, range: midIndex + 1 ..< range.upperBound)

        // If we get here, then we've found the search key!
        } else {
            return midIndex
        }
    }
}
// 19 numbers
let numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67]

// 0 ..< numbers.count 覆盖所有范围
binarySearch(numbers, key: 43, range: 0 ..< numbers.count)  // gives 13
二分查找是将数组分为两个，但是我们不需要正真的创建两个新数组。取而代之，我们使用 Swift Range 对象跟踪这些拆分。左闭右开。upperBound 总是比最后一个元素的索引多一。


插入排序 Insertion Sort
Sat, 24 Nov 2018 16:00:00 +0000
将一个数组从高到低或者从低到高排序。
插入排序算法的工作原理：

将若干数字放在一个数组里，数组是乱序的。
从数组中挑选一个数字，它是哪个并不重要，但是为了方便我们挑选数组头部的这个。
将这个数字插入到一个新的数组里。
从乱序数组里挑选下一个数字也将它放到新数组里。这个数字要么在第一个数字前或者后，所以这个两个数字是被排序的。
再次重从乱序数组里挑选下一个数字也将它放到新数组里，并将数字放在正确的位置。
一直如此进行直到乱序数组中没有数字。这时也将等到一个排序好的新数组。


自己的一个实现：
let array = [2, 1, 3, 8, 3, 5, 4]

var newArray = [Int]()
for (k, v) in array.enumerated() {
    for (nK, nV) in newArray.enumerated() {
        // 本次的数 小于 存在的数的第一个(nv)
        if v < nV {
            newArray.insert(v, at: nK)
            break
        }
    }
    // 没有插入成功 放在末尾
    if newArray.count < k + 1 {
        newArray.append(v)
    }
}
In-place sort
上面的排序需要两个数组，一个原始的，一个排好顺序的。但是我们也可以 就地排序 无需创建一个额外的数组。我们只需要跟踪记录原始数组中哪里部分排好顺序了，哪一部分还没有排序。
举例：[ 8, 3, 5, 4, 6 ] 使用 | 分割是否排好顺序的部分。
// 开始时 | 在最前
[| 8, 3, 5, 4, 6 ]

// 开始向左移动，左侧只有个 8 无论什么顺序都是正确的，右侧是未排序的部分
[ 8 | 3, 5, 4, 6 ]

// 依次进行 将未排序的头部元素放在已排部分的正确位置
[ 3, 8 | 5, 4, 6 ]
[ 3, 5, 8 | 4, 6 ]
[ 3, 4, 5, 8 | 6 ]
[ 3, 4, 5, 6, 8 |]
每次 | 移动，都对左侧进行排序，未排序的部分逐渐减少，排序部分增加。直到未排序部分为零。
How to insert
将未排序的头部元素放在已排部分的正确位置，如何这到这点的？
// 从此状态开始。下个说的 4，我们需要将 4 插入到 [ 3, 5, 8 ] 这个已经排好的数组里
[ 3, 5, 8 | 4, 6 ]

// 移动 |，这时我们注意 8 这个元素
[ 3, 5, 8, 4 | 6 ]
        ^

// 8 大于 4，所有 8 应该在 4 的右边，8 与 4 进行位置调换
[ 3, 5, 4, 8 | 6 ]
        <-->
      swapped

// 将 4 与现在的前面的元素 5 进行比较，5 大于 4，所以 5 与 4 进行位置调换
[ 3, 4, 5, 8 | 6 ]
     <-->
    swapped

// 3 小于 4 这个数，所以我们完成了对 4 的排序，这时从头到 |，是排好顺序的
[ 3, 4, 5, 8 | 6 ]
这就是对插入排序算法的内循环的描述。
The code
func insertionSort(_ array: [Int]) -> [Int] {
    // 1
    var a = array
    // 2
    for x in 1.. 0 && a[y] < a[y - 1] {
            a.swapAt(y - 1, y)
            y -= 1
        }
    }
    return a
}

将 array 复制一个副本。因为我们无法直接修改参数中的 array，就想 Swift 自身的 sort()，insertionSort() 将返回一个排序顺序的副本数组。
两个循环在方法中。外层循环遍历轮到排序的元素，也就是从待排数组中挑选出头部的元素。x 索引为排好顺序的结尾索引同时也是待排数组的开头。记住，如何时间从开头到 x 永远都是排好顺序的，从 x 到最后的元素都是未排序的。
内层循环查询 x 索引位置的元素。这个元素可能小于之前排序顺序数组中的每一个元素。内层循环从后倒序遍历每一个已排序的元素，每次发现这个元素之前的元素比它大，则交互位置。当内层循环完成时，数组从开头到 x 将又是已排序的。

tip：外层循环从索引 1 开始，而不是 0。将第一个元素从堆移动到排序部分实际上并没有改变任何东西，所以我们不妨跳过它。
No more swaps
上面的插入排序可以正常的工作了。我们还可以通过移除调用 swap() 让程序更快一些。
我们可以将所有需要换位置的元素向右移动一个位置，然后将新数字复制到正确的位置。
[ 3, 5, 8, 4 | 6 ]   remember 4
           *

[ 3, 5, 8, 8 | 6 ]   shift 8 to the right
        --->

[ 3, 5, 5, 8 | 6 ]   shift 5 to the right
     --->

[ 3, 4, 5, 8 | 6 ]   copy 4 into place
     *
func insertionSort(_ array: [Int]) -> [Int] {
    var a = array
    for x in 1.. 0 && temp < a[y - 1] {
            // 1
            a[y] = a[y - 1]
            y -= 1
        }
        // 2
        a[y] = temp
    }
    return a
}

原本需要换位置的元素右移一个位置。
当内层结束时，y 的索引位置就是新元素的排序后的位置，将元素放在此。

tip：这里我自己写成了 while y > 0 && a[y] < a[y - 1] 这是不对的，因为我要找的是 原本 的 a[y] 的位置，但是循环一次后 a[y] 将发生变化。
Making it generic
func insertionSort(_ array: [T], _ isOrderedBefore: (T, T) -> Bool) -> [T] {
    var a = array
    for x in 1.. 0, isOrderedBefore(temp, a[y - 1])  {
            a[y] = a[y - 1]
            y -= 1
        }
        a[y] = temp
    }

    return a
}
通过闭包来执行大小比较。
let numbers = [ 10, -1, 3, 9, 2, 27, 8, 5, 1, 3, 0, 26 ]
insertionSort(numbers, <)

let objects = [ obj1, obj2, obj3, ... ]
insertionSort(objects) { $0.priority < $1.priority }
插入排序是一种稳定 stable 的排序。当排序后具有相同排序键的元素保持相同的相对顺序时，排序是稳定的。这对于诸如数字或字符串之类的简单值并不重要，但在排序更复杂的对象时这很重要。在上面的示例中，如果两个对象具有相同的优先级，则无论其他属性的值如何，这两个对象都不会被交换。
Performance
最差的插入排序是 O(n^2) 因为俩个相近的循环嵌套。其他排序算法（如快速排序和合并排序）具有 O(n log n) 性能，在大输入时速度更快。
插入排序实际上对于排序小数组非常快。某些标准库具有排序功能，当分区大小为 10 或更小时，可以从快速排序切换到插入排序。
将 insertSort() 与 Swift 的内置 sort() 进行比较。在大约 100 元素左右的阵列上，速度差异很小。但是，随着输入变大，O(n^2) 快速开始执行比 O(n log n) 差很多，并且插入排序无法跟上。
文章代码：GitHub - imzyf/data-structure-and-algorithm/003-Insertion Sort/。
References

raywenderlich/swift-algorithm-club/Insertion Sort




队列 Queue Data Structure
Thu, 22 Nov 2018 16:00:00 +0000
实现一个 队列，包括 enqueue、dequeue、peek。
Queue
队列 核心也是 array，A queue gives you a FIFO or first-in, first-out order. 队列是：先进先出的。
public struct Queue<T> {
    fileprivate var array = [T]()
}

enqueue
进队，在数组尾部追加元素。
public mutating func enqueue(_ element: T) {
    array.append(element)
}
dequeue
出队，将首位的元素移除。因为首位元素移除后，其他元素依次向前移动，所以是 O(n)。
public var isEmpty: Bool {
    // 使用数组自身的方法，而不是 array.count > 0
    return array.isEmpty
}

public mutating func dequeue() -> T? {
    // 使用定义的变量
    if isEmpty {
        return nil
    } else {
        return array.removeLast()
    }
}
peek
查看队首元素。
/// peek() 改为更有语义话的只读变量
public var front: T? {
    return array.first
}
优化出队
在出队后不移动元素而是移动 起始索引，就像动的收银台而不是排队的人。
/// 优化 队列 的出队
public struct OptimizedQueue<T> {

    /// 这里改为了可选型，为了可以清理无效的元素
    fileprivate var array = [T?]()
    /// 起始索引
    fileprivate var head = 0

    public var count: Int {
        // 减去 起始索引 前面的数量
        return array.count - head
    }

    public var isEmpty: Bool {
        // 根据实际数量判断
        return count == 0
    }

    // 保持不变
    public mutating func enqueue(_ element: T) {
        array.append(element)
    }

    public mutating func dequeue() -> T? {
        guard head < array.count,
            let element = array[head] else {
            return nil
        }
        // 置空当前位置元素
        array[head] = nil
        // 前移起始索引
        head += 1

        // 空索引的占用比例
        let percentage = Double(head)/Double(array.count)
        // 50 0.25 都是魔法数字，主要是为了控制数组修剪的频率，可以自行调整
        if array.count > 50 && percentage > 0.25 {
            // 将起始空元素删除
            array.removeFirst(head)
            // 重置 起始索引
            head = 0
        }

        return element
    }

    public var front: T? {
        if isEmpty {
            return nil
        } else {
            // 根据 起始索引进行 返回
            return array[head]
        }
    }
}
文章代码：GitHub - imzyf/data-structure-and-algorithm/002-Queue/。


栈 Stack Data Structure
Thu, 22 Nov 2018 14:00:00 +0000
加入 Swift Algorithm Club /‘ælgə’rɪðəm/，回炉重新学习数据结构与算法。
自己创建的项目：GitHub - imzyf/data-structure-and-algorithm。
实现一个 栈 /stæk/，包含 push peek pop 与 Generics 泛型。

stack
栈 非常像一个数组，它包括少量的方法。

push 添加一个新元素到栈顶
pop 从栈顶移除一个元素
peek 查看栈顶的一个元素但是不 pop

A stack gives you a LIFO or last-in first-out order. 栈是后进先出，队列是先进先出。
public struct Stack {
    fileprivate var array: [Element] = []
}
push
push 是在数组的尾部添加元素是以 O(1)，如果是在数组最前添加是 O(n) 这是昂贵的。
public mutating func push(_ element: Element) {
  array.append(element)
}
因为使用的 struct，修改属性值的方法要加 mutating。
pop
想从一个空栈中弹出最后一个元素将返回 nil。
public mutating func pop(_ element: Element) {
    return array.popLast()
}
peek
与 pop 有点像，但是并没有移除栈顶的元素。
/// peek 改为更加语义化的 top 只读变量
public var top: T? {
    return array.last
}
other
两个其他的常用属性，栈是否为空，栈中元素的个数。
public var isEmpty: Bool {
  return array.isEmpty
}

public var count: Int {
  return array.count
}
References

Swift Algorithm Club: Swift Stack Data Structure

– EOF –



在 MySQL 中选择合适的日期类型
Fri, 25 May 2018 16:00:00 +0000
如何在 MySQL 中选择合适的日期类型困扰了很久，varchar、int、timestamp、datetime 都有尝试过，近来有所感悟，做此总结。
注：此总结考虑了 PHP 和 Laravel 框架的特点。
使用 varchar
varchar 存储日期时间的格式完全可以自己控制，月/日/年 还是 年-月-日 需求怎么说就怎么存，读取后展示是也不用在格式化。同时伏笔也就此埋下：日期时间格式没强制约束，总有一天字段里出现了与众不同的格式；要是日期时间会 变化 或作为 查询条件 或要进行 排序 时就又是一坑，还是要格式化标准格式再处理。可以说 varchar 应该是最差的选择了。

使用 int 与 timestamp
PHP time() 可以直接获取当前时间戳秒数，数据库字段要也是 int 一存就完事了，不会有格式问题，谁用什么样转什么样。但是在数据库工具中查看此字段时显示不够直观，范围时会不方便，这些在使用 timestamp 是会得到解决。
timestamp 是我一直迷惑的一个类型。我写了几个例子做测试：

将 Laravel 项目设置为 CST 中国标准时间，MySQL 时区设置为 UTC，使用 now() 获取当前日期时间，比如：2018-5-25 11:00:00 存入 timestamp 类型的字段中，使用数据库工具查看字段结果为仍然为 2018-5-25 11:00:00。
继续上面的操作，项目中使用查询语句查询刚才的记录，结果显示为 2018-5-25 11:00:00，将项目时区从 CST 改为 UTC 后再次查询的结果仍然为 2018-5-25 11:00:00 没有变化。
继续上面的操作，将数据库的时区改为 +8:00，数据库工具、项目查询后的结果为 2018-5-25 19:00:00 发生了变化，修改项目为 CST 查询结果是 2018-5-25 19:00:00 和刚才一样也变化了。

这个测试说明了：

项目的时区影响的是 PHP 的时区，影响的是 now() 产生的日期时间。
一个日期时间从项目存入数据库时，这个日期时间的时区是数据库设置的时区，和项目无关了。传入什么样子数据库存什么样子，更换了参照系，但是没有转换日期时间。
从数据库中读一个时间戳日期时间，这个是时间戳日期时间受到数据库的时区影响，和项目的时区无关。

我现在认识的结论：

因为数据库时区不可能轻易改变，所以依靠数据库转换时区不可能。
没看出来时间戳对于处理时区对 datatime 有什么过人之处，若有就是时间戳将时间标准设置在了 UTC，占 4 字节更小些。
数据库时区和项目时区不一致可能会坑，如果一直不一致同时各个项目也一直错下去，没不会有察觉。
对应国际化项目，是不是应该将数据库和项目还有服务器都设置为 UTC？谁使用谁根据用户的时区进行处理。

使用 timestamp 与 datetime
datetime 字段类型存储的时间不会随时间库时区发生变化，占 8 个字节，可存储 1000-01-01 00:00:00 到 9999-12-31 23:59:59。而时间戳只能存储 1970 年到 2038 年多，2038 还有 20 年怎么感觉马上就到了。
datetime 个人推荐的存储时间的格式。
时区处理常见问题
北京用户在北京时间 2018-05-27 10:00:00 发布一个文章。
如果在前端发布日期时间为 2018-05-27 10:00:00，在北京用户看来是没问题的，但是在美国的用户看来是奇怪的，因为美国没有到 2018-05-27 10:00:00 他们甚至还在 26 日。
这时 1 min ago 这种展示形式就解决了这个问题，ago 是一种绝对的方式，在一个月之后再显示完整的日期时间，此时世界各地肯定已经度过了这个要展示日期时间，无论在哪国用户显示 2018-05-27 10:00:00 都不会奇怪了。
同时也要注意，我们将各个时区都设置为 UTC 后，ago 的时间很好计算，但是在一个月之后日前时间完全显示，美国用户看北京用户的发布日期时间也应该是在中国看来的 2018-05-27 10:00:00，此发布日期不应该以美国用户为标准。这个问题的解决方法还在考虑，日期时间是存储多个字段来区分用于显示或比较，还是自行转换处理，需要实践测试。
MySQL 查看、修改时区
查看时区
> select now();   # 或 select curtime();

> show variables like "%time_zone%"; # SELECT @@global.time_zone, @@session.time_zone;
+------------------+--------+
| Variable_name    | Value  |
+------------------+--------+
| system_time_zone | CST    |
| time_zone        | SYSTEM |
+------------------+--------+

# time_zone 说明 mysql 使用 system 的时区，system_time_zone 说明 system 使用 CST 时区
修改时区
> set global time_zone = '+8:00';  # 修改 mysql 全局时区为北京时间，即我们所在的东8区
> set time_zone = '+8:00';  # 修改当前会话时区 SET time_zone = 'Asia/Shanghai'
> flush privileges;  # 立即生效
通过修改 my.cnf 配置文件来修改时区
# vim /etc/my.cnf
# 在[mysqld]区域中加上
default-time-zone='+8:00'

# /etc/init.d/mysqld restart  # 重启 mysql 使新时区生效
最后的总结
全球化的项目应当考虑：

项目、数据库、服务器都建议设置为 UTC
要考虑时分秒的字段用 datetime 类型，不用考虑时分秒的字段用 date
created_at 和 updated_at 字段，考虑 Laravel 框架的特点使用 timestamp

References

mysql 修改时区的几种方法

– EOF –



【Modern PHP】笔记
Tue, 08 May 2018 17:00:00 +0000
又回到 PHP Web 开发，使用 Laravel 框架，重读《Modern PHP》。

PHP 正在重生。

特性
命名空间
声明命名空间：
php
namespace Oreilly\ModernPHP;
导入和别名：
php
use Symfony\Component\HttpFoundation\Response as Res;

$r = new Res('Oops', 400);
$r->send();
PHP 5.6 开始可以导入函数和常量：
php
use func Namespace\functionName;
use constant Namespace\CONST_NAME;

functionName();
echo CONST_NAME;
使用接口
接口是两个 PHP 对象之间的契约，其目的不是让一个对象依赖另一个对象的身份，而是依赖另一个对象的能力。
使用接口编写更加灵活，能委托别人实现细节。
性状 trait
性状是类的部分实现，可以混入一个或者多个现有的 PHP 类中。性状有两个作用：表明类可以做什么（像是接口）；提供模块化实现（像是类）。
如果想让两个无关的 PHP 类具有类似的行为，应该怎么呢？性状就是为了解决这种问题而诞生的。性状能把模块化的实现方式注入多个无关的类中。而且性状还能促进代码的重用。
这与创建一个接口，两个无关的类实现这个接口的优势在于：不用写相同的实现代码，符合 DRY 原则。
PHP 解释器在编译时会把性状复制粘贴到类的定义体中，但是不会处理这个操作引入的不兼容问题。如果性状假定类中有特定的属性和方法（在性状中没有定义），要确保相应的类中有对应的属性和方法。
生成器
Generator 是 PHP 5.5.0 引入的功能。生成器是简单的迭代器，仅此而已。
PHP 生成器不要求类实现 Iterator 接口，从而减轻了类的负担。生成器会根据需求计算并产生要迭代的值。这对应该的性能有重大影响。假如标准的 PHP 迭代器经常在内存中执行迭代操作，这要预先计算出数据集，性能低；此时我们可以使用生成器，即时计算并产出后续值，不占用宝贵的内存资源。
PHP 生成器不能满足所有迭代操作的需求，因为如果不查询，生成器永远不知道下一个要迭代的值是什么，在生成器中无法后退和快进。生成器还是一次性，无法多次迭代同一个生成器。不过，如果需要，可以重建或克隆生成器。
PHP 生成器是 PHP 函数，只不过要在函数中一次或者多次使用 yield 关键字。生成器从不返回值，值产出值。
function myGenerator() {
  yield 'value1';
  yield 'value2';
  yield 'value3';
}

foreach (myGenerator()  as $yieldedValue) {
   echo $yieldedValue, PHP_EOL;
}

value1
value2
value3
使用生成器处理 CSV：
function getRows($file) {
    $handle = fopen($file, 'rb');
    if ($handle === false) {
        throw new Exception();
    }
    while (feof($handle) === false) {
        yield fgetcsv($handle);
    }
    fclose($handle);
}

foreach (getRows('data.csv') as $row) {
   print_r($row);
}
闭包
理论上讲，闭包和匿名函数是不同的概念。不过，PHP 将其视作相同的概念。
$closure = function ($name) {
    return sprintf('Hello %s', $name);
}

echo $closure("Josh");
我们之所以能调用 $closure 变量，是因为这个变量的值是一个闭包，而且闭包对象实现了 __invoke() 魔术方法。只要变量名后有()，PHP 就会查找并调用 __invoke() 方法。
PHP 闭包常被当做函数和方法的回调使用。
$numbersPlusOne = array_map(function ($number) {
    return $number + 1;
}, [1,2,3]);

print_r($numbersPlusOne);

// [2,3,4]
在有闭包之前，只能单独创建具名函数，然后使用名称引用那个函数：
$numbersPlusOne = array_map('incrementNumber', [1,2,3]);
// 如果只需要使用一次回调，没必要单独定义。把闭包当成回调使用，写出的代码更整洁、更清晰。
使用 use 关键字附加闭包状态：
function enclosePerson($name) {
    return function ($doCommand) use ($name) {
        return sprintf('%s, %s', $name, $doCommand);
    }
}

// 把字符串 Clay 封装到闭包里
$clay = enclosePerson('Clay');

// 传入参数，调用闭包
echo $clay('get me sweet tea!');

// "Clay, get me sweet tea!"
具名函数 enclosePerson() 有个名为 $name 的参数，这个函数返回一个闭包对象，而且这个闭包封装了 $name 参数。即便返回的闭包对象跳出了 enclosePerson() 函数的作用域，它也会记住 $name 参数的值，因为 $name 变量仍在闭包中。
PHP 闭包是对象。闭包对象的默认状态没什么用，不过有一个 __invoke() 魔术方法和 bindTo() 方法。
Zend OPcache
字节码缓存能存储预先编译好的 PHP 字节码。这意味着，请求 PHP 脚本时，PHP 解释器不用每次都读取、解析和编译 PHP 代码。
内置的 HTTP 服务器
启动这个服务器：
php -S localhost:4000

// 让 PHP Web 服务器监听所有接口
php -S 0.0.0.0:4000
标准
PSR 是什么
PHP Standards Recommendation.

PSR-1 基本的代码风格
PSR-2 严格的代码风格
PSR-3 日志记录器接口
PSR-4 自动加载

组件
查找组件

Awesome PHP
Packagist

良好实践
流
流式数据的种类各异，每种类型需要独特的协议，以便读写数据。称这些协议为流封装协议。

开始通信
读取数据
写入数据
结束通信

指定协议和目标的方法是使用流标识符：
://
使用 HTTP 流封装协议创建了一个与 Flickr API 通信的 PHP 流：
php
$json = file_get_contents(
    'http://api.flickr.com/services/feeds/photos_public.gne?format=json'
);
不要误以为这是普通的网页 URL，file_get_contents() 函数的字符串参数其实是一个流标识符。http 协议会让 PHP 使用 HTTP 流封装协议。在这个参数中，http 之后是流的目标。很多 PHP 开发者不知道普通的 URL 其实是 PHP 流封装协议标识的伪装。
我们使用 file_get_contents() fopen() fwrite() 和 fclose() 函数读写文件系统。因为 PHP 默认使用的流封装协议是 file://，使用我们很少认为这些函数使用的是 PHP 流。
隐式使用 file:// 流封装协议：
$handle = fopen('/etc/hosts', 'rb');
while (feof($handle) !== ture) {
    echo fgets($handle);
}
fclose($handle);
显示使用 file:// 流封装协议：
...
$handle = fopen('file://etc/hosts', 'rb');
...
我们通常会省略 file:// 封装协议，这是 PHP 使用的默认值。
编写命令行脚本的 PHP 开发者会感激 php:// 流封装协议。这个流封装协议的作用是与 PHP 脚本的标准输入、标准输出和标准错误文件描描述符通信。
php://stdin 只读 PHP 流，其中的数据来自标准输入。例如，接收命令行传入脚本的信息。
php://stdout 把数据写入当前的缓冲区。这个流只能写，无法读或寻址。
php://memory 从系统内存中读取数据，或者把数据写入系统内存。缺点是，可用内存是有限的。使用 php://temp 流更安全。
php://temp 和 php://memory 类似，不过没有可以内存时，PHP 会把数据写入临时文件。
错误和异常
提到了 Monolog 记录日志。
调优
内存
一共能分配给 PHP 多少内存？
Linode 2GB 的 sever 留 512MB 给 PHP。
单个 PHP 进程平均消耗多少内存？
使用 top 命令查看。一般 PHP 进程消耗 5 ~ 20MB 内存。
能负担的起多少个 PHP-FPM 进程？
假设 PHP 分配了 512MB 内存，每个 PHP 平均消耗 15MB 内存，从而确定能负担的起 34 个进程。
压力测试工具：

ab - Apache HTTP server benchmarking tool
Siege

Zend OPcache
opcache.memory_consumption = 64
# 为操作码缓存分配的内存量（单位 MB）。

opcache.interned_strings_buffer = 16
# 用来存储驻留字符串的内存量（单位 MB，默认 4MB）。

opcache.max_accelerated_file = 4000
# 操作码缓存中最多能存储多少个 PHP 脚本。这个值一定比 PHP 应用中的文件数量大。

opcache.validate_timestamps = 1
# 为 1 时，一段时间后 PHP 会检查 PHP 脚本的内容是否变化。检查的时间间隔由 revalidate_freq 指定。
# 开发环境设为 1，在生成环境中为 0。

opcache.revalidate_freq = 0
# 设置多久检查一次 PHP 脚本的内容是否有变化。

opcache.fast_shutdown = 1
# 这么设置能让操作码使用更快的停机步骤，把对象析构和内存释放交给 Zend Engine 的内存管理器完成。
文件上传
file_uploads = 1
upload_max_filesize = 10M
max_file_uploads = 3
如果需要上传非常大的文件，还要调整 nginx 虚拟主机配置中的 client_max_body_size 设置。
会话处理
session.save_handler = 'memcached'
session.save_path = '127.0.0.2:11211'
缓冲输出
output_buffering = 4096
implicit_flush = false
确保使用的值是 4（32 位系统）或者 8（64 位系统）的倍数。
真实路径缓存
realpath cache，PHP 会缓存应用使用的文件路径，这样每次包含或者导入文件时就无需不断搜索包含路径了。
realpath_cache_size = 64k
部署
提到了 Capistrano 待研究。
测试

PHPUnit
Xdebug
使用 Travis CI 持续测试

分析

XHProf 较新的 PHP 应用分析器
XHGUI
New Relic
Blackfire

HHVM 和 Hack
Hip-Hop Virtual Machine.
Hack 是一门建立在 PHP 之上的编程语音，引入了静态类型，新的数据结构和额外的接口，同时还能向后兼容现有的动态类型 PHP 代码。
动态类型和静态类型，二者之间的区别在于何时检查 PHP 类型。动态类型在运行时检查类型，而静态类型在编译时检查类型。
– EOF –



PhpStorm 使用经验
Sat, 05 May 2018 14:00:00 +0000
Getting Started
Two shortcuts to get started

Shift+Shift(⇧+⇧) helps you find anything within your project.
Alt+Enter(Option+Enter) provides instant access to contextual actions and quick fixes relevant to the selected code.

Getting started with PHP in PhpStorm
还有个 One Dark theme 但是 Material Theme UI 已经包含这个主题。
配置：
Preferences > Appearance & Behavior > Appearance 下，右侧配置：Theme: Darcula，勾选 User custom font: .AppleSystemUIFont Size: 18。
Preferences > Editor > Font 下，右侧配置：Font: Menlo Size: 18 Line spacing: 1.2。
Preferences > Editor > Color Scheme 下，右侧配置：Seheme: Atom One Dark(Material) 点击右侧的三个点 Duplicate 复制一份。
Preferences > Editor > Color Scheme > General 下，右侧配置：

Editor > Gutter background，右侧 Background: 292929（设置行号背景色）
Editor > Vertical Scrollar > Thumb 与 Thumb while scrolling，右侧 Background: 305599C0（设置垂直滑块色）
Editor > Text > Default text，右侧 Background: 292929（设置面板背景色）

快捷键

command + , 打开设置
command + shift + t 在代码和对应单元测试间用快速切换
command + e 查看最近编辑文件列表
shift + shift 搜索文件/类/操作/设置
command + option + t 快速包裹 if/foreach/while 等控制结构

command + option + +/- 快速展开/折叠


option + F12 呼出内置终端
command + shift + a “Quick Lists” 创建高频操作集合
Refactor

control + t 重构代码优化
command + n 代码生成
option + return 语法修复、代码优化等建议
option + 鼠标选择 同时修改多处相同内容


Git

command + k Commit Changes
command + shift + k Push Changes
control + v 查看版本操作菜单


Debug

command + F8   # 添加断点
control + d    # 启动调试
F8             # Step Over
F7             # Step Into
shift + F8     # Step Out



技巧
围绕选择输入
设置选择了一个词后，再按单引号或双引号，将选中的单词用引号括起来。
Preferences 中搜索 Surround Selection on typing quote or brace 将其勾选（Editor > General > Smart Keys 下）。
关闭文档提示
鼠标放在方法上会出现文档提示，想关闭。
Preferences 中搜索 Show quick documentation on mouse move 取消勾选（Editor > Code Editing 下）。
使用 PHP-CS-Fixer

The PHP Coding Standards Fixer (PHP CS Fixer) tool fixes your code to follow standards.

工作环境：MacBook。
打开 PhpStorm Preferences > Tools > External Tools 添加：


Program: /usr/local/bin/php-cs-fixer
Arguments: --verbose fix "$FileDir$/$FileName$" --dry-run --rules=@PSR1,@PSR2,@Symfony（Note that previous verions of PHP-CS-Fixer used –levels instead of –rules. 未找到）
Working directory: $ProjectFileDir$
我取消勾选了 Open console for tool output，可以不输出日志信息

为了方便使用，保存文件时就可以格式化，设置快捷键 Preferences > Keymap > Macros：

设置 php-cs-fix 单独的快捷键 Preferences > Keymap > External Tools：

关闭不常用的插件
Preferences > Plugins > Installed 向下滚动，Bundled 中有不少预装但不常用的可以禁掉。
遇到过的一些问题
文件类型错误
一个文件被新建后，明明扩展名没有错，但是却没有语法高亮，删除文件后也不解决问题。
解决办法：Editor > File Types 找 Text 将里面涉及的文件删除掉。

phpstorm 文件类型错误

Undefined function XXX
出现 PHP 的原生方法未定义的警告。
解决方法：File > Invalidate Caches / Restart
Typo: In word XXX
提示单词拼写错误，但是其中没有问题，比如全拼的名字。
解决方法：option + enter -> Save to dictionary

Spellchecking | jetbrains

warning: Multiple definitions exists for class
I resolved this by going to Preferences-> Languages & Frameworks-> PHP; and then under Include path, remove the conflicting path. (In my case a package reference in the vendor directory to a package I was developing inside my Laravel project)
References

打造漂亮的 PhpStorm 界面
大牛们的 PHPstorm 使用技巧和建议
Use PHP-CS-Fixer in PHPStorm




使用 Certbot 获取 Let’s Encrypt 颁发的 TLS 证书
Thu, 26 Apr 2018 16:00:00 +0000
Certbot 和 Let’s Encrypt 的关系
Let’s Encrypt

一个免费、自动化、开放的公共证书颁发机构（CA）。
通过 ACME（Automatic Certificate Management Environment）协议向域名所有者颁发 DV（Domain Validation）TLS/SSL 证书。

Certbot

由 Electronic Frontier Foundation (EFF) 维护的开源 ACME 客户端。
主要目标是简化与 Let’s Encrypt 之间的交互：

自动化域名验证（HTTP-01、DNS-01、TLS-ALPN-01 等）
安装并续期证书
更新 Web 服务器配置（Apache、Nginx、Lighttpd 等）


Certbot 也能与任何兼容 ACME 的 CA 通信，不限于 Let’s Encrypt。

典型工作流程

解析参数并检测服务器类型。
选择并执行挑战（例如在 /.well-known/acme-challenge/ 下写入 token）。
Let’s Encrypt 回访验证域名归属。
验证通过后签发证书；Certbot 下载并安装到本地。
创建定时任务 certbot renew 自动续期。

开始实验

实验环境：Amazon Linux 2023 (AL2023)

知识补充

dnf（Dandified YUM） 是 RPM-系 Linux 发行版的下一代包管理器。它在功能上取代了传统的 yum，两者命令参数几乎保持兼容。
RPM 一开始叫 Red Hat Package Manager，后来改名为递归含义的 RPM Package Manager。
RPM-系发行版 是把 RPM 作为原生软件包格式与核心包管理工具链的那一族 Linux 发行版。常听到的 Fedora / RHEL / CentOS / AlmaLinux / Rocky Linux / openSUSE / SUSE Linux Enterprise / Amazon Linux 2023 等。
dnf 不是对 rpm CLI 的简单封装，而是调用 librpm 完成最终操作。


  
      
          包管理器
          代表发行版
          归属
      
  
  
      
          dnf / yum
          Fedora, RHEL, CentOS
          RPM
      
      
          zypper
          openSUSE, SLE
          RPM
      
      
          apt / apt-get
          Debian, Ubuntu
          DEB
      
      
          pacman
          Arch Linux
          tar.xz
      
      
          apk
          Alpine
          .apk
      
  


snap 是一种由 Canonical（Ubuntu 的开发公司）推出的跨发行版应用打包和分发格式，也指围绕它的一整套生态系统。

跨发行版。同一个 snap 包可以在几十种发行版上直接安装运行，不依赖各自的 RPM/Deb 系统仓库。
自包含（bundled）依赖。snap 包内部包含所有依赖，无需外部安装。
https://snapcraft.io/



Launch an AWS EC2 instance

Instance type: t2.nano
Username: ec2-user
Security Groups: Allow HTTP and HTTPS
Public IPv4: 35.86.90.4

配置 nginx
sudo dnf update -y

sudo dnf install -y nginx
nginx -v
# nginx version: nginx/1.28.0

sudo systemctl start nginx
sudo systemctl enable nginx
systemctl status nginx
# Started nginx.service - The nginx HTTP and reverse proxy server.
直接通过 http://35.86.90.4，会看到默认的 nginx 欢迎页面。
sudo vi /etc/nginx/conf.d/default.conf
#
server {
    listen       80;
    listen       [::]:80;
    server_name  tmp.yifans.net;
    root         /usr/share/nginx/html;

    error_page 404 /404.html;
    location = /404.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }
}
sudo nginx -t
sudo systemctl reload nginx
将自己的域名（tmp.yifans.net）解析到 35.86.90.4，然后访问 http://tmp.yifans.net 同样看到 nginx 欢迎页面，游览器显示 Not Secure。
配置 certbot
# 暂无官方支持 AL2023
sudo wget -O /etc/yum.repos.d/snapd.repo \
    https://bboozzoo.github.io/snapd-amazon-linux/al2023/snapd.repo
sudo dnf install -y snapd
sudo systemctl enable --now snapd.socket

sudo snap install --classic certbot
sudo ln -s /snap/bin/certbot /usr/bin/certbot

certbot --version
# certbot 4.1.1
# 前置 nginx 配置中要有 server_name tmp.yifans.net;
sudo certbot --nginx -d tmp.yifans.net
# 全自动完成
访问 http://tmp.yifans.net 会自动跳转 https。
# 看看被 certbot 自动修改的 nginx 配置
cat /etc/nginx/conf.d/default.conf
server {
    server_name  tmp.yifans.net;
    root         /usr/share/nginx/html;

    error_page 404 /404.html;
    location = /404.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }

    listen [::]:443 ssl ipv6only=on; # managed by Certbot
    listen 443 ssl; # managed by Certbot
    ssl_certificate /etc/letsencrypt/live/tmp.yifans.net/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/tmp.yifans.net/privkey.pem; # managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
}

server {
    if ($host = tmp.yifans.net) {
        return 301 https://$host$request_uri;
    } # managed by Certbot

    listen       80;
    listen       [::]:80;
    server_name  tmp.yifans.net;
    return 404; # managed by Certbot
}
# 看看 certbot 预置的参数
# include /etc/letsencrypt/options-ssl-nginx.conf;
cat /etc/letsencrypt/options-ssl-nginx.conf
# This file contains important security parameters. If you modify this file
# manually, Certbot will be unable to automatically provide future security
# updates. Instead, Certbot will print and log an error message with a path to
# the up-to-date file that you will need to refer to when manually updating
# this file. Contents are based on https://ssl-config.mozilla.org

ssl_session_cache shared:le_nginx_SSL:10m;
# 在内存里创建名为 le_nginx_SSL 的共享会话缓存区域，大小 10 MiB。
# 能加速后续同客户端的 TLS 握手（避免完整密钥交换）。
# 10 MiB 足够保存约 40 000 个会话条目。

ssl_session_timeout 1440m;
# 单位是分钟（1440 m = 24 h）。
# 表示缓存的会话条目过期时间；设为一天可在常见浏览器会话周期内复用。

ssl_session_tickets off;
# 关闭 TLS Session Tickets。
# 原因：早期实现无法便捷轮换 ticket 加密密钥，导致前向安全受损。

ssl_protocols TLSv1.2 TLSv1.3;
# 明确只允许 1.2 / 1.3。
# 关闭已不安全的 SSLv3、TLS 1.0、TLS 1.1。

ssl_prefer_server_ciphers off;
# 让客户端来决定从交集里选哪一组加密套件（服务器不强制优先级）。
# 在只开放现代安全套件的前提下，这样做兼容性好且简化维护。
# 如果你想严格控制，可改为 on 并自行调整 ssl_ciphers 顺序。

ssl_ciphers "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384";
# 仅保留 GCM / ChaCha20-Poly1305 这一代 AEAD 套件；弃用 CBC、RC4、3DES 等。
# ECDHE-ECDSA（椭圆曲线 DH，证书是 ECDSA）
# ECDHE-RSA（证书是 RSA）
# DHE-RSA（传统 DH，给极旧设备兜底）
ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

`ssl_dhparam` 告诉 Nginx 在使用 DHE（Diffie-Hellman Ephemeral）握手方式时，不用默认的 1024 位弱参数，而改用一份 自定义、更安全的 DH 参数文件。

DHE 是 TLS/SSL 协议中的一种「密钥交换算法」。它的核心作用只有两点：
  - 让客户端与服务器在 公网信道 上安全地“协商出”一个对称加密用的随机密钥。
  - 提供 前向安全（Forward Secrecy）：哪怕以后服务器的长期私钥被泄露，过去抓到的加密数据也无法解密。
# 看看证书
sudo openssl x509 -in /etc/letsencrypt/live/tmp.yifans.net/fullchain.pem -noout -text | grep yifans.net

        Subject: CN=tmp.yifans.net
                DNS:tmp.yifans.net
只获取证书
首先需要将 tmp-certonly.yifans.net 解析到 35.86.90.4，为了自动完成 acme challenge。
sudo vi /etc/nginx/conf.d/certonly.conf
server {
    listen       80;
    listen       [::]:80;
    server_name  tmp-certonly.yifans.net;
    root         /usr/share/nginx/html;

    error_page 404 /404.html;
    location = /404.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }
}
sudo nginx -t
sudo systemctl reload nginx

sudo certbot certonly --nginx

We recommend selecting either all domains, or all domains in a VirtualHost/server block.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: tmp.yifans.net
2: tmp-certonly.yifans.net

# 选择 2
Successfully received certificate.
Certificate is saved at: /etc/letsencrypt/live/tmp-certonly.yifans.net/fullchain.pem
Key is saved at:         /etc/letsencrypt/live/tmp-certonly.yifans.net/privkey.pem
This certificate expires on 2025-10-01.
# /etc/nginx/conf.d/certonly.conf 没有被自动修改，需要手动添加证书
Wildcard Certificate

需要 DNS Credentials。
*.example.com 不覆盖 example.com, hello.goodbye.example.com。
*.goodbye.example.com 可覆盖 hello.goodbye.example.com。
不可以申请 *.*.example.com 只能一个 * asterisk。

可以通过 DNS Plugins 插件申请 Wildcard Certificate，但是我觉得 manual 更简单。
sudo certbot certonly --manual -d '*.tmp.yifans.net' --preferred-challenges dns

Please deploy a DNS TXT record under the name:

_acme-challenge.tmp.yifans.net.

with the following value:
...

# 访问 https://toolbox.googleapps.com/apps/dig/#TXT/_acme-challenge.tmp.yifans.net. 预测试配置结果。
# 如果看到对应的值，按 Enter 继续。

Successfully received certificate.
Certificate is saved at: /etc/letsencrypt/live/tmp.yifans.net-0001/fullchain.pem
Key is saved at:         /etc/letsencrypt/live/tmp.yifans.net-0001/privkey.pem
# 看看证书
sudo openssl x509 -in /etc/letsencrypt/live/tmp.yifans.net-0001/fullchain.pem -noout -text | grep yifans.net

        Subject: CN=*.tmp.yifans.net
                DNS:*.tmp.yifans.net
sudo vi /etc/nginx/conf.d/wildcard.conf
server {
    server_name  *.tmp.yifans.net;
    root         /usr/share/nginx/html;

    error_page 404 /404.html;
    location = /404.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }

    listen 443 ssl;
    ssl_certificate /etc/letsencrypt/live/tmp.yifans.net-0001/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/tmp.yifans.net-0001/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
}

server {
    listen 80;
    server_name *.tmp.yifans.net;
    return 301 https://$host$request_uri;
}
sudo nginx -t
sudo systemctl reload nginx
将 1.tmp.yifans.net 解析到 35.86.90.4，然后访问 https://1.tmp.yifans.net，在 Chrome 的证书信息里可以看到 Common Name (CN) *.tmp.yifans.net。
证书续期
sudo certbot renew --dry-run
References

Nginx on Linux (snap) | Certbot

– EOF –



Swift 初始化
Sat, 31 Mar 2018 17:00:00 +0000
因为自己是直接从 Swift 进入的 iOS 开发，Swift 与 Objective-C 初始化的对比就不多提了。感觉上 Swift 初始化的方式像 Java，自己也只是这样套着 Java 去理解，但也发现了不相同的地方。
初始化顺序
class Blog: NSObject {
    let param: String

    override init() {
    }
}
这里有一条错误 error: property 'self.param' not initialized at implicitly generated super.init call，说明 param 参数没有在隐式生成 super.init 调用之前完成初始化。
Swift 中并不是不调用 super.init，而是为了方便开发者，由编译器完成了这一步。但要求在调用 super.init 之前完成成员变量的初始化。

class Blog: NSObject {
    let param: String

    override init() {
        param = "swift init"
    }
}
对于需要修改父类中成员变量值的情况，我们需要在调用 super.init 之后再进行修改：
class Cat {
    var name: String

    init() {
        name = "cat"
    }
}

class Tiger: Cat {
    let power: Int

    override init() {
        power = 10
        super.init()
        name = "tiger"
    }
}
Swift 中类的初始化顺序：

初始化自己的成员变量（必须）
调用父类初始化方法（如无需第三步，则这一步可省略）
修改父类成员变量（可选）

补充说明：

let 声明的常量可以在初始化方法中进行赋值。Swift 中的 init 方法只会被调用一次，这与 Objective-C 不同
即使成员变量是可选类型，如 let power: Int? 仍然需要进行初始化；var power: Int? 则可以不用

关键字
例子 1：
class CustomView: UIView {
    let param: Int

    override init() { // error 1
        self.param = 1
        super.init() // error 2
    }
} // error 3
将父类从 NSObject 修改为 UIView，竟然收到 3 条错误：

initializer does not override a designated initializer from its superclass
must call a designated initializer of the superclass ‘UIView’
‘required’ initializer ‘init(coder:)’ must be provided by subclass of ‘UIView’

例子 2：
class CustomView: UIView {
    convenience init(param: Int, frame: CGRect) {
        super.init(frame: frame) // error
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}
error：

convenience initializer for ‘CustomView’ must delegate (with ‘self.init’) rather than chaining to a superclass

上面两个例子出现了 3 个关键字：designated、convenience 和 required。
designated
Swift 定义了两种类初始化器类型，用来保证所有成员属性能够获得一个初始化值。即 designated initializers [i’niʃəlaizə] 和 convenience initializers。

Designated initializers are the primary initializers for a class. A designated initializer fully initializes all properties introduced by that class and calls an appropriate superclass initializer to continue the initialization process up the superclass chain.


primary initializers：designated initializers 是一个类的主初始化器，理论上来说是一个类初始化的必经之路。（不同的初始化路径可能调用不同的 designated initializers）
fully initializes all properties：必须在 designated initializers 中完成所有成员属性的初始化
calls an appropriate superclass initializer：需要调用合适的父类初始化器完成初始化，不能随意调用

在 Swift 中 designated initializers 的写法和一般的初始化方法无异。在 Sample 1 中，我们试图去 override init，可以理解为我们就是在 override 一个 designated initializers，然后收到了错误 Initializer does not override a designated initializer from its superclass，可见我们并没有找到合适的 designated initializers。进入父类 UIView，可以看到下面两个初始化方法：
public init(frame: CGRect)
public init?(coder aDecoder: NSCoder)
原来，这两个才是父类的 designated initializers，那我们改改试试：
class CustomView: UIView {
    let param: Int

    override init(frame: CGRect) { // error 1 fixed
        self.param = 1
        super.init(frame: frame) // error 2 fixed
    }
} // error 3
error 1 fixed 由此可见：我们去 override 一个不是 designated initializers 的初始化器时，是不满足定义中所说的 primary initializers，这就可能导致这个初始化器不被执行，成员变量没有初始化，这样创建的“半成品”实例可能存在一些不安全的情况。
第二条 fully initializes all properties，这点我们并没有犯错，因为我们已经初始化了 CustomView 类中引入的 param 变量。
第三条 calls an appropriate superclass initializer 很明显就对应了 error 2，我们 override init(frame:)，那我们就必须调用对应的父类初始化方法。
error 3 提示我们 init(coder:) 是一个 ‘required’ initializer，子类必须提供
required

Write the required modifier before the definition of a class initializer to indicate that every subclass of the class must implement that initializer.

通过添加 required 关键字强制子类对某个初始化方法进行重写。
class CustomView: UIView {
    let param: Int

    override init(frame: CGRect) { // error 1 fixed
        self.param = 1
        super.init(frame: frame) // error 2 fixed
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
} // error 3 fixed
error 3 fixed。插入的这个方法很奇怪，方法体里直接写 fatalError("init(coder:) has not been implemented")，那岂不是走到这里就 crash 了？
designated initializers 是一个类的主初始化器，理论上来说是一个类初始化的必经之路（不同的初始化路径可能调用不同的 designated initializers）。其实，这个 init(coder:) 与 init(frame: frame) 就是不同的初始化路径，当我们使用 xib 方式初始化一个 view 时，就会走到 init(coder:)。此时，如果我们没有真正实现这个方法，就会出现 fatal crash。
完整初始方案：
class CustomView: UIView {
    let param: Int

    override init(frame: CGRect) {
        self.param = 1
        super.init(frame: frame)
    }

    required init?(coder aDecoder: NSCoder) {
        self.param = 1
        super.init(coder: aDecoder)
    }
}
convenience

Convenience initializers are secondary, supporting initializers for a class. You can define a convenience initializer to call a designated initializer from the same class as the convenience initializer with some of the designated initializer’s parameters set to default values. You can also define a convenience initializer to create an instance of that class for a specific use case or input value type.

convenience initializers 是对类初始化方法的补充，用于为类提供一些快捷的初始化方法。可以不创建这类方法，但如果创建了，就需要遵循原则：call a designated initializer from the same class，也就是说要调用该类自己的 designated initializer。那么我们应该 override init(frame:)，然后修改为：
class CustomView: UIView {
    convenience init(param: Int, frame: CGRect) {
        self.init(frame: frame) // error fixed
    }

    override init(frame: CGRect) {
        super.init(frame: frame)
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}
然后对成员变量 param 赋值：
class CustomView: UIView {
    var param: Int

    convenience init(param: Int, frame: CGRect) {
        self.param = param // error
        self.init(frame: frame)
    }

    override init(frame: CGRect) {
        super.init(frame: frame) // error
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}
出现两个错误：

Use of ‘self’ in property access ‘param’ before self.init initializes self
Property ‘self.param’ not initialized at super.init call

第二个错误我们清楚，是需要在调用 super.init 之前初始化本类成员属性。
第一个错误其实是 Swift 编译器提供的安全检查，文档原文如下：

A convenience initializer must delegate to another initializer before assigning a value to any property (including properties defined by the same class). If it doesn’t, the new value the convenience initializer assigns will be overwritten by its own class’s designated initializer.

原来 Swift 防止 convenience initializers 中赋值之后又被该类自己的 designated initializer 覆盖而做了检查。因此，正确的方式应该是调用该类的其他初始化方法之后再修改属性值，最终修改如下：
class CustomView: UIView {
    var param: Int

    convenience init(param: Int, frame: CGRect) {
        self.init(frame: frame)
        self.param = param // error fixed
    }

    override init(frame: CGRect) {
        self.param = 0 // error fixed
        super.init(frame: frame)
    }

    required init?(coder aDecoder: NSCoder) {
        self.param = 0
        super.init(coder: aDecoder)
    }
}
小结

子类中初始化方法必须覆盖全部初始化路径，以保证对象完全初始化
子类中 designated initializer 必须调用父类中对应的 designated initializer，以保证父类也能完成初始化
子类中如果重写父类中 convenience initializer 所需要的全部 init 方法，就可以在子类中使用父类的 convenience initializer 了
子类如果没有定义任何 designated initializer，则默认继承所有父类的 designated initializer 及 convenience initializer
子类中必须实现的 designated initializer，可以通过添加 required 关键字强制子类重写其实现，以保证依赖该方法的 convenience initializer 始终可以使用
convenience initializer 必须调用自身类中的其他初始化方法，并在最终必须调用一个 designated initializer
在构造器完成初始化之前，不能调用任何实例方法或读取任何实例属性的值，self 本身也不能被引用

可失败初始化器
可失败初始化器 Failable Initializers，即可能返回 nil 的初始化方法。

A failable initializer creates an optional value of the type it initializes. You write return nil within a failable initializer to indicate a point at which initialization failure can be triggered.

就是将初始化返回值变成 optional value，并在不满足初始化条件的地方 return nil。通过调用处判断是否有值即可知道是否初始化成功。
class Product {
    let name: String
    init?(name: String) {
        if name.isEmpty { return nil }
        self.name = name
    }
}

class CartItem: Product {
    let quantity: Int
    init?(name: String, quantity: Int) {
        if quantity < 1 { return nil }
        self.quantity = quantity
        super.init(name: name)
    }
}
CartItem 类的初始化方法先对传入参数 quantity 的值进行判断，小于 1 则为无效参数，然后 return nil（初始化失败），大于或等于 1 则继续调用父类 Product 的初始化方法，再次判断传入参数 name，为空则 return nil（初始化失败），否则继续初始化。
总的来说，可失败初始化器的设定，是在保证安全性的基础上提供了逻辑上更清晰的初始化方式。Failable Initializers 所有的结果都将是 T? 类型，通过 Optional Binding 方式，我们就能知道初始化是否成功，并安全地使用它们了。
References

从 Swift 初始化说起
The Swift Programming Language (Swift 4.1) Initialization
Swift 类构造器的使用

– EOF –



【Git 权威指南】读书笔记 - 协同模型
Fri, 19 Jan 2018 14:00:00 +0000
主要内容：【Git 协同模型】
经典 Git 协同模型
集中式协同模型
可以像集中式版本控制系统那样使用 Git，在一个大家都可以访问到的服务器上架设 Git 服务器，每个人从该服务器克隆代码，本地提交推送到服务器上。
金字塔式协同模型
虽然理论上每个开发者的版本库都是平等的，但是会有一个公认的权威的版本库，这个版本库由一个或者多个核心开发者负责维护（具有推送的权限）。
开源社区逐渐发展出金字塔模型，而这也是必然之选。

Topgit 协同模型

笔者注：Topgit 是否已经过时？

卖主分支 Vendor Branch 是在版本库中专门创建一个和上游同步的分支，一旦有上游代码发布就捡入到卖主分支中。
子模组协同模型
创建子模组
git submodule add /path/to/repos/libA.git lib/lib_a
.gitmodules 的内容：
cat .gitmodules
[submodule "lib/lib_a"]
        path = lib/lib_a
        url = /path/to/repos/libA.git
克隆带子模组的版本库
git clone /path/to/repos/super.git /path/to/my/workspace/super-clone
子模组的版本库并不会默认克隆，如果需要克隆出子模组型式引用的外部库，需要执行：
git submodule init
git submodule update
在子模组中修改和子模组的更新
修改更新的方式和普通仓库一样。如果修改了子模块，要先推送子模块的修改，再推送主仓库，以防止其他人克隆 super 版本库、更新模组时因为找不到该子模组版本库相应的提交而导致出错。
查看子模组状态：
git submodule status
子树合并
引入外部版本库
# 注册外部版本库
git remote add util /path/to/repos/util.git

git fetch util

# 查看所有分支
git branch -a

# 从 util/master 远程分支创建一个本地分支 util-branch
git checkout -b util-branch util/master
子目录方式合并外部版本库
# 在主分支，将分支 util-branch 读取到当前分支的一个子目录下
git read-tree --prefix=lib util-branch

# 将 lib 目录下的文件更新出来
git checkout -- lib
现在还不能忙着提交，因为如果现在进行提交就体现不出来两个分支的合并关系。需要使用 Git 底层的命令进行数据提交。
# 将暂存区的目录树保存下来

git write-tree
要手工创建一个合并提交，即新的提交要有两个父提交。这两个父提交分别是 master 分支和 util-branch 分支的最新提交。
echo "subtree merge" | \
  git commit-tree 2153518409d218609af40babededec6e8ef51616 \
  -p 911b1af2e0c95a2fc1306b8dea707064d5386c2e \
  -p 12408a149bfa78a4c2d4011f884aa2adb04f0934
62ae6cc3f9280418bdb0fcf6c1e678905b1fe690
需要把当前的 master 分支重置到此提交 ID：
git reset 62ae6cc3f9280418bdb0fcf6c1e678905b1fe690
操作繁琐，可使用下面 subtree 命令进行代替。
利用子树合并跟踪上游改动
git checkout util-branch

git pull

git checkout master

git merge -Xsubtree=lib util-branch
Git Subtree
管理子项目
假设 P1 项目、P2 项目 共用 S 项目

关联 S 项目

git subtree add --prefix=  <分支> --squash
--squash 意思是把 subtree 的改动合并成一次 commit，这样就不用拉取子项目完整的历史记录。--prefix 之后的 = 等号也可以用空格。

更新代码

P1、P2 项目里各种提交 commit，其中有些 commit 会涉及到 S 目录 的更改，但是没关系。

提交更改到子项目

git subtree push --prefix=  <分支>
Git 会遍历 步骤 2 中所有的 commit，从中找出针对 S 目录 的更改，然后把这些更改记录提交到 S 项目 的 Git 服务器上，并保留 步骤 2 中的相关 S 的提交 记录到 S仓库 中。

更新子目录

git subtree pull --prefix=  <分支> --squash
拆分已有项目

需要从现有项目中抽取公共模块单独进行 Git 管理，假设已有 项目 P 抽取 项目 S。

提交日志分离

git subtree split -P  -b <临时branch>
Git 会遍历所有的 commit，分离出与 S 项目的相对路径相关的 commit，并存入临时 branch 中。

创建子 repo

mkdir 
cd S项目新路径
git init
git pull  <临时branch>
git remote add origin 
git push origin -u master

清理数据

cd P项目的路径
git rm -rf 
git commit -m '移除相应模块' # 提交删除申请
git branch -D <临时branch> # 删除临时分支

添加 subtree

git subtree add --prefix=  <分支> --squash
git push origin master
执行完第 2 步时，对应的目录已经剥离出来形成独立的项目了。第 3，4 步主要是把当前项目的对应的文件给删除，重新在 P 项目建立 Subtree。
tip:
推送到 GitHub Page：
git subtree push --prefix=dist origin gh-pages
References

4. 协同模型 — GotGit
Git Subtree 的使用

– EOF –



【Git 权威指南】读书笔记 - 和声
Wed, 17 Jan 2018 19:00:00 +0000
主要内容：【Git 协议与工作协同】、【冲突解决】、【Git 里程碑】、【Git 分支】、【远程版本库】、【补丁文件交互】
Git 协议与工作协同
Git 支持的协议
SSH、GIT、HTTP、HTTPS、FTP、FTPS、RSYNC 及前面已经看到的本地协议。
SSH 协议：
ssh://[user@]example.com[:port]/path/to/repo.git/

[user@]example.com:path/to/repo.git/
GIT 协议，最常用的只读协议：
git://example.com[:port]/path/to/repo.git/
HTTP[S] 协议：
http[s]://example.com[:port]/path/to/repo.git/

强制非快进式推送
git push -f
强制推送，会强制刷新服务器中的版本。
禁止非快进式推送
git --git-dir=/path/to/repos/shared.git config receive.denyNonFastForwards true
冲突解决
拉回操作中的合并
git pull = git fetch + git merge
合并策略

Merge Strategis

Git 合并操作支持很多合并策略，默认会选择最适合的合并策略。例如，和一个分支进行合并时会选择 recursive 合并策略，当和两个或两个以上的其他分支进行合并时采用 octopus 合并策略。
git merge [-s ] [-X ] [...]
This option forces conflicting hunks to be auto-resolved cleanly by favoring our version.
git merge -s recursive -X ours [...]
Merge branch obsolete into the current branch, using ours merge strategy:
git merge -s ours obsolete
Git 里程碑
显示里程碑
git tag
显示说明。-n 显示最多  行里程碑的说明：
git tag -n1
使用统配：
git tag -l v1.*
查看提交对应的里程碑及其他引用：
git log --oneline --decorate
创建里程碑
当创建了里程碑 mytag 后，会在版本库的 .git/refs/tags 目录下创建一个新文件。实际上指向的是一个提交：
git tag mytag

git cat-file -t mytag
commit
带说明的 tag 指向的不再是一个提交，而是一个 tag 对象：
git tag -m "My first annotated tag." mytag2

git cat-file -t mytag2
tag
为里程碑对象添加 GnuPG 签名：
git tag -s -m "My first GPG-signed tag." mytag3
删除里程碑
git tag -d mytag
Deleted tag 'mytag' (was 60a2f4f)
共享里程碑
创建的里程碑，默认只在本地版本库中可见，不会因为对分支执行推送而将里程碑也推送到远程版本库。
将 mytag 里程碑共享到上游版本库：
git push origin mytag
所有里程碑全部推送到远程版本库：
git push origin refs/tags/*

里程碑共享，必须显式的推送。
执行获取或拉回操作，自动从远程版本库获取新里程碑，并在本地版本库中创建。
如果本地已有同名的里程碑，默认不会从上游同步里程碑，即使两者里程碑的指向是不同的。

删除远程版本库的里程碑
git push origin :mytag2
里程碑命名规范
语义化版本 2.0.0
版本格式：主版本号.次版本号.修订号，版本号递增规则如下：

主版本号：当你做了不兼容的 API 修改，
次版本号：当你做了向下兼容的功能性新增，
修订号：当你做了向下兼容的问题修正。

先行版本号及版本编译信息可以加到 主版本号.次版本号.修订号 的后面，作为延伸。
Git 分支
分支是代码管理的利器。如果没有有效的分支管理，代码管理就适应不了复杂的开发过程和项目的需要。
分支命令概述
# 显示
1. git branch

# 创建
2. git branch 
3. git branch  

# 删除，-d 在删除分支  时会检查所要删除的分支是否已经合并到其他分支中，否则拒绝删除。
4. git branch -d 
5. git branch -D 

# 重命名，-m 如果版本库中已经存在名为  的分支，拒绝执行重命名，而 7 会强制执行。
6. git branch -m  
7. git branch -M  
创建并切换到新分支：
git checkout -b  []
分支变基

master
dev（开发完成，领先 master）

# 先切换到 dev
git checkout dev

# 变基操作
git rebase master

# 遇到冲突，解决冲突

# 添加到暂存区
git add -u

# 继续变基
git rebase --continue

# 直接将 dev 推送到远程 master
git push origin dev:master

# 切换到 master
git checkout master

# 拉取最新代码
git pull

# 删除 dev 分支
git branch -d dev
远程版本库
远程分支
查看远程分支：
git branch -r
在向远程版本库执行获取操作时，不是把远程版本库的分支原封不动地复制到本地版本库的分支中，而是复制到另外的命名空间。
远程分支不是真正意义上的分支，是类似于里程碑一样的引用。如果针对远程分支执行检出命令，会看到大段的错误警告。
远程分支类似于里程碑，如果检出就会使得头指针 HEAD 处于分离头指针状态。实际上除了以 refs/heads 为前缀的引用之外，如果检出任何其他引用，都将使工作区处于分离头指针状态。如果对远程分支进行修改就需要创建新的本地分支。
分支追踪
为了能够在远程分支 origin/hello-1.x 上进行工作，需要基于该远程分支创建本地分支：
git checkout hello-1.x
从远程分支创建本地分支，自动建立了分支间的跟踪，而从一个本地分支创建另外一个本地分支则没有。
从 hello-1.x 分支中创建新的本地分支 hello-jx，并与远程建立联系。
git checkout -b hello-jx hello-1.x
cat .git/config
远程版本库
# 设置
git remote add new-remote file:///path/to/repos/hello-user1.git

# 修改 url
git remote set-url new-remote file:///path/to/repos/hello-user2.git

# 单独修改 push 地址
git remote set-url --push new-remote /path/to/repos/hello-user2.git

# 修改 版本库名称
git remote rename new-remote user2

# 当注册了多个远程版本库并希望获取所有远程版本库的更新
git remote update

# 如果某个远程版本库不想在执行 git remote update 时获得更新
git config remote.user2.skipDefaultUpdate true

# 删除
git remote rm
PUSH 和 PULL 操作与远程版本库
在执行 git pull 操作的时候可以通过参数 --rebase 设置使用变基而非合并操作，将本地分支的改动变基到跟踪分支上。为了避免因为忘记使用 --rebase 参数导致分支的合并，可进行设置：
git config branch..rebase true
这样在遇到冲突（本地和远程分支出现偏离）的情况下，会采用变基操作，而不是默认的合并操作。
如果为本地版本库设置参数 branch.autosetuprebase ，值为 true，则在基于远程分支建立本地追踪分支时，会自动配置 branch..rebase 参数。
分支和里程碑的安全性


用 reflog 记录对分支的操作历史。默认创建的带工作区的版本库都会包含 core.logallrefupdates 为 true 的配置，这样在版本库中建立的每个分支都会创建对应的 reflog。但是创建的裸版本库默认不包含这个设置，也就不会为每个分支设置 reflog。可能因为分支误操作导致数据丢失，可以考虑为裸版本库添加此配置。


关闭非快进式提交。配置 receive.denyNonFastForwards 设置为 true，则禁止一切非快进式推送。更好的方法是通过架设基于 SSH 协议的 Git 服务器，配置强制提交的用户权限。


关闭分支删除功能。配置 receive.denyDeletes 设置为 true，则禁止删除分支。更好的方法是：配置分支删除的用户权限。


补丁文件交互
将最近三个提交转换为补丁文件：
git format-patch -s HEAD~3..HEAD
-s 会在导出的补丁文件中添加当前用户的签名。
应用补丁：
git am user1-mail-archive
git apply 可以应用一般格式的补丁文件，但是不能执行提交，也不能保持补丁中的作者信息。
References

3. Git 和声 — GotGit




iOS 开发技巧与工具推荐
Fri, 12 Jan 2018 13:00:00 +0000
状态栏
Help
Search 框可以方便地检索相关设置项。


Navigator
⌘ 1 .. ⌘ 7 可以切换窗口。
Show the Symbol navigator
在类不多时，可以方便查看所有类的结构；类多时可使用下方的 filter 功能过滤。

Show the Breakpoint navigator
点击右下角 + 选择 Exception Breakpoint..，可以添加更明确的报错断点，支持选择 Objective-C 或 Swift 语言。

Utilities
⌘ ⌥ 1 .. ⌘ ⌥ 7 可以切换窗口。
Show the Code Snippet Library
代码片段模板，也可以将自己写好的代码片段拖入。

Show the Media Library
可以直接拖拽图片到 xib 中，自动创建 UIImageView。
xib
快捷键
按住 option 拖拽可以快速复制组件。
快捷键
option ⌥

按住 ⌥ 并点击代码或方法时，可查看行内文档帮助。
按住 ⌥ 点击文件可以在辅助编辑窗模式打开文件（多栏显示，适用于 xib 与代码绑定）。推荐
按住 ⌥ ⇧ 点击文件可以选择文件打开的窗口位置。

显示和隐藏栏

⌘ ⇧ y 显示/隐藏调试区域。
⌘ ⌥ ⏎ 显示辅助编辑栏，Open the assistant editor
⌘ ⏎ 隐藏辅助编辑器栏。

组合键

^ 为 control，⌥ 为 option


⌘ ⌥ { ⌘ ⌥ } 整行上下移动代码。
将光标放在方法名上任一位置，点开 Edit，按住 ⌃ ⇧ 将看到 Copy Qualified Symbol Name，按住 ⌃ ⇧ ⌥ 将看到 Copy Symbol Name。例如 [UIColor colorWithRed:255/255.0f green:127/255.0f blue:80/255.0f alpha:1] 将被拷贝为 +[UIColor colorWithRed:green:blue:alpha:]。
自动缩进代码：^ i，或全选 ⌘ a 后 ^ i。
⌘ ⇧ o Open Quickly 快速查找文件。

UIKit 技巧
UITableViewCell 自适应 UITextView 高度
使用 Auto Layout 实现：

给 textView 上下左右建立相对于 cell 的约束
取消 textView 的 Scrolling Enabled
设置 tableView.estimatedRowHeight = 70
设置 textView.delegate = self

关键代码（避免 reloadData 导致键盘隐藏和跳动）：
func textViewDidChange(_ textView: UITextView) {
    let currentOffset = tableView.contentOffset
    UIView.setAnimationsEnabled(false)
    tableView.beginUpdates()
    tableView.endUpdates()
    UIView.setAnimationsEnabled(true)
    tableView.setContentOffset(currentOffset, animated: false)
}
Command Line

security find-identity -v 显示已安装的有效证书身份。

常见问题
Too many symbol files
上传 App Store 后收到此警告，通常是因为三方库生成了冗余的 32 位 symbols 文件。
解决方法：在 Podfile 中添加：
post_install do |installer|
  installer.pods_project.targets.each do |target|
    target.build_configurations.each do |config|
      config.build_settings['ARCHS'] = 'arm64'
    end
  end
end
检查 info.plist：
UIRequiredDeviceCapabilities

    arm64

在 Build Settings 中搜索 valid architecture，填写 arm64。
库推荐
R.swift - 强类型引用资源
R.swift 获取强类型、自动编译的图片、字体、segues 等资源，避免字符串引用导致的运行时错误。
// 传统方式（字符串，无编译检查）
let icon = UIImage(named: "settings-icon")
let font = UIFont(name: "San Francisco", size: 42)

// R.swift（强类型，编译时检查）
let icon = R.image.settingsIcon()
let font = R.font.sanFrancisco(size: 42)
配置要点：

添加 R.generated.swift 时不要勾选 Copy items if needed
在 .gitignore 添加 *.generated.swift
新增资源后需 ⌘ + B 编译才可使用

PromiseKit - 异步编程
PromiseKit 用于解决回调地狱问题：
// Promise 链式调用
firstly {
    login()
}.then { creds in
    fetch(avatar: creds.user)
}.done { image in
    self.imageView = image
}.catch {
    // 错误处理
}

// 并行操作
when(fulfilled: operation1(), operation2())
核心概念：

then - 链式调用，返回新 Promise
done - 链尾成功处理
catch - 统一错误处理
when - 并行等待多个 Promise
ensure - 无论成功失败都执行

fastlane - 自动化构建
fastlane 是 iOS/Android 自动化构建工具集：

produce - 创建 App ID
cert / sigh - 管理证书和描述文件
gym - 构建打包
deliver - 上传 App Store
snapshot - 自动截图
match - 团队证书同步


建议直接参考 fastlane 官方文档，并结合 Xcode Cloud 或 GitHub Actions 实现 CI/CD。

References

[译]每个 iOS 开发者都该知道的 17 个 Xcode 小技巧
R.swift - GitHub
PromiseKit - Getting Started
fastlane 官方文档




回顾 2017
Sun, 31 Dec 2017 22:00:00 +0000
2017 关键词：Birds、离职、狼人杀、白洋淀、iOS、自如。

Birds
Birds 是自己编写时间最长的一个 Web 项目。项目接手、改版、重构、迭代、盈利，上半年每天工作都是面对它。

Birds 良好的表现与需求互相推动，这点很重要，假如有需求而项目没有成长，或项目成长没了需求，对工程来说都只能是纸上谈兵、无事可做。项目中的规范的重要性，无论是代码还是数据库，只要项目不是夭折终将显现，对于规范性我绝不会开倒车，做任何妥协，种种经历只说明：这里欠的东西总会还。如何应对需求的千变万化，小结几点：模块化、组件化思想，功能多可配置，功能可拔插，功能方法粒度要小；不要对程序肆意进行打补丁式的修改，减少对流程入侵；当某一处的逻辑增加时要及时重新修改、定义流程；对需求目的的正确理解更是能高效开发。
对前端重新认识的一年。现在的前端和大学时刚刚接触时，已经大不一样了。前端能做的事情越来越多，很多业务逻辑都在前端处理，服务端只需要提供接口，分工合作更容易。浅尝 React Vue Webpack 后，也许前端才是自己的归宿。
离职
离职的不是我。老人走，新人来，新人走。离职一词在我身边跟了一年都没有停下来。同事离职的原因很多，离开北京、公司发展、自我发展… 马云说离职的原因就两个：1. 钱没给够。2. 受了委屈。我起初是认同这一说法的，但是后来觉得 “人” 或者说 “人的思想” 或者说 “人性” 在其中影响作用非常的大。相同的事情不同的角度看，结果相去甚远，如果基本的理念不同，那事情基本是无法调和的。
对做的事情的认同感，对自我的定位与认识，对现实情况的冷静思考，这几点需要反复咀嚼。
分享一篇文章：公司没大牛带，需要离职么？。对于刚入门的我们，这是一个很有代表性的问题。太多时候我们期待别人，忘了自己。公司有大牛，能跟着学是幸运，没有是常态。先接受了这个设定，会更容易找提高自己的方法。有没有大牛并不重要，我们是为了那个更好的自己。
狼人杀
2017 火的游戏很多：狼人杀、守望先锋、王者荣耀、吃鸡。狼人杀这一杀，好像杀到了毕业前和同学舍友在一起臭 high 的日子。可说骚话、互相 diss、互相吹捧，真真假假其乐无穷。最赤鸡的是鱼炸出了个女盆友，各路同学亲上加亲，无法克说。
白洋淀

我想 你说
你不要在孤单 让我做你的伴

白洋淀去过四次，那里的温泉过去两次，年中 Team Building 再喜加一，而这一次让这里有了美丽故事。喷泉、沙发，出现了对的人。
iOS
React Native 的一波尝试后，走上了移动开发的道。Swift 让上 iOS 车的门槛降低不少，Swift API 趋向稳定，可以说这是最好的时候。GitHub 应该是再也放不下了，外文的书籍、文档确实靠谱啊，推荐一个教程网站 iOS Tutorials - Ray Wenderlich 真的零基础入门。
我相信：一个人语言的界限，就是他世界的边界。
自如
一场大火让无数人无家可归，年末换房也受牵连。被自如圈粉，其他中介的房子真的太 low 了。自如订房子居然也要抢，一波三折、失而复得。在没抢到房子时，真的想走，想离开这里了，很凄凉。最终是在公司对面住下了，过上了在家吃中饭晚饭的日子。
2018 Happy New Year
2017 自己是幸运的，2018 猥琐发育，不要浪，胜利属于伏地魔。


【Git 权威指南】读书笔记 - 独奏 - Part 4
Mon, 25 Dec 2017 16:00:00 +0000
主要内容：【历史穿梭】、【改变历史】、【Git 克隆】
历史穿梭
查看条件个数：
git rev-list HEAD | wc -l
版本表示法：git rev-parse
git rev-parse pick out and massage parameters for other git commands.

--git-dir 可以显示 Git 版本库的位置
--show-cdup 当前工作区目录的深度
--parseopt 可以用于被 Git 无关应用用于解析命令行参数

# 显示分支，tag
git rev-parse --symbolic --branches

git rev-parse --symbolic --branches

# 显示定义的所有引用
git rev-parse --symbolic --glob=refs/*

# 显示多个表达式的 SHA1 哈希值：

git rev-parse  master  refs/heads/master
6652a0dce6a5067732c00ef0a220810a7230655e
6652a0dce6a5067732c00ef0a220810a7230655e

^后面的数字代表该提交的第几个父提交，~就相当于连续个符号^

git rev-parse  A~3  A^^^
e80aa7481beda65ae00e35afc4bc4b171f9b0ebf
e80aa7481beda65ae00e35afc4bc4b171f9b0ebf

# 暂存区里的文件和HEAD中的文件相同

git rev-parse  :gitg.png  HEAD:gitg.png
fc58966ccc1e5af24c2c9746196550241bc01c50
fc58966ccc1e5af24c2c9746196550241bc01c50

# 在提交日志中查找字串的方式显示提交
git rev-parse :/"Commit A"
81993234fc12a325d303eccea20f6fd629412712
版本范围表示法：git rev-list
git rev-list 可以帮助研究 Git 的各种版本范围语法。
# 从开始到 tag：A 的所有历史提交
git rev-list --oneline  A

# 每个 tag 历史提交的并集
git rev-list --oneline  D  F

# ^ 排除这个版本及其历史版本
git rev-list --oneline  ^G D

# ^G D 等价于 G..D
git rev-list --oneline  G..D

# 含 ^ 的参数顺序不重要，..
# ^B C 相当于 B..C
# C ^B 相当于 B..C
# C..B 相当于 ^C B
浏览日志：git
--graph 参数调用 git log 可以显示字符界面的提交关系图。
git config --global alias.glog "log --graph"

--oneline 单行显示
- 显示最近的  条日志
-p 显示变动
--stat 显示变动摘要

查看、分析某一个提交：
git show D --stat
tag D
...

git cat-file -p D^0
差异比较：git diff

比较里程碑 B 和里程碑 A，用命令：git diff B A
比较工作区和里程碑 A，用命令：git diff A
比较暂存区和里程碑 A，用命令：git diff -cached A
比较工作区和暂存区，用命令：git diff
比较暂存区和 HEAD，用命令：git diff -cached
比较工作区和 HEAD，用命令：git diff HEAD

显示不同版本下的文件差异：
git diff   -- 
非 Git 目录/文件的差异比较，可在版本库之外使用：
git diff  

--word-diff 差异逐 词 比较，而非缺省的逐 行 比较

文件追溯：git blame
逐行显示文件，在每一行的行首显示此行最早是在什么版本引入的，由谁引入。
只想查看某几行，使用 -L n,m 参数：
git blame -L 6,+5 README
二分查找：git bisect
定位问题代码。
改变历史
作为分布式版本控制系统，一旦版本库被多人共享，改变历史就可能是无法完成的任务。
悔棋
git commit –amend 单步悔棋，修补式提交。
检出文件到前一版：
git checkout HEAD^ -- src/hello.h
多步悔棋
git reset --soft HEAD^^
回到未来
拣选指令 git cherry-pick 从众多的提交中挑选出一个提交应用在当前的工作分支中。
该命令需要提供一个提交 ID 作为参数，操作过程相当于将该提交导出为补丁文件，然后在当前 HEAD 上重放形成无论内容还是提交说明都一致的提交。
操作例子：A B C D E F 6 次提交。
例子 1.1：出掉 D：
# 将 HEAD 指针切换到 C
git checkout C

# 拣选将 E 提交在当前 HEAD 上
git cherry-pick E

# 拣选操作将 F 提交在当前 HEAD 上
git cherry-pick master

# 将 master 分支指向新的提交 ID（f677821）上
git checkout master
git reset --hard HEAD@{1}
例子 1.2：D 融入 C：
git checkout D

# 将 C 和 D 融合
git reset --soft HEAD^^

# 提交说明重用C提交的提交说明
git commit -C C

git cherry-pick E
git cherry-pick F
git rebase 对提交执行变基操作，即可以实现将指定范围的提交“嫁接”到另外一个提交之上。
git rebase --onto   
变基操作的过程：

首先执行 git checkout ，如果 till 不是一个分支，则变基操作是在 detached HEAD 分离头指针 状态的，当变基结束后，对 master 分支执行重置以实现把变基结果记录在分支中。
将..所标识的提交范围写到一个临时文件中。（..是指包括的所有历史提交排除以及的历史提交后形成的版本范围）
当前分支强制重置（git reset –hard）到。
从保存在临时文件中的提交列表中，一个一个将提交按照顺序重新提交到重置之后的分支上。
如果遇到提交已经在分支中包含，跳过该提交。
如果在提交过程遇到冲突，变基过程暂停。用户解决冲突后，执行 git rebase –continue 继续变基操作。或者执行 git rebase –skip 跳过此提交。或者执行 git rebase –abort 就此终止变基操作切换到变基前的分支上。

例子 2.1：出掉 D：
git rebase --onto C D F
# or
git rebase --onto C E^ F
例子 2.2：D 融入 C：
git checkout D

# C和D融合
git reset --soft HEAD^^

git add .

# 复用 C 的提交信息
git commit -C C

# 记住这个提交 ID，可以用 tag 的方法
git tag newbase

git rebase --onto newbase E^ master
-i 交互式变基方法。
例子 3.1：出掉 D：
git rebase -i D^

# d, drop = remove commit
# 提交 D 标示修改为 d
例子 3.2：D 融入 C：
git rebase -i C^

# 提交 D 标示修改为 s
丢弃历史
重点内容第一次 Get
历史有的时候会成为负担。只保留最近的 100 次提交，抛弃之前的历史提交。那么应该如何操作呢？
例：清除 tag A 之前的提交历史：
# 查看里程碑A指向的目录树
git cat-file -p A^{tree}

# 使用git commit-tree命令直接从该目录树创建提交
echo "Commit from tree of tag A." | git commit-tree A^{tree}
8f7f94ba6a9d94ecc1c223aa4b311670599e1f86

# 命令git commit-tree的输出是一个提交的SHA1哈希值。
# 会发现这个提交没有历史提交，可以称之为孤儿提交。
git log 8f7f94ba6a9d94ecc1c223aa4b311670599e1f86

# 将master分支从里程碑到最新的提交全部迁移到刚刚生成的孤儿提交上。
git rebase --onto 8f7f94ba6a9d94ecc1c223aa4b311670599e1f86 A master
反转提交
git revert HEAD
Git 克隆
鸡蛋不装在一个篮子里
1. git clone  
2. git clone --bare    
3. git clone --mirror  
一般约定俗成裸版本库的目录名以 .git 为后缀。
用法 3 区别于用法 2 之处在于用法 3 克隆出来的裸版本对上游版本库进行了注册，这样可以在裸版本库中使用 git fetch 命令和上游版本库进行持续同步。
克隆生成裸版本库
git clone --bare /path/to/my/workspace/demo /path/to/repos/demo.git
demo.git 目录就是版本库目录，不含工作区。
git --git-dir=/path/to/repos/demo.git config core.bare
true

# 向其 push
git push /path/to/repos/demo.git
创建生成裸版本库
git init --bare /path/to/repos/demo-init.git
References

2. Git 独奏 — GotGit




【Git 权威指南】读书笔记 - 独奏 - Part 3
Thu, 03 Aug 2017 11:00:00 +0000
主要内容：【Git 基本操作】
Git 基本操作
先来合个影
在 Git 里，“留影”用的命令叫做 tag，更加专业的术语叫做“里程碑”（打 tag，或打标签）。
git tag -m "Say bye-bye to all previous practice." old_practice
里程碑无非也是一个引用，通过记录提交 ID（或者创建 Tag 对象）来为当前版本库状态进行“留影”。
git rev-parse refs/tags/old_practice
41bd4e2cce0f8baa9bb4cdda62927b408c846cd6
git describe 显示当前版本库的最新提交的版本号。格式：最近的 tag - 距离此 tag 的个数 - 该提交的 SHA1
git describe
old_practice

# .. commit something

git describe
old_practice-2-g8861c65

删除文件
rm *.txt 针对的是 工作区，对 暂存区 和 版本库 没有任何影响。
git rm detached-commit.txt hack-1.txt new-commit.txt welcome.txt 删除动作加入了暂存区，commit 后在版本库罪行提交中删除了，在历史提交中尚在。
可以通过下面命令查看历史版本的文件列表：
git ls-files --with-tree=HEAD^
detached-commit.txt
new-commit.txt
welcome.txt
查看在历史版本中尚在的删除文件的内容：
git cat-file -p HEAD^:welcome.txt
Hello.
Nice to meet you.
git add -u 命令会对工作区中 所有改动 以及 删除文件 添加到暂存区。
恢复删除的文件
git cat-file -p HEAD~1:welcome.txt > welcome.txt
然后加入暂存区，提交到版本库：
git add -A
git commit -m "restore file: welcome.txt"
这是通过再次添加的方式恢复被删除的文件。
git add -A 命令会对工作区中 所有改动 以及 新增文件 添加到暂存区。
移动文件
git mv welcome.txt README
交互界面
git add -i
文件忽略
cat > .gitignore << EOF
> hello
> *.o
> *.h
> EOF
查看被忽略的文件：
git status --ignored -s
将忽略的文件强制添加到仓库中：
git add -f hello.h
git commit -m "add hello.h"
[master 48456ab] add hello.h
 1 files changed, 1 insertions(+), 0 deletions(-)
 create mode 100644 src/hello.h
忽略只对未跟踪文件有效，对于已加入版本库的文件无效。 将 hello.h 添加到版本库后，对 hello.h 的修改都会立刻被跟踪到。.gitignore 只是对未入库的文件起作用。
本地独享式忽略文件
.gitignore 设置的文件忽略是共享式的，是因为.gitignore 被添加到版本库后成为了版本库的一部分，文件忽略在他人的工作区中同样生效。
享式忽略有两种方式：

在版本库.git 目录下的一个文件.git/info/exclude 来设置文件忽略。
通过 Git 的配置变量 core.excludesfile 指定的一个忽略文件，其设置的忽略对所有文件均有效。

git config --global core.excludesfile /home/jiangxin/_gitignore
git config core.excludesfile
/home/jiangxin/_gitignore

cat /home/jiangxin/_gitignore
*~        # vim 临时文件
*.pyc     # python 的编译文件
.*.mmx    # 不是正则表达式哦，因为 FreeMind-MMX 的辅助文件以点开头
Git 忽略语法

# 表示开始的行被忽略。
通配符。* 任意多字符，? 一个字符，[abc] 可选字符范围。
最后面是一个 / 表示忽略的是整个目录，同名文件不忽略，否则同名的文件和目录都忽略。
最前面 ! 表示不忽略。

# 这是注释行 —— 被忽略
*.a       # 忽略所有以 .a 为扩展名的文件。
!lib.a    # 但是 lib.a 文件或者目录不要忽略，即使前面设置了对 *.a 的忽略。
/TODO     # 只忽略根目录下的 TODO 文件，子目录的 TODO 文件不忽略。
build/    # 忽略所有 build/ 目录下的文件。
doc/*.txt # 忽略文件如 doc/notes.txt，但是文件如 doc/server/arch.txt 不被忽略。
文件归档
如果想压缩工作区文件归档，可能一不小心会把版本库（.git 目录）包含其中，甚至将工作区中的忽略文件、临时文件也包含其中。所以 Git 提供了一个归档命令 git archive。
# 基于最新提交建立归档文件latest.zip
git archive -o latest.zip HEAD

# 只将目录 src 和 doc 建立到归档 partial.tar 中
git archive -o partial.tar  HEAD src doc

# 基于里程碑v1.0建立归档，并且为归档中文件添加目录前缀1.0
git archive --format=tar --prefix=1.0/ v1.0 | gzip > foo-1.0.tar.gz
References

2. Git 独奏 — GotGit




【Git 权威指南】读书笔记 - 独奏 - Part 2
Thu, 20 Jul 2017 11:00:00 +0000
主要内容：【Git 重置】、【Git 检出】、【恢复进度】
Git 重置
分支游标 master 的探秘
git log --graph --oneline
* e695606 which version checked in?
* a0c641e who does commit?
* 9e8a761 initialized.
引用 refs/heads/master 就好像是一个游标，在有新的提交发生的时候指向了新的提交。
Git 提供了 git reset 命令，可以将“游标”指向任意一个存在的提交 ID。注意下面的命令中使用了 --hard 参数，会破坏工作区未提交的改动，慎用。
git reset --hard HEAD^
HEAD is now at e695606 which version checked in?

用 reflog 挽救错误的重置
通过 .git/logs 目录下日志文件记录了分支的变更。默认非裸版本库（带有工作区）都提供分支日志功能，这是因为带有工作区的版本库都有如下设置：
git config core.logallrefupdates
true
查看一下 master 分支的日志文件 .git/logs/refs/heads/master 中的内容。
tail -5 .git/logs/refs/heads/master
Git 提供了一个 git reflog 命令，对这个文件进行操作。
git reflog show master | head -5
9e8a761 master@{0}: 9e8a761: updating HEAD
e695606 master@{1}: HEAD^: updating HEAD
4902dc3 master@{2}: commit: does master follow this new commit?
...
重置 master 为两次改变之前的值。
git reset --hard master@{2}
深入了解 git reset 命令
git reset [-q] [] [--] ...
git reset [--soft | --mixed | --hard | --merge | --keep] [-q] []
为了避免路径和引用（或者提交 ID）同名而冲突，可以在  前用两个连续的短线（减号）作为分隔。


--hard 会执行上图中的 1、2、3 全部的三个动作。


替换引用的指向。引用指向新的提交 ID。
替换暂存区。替换后，暂存区的内容和引用指向的目录树一致。
替换工作区。替换后，工作区的内容变得和暂存区一致，也和 HEAD 所指向的目录树内容相同。


--soft 会执行上图中的操作 1。
--mixed（缺省）会执行上图中的操作 1 和操作 2。

git reset
git reset HEAD
# 仅用 HEAD 指向的目录树重置暂存区，工作区不会受到影响，相当于将之前用 git add 命令更新到暂存区的内容撤出暂存区。引用也未改变，因为引用重置到 HEAD 相当于没有重置。

git reset -- filename
git reset HEAD filename
# 仅将文件 filename 撤出暂存区，暂存区中其他文件不改变。相当于对命令 git add filename 的反向操作。

git reset --soft HEAD^
# 工作区和暂存区不改变，但是引用向前回退一次。当对最新提交的提交说明或者提交的更改不满意时，撤销最新的提交以便重新提交。git commit 的反向操作。
# 在之前曾经介绍过一个修补提交命令 git commit --amend，用于对最新的提交进行重新提交以修补错误的提交说明或者错误的提交文件。修补提交命令实际上相当于执行了下面两条命令。（注：文件 .git/COMMIT_EDITMSG 保存了上次的提交日志）
git reset --soft HEAD^
git commit -e -F .git/COMMIT_EDITMSG

git reset HEAD^
# 工作区不改变，但是暂存区会回退到上一次提交之前，引用也会回退一次。

git reset --hard HEAD^
# 彻底撤销最近的提交。引用回退到前一次，而且工作区和暂存区都会回退到上一次提交的状态。自上一次以来的提交全部丢失。
Git 检出
重置命令 git reset 的一个用途就是修改引用（如 master）的游标。如果 HEAD 要改变该如何改变呢？检出命令 git checkout 该命令的实质就是修改 HEAD 本身的指向，该命令不会影响分支“游标”（如 master）。
HEAD 的重置即检出
git co HEAD^
Note: checking out 'HEAD^'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.
# 您现在处于 '分离头指针' 状态。您可以检查、测试和提交，而不影响任何分支。
# 通过执行另外的一个 checkout 检出指令会丢弃在此状态下的修改和提交。

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:
# 如果想保留在此状态下的修改和提交，使用 -b 参数调用 checkout 检出指令以
# 创建新的跟踪分支。如：

  git checkout -b 

HEAD is now at 3175afd...
什么叫做 detached HEAD “分离头指针”状态？查看一下此时 HEAD 的内容就明白了。
cat .git/HEAD
3175afde9450a1dc40b09d05a012b45e967cb80f
原来“分离头指针”状态指的就是 HEAD 头指针指向了一个具体的提交 ID，而不是一个引用（分支）。注意上面的 reflog 是 HEAD 头指针的变迁记录，而非 master 分支。
查看一下 HEAD 和 master 对应的提交 ID，会发现现在它们指向的不一样。
git rev-parse HEAD master
3175afde9450a1dc40b09d05a012b45e967cb80f
bd08cb462d38b54b930cf1934b0c33f2e4592390
在“分离头指针”模式仍然可以进行提交：
git status
HEAD detached at 3175afd
...
但是在 checkout 到其他分支时，刚才的提交会丢失，但是这个提交仍然在版本库中，由于这个提交没有被任何分支跟踪到，因此并不能保证这个提交会永久存在。
实际上当 reflog 中含有该提交的日志过期后，这个提交随时都会从版本库中彻底清除。
挽救分离头指针
在“分离头指针”模式下进行的测试提交除了使用提交 ID acc2f69 访问之外，不能通过 master 分支或其他引用访问到。使用合并操作 git merge 将提交 acc2f69 合并到 master 分支中来。
git merge acc2f69
Merge made by recursive.
...
恢复进度
继续暂存区未完成的实践
# 保存当前工作进度
git stash

# 查看保存的进度用命令
git stash list

# 最近保存的进度进行恢复
git stash pop
git stash pop [--index] []
# --index 除了恢复工作区的文件外，还尝试恢复暂存区
# 从该  中恢复
git stash [save [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]
                [-u|--include-untracked] [-a|--all] []]

--patch 会显示工作区和 HEAD 的差异，通过对差异文件的编辑决定在进度中最终要保存的工作区的内容，通过编辑差异文件可以在进度中排除无关内容。
使用 -k 或者 --keep-index 参数，在保存进度后不会将暂存区重置。

# 不删除恢复的进度之外，其余和 git stash pop 命令一样
git stash apply [--index] []

# 删除一个存储的进度
git stash drop []

# 删除所有存储的进度
git stash clear

# 基于进度创建分支
git stash branch  
探秘 git stash
在执行 git stash 命令时，Git 实际调用了一个脚本文件实现相关的功能。
git --exec-path
/usr/lib/git-core

file /usr/lib/git-core/git-stash
/usr/lib/git-core/git-stash: POSIX shell script text executable
本地没有被版本控制系统跟踪的文件并不能保存进度。因此本地新文件需要执行添加 add 再执行 git stash 命令。
在用 git stash 命令保存进度时，提供说明更容易找到对应的进度文件。
每个进度的标识都是 stash@{} 格式，像极了前面介绍的 reflog 的格式。git stash 的就是用到了前面介绍的引用和引用变更日志 reflog 来实现的。
用 git stash 保存进度，实际上会将进度保存在引用 refs/stash 所指向的提交中。多次的进度保存，实际上相当于引用 refs/stash 一次又一次的变化，而 refs/stash 引用的变化由 reflog（即.git/logs/refs/stash）所记录下来。
如何在引用 refs/stash 中同时保存暂存区的进度和工作区中的进度
git log --graph --pretty=raw  refs/stash -2
*   commit e5c0cdc2dedc3e50e6b72a683d928e19a1d9de48
|\  tree 780c22449b7ff67e2820e09a6332c360ddc80578
| | parent 2b31c199d5b81099d2ecd91619027ab63e8974ef
| | parent c5edbdcc90addb06577ff60f644acd1542369194
| | author Jiang Xin  1291623066 +0800
| | committer Jiang Xin  1291623066 +0800
| |
| |     WIP on master: 2b31c19 Merge commit 'acc2f69'
| |
| * commit c5edbdcc90addb06577ff60f644acd1542369194
|/  tree 780c22449b7ff67e2820e09a6332c360ddc80578
|   parent 2b31c199d5b81099d2ecd91619027ab63e8974ef
|   author Jiang Xin  1291623066 +0800
|   committer Jiang Xin  1291623066 +0800
|
|       index on master: 2b31c19 Merge commit 'acc2f69'
最新的提交说明中有 WIP（Work In Progess）字样，说明代表了工作区进度。而最新提交的第二个父提交（上图中显示为第二个提交）有 index on master 字样，说明这个提交代表着暂存区的进度。
References

2. Git 独奏 — GotGit




【Git 权威指南】读书笔记 - 独奏 - Part 1
Wed, 19 Jul 2017 16:00:00 +0000
主要内容：【Git 初始化】、【Git 暂存区】、【Git 对象】
Git 初始化
设置一下 Git 的环境变量，这个设置是一次性的工作。即这些设置会在全局文件（用户主目录下的 ~/.gitconfig）或系统文件（/etc/gitconfig）中做永久的记录。
配置的用户名和邮件地址将在版本库提交时作为提交者的用户名和邮件地址。
git config --global user.name "Jiang Xin"
git config --global user.email jiangxin@ossxp.com
设置一些 Git 别名，以便可以使用更为简洁的子命令
只在本用户的全局配置中添加 Git 命令别名：
git config --global alias.br branch
git config --global alias.ci "commit -s"
git config --global alias.co checkout
git config --global alias.st "-p status"

版本库的初始化
mkdir demo
cd demo
git init
初始化空的 Git 版本库于 /path/to/my/workspace/demo/.git/
git init 命令的后面直接输入目录名称
cd /path/to/my/workspace
git init demo
ls -aF
./  ../  .git/
这个隐藏的 .git 目录就是 Git 版本库（又叫仓库，repository）。
.git 版本库目录所在的目录，即 /path/to/my/workspace/demo 目录称为 工作区。
将新建立的文件添加到版本库
git add welcome.txt
再执行一次提交操作，使用 -m 参数直接给出了提交说明。
git ci -m "initialized"
[master (root-commit) 7f0b2be] init
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 welcome.txt
git ci 是上面配置的别名，我个人觉得 -s 这个参数比较冗余。
思考：为什么工作区下有一个 .git 目录？
Git 的这种设计，将版本库放在工作区根目录下，所有的版本控制操作（除了和其他远程版本库之间的互操作）都在本地即可完成，不像 Subversion 只有寥寥无几的几个命令才能脱离网络执行。而且 Git 也没有 CVS 和 Subversion 的安全泄漏问题（只要保护好 .git 目录），也没有 Subversion 在本地文件搜索时出现搜索结果混乱的问题，甚至 Git 还提供了一条 git grep 命令来更好地搜索工作区的文件内容。
git grep "工作区文件内容搜索"
当工作区中包含了子目录，在子目录中执行 Git 命令时，如何定位版本库呢？
当在 Git 工作区目录下执行操作的时候，会对目录依次向上递归查找 .git 目录，找到的 .git 目录就是工作区对应的版本库，.git 所在的目录就是工作区的根目录，文件 .git/index 记录了工作区文件的状态（实际上是 暂存区 的状态）。
如果跟踪一下执行 git status 命令时的磁盘访问，会看到沿目录依次向上递归的过程。
strace -e 'trace=file' git status
那么有什么办法知道 Git 版本库的位置，以及工作区的根目录在哪里呢？
显示版本库 .git 目录所在的位置。
git rev-parse --git-dir
/path/to/my/workspace/demo/.git
显示工作区根目录。
git rev-parse --show-toplevel
/path/to/my/workspace/demo
把版本库 .git 目录放在工作区，是不是太不安全了？
Git 克隆可以降低因为版本库和工作区混杂在一起导致的版本库被破坏的风险。在本机另外的磁盘/目录中建立 Git 克隆，并在工作区有改动提交时，手动或自动地执行向克隆版本库的推送 git push 操作。如果使用网络协议，还可以实现在其他机器上建立克隆，这样就更安全了（双机备份）。
思考：git config 命令参数的区别？
将打开 /path/to/my/workspace/demo/.git/config 文件进行编辑：
cd /path/to/my/workspace/demo/
git config -e
将打开 /home/jiangxin/.gitconfig（用户主目录下的 .gitconfig 文件）全局配置文件进行编辑：
git config -e --global
将打开 /etc/gitconfig 系统级配置文件进行编辑：
git config -e --system
Git 的三个配置文件分别是 版本库级别的配置文件、全局配置文件（用户主目录下）和 系统级配置文件（/etc 目录下）。
其中 版本库级别配置文件 的优先级最高，全局配置文件 其次，系统级配置文件 优先级最低。
Git 配置文件采用的是 INI 文件格式。
cat /path/to/my/workspace/demo/.git/config
[core]
        repositoryformatversion = 0
        filemode = true
        bare = false
        logallrefupdates = true
例如读取 [core] 小节的 bare 的属性值
git config .

git config core.bare
false
更改或设置 INI 文件中某个属性
git config . 

git config a.b something
git config x.y.z others
打开 .git/config 文件
[a]
        b = something
[x "y"]
        z = others
可以用 git config 命令操作任何其他的 INI 文件
GIT_CONFIG=test.ini git config a.b.c.d "hello, world"
GIT_CONFIG=test.ini git config a.b.c.d
hello, world
思考：是谁完成的提交？
当最新的提交删除了 user.name 和 user.email，提交时 Git 对提交者的用户名和邮件地址做了大胆的猜测，这个猜测可能是错的。
重新设置 user.name 和 user.email，然后执行下面的命令，重新修改最新的提交，改正作者和提交者的错误信息。
git commit --amend --allow-empty --reset-author

参数 --amend 是对刚刚的提交进行修补，这样就可以改正前面错误的提交（用户信息错误），而不会产生另外的新提交。
参数 --allow-empty 是因为要进行修补的提交实际上是一个空白提交，Git 默认不允许空白提交。
参数 --reset-author 的含义是将 Author（提交者）的 ID 重置，否则只会影响最新的 Commit（提交者）的 ID。这条命令也会重置 AuthorDate 信息。

思考：随意设置提交者姓名，是否太不安全？
Git 可以随意设置提交的用户名和邮件地址信息，这是分布式版本控制系统的特性使然，每个人都是自己版本库的主人，很难也没有必要进行身份认证从而使用经过认证的用户名作为提交的用户名。
但是可以使用 GitLab 等服务管理权限。
思考：命令别名是干什么的？
命令别名可以帮助用户解决从其他版本控制系统迁移到 Git 后的使用习惯问题。
备份本章的工作成果
cd /path/to/my/workspace
git clone demo demo-step-1
Cloning into demo-step-1...
done.
Git 暂存区
git log --stat
可以用 git log 查看提交日志，附加的 --stat 参数看到每次提交的文件变更统计。
修改不能直接提交？
现在就将修改的文件“添加”到提交暂存区：
git add welcome.txt
这时如果和 HEAD（当前版本库的头指针）或者 master 分支（当前工作分支）进行比较，会发现有差异。这个差异才是正常的，因为尚未真正提交么。
git diff HEAD
用简洁方式显示状态
git status -s
M  welcome.txt
通过参数 --cached 或者 --staged 参数调用 git diff 命令，看到的是提交暂存区 stage 和版本库中文件的差异。不然看到的是工作区的变动。
git diff --cached
现在执行 git commit 命令进行提交。
git commit -m "which version checked in?"
如何证明提交成功了呢？通过查看提交日志，看到了新的提交。
git log --pretty=oneline
理解 Git 暂存区 stage
当执行 git status 命令（或者 git diff 命令）扫描工作区改动的时候，先依据 .git/index 文件中记录的（工作区跟踪文件的）时间戳、长度等信息判断工作区文件是否改变。
文件 .git/index 实际上就是一个包含文件索引的目录树，像是一个虚拟的工作区。在这个虚拟工作区的目录树中，记录了文件名、文件的状态信息（时间戳、文件长度等）。文件的内容并不存储其中，而是保存在 Git 对象库 .git/objects 目录中，文件索引建立了文件和对象库中对象实体之间的对应。


图中可以看出此时 HEAD 实际是指向 master 分支的一个“游标”。所以图示的命令中出现 HEAD 的地方可以用 master 来替换。
图中的 objects 标识的区域为 Git 的对象库，实际位于 .git/objects 目录下，会在后面的章节重点介绍。
当执行 git reset HEAD 命令时，暂存区的目录树会被重写，被 master 分支指向的目录树所替换，但是工作区不受影响。
当执行 git rm --cached  命令时，会直接从暂存区删除文件，工作区则不做出改变。
当执行 git checkout . 或者 git checkout --  命令时，会用暂存区全部或指定的文件替换工作区的文件。这个操作很危险，会清除工作区中未添加到暂存区的改动。
当执行 git checkout HEAD . 或者 git checkout HEAD  命令时，会用 HEAD 指向的 master 分支中的全部或者部分文件替换暂存区和以及工作区中的文件。这个命令也是极具危险性的，因为不但会清除工作区中未提交的改动，也会清除暂存区中未提交的改动。

Git diff 魔法
有什么办法能够像查看工作区一样的，直观的查看暂存区以及 HEAD 当中的目录树么？
git ls-tree -l HEAD
100644 blob fd3c069c1de4f4bc9b15940f490aeb48852f3c42      25    welcome.txt
要显示暂存区的目录树，可以使用 git ls-files 命令。
git ls-files -s
100644 18832d35117ef2f013c4009f5b2128dfaeff354f 0       a/b/c/hello.txt

不要使用 git commit -a
提交命令 git commit 可以带上 -a 参数，对本地所有变更的文件执行提交操作，包括本地修改的文件，删除的文件，但不包括未被版本库跟踪的文件。
这个“偷懒”的提交命令，就会丢掉 Git 暂存区带给用户最大的好处：对提交内容进行控制的能力。
Git 对象
什么是 HEAD？什么是 master？为什么它们二者可以相互替换使用？为什么 Git 中的很多对象像提交、树、文件内容等都用 40 位的 SHA1 哈希值来表示？
Git 对象库探秘
40 位十六进制数字组成的 SHA1 哈希值
git log -1 --pretty=raw
# 这是本次提交的唯一标识。
commit e695606fc5e31b2ff9038a48a3d363f4c21a3d86
# 这是本次提交所对应的目录树。
tree f58da9a820e3fd9d84ab2ca2f1b467ac265038f9
# 这是本地提交的父提交（上一次提交）。
parent a0c641e92b10d8bcca1ed1bf84ca80340fdefee6

    which version checked in?
研究 Git 对象 ID 的命令是 git cat-file，用下面的命令可以查看一下这三个 ID 的类型。
git cat-file -t e695606
commit
git cat-file -t f58d
tree
git cat-file -t fd3c06
blob

再用 git cat-file 命令查看一下这几个对象的内容。对于 blob 对象，这个对象保存着文件 welcome.txt 的内容。
git cat-file -p fd3c06
Hello.
Nice to meet you.
这个写对象都存在 Git 库中的 objects 目录下，ID 的前两位作为目录名，后 38 位作为文件名。
for id in e695606 f58da9a a0c641e fd3c069; do \
  ls .git/objects/${id:0:2}/${id:2}*; done
.git/objects/e6/95606fc5e31b2ff9038a48a3d363f4c21a3d86
.git/objects/f5/8da9a820e3fd9d84ab2ca2f1b467ac265038f9
.git/objects/a0/c641e92b10d8bcca1ed1bf84ca80340fdefee6
.git/objects/fd/3c069c1de4f4bc9b15940f490aeb48852f3c42

HEAD 和 master 的奥秘
git log -1 HEAD
git log -1 master
git log -1 refs/heads/master
在当前版本库中，HEAD、master 和 refs/heads/master 具有相同的指向。现在到版本库 .git 中一探它们的究竟：
find .git -name HEAD -o -name master
.git/HEAD
.git/logs/HEAD
.git/logs/refs/heads/master
.git/refs/heads/master
显示一下 .git/HEAD
cat .git/HEAD
ref: refs/heads/master
指向一个引用：refs/heads/master
cat .git/refs/heads/master
e695606fc5e31b2ff9038a48a3d363f4c21a3d86
显示该提交的内容
git cat-file -p e695606fc5e31b2ff9038a48a3d363f4c21a3d86
tree f58da9a820e3fd9d84ab2ca2f1b467ac265038f9
parent a0c641e92b10d8bcca1ed1bf84ca80340fdefee6

which version checked in?
原来分支 master 指向的是一个提交 ID（最新提交）。
这样的分支实现是多么的巧妙啊：既然可以从任何提交开始建立一条历史跟踪链，那么用一个文件指向这个链条的最新提交，那么这个文件就可以用于追踪整个提交历史了。
这个文件就是 .git/refs/heads/master 文件。

目录 .git/refs 是保存引用的命名空间，其中 .git/refs/heads 目录下的引用又称为分支。对于分支既可以使用正规的长格式的表示法，如 refs/heads/master，也可以去掉前面的两级目录用 master 来表示。Git 有一个底层命令 git rev-parse 可以用于显示引用对应的提交 ID。
问题：SHA1 哈希值到底是什么，如何生成的？
哈希(hash)是一种数据摘要算法（或称散列算法），是信息安全领域当中重要的理论基石。该算法将任意长度的输入经过散列运算转换为固定长度的输出。固定长度的输出可以称为对应的输入的数字摘要或哈希值。
echo -n Git |sha1sum
5819778898df55e3a762f0c5728b457970d72cae  -
提交的 SHA1 哈希值生成方法：
git cat-file commit HEAD | wc -c
234

# 在提交信息的前面加上内容 `commit 234`（``为空字符），然后执行 SHA1 哈希算法。
( printf "commit 234\000"; git cat-file commit HEAD ) | sha1sum
e695606fc5e31b2ff9038a48a3d363f4c21a3d86  -

# 上面命令得到的哈希值和用 `git rev-parse` 看到的是一样的。
git rev-parse HEAD
e695606fc5e31b2ff9038a48a3d363f4c21a3d86
文件内容的 SHA1 哈希值生成方法：
# 文件总共包含 25 字节的内容。
git cat-file blob HEAD:welcome.txt | wc -c
25

# 在文件内容的前面加上blob 25的内容，然后执行SHA1哈希算法。
( printf "blob 25\000"; git cat-file blob HEAD:welcome.txt ) | sha1sum
fd3c069c1de4f4bc9b15940f490aeb48852f3c42  -

# 上面命令得到的哈希值和用git rev-parse看到的是一样的。
git rev-parse HEAD:welcome.txt
fd3c069c1de4f4bc9b15940f490aeb48852f3c42
树的 SHA1 哈希值的形成方法：
# HEAD对应的树的内容共包含39个字节。
git cat-file tree HEAD^{tree} | wc -c
39

# 在树的内容的前面加上tree 39的内容，然后执行SHA1哈希算法。
( printf "tree 39\000"; git cat-file tree HEAD^{tree} ) | sha1sum
f58da9a820e3fd9d84ab2ca2f1b467ac265038f9  -

# 上面命令得到的哈希值和用git rev-parse看到的是一样的。
git rev-parse HEAD^{tree}
f58da9a820e3fd9d84ab2ca2f1b467ac265038f9
问题：为什么不用顺序的数字来表示提交？
集中式版本控制系统因为只有一个集中式的版本库，可以很容易的实现依次递增的全局唯一的提交号。Git 作为分布式版本控制系统，开发可以是非线性的。这就要求提交的编号不能仅仅是本地局部有效，而是要“全球唯一”。
采用部分的 SHA1 哈希值。不必写全 40 位的哈希值，只采用开头的部分，不和现有其他的冲突即可。
使用 master 代表分支 master 中最新的提交，使用全称 refs/heads/master 亦可。
使用 HEAD 代表版本库中最近的一次提交。
符号 ^ 可以用于指代父提交。例如：

HEAD^ 代表版本库中上一次提交，即最近一次提交的父提交。
HEAD^^ 则代表 HEAD^ 的父提交。

对于一个提交有多个父提交，可以在符号 ^ 后面用数字表示是第几个父提交。例如：

a573106^2 含义是提交 a573106 的多个父提交中的第二个父提交。
HEAD^1 相当于 HEAD^ 含义是 HEAD 多个父提交中的第一个。
HEAD^^2 含义是 HEAD^（HEAD 父提交）的多个父提交中的第二个。

符号 ~ 也可以用于指代祖先提交。效果等同：
a573106~5
a573106^^^^^
提交所对应的树对象：a573106^{tree}
某一此提交对应的文件对象：a573106:path/to/file
暂存区中的文件对象：:path/to/file
git rev-parse HEAD
git cat-file -p e695
git cat-file -p e695^
git rev-parse e695^{tree}
References

2. Git 独奏 — GotGit




【Git 权威指南】读书笔记 - 初识 Git
Wed, 12 Jul 2017 15:00:00 +0000
Git 是一款分布式版本控制系统，有别于 CVS 和 SVN 等集中式版本控制系统，Git 可以让研发团队更加高效地协同工作、提高生产率。使用 Git，开发人员的工作不会因为频繁地遭遇提交冲突而中断，管理人员也无须为数据的备份而担心。经过 Linux 这样庞大的项目的考验之后，Git 被证明可以胜任任何规模的团队，即便这个团队的成员分布于世界各地。
Git 是开源社区奉献给每一个人的宝贝，用好它可以实现个人的知识积累、保护好自己的数据，而且还能与他人分享自己的成果。
版本控制的前世和今生
即便是在 CVS 出现之前的“史前时代”，也已经有了非常好用的源码比较和打补丁的工具：diff 和 patch，他们今天生命力依然顽强。

对这 hello world 两个文件执行 diff 命令，查看两个文件的差异。如下所示：
diff -u hello world | less -N
上面执行 diff 命令的 -u 参数很重要，使得差异输出中带有上下文。管道后面带有 -N 参数的 less 命令（按字母 q 退出）会在输出的每一行前面添加行号，便于对输出结果进行说明。
命令 patch 相当于 diff 的反向操作
分布式版本控制系统最大的反传统之处在于，可以不需要集中式的版本库，每个人都工作在通过克隆操作建立的本地版本库中，也就是说每个人都拥有一个完整的版本库。分布式版本控制系统的几乎所有操作包括查看提交日志、提交、创建里程碑和分支、合并分支、回退等都直接在本地完成而不需要网络连接。每个人都是本地版本库的主人，不再有谁能提交谁不能提交的限制，加之多样的协同工作模型（版本库间推送、拉回，及补丁文件传送等）让开源项目的参与度有爆发式增长。
爱上 Git 的理由

每日的工作备份。鸡蛋不全放在一个篮子里。
异地协同工作。通过一个远程版本库，同步数据。
现场版本控制。在部署的现场，进行源代码的修改，能够将修改结果甚至修改过程一并带走，并能够将修改结果合并至项目对应的代码库中。
避免引入辅助目录。只在工作区的顶级目录下创建名为 .git 的目录（版本库目录），如果认为唯一的一个 .git 目录也过于碍眼，可以将其放到工作区之外的任意目录。一旦这么做了，你在执行 Git 命令时，要通过命令行 --git-dir 或环境变量 GIT_DIR 为工作区指定版本库目录，甚至还要指定工作区目录。
重写提交说明。这个命令如果不带 -m 参数，会进入提交说明编辑界面。

git commit --amend

想吃后悔药。假如提交的数据中不小心包含了一个不应该检入的虚拟机文件——大约有 1 个 GB。

git rm --cached winxp.img
git commit --amend

更好用的提交列表。正确的版本控制系统的使用方法是：一次提交只干一件事。而不要在下班时才想起来要提交，那样的话版本控制系统就被降格为文件备份系统了。
更好的差异比较。git diff
工作进度保存。

git stash
git checkout <new_branch>
# do something
git checkout <orignal_branch>
git stash pop

代理 SVN 提交实现移动式办公。
无处不在的分页器。-p
快。Git 作为分布式版本控制系统几乎所有的操作都在本地进行。

安装 Git
sudo aptitude install git
sudo aptitude install git-doc git-svn git-email gitk
软件包 git-svn、git-email、gitk 本来也是 Git 软件包的一部分，但是因为有着不一样的软件包依赖（如更多 perl 模组，tk 等），所以单独作为软件包发布。


NGINX 启用 HTTP/2
Tue, 06 Jun 2017 21:00:00 +0000
简介
HTTP/2（RFC 7540，2015 年发布）是自 1999 年 HTTP/1.1 以来的第一次重大升级，目标是在 不改变应用语义 的前提下，改善延迟、并发和网络效率。浏览器端基本只在 TLS 上启用（h2），明文版本 h2c 仅用于内部服务间通信。

h2：HTTP/2 over TLS（最常见，浏览器只支持这一种）
h2c：HTTP/2 over TCP（无加密）

设计背景
移动端和富媒体时代，请求量激增，HTTP/1.1 的队头阻塞、多个 TCP 连接并行带来的 慢启动/拥塞竞争 成为瓶颈。
谷歌的 SPDY 原型验证了“单连接、多路复用、压缩头部”等思路；IETF 在 SPDY 3.1 基础上标准化为 HTTP/2。
核心特性

  
      
          特性
          作用
      
  
  
      
          二进制分帧 (Binary Framing)
          把 HTTP 报文拆成小型 Frame；机器易解析、可并行
      
      
          多路复用 (Multiplexing)
          多个请求/响应 共享一个 TCP 连接，互不阻塞
      
      
          流与优先级 (Stream & Priority)
          每个请求是双向 Stream，可指定权重与依赖
      
      
          头部压缩 (HPACK)
          静态 Huffman + 动态表，大幅减少重复的 Header 字节
      
      
          服务器推送 (Server Push)
          服务器可在请求外预送资源 (已被多数浏览器弱化/关闭)
      
      
          流量控制
          端到端窗口，避免单个大文件占满带宽
      
  

开始实验
启用 HTTP/2 需要使用 HTTPS，请先参考 在本地环境使用 HTTPS ｜ ZYF.IM。
修改 NGINX default.conf 配置文件，启用 HTTP/2：
# vi default.conf
server {
    listen 443 ssl;
    # 启用 HTTP/2
    http2 on;

    server_name localhost;
    ssl_certificate /etc/ssl/certs/localhost.pem;
    ssl_certificate_key /etc/ssl/certs/localhost-key.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    location / {
        root /usr/share/nginx/html;
        index  index.html index.htm;
    }
}
docker container restart nginx-ssl
测试
游览器
游览器访问 https://localhost:8443/，在 Chrome 开发者工具 Network 面板勾选 Protocol，可看到 h2 字样。
或者使用 Chrome 插件 HTTP Indicator：

HTTP/1.1 显示为灰色。
HTTP/2 显示为蓝色。
HTTP/3 显示为绿色。

curl
# -I (--head) 只返回响应头
curl -I https://localhost:8443/

HTTP/2 200
server: nginx/1.29.0
date: Fri, 27 Jun 2025 01:56:55 GMT
content-type: text/html
content-length: 615
last-modified: Tue, 24 Jun 2025 17:57:38 GMT
etag: "685ae712-267"
accept-ranges: bytes
HTTP/3
请移步 NGINX 启用 HTTP/3 ｜ ZYF.IM。
References

NGINX HTTP/2 模块

– EOF –



【摔跤吧，爸爸】随笔
Sun, 14 May 2017 13:00:00 +0000
周末看了《摔跤吧，爸爸》，也是第一次独自电影院看电影，试写一篇影评纪念下。
注意：严重剧透预警。
主角爸爸是印度全国摔跤冠军，一心想着为国家赢取一枚金牌。可自己没能实现梦想，把梦想转移给了自己还未出世的孩子。可事与愿违，想要男孩的主角爸爸的前三个孩子都是女孩，第四个还是女孩。主角爸爸近乎要放弃为国争取金牌的梦想时，却意外看的了大女儿、二女儿身上的摔跤天赋。

主角妈妈在得知主角爸爸准备将女儿们训练为拳击手时，道出了 “你不能将你的梦想施加在女儿们身上”，主角爸爸沉思片刻 “给我一年时间，其间你不要插手，如果没成功，我将有永远放弃我的梦想”。在主角爸爸说出这句话之前，我是反对父母将自己的梦想让孩子去实现的，也更没有去争取过孩子们的想法，现实中这样做的父母我是常为 Loser. 但是主角爸爸的回答让我看到的不是一个：被自己个人梦想冲昏头，用孩子的全部去成就自己的父亲。主角爸爸是讲道理的，一年后如果失败也会甘愿放弃。坚持与固执的区别也许就在此。
主角爸爸变身为女儿们的魔鬼摔跤教练，每天除了上学就是训练，跑步时衣服不合适换男生衣服，找侄子当陪练，没有力量加餐牛奶、鸡肉，长头发难清理剪成了寸头。受苦中的女儿们找妈妈求情，主角妈妈遵守承诺，不干预主角爸爸的训练。这里真的要给主角妈妈点赞，后面女儿们的成功，女儿们、主角爸爸的努力在明面放着，而主角妈妈的守诺不干预，对主角爸爸的信赖，是同样的伟大。不然那柔弱的耳边风不知乱了多少坚定的意志。
训练太辛苦的女儿们采用消极怠工对抗主角爸爸。破坏闹钟、破坏场地、假摔示弱。而旷工一天参加好友的婚礼现场被主角爸爸收拾。在与好友诉苦时，才发现了：对比其他女孩一望到底的家庭妇女人生，主角爸爸的狠心是那样让人羡慕。
观念改变的女儿们开始主动训练。大女儿首次参赛就初露锋芒，差一点将男孩对手打败。逐渐成长的大女儿愈战愈勇的直到赢得全国冠军。全国冠军都会进入国家体育学校学习，大女儿也要离开主角爸爸接受新教练的训练，备战世界大赛。从小镇走出来的大女儿，没了主角爸爸的严格管束，开始着迷于这外面多彩的世界。吃油炸食品、留起头发、逛街、电影院。假期回家的大女儿用自己新学的技巧击败了主角爸爸，更是产生自我膨胀，对主角爸爸传统技术技巧的不屑与不信任。
国际大赛上大女儿频频失利，无能教练将此归为命运。与此同时坚信主角爸爸训练方式的二儿女也获得全国冠军，进入国家队。在二儿女和主角妈妈的劝解下，一通电话化解了大女儿和主角爸爸的隔阂。主角爸爸亲自来到体育学校，为大女儿备战下次的国际大赛。
主角爸爸在仔细研究大女儿对手后，制定了针对性的战术帮助大女儿杀入决赛。无能教练为了不让主角爸爸抢了自己的功劳，在决赛开始前将主角爸爸骗入小黑屋，无法让主角爸爸指导大女儿比赛。决赛第二局大女儿没能把握赛点，让对手追平。主角爸爸继续被困，只能默默祈祷。决赛最后一局，大女儿大比分落后，最后 10 秒大女儿脑海闪现着主角爸爸的叮咛，一击 5 分绝杀翻盘，赢得世界冠军。冠军的国歌声奏起，小黑屋中的主角爸爸也被路人解救，冲入赛场的主角爸爸与大女儿四目相对，此时这已经不是大女儿或主角爸爸哪一个人的冠军，而是所有正在与命运抗战者的胜利。
主角爸爸：“你是我的骄傲”

电影的专业手法和技术自己不懂，但是自己有个感觉：影片后期有大量的摔跤比赛，时不时有种看奥运赛的感觉，但是自己并没有感到乏味。电影故事情节很寻常，但是娓娓道来，很多细节小事让节奏不拖沓。故事人物有主角爸爸的理性和坚持、主角妈妈的守诺不干预、女儿们自我的成长、侄子的酱油加醋、无能教练损人为己
电影给我也留下了几个现实问题：

父母的认识经验一定比子女高的多，主角爸爸在看到女儿们的摔跤天赋时，狠心训练与女儿本身的意愿如何选择？
父母逐渐变老，他们真的跟不上我们了吗？
如何辨别无能教练的瞎指挥？

– EOF –


MySQL 5.6 5.7 组内排序的区别
Thu, 20 Apr 2017 20:00:00 +0000
MySQL 5.7 对比 5.6 有很多的变化。一个常见的需求：按条件分组后，取出每组中某字段最大值的那条记录。其实就是组内排序的问题，我的做法是：子查询先进行倒序排序，外层查询分组。
示例
+----+----+-------+
| id | no | name |
+----+----+-------+
| 5 | 5 | Mike |
| 4 | 4 | Herry |
| 3 | 3 | wyett |
| 2 | 2 | John |
| 7 | 2 | John |
| 1 | 1 | Mike |
| 6 | 1 | John |
| 8 | 1 | Mike |
| 9 | 1 | Mike |
+----+----+-------+
要求：取出每人（按 name），最大 no 的记录。
select * from (
    select id,no,name from testorder order by no desc
)a group by a.name;
+----+----+-------+
| id | no | name |
+----+----+-------+
| 4 | 4 | Herry |
| 2 | 2 | John |
| 5 | 5 | Mike |
| 3 | 3 | wyett |
+----+----+-------+
但是在 5.7 中，首先需要关闭 ql_mode = ONLY_FULL_GROUP_BY；相同的 name 值，返回则是取了 最早写入的数据行 ，忽略了 order by no desc，按照数据的逻辑存储顺序来返回
+----+----+-------+
| id | no | name |
+----+----+-------+
| 4 | 4 | Herry |
| 2 | 2 | John |
| 1 | 1 | Mike |
| 3 | 3 | wyett |
+----+----+-------+
等价于
select id,no,name from testorder group by name

A query such as
SELECT field1, field2 FROM ( SELECT field1, field2 FROM table1 ORDER BY field2 ) alias
returns a result set that is not necessarily ordered by field2. This is not a bug.
A “table” (and subquery in the FROM clause too) is - according to the SQL standard - an unordered set of rows.
Rows in a table (or in a subquery in the FROM clause) do not come in any specific order.
可以总结为：

在 FROM 后的 subquery 中的 ORDER BY 会被忽略
GROUP BY cloumn 返回的行是无序的

解决方案
select a.id,a.no,a.name
    from testorder a inner join (
        select max(no) no,name from testorder group by name
    ) b on a.no = b.no and a.name = b.name
group by name,no
其他方案：

对于不符合 ONLY_FULL_GROUP_BY 限制的字段，添加 unique 索引。
使用 ANY_VALUE()，让 MySQL 跳过 ONLY_FULL_GROUP_BY 检测。

小结

MySQL 5.6 Handling of GROUP BY

In standard SQL, a query that includes a GROUP BY clause cannot refer to nonaggregated columns in the select list that are not named in the GROUP BY clause.
在标准 SQL 中，包含 GROUP BY 子句的查询 不能引用 select 列表中未在 GROUP BY 子句中命名的列。
MySQL extends the standard SQL use of GROUP BY so that the select list can refer to nonaggregated columns not named in the GROUP BY clause. This means that the preceding query is legal in MySQL.
MySQL 扩展了 GROUP BY 的标准 SQL 使用，以便选择列表可以引用 GROUP BY 子句中未命名的非集合列。这意味着前面的查询在 MySQL 中是合法的。
However, this is useful primarily when all values in each nonaggregated column not named in the GROUP BY are the same for each group. The server is free to choose any value from each group, so unless they are the same, the values chosen are indeterminate.
但是，主要是在 GROUP BY 中 未命名的每个非分组列中的所有值对于每个组是相同的，这是有用的。服务器可以自由选择每个组中的任何值，因此除非它们相同，所选择的值是 不确定的。
Furthermore, the selection of values from each group cannot be influenced by adding an ORDER BY clause. Result set sorting occurs after values have been chosen, and ORDER BY does not affect which values within each group the server chooses.
此外，通过添加 ORDER BY 子句不会影响来自每个组的值的选择。结果集排序发生在选择值后，ORDER BY 不影响 服务选择的每个组中的哪些值。

MySQL 5.7 Handling of GROUP BY

MySQL 5.7.5 and up implements detection of functional dependence. If the ONLY_FULL_GROUP_BY SQL mode is enabled (which it is by default), MySQL rejects queries for which the select list, HAVING condition, or ORDER BY list refer to nonaggregated columns that are neither named in the GROUP BY clause nor are functionally dependent on them. (Before 5.7.5, MySQL does not detect functional dependency and ONLY_FULL_GROUP_BY is not enabled by default.)
MySQL 5.7.5 及以上功能依赖检测功能。如果启用了 ONLY_FULL_GROUP_BY SQL 模式（默认情况下），MySQL 将拒绝对列表，HAVING 条件或 ORDER BY 列表的查询引用在 GROUP BY 子句中既未命名的非集合列，也不在功能上依赖于它们。（5.7.5 之前，MySQL 没有检测到功能依赖关系，默认情况下不启用 ONLY_FULL_GROUP_BY）
You can achieve the same effect without disabling ONLY_FULL_GROUP_BY by using ANY_VALUE() to refer to the nonaggregated column.
你可以通过使用 ANY_VALUE() 使禁用了 ONLY_FULL_GROUP_BY 的 SQL，来实现相同的效果来引用非聚合列。
5.6 与 5.7 的区别
5.6 升级到 5.7 版本要注意：

sql_mode 默认值的改变。
optimizer_switch 值的改变。
备库升级影响主备复制。

SELECT @@SQL_MODE, @@GLOBAL.SQL_MODE;

-- 5.6
-- NO_ENGINE_SUBSTITUTION

-- 5.7
-- ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION

ONLY_FULL_GROUP_BY SELECT 查询的字段必须是 GROUP BY 中出现的或者使用聚合函数的或者是具有唯一索引的。
STRICT_TRANS_TABLES 在该模式下，如果一个值不能插入到一个事务表中，则中断当前的操作，对非事务表不做任何限制。
NO_ZERO_IN_DATE 在严格模式，不接受月或日部分为 0 的日期。如果使用 IGNORE 选项，我们为类似的日期插入'0000-00-00’。在非严格模式，可以接受该日期，但会生成警告。
NO_ZERO_DATE 在严格模式，不要将 ‘0000-00-00’做为合法日期。你仍然可以用 IGNORE 选项插入零日期。在非严格模式，可以接受该日期，但会生成警告。
ERROR_FOR_DIVISION_BY_ZERO 在严格模式，在 INSERT 或 UPDATE 过程中，如果被零除(或 MOD(X，0))，则产生错误(否则为警告)。如果未给出该模式，被零除时 MySQL 返回 NULL。如果用到 INSERT IGNORE 或 UPDATE IGNORE 中，MySQL 生成被零除警告，但操作结果为 NULL。
NO_AUTO_CREATE_USER 防止 GRANT 自动创建新用户，除非还指定了密码。
NO_ENGINE_SUBSTITUTION 如果需要的存储引擎被禁用或未编译，那么抛出错误。不设置此值时，用默认的存储引擎替代，并抛出一个异常。

STRICT_TRANS_TABLES 和 STRICT_ALL_TABLES 的区别
唯一的区别是：对于不支持事务的表，若开启 STRICT_TRANS_TABLES，MySQL 会尝试将一个不合法的字段值转换成一个值最近的合法值插入表中；而开启 STRICT_ALL_TABLES 后，则表现为不写入数据，且抛出错误。
因为现在绝大部分用的 InnoDB 引擎，是支持事务的，所以基本不用关心这种区别。
严格模式和非严格模式的区别
SET sql_mode = 'STRICT_TRANS_TABLES';
严格模式下不能在无符号整数字段插入负值。

非严格模式下，会存储为 0。
严格模式下，报错。

严格模式下，无默认值的 NOT NULL 字段在插入数据时必须指定值。

非严格模式下，若不插入数据会存储字段类型的默认值。
严格模式下，报错。

严格模式下，插入字符串不能超出定义长度

非严格模式下，会成功插入数据，但是内容被截断。
严格模式下，报错。

References

MySQL 组内排序取最大值 | mysqlwyett
sql - MySQL Group By and Order By; - Stack Overflow
MySQL5.7 中的 sql_mode 默认值 | zhihu
MySQL: 严格模式 | letianbiji

– EOF –



MySQL 管理用户与访问授权
Tue, 11 Apr 2017 11:00:00 +0000
MySQL 创建用户、修改密码、删除用户；查看、授予、撤销用户权限；对 MySQL 远程访问的新理解。
-- 创建用户 + 授权
GRANT ALL PRIVILEGES ON _._ TO 'tom'@'%' IDENTIFIED BY 'pwd123' WITH GRANT OPTION;
-- 查询权限
SHOW GRANTS FOR 'tom'@'%';
-- 授权
GRANT SELECT ON `my_db`.* TO 'tom'@'%';
-- 撤权
REVOKE ALL PRIVILEGES ON `my_db`.* FROM  'tom'@'%';
REVOKE GRANT OPTION ON `my_db`.* from 'tom'@'%';

-- not necessary
FLUSH PRIVILEGES;
管理用户
创建用户
CREATE USER 'username'@'host' IDENTIFIED BY 'password';

username：创建的用户名
host：该用户在哪个主机上可以登陆。如果是本地用户可用 localhost；如果想让该用户可以从任意远程主机登陆，可以使用通配符 %
password：该用户的登陆密码。密码可以为空，如果为空则该用户可以不需要密码登陆服务器

例子：
CREATE USER 'dog'@'localhost' IDENTIFIED BY '123456';
CREATE USER 'pig'@'192.168.1.%' IDENDIFIED BY '123456';
CREATE USER 'pig'@'%' IDENTIFIED BY '123456';
CREATE USER 'pig'@'%' IDENTIFIED BY '';
CREATE USER 'pig'@'%';
修改用户密码
SET PASSWORD FOR 'username'@'host' = PASSWORD('newpassword');

SET PASSWORD FOR 'pig'@'%' = PASSWORD("123456");
如果修改当前登陆用户密码：
SET PASSWORD = PASSWORD("newpassword");
删除用户
DROP USER 'username'@'host';
访问授权
查看用户权限
SHOW GRANTS FOR 'pig'@'%';
授予用户权限
GRANT PRIVILEGES ON databasename.tablename TO 'username'@'host'

GRANT SELECT, INSERT ON test.user TO 'pig'@'%';
GRANT ALL ON *.* TO 'pig'@'%';

privileges：用户的操作权限，如 SELECT INSERT UPDATE 等，如果要授予所的权限则使用 ALL
databasename：数据库名
tablename：表名，如果要授予该用户对所有数据库和表的相应操作权限则可用 * 表示

注意： 用以上命令授权的用户不能给其它用户授权，如果想让该用户可以授权，用 WITH GRANT OPTION 命令：
GRANT PRIVILEGES ON databasename.tablename TO 'username'@'host' WITH GRANT OPTION;
撤销用户权限
REVOKE PRIVILEGE ON databasename.tablename FROM 'username'@'host';

REVOKE SELECT ON *.* FROM 'pig'@'%';
注意： 假如你在给用户’pig’@’%‘授权的时候是这样的（或类似的）：
GRANT SELECT ON test.user TO 'pig'@'%';
则在使用：
REVOKE SELECT ON _._ FROM 'pig'@'%';
命令并 不能 撤销该用户对 test 数据库中 user 表的 SELECT 操作。
相反，如果授权使用的是：
GRANT SELECT ON _._ TO 'pig'@'%';
则：
REVOKE SELECT ON test.user FROM 'pig'@'%';
命令 也不能 撤销该用户对 test 数据库中 user 表的 SELECT 权限。
具体信息可以用查看命令：
SHOW GRANTS FOR 'pig'@'%';
刷新权限
FLUSH PRIVILEGES;
开启远程访问
通过上面的配置，可以发现：开启 MySQL 远程访问，其实就是修改用户权限：
-- 只允许 192.168.1.100 连接
GRANT ALL PRIVILEGES ON _._ TO 'root'@'192.168.1.100' IDENTIFIED BY 'pwd123' WITH GRANT OPTION;

-- 允许所有 ip 访问
GRANT ALL PRIVILEGES ON _._ TO 'root'@'%' IDENTIFIED BY 'pwd123' WITH GRANT OPTION;
注意： Ubuntu 上还需要修改 MySQL 配置文件
sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf
将 bind-address = 127.0.0.1 这一行注释掉, 即:
#bind-address = 127.0.0.1
重启 MySQL
补充
查询当前用户：
mysql> SELECT CURRENT_USER();

  
      
          HOST
          User
          被条目匹配的连接
      
  
  
      
          ’thomas.loc.gov’
          ‘fred’
          fred, 从 thomas.loc.gov 连接
      
      
          ’thomas.loc.gov'
          ''
          任何用户, 从 thomas.loc.gov 连接
      
      
          ‘%’
          ‘fred’
          fred, 从任何主机连接
      
      
          ‘%’
          ''
          任何用户, 从任何主机连接
      
      
          ‘%.loc.gov’
          ‘fred’
          fred, 从在 loc.gov 域的任何主机连接
      
      
          ‘x.y.%’
          ‘fred’
          fred, 从 x.y.net、x.y.com,x.y.edu 等联接（这或许无用）
      
      
          ‘144.155.166.177’
          ‘fred’
          fred, 从有 144.155.166.177 的主机连接
      
      
          ‘144.155.166.%’
          ‘fred’
          fred, 从 144.155.166 C 类子网的任何主机连接
      
  

可以在 Host 字段使用 IP 通配符值（例如，'144.155.166.%' 匹配在一个子网上的每台主机），有可能某人可能企图探究这种能力，通过命名一台主机为 144.155.166.somewhere.com。为了阻止这样的企图，MySQL 不允许匹配以数字和一个点起始的主机名，这样，如果你用一个命名为类似 1.2.foo.com 的主机，它的名字决不会匹配授权表中的 Host 列。只有一个 IP 数字能匹配 IP 通配符值。
References

MySQL 创建用户与授权 - 简书
5.7.5. 访问控制, 阶段 1：连接核实

– EOF –



Git pull rebase 和 merge no-ff 保持提交线图整洁
Fri, 17 Mar 2017 16:00:00 +0000
git log 中的一个清晰的提交线图是很方便进行 code review 和代码回退
git pull --rebase 主要是为是将提交约线图平坦化，而 git merge --no-ff 则是刻意制造分叉
pull rebase

perform a rebase after fetching

状况
Git 作为分布式版本控制系统，所有修改操作都是基于本地的，在团队协作过程中，假设你和你的同伴在本地中分别有各自的新提交，而你的同伴先于你 push 了代码到远程分支上，所以你必须先执行 git pull 来获取同伴的提交，然后才能 push 自己的提交到远程分支。

按照 Git 的默认策略，如果远程分支和本地分支之间的提交线图有分叉的话（即不是 fast-forwarded），Git 会执行一次 merge 操作，因此产生一次没意义的提交记录，从而造成了像上图那样的混乱。
解决
其实在 pull 操作的时候，使用 git pull --rebase 选项即可很好地解决上述问题。 加上 --rebase 参数的作用是，提交线图有分叉的话，Git 会 rebase 策略来代替默认的 merge 策略。
假设提交线图在执行 pull 前是这样的：
                 A---B---C  remotes/origin/master
                /
           D---E---F---G  master
如果是执行 git pull 后，结果多出了 H 这个没必要的提交记录。提交线图会变成这样：
                 A---B---C remotes/origin/master
                /         \
           D---E---F---G---H master
如果是执行 git pull --rebase 的话，提交线图就会变成这样：
                       remotes/origin/master
                           |
           D---E---A---B---C---F'---G'  master
F G 两个提交通过 rebase 方式重新拼接在 C 之后，多余的分叉去掉了，目的达到。
注意
使用 git log --graph 可查看提交线图
使用 git pull --rebase 是为了使提交线图更好看，从而方便 code review 和代码回退
使用 git pull --rebase 比直接 pull 容易导致冲突的产生，如果预期冲突比较多的话，建议还是直接 pull

merge no-ff

generate a merge commit even if the merge resolve

例子 1
git pull --rebase 策略目的是修整提交线图，使其形成一条直线，而即将要用到的 git merge --no-ff  策略偏偏是反行其道，刻意地弄出提交线图分叉出来。
假设你在本地准备合并两个分支，而刚好这两个分支是 fast-forwarded 的，那么直接合并后你得到一个直线的提交线图，当然这样没什么坏处，但如果你想更清晰地告诉你同伴：这一系列的提交都是为了实现同一个目的，那么你可以刻意地将这次提交内容弄成一次提交线图分叉。
执行 git merge --no-ff  的结果大概会是这样的：

中间的分叉线路图很清晰的显示这些提交都是为了实现：complete adjusting user domains and tags
例子 2
往往在合并分支之前（假设要在本地将 feature 分支合并到 dev 分支），会先检查 feature 分支是否部分落后于远程 dev 分支：
git checkout dev
git pull # 更新 dev 分支
git log feature..dev # 对比
如果没有输出任何提交信息的话，即表示 feature 对于 dev 分支是 up-to-date 的。如果有输出的话而马上执行了 git merge --no-ff 的话，提交线图会变成这样：

所以这时在合并前，通常先执行：
git checkout feature
git rebase dev
这样就可以将 feature 重新拼接到更新了的 dev 之后，然后就可以合并了。这时分叉点将上移，最终得到一个干净舒服的提交线图
总结

使用 git pull --rebase 和 git merge --no-ff 其实和直接使用 git pull git merge 得到的代码应该是一样。
使用 git pull --rebase 主要是为是将提交约线图平坦化，而 git merge --no-ff 则是刻意制造分叉。

References

洁癖者用 Git：pull –rebase 和 merge –no-ff

– EOF –



Git 修改提交历史
Mon, 13 Mar 2017 17:00:00 +0000
在使用 Git 时，我们经常需要修改本地提交记录，比如：修改最近一次提交、将多次小的 commit 合并成一个、或者批量修改提交者信息。

以下操作会修改 Git 历史记录（SHA 值会变化），请确保不要对已推送到共享仓库的提交执行这些操作。

修改最近一次提交
修改提交说明
git commit --amend
进入编辑器修改提交说明，保存退出即可。
追加文件到最近一次提交
先将修改的文件添加到暂存区，再运行 --amend：
git add new_file.cpp
git commit --amend
也可以用 -a 自动暂存所有已跟踪文件的修改，但要注意不要提交多余文件：
git commit -a --amend
将文件从本次提交中移除
git reset HEAD~1
git checkout -- filename  # 要从本次提交移除的文件
git commit -m "new commit"
修改多个提交记录（交互式 Rebase）
使用 git rebase -i 可以对历史提交进行修改、重排、合并、拆分等操作。
例如修改最近 3 次提交：
git rebase -i HEAD~3
进入交互界面后，会看到提交列表（注意顺序与 git log 相反，最早的在上面）：
pick fecb551 Init the view model
pick bb199a0 Update the version
pick bc5cd9d Add new method

# Commands:
#  p, pick = use commit
#  r, reword = use commit, but edit the commit message
#  e, edit = use commit, but stop for amending
#  s, squash = use commit, but meld into previous commit
#  f, fixup = like "squash", but discard this commit's log message
#  x, exec = run command (the rest of the line) using shell
修改指定提交说明
将 pick 改为 reword：
reword fecb551 Init the view model
pick bb199a0 Update the version
pick bc5cd9d Add new method
保存退出后，rebase 会在该提交处打开编辑器让你修改说明。
如果还需要修改提交内容，使用 edit：
edit fecb551 Init the view model
pick bb199a0 Update the version
pick bc5cd9d Add new method
rebase 会在该提交处暂停，完成修改后运行：
git commit --amend
git rebase --continue
重排或删除提交
直接调整行的顺序或删除对应行即可。例如删除 “Update the version” 并交换其余两次提交的顺序：
pick bc5cd9d Add new method
pick fecb551 Init the view model
合并提交（Squash）
将 pick 改为 squash，该提交会被合并到上一个提交中：
pick fecb551 Init the view model
squash bb199a0 Update the version
squash bc5cd9d Add new method
保存退出后，rebase 会让你编辑合并后的提交说明。
拆分提交
使用 edit 暂停在要拆分的提交处，然后重置并分次提交：
pick fecb551 Init the view model
edit bb199a0 Update the version
pick bc5cd9d Add new method
rebase 暂停后执行：
git reset HEAD^
git add file1
git commit -m 'Update the version1'
git add file2
git commit -m 'Update the version2'
git rebase --continue
批量修改提交者信息
查看当前仓库中所有提交者信息：
git log --format='%aN %aE' | sort -u
使用 filter-branch 批量替换（如果 email 从未设置过，OLD_EMAIL 可以填 user.name）：
git filter-branch -f --env-filter '
OLD_EMAIL="old@qq.com"
CORRECT_NAME="new_name"
CORRECT_EMAIL="new@gmail.com"
if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_COMMITTER_NAME="$CORRECT_NAME"
    export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_AUTHOR_NAME="$CORRECT_NAME"
    export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL"
fi
' --tag-name-filter cat -- --branches --tags
修改历史后需要强制推送：
git push -f --tags
如果远程分支有保护策略（如 GitLab），需要先在 Project → Settings → Repository → Protected branches 中取消保护。
References

Git 修改提交历史 - GLGJing’s Blog
Git 批量修改历史 commit 中的 user.name 和 user.email | segmentfault

– EOF –



回顾 2016
Sat, 31 Dec 2016 22:00:00 +0000
2016 肯定是很特别的一年。年初离开了老师的队伍，来北京找实习。年中和 318 告别，大学毕业了。年末换房学做饭，开始另种生活。对于 2017 更多了对自己的期待。


2016 是在保定的雾霾中开始。结束了大为，决定离开老师的队伍，来北京实习，这对我来说是一个不大不小的决定。老师带着，跟学长一起走到这里，这里有了很多宝贵的东西，有很多回忆，很多故事可以讲。选择离开，主要还是想看看在这之外的是什么样子。
朋友、老师、爸妈都为我的实习操过心，不过推荐的地方在各种奇怪的理由下都没有成。自己开始在拉勾上投简历，一次次来返在京石铁路上。面试一直是不顺的。完全没有想到对实习生有如此高的要求，很多技术问题正中下怀。心里是有落差的，在我当时的想法里，那些在工程中是用不易用到的，但也感到自己技术知识的浅薄。面试了俩三家后也发现了套路，回答不好的、答不上的问题，回去查查准备准备，下回就能用上。
没什么难度的大学毕业。大学里更多的收获是跟着老师、学长在课堂外搞事，是和宿舍的、好朋友在一起的时间。真的好幸运啊，遇到 318 的舍友们。没想到和你们每一个人都超级聊的来。大四的时候人就渐渐不齐，但只要宿舍在，不到最后毕业真的不知道要分别了。我们相互影响着成长，至少除去了我很多很 low 的思想。我们相互练着酒量、每天演着戏、日常说着骚话。
德育答辩上一个同学说：我常翘课、考试挂科，但我大学四年过的很坦荡，我会因为和舍友游戏上的一个好玩的套路高兴很久。我收获朋友。我没什么后悔的。
这很戳中我的泪点。没什么后悔的，也是对我大学的注脚。愿你们成家的幸福，工作的有成。
从上学到工作，过渡的很平稳。工作中有一些挑战，但总之是还应对的来。可没有什么出众的地方，我不想过的太平凡，愿有一技之长，独挡一面。我常说自己：菜啊、傻啊、什么的，我确实不想用这些来词来逃避问题，我想尽快的甩掉这些。我也愿自己可以更有底气和勇气说出，现在不能说出的话，愿更决绝的对大事小情做决定。
年末随着公司搬家，自己也搬了。炒菜做饭成了每天另一部分。也许才是真正生活二字的开始。
突然想到学长提的一个问题：你们有谁把技术当做以后安身立命的本事？
现在对于我来说，这问题的答案比任何时候都更加清晰。
最后，还是怀揣着 2014 末的敬请期待，让一切皆有可能，开始 2017。
—— 送给 木林木丶
– EOF –


LeetCode Shell 解题集合
Mon, 19 Sep 2016 16:00:00 +0000
LeetCode Shell 的试题多为文本操作，195. Tenth Line、193. Valid Phone Numbers、192. Word Frequency、194. Transpose File 暂时只有 4 道题，就整合在这一起了
Shell 中文本处理的事情基本 awk sed grep sort uniq tail head 几个命令组合组合就搞定了

195. Tenth Line
大体意思
How would you print just the 10th line of a file?
For example, assume that file.txt has the following content:
Line 1
Line 2
Line 3
Line 4
Line 5
Line 6
Line 7
Line 8
Line 9
Line 10
Your script should output the tenth line, which is:
Line 10
打印出文本文件中第 10 行的内容。
自己的解法
cat  file.txt | tail -n +10 | head -n 1
这是学习了：linux 如何显示一个文件的某几行(中间几行) - 香格里拉(^o^)/
别人的解法
方法一：
awk 'NR==10' file.txt
# awk的默认动作就是打印$0，所以NR==10后面可以不用加{print $0}
方法二：
sed -n '10p' file.txt
# 如果不够10行，则什么也不打印
方法三：
line=$(cat file.txt | wc -l)     # 千万注意，等号前后一定不要有空格
if [ "$line" -ge 10 ] ; then     # $line的双引号也可以不用加
  cat file.txt | head -n 10 | tail -n 1
fi
Reference: leetcode-195 Tenth Line - 2> /dev/null
193. Valid Phone Numbers
大体意思
Given a text file file.txt that contains list of phone numbers (one per line), write a one liner bash script to print all valid phone numbers.
You may assume that a valid phone number must appear in one of the following two formats: (xxx) xxx-xxxx or xxx-xxx-xxxx. (x means a digit)
You may also assume each line in the text file must not contain leading or trailing white spaces.
For example, assume that file.txt has the following content:
987-123-4567
123 456 7890
(123) 456-7890
Your script should output the following valid phone numbers:
987-123-4567
(123) 456-7890
匹配有效的电话号码
自己的解法
cat file.txt | grep '^[0-9]\{3\}-[0-9]\{3\}-[0-9]\{4\}$\|^([0-9]\{3\}) [0-9]\{3\}-[0-9]\{4\}$'
别人的解法
grep -P '^(\(\d{3}\)|\d{3}-)\d{3}-\d{4}$' file.txt
Reference: LeetCode 193: Valid Phone Numbers – Revo
192. Word Frequency
大体意思
Write a bash script to calculate the frequency of each word in a text file words.txt.
For simplicity sake, you may assume:
words.txt contains only lowercase characters and space ' ' characters.
Each word must consist of lowercase characters only.
Words are separated by one or more whitespace characters.
For example, assume that words.txt has the following content:
the day is sunny the the
the sunny is is
Your script should output the following, sorted by descending frequency:
the 4
is 3
sunny 2
day 1
Note:
Don’t worry about handling ties, it is guaranteed that each word’s frequency count is unique.
统计单词出现的频次，然后倒序排列
别人的解法
awk '{i=1;while(i<=NF){print $i;i++}}' words.txt  | sort | uniq -c  | sort -k1nr  | awk '{print $2 " " $1}'
1、利用 awk 默认一行一条记录，默认以空格划分每条记录，NF 为划分的总块数先打印出所有单词
2、排序 + 统计 + 消除重复
3、输出
Reference: LeetCode 192 Word Frequency - wangxiaobupt 的专栏
awk '
{ for (i=1; i<=NF; i++) { ++S[$i]; } }
END { for (i in S) { print i, S[i] } }
' words.txt | sort -nr -k 2
Reference: leetcode/solutions/192.Word_Frequency at master · illuz/leetcode
194. Transpose File
大体意思
Given a text file file.txt, transpose its content.
You may assume that each row has the same number of columns and each field is separated by the ' ' character.
For example, if file.txt has the following content:
name age
alice 21
ryan 30
Output the following:
name alice ryan
age 21 30
别人的解法
awk '
{
    for (i = 1; i <= NF; i++) {
        if(NR == 1) {
            s[i] = $i;
        } else {
            s[i] = s[i] " " $i;
        }
    }
}
END {
    for (i = 1; s[i] != ""; i++) {
        print s[i];
    }
}' file.txt
Reference: leetcode/solutions/194.Transpose_File at master · illuz/leetcode
总结
Shell 中文本处理的事情基本 awk sed grep sort uniq tail head 几个命令组合组合就搞定了，各命令的常用方法之后总结



MySQL LIMIT 查询优化
Sun, 18 Sep 2016 14:00:00 +0000
最近常在 SQL 中使用到 LIMIT ? ?，在执行 LIMIT 0, 1000 与 LIMIT 100000, 1000 时，查询速度明显有很大的区别，而且随着 LIMIT 的偏移量的增加，查询速度越来越慢。是否有办法对 SQL 中 LIMIT 查询进行优化呢？

LIMIT 速度慢的原因
LIMIT 100000, 1000 的意思扫描满足条件的 101000 行，扔掉前面的 100000 行，返回最后的 1000 行，问题就在这里。
LIMIT 优化思路
1、尽可能从索引中直接获取数据，避免或减少直接扫描行数据的频率
2、尽可能减少扫描的记录数，也就是先确定起始的范围，再往后取 N 条记录即可
LIMIT 优化示例
原始 SQL
-- 含条件
SELECT * FROM `t1` WHERE ftype=1 ORDER BY id DESC LIMIT 100, 10;
-- 不含 WHERE
SELECT * FROM `t1` ORDER BY id DESC LIMIT 100, 10;
子查询优化 SQL
-- 采用子查询的方式优化，在子查询里先从索引获取到最大 id，然后倒序排，再取 10 行结果集
-- 注意这里采用了 2 次倒序排，因此在取 LIMIT 的 start 值时，比原来的值加了 10，即 935510，否则结果将和原来的不一致
SELECT * FROM
  (SELECT * FROM `t1` WHERE id >
    ( SELECT id FROM `t1` WHERE ftype=1 ORDER BY id DESC LIMIT 935510, 1)
  LIMIT 10) T
ORDER BY id DESC;
INNER 优化 SQL
-- 采用 INNER JOIN 优化，JOIN 子句里也优先从索引获取 ID 列表，然后直接关联查询获得最终结果，这里不需要加 10
SELECT * FROM `t1`
  INNER JOIN ( SELECT id FROM `t1`
    WHERE ftype=1 ORDER BY id DESC LIMIT 935500,10) t2
  USING (id);
1、要学着使用 EXPLAIN 对 SQL 进行优化调整
2、推荐使用 INNER 优化 SQL
3、发现了一个 ubuntu 中监控 MySQL 的 mytop 命令，刚刚安装还没细研究


LeetCode Database Trips and Users 262
Wed, 14 Sep 2016 13:45:00 +0000
262. Trips and Users
  The Trips table holds all taxi trips. Each trip has a unique Id, while Client_Id and Driver_Id are both foreign keys to the Users_Id at the Users table. Status is an ENUM type of (‘completed’, ‘cancelled_by_driver’, ‘cancelled_by_client’).
+----+-----------+-----------+---------+--------------------+----------+
| Id | Client_Id | Driver_Id | City_Id |        Status      |Request_at|
+----+-----------+-----------+---------+--------------------+----------+
| 1  |     1     |    10     |    1    |     completed      |2013-10-01|
| 2  |     2     |    11     |    1    | cancelled_by_driver|2013-10-01|
| 3  |     3     |    12     |    6    |     completed      |2013-10-01|
| 4  |     4     |    13     |    6    | cancelled_by_client|2013-10-01|
| 5  |     1     |    10     |    1    |     completed      |2013-10-02|
| 6  |     2     |    11     |    6    |     completed      |2013-10-02|
| 7  |     3     |    12     |    6    |     completed      |2013-10-02|
| 8  |     2     |    12     |    12   |     completed      |2013-10-03|
| 9  |     3     |    10     |    12   |     completed      |2013-10-03|
| 10 |     4     |    13     |    12   | cancelled_by_driver|2013-10-03|
+----+-----------+-----------+---------+--------------------+----------+
  The Users table holds all users. Each user has an unique Users_Id, and Role is an ENUM type of (‘client’, ‘driver’, ‘partner’).
+----------+--------+--------+
| Users_Id | Banned |  Role  |
+----------+--------+--------+
|    1     |   No   | client |
|    2     |   Yes  | client |
|    3     |   No   | client |
|    4     |   No   | client |
|    10    |   No   | driver |
|    11    |   No   | driver |
|    12    |   No   | driver |
|    13    |   No   | driver |
+----------+--------+--------+
  Write a SQL query to find the cancellation rate of requests made by unbanned clients between Oct 1, 2013 and Oct 3, 2013. For the above tables, your SQL query should return the following rows with the cancellation rate being rounded to two decimal places.
+------------+-------------------+
|     Day    | Cancellation Rate |
+------------+-------------------+
| 2013-10-01 |       0.33        |
| 2013-10-02 |       0.00        |
| 2013-10-03 |       0.50        |
+------------+-------------------+

大体意思
写一个 SQL 语句，查询非禁止客户（Users 表中 Banned 列为 No 的客户）在 2013-10-1 至 2013-10-3 间的单据取消率，结果为四舍五入后的两位有效数字。
别人的解法
SELECT Request_at DAY,
       ROUND(SUM(IF(Status = 'completed', 0, 1)) / COUNT(*), 2) 'Cancellation Rate'
FROM   Trips t
 LEFT JOIN Users t1 ON t.Client_Id = t1.Users_Id
WHERE  t1.Banned = 'No' AND Request_at BETWEEN '2013-10-01' AND '2013-10-03'
GROUP  BY t.Re quest_at;
这道题主要是统计计算
笔记：
1、函数：ROUND(column_name,decimals)
column_name 必需。要舍入的字段
decimals 必需。规定要返回的小数位数
2、SUM(IF(Status = 'completed', 0, 1))
统计 SUM 这里也好巧妙
3、having 与 where 的区别
having 字句可以让我们筛选成组后的各种数据，where 字句在聚合前先筛选记录，也就是说作用在 group by 和 having 字句前。而 having 子句在聚合后对组记录进行筛选。
SELECT region, SUM(population), SUM(area)
FROM bbc
GROUP BY region
HAVING SUM(area) > 1000000
在这里，我们不能用 where 来筛选超过 1000000 的地区，因为表中不存在这样一条记录。相反，having 子句可以让我们筛选成组后的各组数据

Reference:
LeetCode：Trips and Users - 出租车接单取消率 - Tsybius2014 > mysql 中的 where 和 having 子句的区别 - Hukin




LeetCode Database Department Highest Salary 184
Mon, 12 Sep 2016 14:00:00 +0000
184. Department Highest Salary
  The Employee table holds all employees. Every employee has an Id, a salary, and there is also a column for the department Id.
+----+-------+--------+--------------+
| Id | Name  | Salary | DepartmentId |
+----+-------+--------+--------------+
| 1  | Joe   | 70000  | 1            |
| 2  | Henry | 80000  | 2            |
| 3  | Sam   | 60000  | 2            |
| 4  | Max   | 90000  | 1            |
+----+-------+--------+--------------+
  The Department table holds all departments of the company.
+----+----------+
| Id | Name     |
+----+----------+
| 1  | IT       |
| 2  | Sales    |
+----+----------+
  Write a SQL query to find employees who have the highest salary in each of the departments. For the above tables, Max has the highest salary in the IT department and Henry has the highest salary in the Sales department.
+------------+----------+--------+
| Department | Employee | Salary |
+------------+----------+--------+
| IT         | Max      | 90000  |
| Sales      | Henry    | 80000  |
+------------+----------+--------+

大体意思
查询出每一个部门中收入最后的员工的信息
自己的解法
一开始时自己没有考虑收入最高可能有并列的情况，就直接 MAX()，加 join in 了；同时也要考虑到：所属部门不存在的情况；修改后 SQL 为
SELECT
  d.NAME Department,
  e.NAME Employee,
  e.Salary
FROM
  Employee e
  JOIN ( SELECT max( salary ) salary, departmentId FROM Employee GROUP BY departmentId ) m USING ( salary, departmentId )
  JOIN Department d ON e.departmentId = d.id
别人的解法
基本都是连表查询的套路，但是有一段总结还是有些意思的。
1、聚合函数 max() 的效率不如嵌套子查询
2、in 与 exists 效率差不多，当时在网上查的是：

in 和 not in 也要慎用，否则会导致全表扫描
很多时候用 exists 代替 in 是一个好的选择

3、将 join on 代替了 where 判断，效率提升很多，后来有个看过 MYSQL 源码的大神说：

在 MySQL 的 SELECT 查询当中，其核心算法就是 JOIN 查询算法。其他的查询语句都相应向 JOIN 靠拢：单表查询被当作 JOIN 的特例；子查询被尽量转换为 JOIN 查询

4、将 join 替换为了 straight_join，还是源码大神说的：

对于多表查询，如果可以确定表按照某一固定次序处理可以获得较好的效率，则建议加上 STRAIGHT_JOIN 子句，以减少优化器对表进行重排序优化的过程。
该子句一方面可以用于优化器无法给出最优排列的 SQL 语句；另一方面同样适用于优化器可以给出最优排列的 SQL 语句，因为 MySQL 算出最优排列也需要耗费较长的流程。
对于后一状况，可以根据 EXPLAIN 的提示选定表的顺序，并加上 STRAIGHT_JOIN 子句固定该顺序。该状况下的使用前提是几个表之间的数据量比例会一直保持在某一顺序，否则在各表数据此消彼长之后会适得其反。

对于经常调用的 SQL 语句，这一方法效果较好；同时操作的表越多，效果越好。

Reference:
leetcode-184-Department Highest Salary 优化记录 - M-zyh




LeetCode Database Consecutive Numbers 180
Sun, 11 Sep 2016 20:45:00 +0000
180. Consecutive Numbers
  Write a SQL query to find all numbers that appear at least three times consecutively.
+----+-----+
| Id | Num |
+----+-----+
| 1  |  1  |
| 2  |  1  |
| 3  |  1  |
| 4  |  2  |
| 5  |  1  |
| 6  |  2  |
| 7  |  2  |
+----+-----+
For example, given the above Logs table, 1 is the only number that appears consecutively for at least three times.

大体意思
写 SQL 查询出连续出现至少 3 次的 Num
自己的解法
SELECT DISTINCT L1.Num AS ConsecutiveNums
FROM Logs L1
 JOIN Logs L2 ON L1.Id + 1 = L2.Id
 JOIN Logs L3 ON L1.Id + 2 = L3.Id
WHERE L1.Num = L2.Num AND L1.Num = L3.Num
很传统连表查询，但是有坑的地方，就是依靠的时 Id，所以局限是 Id 要连贯
别人的解法
首先，增加一个 rank 字段，记录序号，初始值为 1，当后一个值与前一个值相等时，序号加 1。之后，把所有 rank 值大于等于 3 的都检索出来，再去重即可。
SELECT DISTINCT(Num) AS ConsecutiveNums FROM
(SELECT Id,Num,
@Rank:=IF(@prevNum != Num,1,@Rank+1) AS Rank,
@prevNum:=Num
FROM Logs) t,
(SELECT @Rank:=0,@prevNum:=NULL) r
WHERE t.Rank >= 3;
自己的理解
(SELECT @Rank:=0,@prevNum:=NULL) r
是个巧妙的地方，对变量进行了初始化

Reference:
【leetcode Database】180. Consecutive Numbers - Kevin_zhai 的博客




LeetCode Database Second Highest Salary 176
Sun, 11 Sep 2016 19:45:00 +0000
176. Second Highest Salary
  Write a SQL query to get the second highest salary from the Employee table.
+----+--------+
| Id | Salary |
+----+--------+
| 1  | 100    |
| 2  | 200    |
| 3  | 300    |
+----+--------+
For example, given the above Employee table, the second highest salary is 200. If there is no second highest salary, then the query should return null.

大体意思
写 SQL 查询出第二高薪水的 Id。如何没有第二高，则返回 null
自己的解法
SELECT
    Salary
FROM
    Employee
ORDER BY Salary DESC
LIMIT 1,1
但是在没有第二高的时候将没有返回值，不符合题意；看了别人的，发现自己也少考虑 DISTINCT
别人的解法
多加一层 SELECT 并添加一个 IF 条件判断。如果结果有 0 行则返回 NULL，有 1 行返回正常结果。由于可以预期上一步结果只有一个，所以这里可以用 COUNT 而不用 GROUP BY。
构造测试数据：
CREATE TABLE IF NOT EXISTS Employee (
    Id INT,
    Salary INT
);
DELETE FROM Employee;
INSERT INTO Employee VALUES
(1, 100),
(2, 200),
(3, 100),
(4, 300);
预期结果：
+---------------------+
| SecondHighestSalary |
+---------------------+
| 200                 |
+---------------------+
解法一：
SELECT
    IF(COUNT(Salary) >= 1, Salary, NULL) AS SecondHighestSalary
FROM
    (SELECT DISTINCT
        Salary
    FROM
        Employee
    ORDER BY Salary DESC
    LIMIT 1 , 1) tmp
解法二：
正常 Ranking 类问题解法，使用自定义变量计算排名。接着和上面一种解法类似需要对结果进行处理，没有第 2 名的返回 NULL：
SELECT
    IF(COUNT(Salary) >= 1, Salary, NULL) AS SecondHighestSalary
FROM
    (SELECT DISTINCT
        Salary
    FROM
        (SELECT
         Id,
            Salary,
            @rank:=IF(@prevVal > Salary, @rank:=@rank + 1, @rank) AS Rank,
            @prevVal:=Salary
     FROM
         Employee, (SELECT @prevVal:=NULL) x, (SELECT @rank:=1) y
     ORDER BY Salary DESC) tmp
    WHERE
        tmp.Rank = 2) tmp2
解法三：
上面两种解法都是可以扩展到任意排名的，如果想偏一点可以得到其他解法。排名第 2 可以看做是除了 MAX 之外的 MAX，可以得到这两种类似的解法。由于 MAX 函数可以返回 NULL 结果，就不用在进一步加工结果。
SELECT
    MAX(Salary)
FROM
    Employee
WHERE
    Salary < (SELECT
            MAX(Salary)
        FROM
            Employee)
SELECT
    MAX(Salary)
FROM
    Employee
WHERE
    Salary NOT IN (SELECT
            MAX(Salary)
        FROM
            Employee)

Reference:
Leetcode Database: #176 Second Highest Salary | tsuinteru




LeetCode Database Rising Temperature 197
Sun, 11 Sep 2016 19:00:00 +0000
197. Rising Temperature
  Given a Weather table, write a SQL query to find all dates’ Ids with higher temperature compared to its previous (yesterday’s) dates.
+---------+------------+------------------+
| Id(INT) | Date(DATE) | Temperature(INT) |
+---------+------------+------------------+
|       1 | 2015-01-01 |               10 |
|       2 | 2015-01-02 |               25 |
|       3 | 2015-01-03 |               20 |
|       4 | 2015-01-04 |               30 |
+---------+------------+------------------+

For example, return the following Ids for the above Weather table:
+----+
| Id |
+----+
|  2 |
|  4 |
+----+

大体意思
写 SQL 查询出温度比昨天大的日期 Id
别人的解法
The DATEDIFF() function returns the time between two dates
SELECT w1.Id FROM Weather w1, Weather w2
WHERE w1.Temperature > w2.Temperature AND (DATEDIFF(w1.Date, w2.Date) = 1 )

Reference:
LeetCode Q197 Rising Temperature | Lei Jiang Coding




MyBatis Generator 使用配置
Sat, 10 Sep 2016 19:00:00 +0000

⚠️ 内容声明
本文写于 2016 年，内容已不再维护更新。文章中的部分内容已过时：

MyBatis Generator 版本：文中使用的是 1.3.5 版本，当前最新版本已更新至 1.4.x，提供了更多功能和改进
MySQL 驱动：文中使用的 com.mysql.jdbc.Driver 已被弃用，应使用 com.mysql.cj.jdbc.Driver
Eclipse IDE：现代 Java 开发更多使用 IntelliJ IDEA，且 IDE 对 MyBatis 的支持已有专门的插件（如 MyBatisX）

当前最佳实践：

使用 MyBatis Generator 最新版本（1.4.x）
配合现代构建工具（Maven/Gradle）和 IDE 插件使用
考虑使用 MyBatis-Plus 等增强框架，提供更便捷的代码生成和 CRUD 操作
对于新项目，建议评估是否需要代码生成器，或考虑使用 JPA/Spring Data JPA 等现代 ORM 方案


MyBatis Generator (MBG) 是一个 MyBatis 的代码生成器。MBG 可以内省数据库的表（或多个表），然后生成可以用来访问（多个）表的基础对象。这样在与数据库表进行交互时，不需要手动创建对象和配置文件。MBG 解决了对数据库操作影响最大的一些简单 CRUD（插入、查询、更新、删除）操作。
MyBatis Generator 文档

MyBatis Generator 官方文档
MyBatis Generator 中文文档

通过 Maven 运行 MBG
MyBatis Generator (MBG) 包含了一个可以集成到 Maven 构建的 Maven 插件，按照 Maven 的配置惯例，将 MBG 集成到 Maven 很容易。

pom.xml 配置
...

  ...
  
  
  1.3.5
  
  ${basedir}/src/test/resources/generatorConfig.xml
  file:///${basedir}/src/test/resources/generatorConfig.properties

...

  ...
  
    ...
    
    
      org.mybatis.generator
      mybatis-generator-maven-plugin
      ${plugin.mybatis.generator}
      
        ${mybatis.generator.generatorConfig.xml}
        true
        true
      
    
  

...
generatorConfig.xml 核心配置
非常完整的 MBG 核心配置文件，配合文档效果更佳。因为有大量的注释篇幅较长，建议复制到 XML 文件中查看。
generatorConfig.xml 的文件位置要对应 pom.xml 中的配置：
${basedir}/src/test/resources/generatorConfig.xml

  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">


  
  
  
  
  

  
   url="${mybatis.generator.generatorConfig.properties}" />

  
  
   location="${mbg.drive.class.path}" />

  
  
  
   id="mysql_mbg" defaultModelType="flat" targetRuntime="MyBatis3Simple">

    
    
     name="autoDelimitKeywords" value="false" />
    
     name="javaFileEncoding" value="UTF-8" />
    
     name="javaFormatter"
      value="org.mybatis.generator.api.dom.DefaultJavaFormatter" />
    
     name="xmlFormatter"
      value="org.mybatis.generator.api.dom.DefaultXmlFormatter" />

    
    
     name="beginningDelimiter" value="`" />
     name="endingDelimiter" value="`" />

    
    
       name="suppressAllComments" value="true" />
    

    
     driverClass="com.mysql.jdbc.Driver"
      connectionURL="${mbg.jdbc.url}" userId="${mbg.jdbc.username}"
      password="${mbg.jdbc.password}">
      
    

    
    
      type="org.mybatis.generator.internal.types.JavaTypeResolverDefaultImpl">
      
       name="forceBigDecimals" value="false" />
    

    
    
    
     targetPackage="${mbg.model.package}"
      targetProject="src/test/java">
      
       name="constructorBased" value="false" />

      
       name="enableSubPackages" value="false" />

      
       name="immutable" value="false" />

      
      
      

      
       name="trimStrings" value="false" />
    

    
     targetPackage="${mbg.xml.mapper.package}"
      targetProject="src/test/java">
      
       name="enableSubPackages" value="false" />
    

    
    
    
    
    
    
     targetPackage="${mbg.xml.mapper.package}"
      type="XMLMAPPER" targetProject="src/test/java">
      
       name="enableSubPackages" value="false" />
      
      
    

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
     tableName="test_handbook">

      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
       name="useActualColumnNames" value="true" />

      
      
      
      
      
      
      
      
      
      
      
      
      
      
      

      
      
      
      
      

      
      
      
      
      
      
      
      
      
      
    
  

相关的 properties 文件 generatorConfig.properties
generatorConfig.properties 要对应在 pom.xml 中的：
file:///${basedir}/src/test/resources/generatorConfig.properties
# 数据库驱动 jar 路径
mbg.drive.class.path=/home/yifan/.m2/repository/mysql/mysql-connector-java/5.1.39/mysql-connector-java-5.1.39.jar
# 数据库连接参数
mbg.jdbc.driver=com.mysql.jdbc.Driver
mbg.jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8
mbg.jdbc.username=root
mbg.jdbc.password=root
# 包路径配置
mbg.model.package=com.test.demo.mybatis
mbg.dao.package=com.test.demo.mybatis
mbg.xml.mapper.package=com.test.demo.mybatis
生成代码 方法一：Eclipse Maven 运行
如果是在 Eclipse 中，选择 pom.xml 文件，右键选择：
Run AS > Maven Build… > 在 Goals 框中输入：mybatis-generator:generate
在 Console 中可以看到日志。
生成代码 方法二：Shell 运行
在命令行输入 Maven 命令即可。注意：一定要在当前项目目录下运行该命令：
mvn mybatis-generator:generate
Eclipse Plugin 运行 MBG
详细见：MyBatis Generator - Running MyBatis Generator with Eclipse

如果使用这种方法，将不再依靠 Maven，pom.xml 中的配置将可以省去
加载 properties 文件需变化，自己一直没搞清楚 properties 的路径应该怎么写，后来变量就直接写在 generatorConfig.xml 中了。要是有明白的小伙伴，可以在下面留言
需要下载 plugin：Help > Eclipse Marketplace… > Search for “MyBatis Generator”。这个也是个局限，就是使用的人还需要下载 Eclipse plugin，所以推荐上面使用 Maven 的方法

References

MyBatis Generator 官方文档
MyBatis Generator 中文文档
MyBatis Generator 最完整配置详解 - 简书
用 Maven 插件生成 MyBatis 代码 - 边城刀客的博客




SpringMVC 入门使用
Wed, 07 Sep 2016 14:00:00 +0000

⚠️ 内容声明
本文写于 2016 年，部分内容已过时，仅供历史参考：

XML 配置方式的 SpringMVC 已不再推荐
web.xml 配置前端控制器的方式已过时
JSP 视图技术已较少使用
文中提及的 Struts2 框架已基本淘汰

当前最佳实践（2024+）：

项目创建：使用 Spring Initializr 生成 Spring Boot 项目，自动配置 DispatcherServlet
控制器：使用 @RestController 直接返回 JSON，无需 @ResponseBody
路由注解：使用 @GetMapping、@PostMapping 等简化注解替代 @RequestMapping
参数绑定：MVC 基础概念仍适用，但推荐结合 Bean Validation（@Valid）进行校验
视图层：前后端分离（REST API + Vue/React），或使用 Thymeleaf 模板
配置方式：Java Config + application.yml，无需 XML 配置



本文主要参考了 imooc-SpringMVC 起步 视频教程和 SpringMVC 从入门到精通 系列 - HansonQ ，还有自己的一些总结。
主要内容：MVC 简介、前端控制器模式、SpringMVC 基本概念、SpringMVC 配置、SpringMVC 中的注解、SpringMVC 数据绑定。

MVC 简介
1、MVC 是一种架构模式
程序分层，分工合作，既相互独立，又协同工作，分为三层：模型层、视图层和控制层
2、MVC 是一种思考方式

View：视图层，为用户提供 UI，重点关注数据的呈现，为用户提供界面
Model：模型层，业务数据的信息表示，关注支撑业务的信息构成，通常是多个业务实体的组合
Controller：控制层，调用业务逻辑产生合适的数据（Model），传递数据给视图用于呈现

MVC 设计模式在 B/S 下的应用：

①：浏览器发送请求到控制器(这里要知道控制器的作用)
②：控制器不能处理请求必须交给模型层来处理接着去访问数据库
③：模型层将处理好的结果返回给控制层
④：控制层将逻辑视图响应给浏览器(浏览器显示的是渲染过的视图)
MVC 本质：MVC 的核心思想是业务数据抽取同业务数据呈现相分离；分离有利于程序简化，方便编程
前端控制器模式
前端控制器模式（Front Controller Pattern）是用来提供一个集中的请求处理机制，所有的请求都将由一个单一的处理程序处理。该处理程序可以做认证/授权/记录日志，或者跟踪请求，然后把请求传给相应的处理程序。

前端控制器（Front Controller）- 处理应用程序所有类型请求的单个处理程序，应用程序可以是基于 web 的应用程序，也可以是基于桌面的应用程序。
调度器（Dispatcher） - 前端控制器可能使用一个调度器对象来调度请求到相应的具体处理程序。
视图（View） - 视图是为请求而创建的对象。

前端控制器的主要作用：

指前端控制器将我们的请求分发给我们的控制器去生成业务数据
将生成的业务数据分发给恰当的视图模版来生成最终的视图界面


SpringMVC 基本概念

对组件说明：

DispatherServlet：前端控制器 用户请求到达前端控制器，相当于 MVC 中的 C，而 DispatherServlet 是整个流程的核心，它来调用其他组件来处理用户的请求，前端控制器的存在降低了其他组件之间的耦合度。
HandlerMapping：处理器映射器 它的作用就好比去看电影要拿着电影票根据电影票上面的座位号找到座位其中座位就是 Handler，电影票以及上面的座位号就是 URL HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。
Handler：处理器 Handler 是后端控制器，在前端控制器的控制下后端控制器对具体的用户请求进行处理，Handler 涉及到具体的用户业务请求，所以一般情况下需要程序员根据业务需求开发。
HandlerAdapter：处理器适配器 通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过适配器可以对更多类型的处理器进行执行。播放的电影是 3D 的你看不清楚，因此电影院跟你说你要想看清电影就必须戴 3D 眼镜。也就是说 Handler 满足一定的要求才可以被执行。
ViewResolver：视图解析器 ViewResolver 负责将处理结果生成 View 视图，ViewResolver 首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。


工作原理解释说明：
1、用户发送请求到 SpringMVC 框架提供的 DispatcherServlet 这个前端控制器（了解 struts2 的朋友也都知道其实 struts2 也有一个前端控制器 web.xml 中的 filter 标签就是）。
2、前端控制器会去找处理器映射器（HandlerMapping），处理器映射器根据请求 url 找到具体的处理器，生成处理器对象及处理器拦截器（如果有则生成）一并返回给 DispatcherServlet 。
3、根据处理器映射器返回的处理器，DispatcherServlet 会找“合适”的处理器适配器（HandlerAdapter）
4、处理器适配器 HandlerAdpater 会去执行处理器（Handler 开发的时候会被叫成 Controller 也叫后端控制器在 struts2 中 action 也是一个后端控制器）执行之前会有转换器、数据绑定、校验器等等完成上面这些才会去正在执行 Handler
5、后端控制器 Handler 执行完成之后返回一个 ModelAndView 对象 。
6、处理器适配器 HandlerAdpater 会将这个 ModelAndView 返回前端控制器 DispatcherServlet。前端控制器会将 ModelAndView 对象交给视图解析器 ViewResolver。
7、视图解析器 ViewResolver 解析 ModelAndView 对象之后返回逻辑视图。
8、前端控制器 DispatcherServlet 对逻辑视图进行渲染（数据填充）之后返回真正的物理 View 并响应给浏览器。

SpringMVC 配置
1、前端控制器需要在 web.xml 中配置


  web-dispatcher
  org.springframework.web.servlet.DispatcherServlet
  
  
    
    contextConfigLocation
    classpath:spring/spring-*.xml
  
  
  1


web-dispatcher
  
  
  /

2、在 spring/spring-web.xml 配置视图解析器






 class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  
   name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
  
   name="prefix" value="/WEB-INF/jsp/" />
  
   name="suffix" value=".jsp" />

3、在 spring/spring-web.xml 配置 注解模式



4、在 spring/spring-web.xml 配置 扫描 web 相关的 bean

 base-package="com.controller" />
SpringMVC 中的注解
@Controller
@Controller 注解，用于标识这个类是一个后端控制器（类似 struts 中的 action），主要作用就是接受页面的参数，转发页面。
@Controller 源码：
@Target({ElementType.TYPE}) // 表明只能定义在类上面
@Retention(RetentionPolicy.RUNTIME) //保留策略是RUNTIME，在JVM加载类时，会把注解加载到JVM内存中（它是唯一可以用反射来读取注解的策略）
@Documented //@Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员。
@Component //spring框架规定当一个类不好归类（service、dao、controller）的时候可以使用这个注解，由此可见即便好归类内部还是使用的@Component注解
public @interface Controller {
  /**
    * The value may indicate a suggestion for a logical component name,
    * to be turned into a Spring bean in case of an autodetected component.
    * @return the suggested component name, if any
    */
  String value() default "";
}
@RequestMapping
这个注解的作用目标就跟 @Controller 不一样了，这个注解可以定义在类上面也可以定义在方法上面。
/**
* 1.@RequestMapping：除了修饰方法,还可以修饰类
* 2.类定义处：提供初步的请求信息映射.相对于WEB应用的根目录(窄化请求)
* 3.方法处：提供进一步的细分映射信息。相对于类定义处的URL。
*      若类定义处为标注@RequestMapping,则方法出的URL相对于WEB应用的根目录
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {
  String[] value() default {};
  RequestMethod[] method() default {}; //限制请求方式
  String[] params() default {}; //要求请求的URL包含指定的参数
}
代码实例
@Controller
@RequestMapping("/demo")
public class IndexController {
  @RequestMapping(value = "/test", method = RequestMethod.GET)
  public String index(Model model, HttpServletRequest request) {
    // 在游览器访问 http://localhost:8080/demo/test 将进入这里
    model.addAttribute("originURL", "");
    model.addAttribute("controllerName", "index");
    return "index";
  }
}
@RequestMapping 还支持 Ant 方格的请求
?：匹配文件中的一个字符
*：匹配文件中任意字符
**：**匹配多层路径

/user/*/createUser : 匹配 -/user/aa/createUser 或者 -/user/aa/createUser
/user/**/createUser : 匹配 -/user/aa/createUser 或者 -/user/createUser 或者 -/user/aa/cc/createUser
/user/createUser?? : 匹配 -/user/aa/createUseraa
@PathVariable
@PathVariable 这个注解支持现在当下较为流行的 Restful 风格的 URL。 先说说这个注解的作用，支持将 url 中的占位符参数绑定到目标方法的参数上， 该功能也是 SpringMVC 实现 Restful 风格 url 的重要措施。
代码实例
// http://localhost:8080/demo/sss
@RequestMapping(value = "/{slug:.+}", method = RequestMethod.GET)
public String index2(@PathVariable("slug") String slug, Model model) {
  LOG.info("DemoController index2 slug  " + slug);
  // common
  model.addAttribute("originURL", "demo/");
  model.addAttribute("controllerName", "demo");
  model.addAttribute("controllerMethod", "index2");
  model.addAttribute("slug", slug);
  return "demo";
}

//slug = sss
我们熟悉的请求应该是 POST 和 GET 请求，这两个请求也是最常用的而实际上 HTTP1.1 请求还有 PUT、DELETE 等 8 种来表名请求的动作。
在 SpringMVC 中要实现 PUT 和 DELETE 请求需要在 web.xml 额外配置一个过滤器，这个过滤器的作用就是把 POST 请求变为 PUT 和 DELETE 请求。
关于 Restful 的内容计划单独写。
@RequestParam
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {
  String value() default "";//值即为请求参数的参数名
  boolean required() default true;//该参数是否是必须。默认值为true
  String defaultValue() default ValueConstants.DEFAULT_NONE;//请求参数的默认值
}
// http://localhost:8080/demo/para?slug=google
@RequestMapping(value = "/para", method = RequestMethod.GET)
public String index3(@RequestParam(value = "slug", defaultValue = "") String slug, Model model) {
  model.addAttribute("originURL", "demo/");
  model.addAttribute("controllerName", "demo");
  model.addAttribute("controllerMethod", "index3");
  model.addAttribute("slug", slug);
  return "demo";
}
slug = google
另外还有一点要提示一下，参数没有加这个注解也能映射成功，这是应为 SpringMVC 框架支持请求参数和目标方法参数一致的时候可以省略这个注解。
@ResponseBody
/**
 * Annotation that indicates a method return value should be bound to the web
 * response body. Supported for annotated handler methods in Servlet environments.
 *
 * 这个注解指明一个方法的返回值应该绑定在 web response body 中，在 Servlet 环境中支持注解处理方法
 *
 * As of version 4.0 this annotation can also be added on the type level in
 * which case it is inherited and does not need to be added on the method level.
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ResponseBody {
}
代码
// http://localhost:8080/demo/json
@RequestMapping(value = "/json", method = RequestMethod.POST)
public @ResponseBody Domain index7(HttpServletRequest request, Model model) {
  LOG.info("DemoController demo index7");
  model.addAttribute("originURL", "demo/");
  model.addAttribute("controllerName", "demo");
  model.addAttribute("controllerMethod", "index7");

  Domain domain = new Domain();
  domain.setDomain("gggoogle.com");
  domain.setId(100);
  return domain;
}

/* response body
{
  "id": 100,
  "domain": "gggoogle.com"
}
*/
SpringMVC 数据绑定
简单说一下场景：
对于一个注册页面有很多信息譬如：用户名、密码、确认密码、邮箱、手机、兴趣等等。这时候就会想能不能将这些个参数包装在一个对象中（POJO），用这个 POJO 来做目标方法的形参上面。
可以说的是 SpringMVC 是支持将 POJO 作为目标参数的。当然也是要遵循一些规则的，就是表单的 name 属性值要和 POJO 的属性值要一致。当然了，这样又会有一个新的疑问支不支持级联属性答案是支持的。
public class Address {
  private String city;
  ...
}
public class Persion {
  private String name;
  private Address address;
  ...
}
<form action="/demo/pojo">
  NAME:<input type="text" name="name" /> CITY:<input
    type="text"
    name="address.city"
  />
form>
@RequestMapping(value = "/pojo", method = RequestMethod.POST)
public String index4(Persion persion, Model model) {
  `model.addAttribute("originURL", "demo/");
  model.addAttribute("controllerName", "demo");
  model.addAttribute("controllerMethod", "index4");
  model.addAttribute("persion", persion);
  return "demo";`
}
SpringMVC 使用 Servlet API
可以使用 Servlet 原生的 API 作为目标方法的参数。具体支持以下类型：HttpServletRequest、HttpServletResponse、HttpSession、java.security.Principal、Locale、InputStream、OutputStream、Reader、Writer
// http://localhost:8080/demo/req?slug=facebook
@RequestMapping(value = "/req", method = RequestMethod.GET)
public String index5(HttpServletRequest request, Model model) {
  String slug = request.getParameter("slug");
  model.addAttribute("originURL", "demo/");
  model.addAttribute("controllerName", "demo");
  model.addAttribute("controllerMethod", "index5");
  model.addAttribute("slug", slug);
  return "demo";
}
References

IMOOC-SpringMVC 起步
SpringMVC 从入门到精通 系列 - HansonQ

包管理器	代表发行版	归属
dnf / yum	Fedora, RHEL, CentOS	RPM
zypper	openSUSE, SLE	RPM
apt / apt-get	Debian, Ubuntu	DEB
pacman	Arch Linux	tar.xz
apk	Alpine	.apk

特性	作用
二进制分帧 (Binary Framing)	把 HTTP 报文拆成小型 Frame；机器易解析、可并行
多路复用 (Multiplexing)	多个请求/响应共享一个 TCP 连接，互不阻塞
流与优先级 (Stream & Priority)	每个请求是双向 Stream，可指定权重与依赖
头部压缩 (HPACK)	静态 Huffman + 动态表，大幅减少重复的 Header 字节
服务器推送 (Server Push)	服务器可在请求外预送资源 (已被多数浏览器弱化/关闭)
流量控制	端到端窗口，避免单个大文件占满带宽

HOST	User	被条目匹配的连接
’thomas.loc.gov’	‘fred’	fred, 从 thomas.loc.gov 连接
’thomas.loc.gov'	''	任何用户, 从 thomas.loc.gov 连接
‘%’	‘fred’	fred, 从任何主机连接
‘%’	''	任何用户, 从任何主机连接
‘%.loc.gov’	‘fred’	fred, 从在 loc.gov 域的任何主机连接
‘x.y.%’	‘fred’	fred, 从 x.y.net、x.y.com,x.y.edu 等联接（这或许无用）
‘144.155.166.177’	‘fred’	fred, 从有 144.155.166.177 的主机连接
‘144.155.166.%’	‘fred’	fred, 从 144.155.166 C 类子网的任何主机连接

ZYF.IM BLOG

从 1Password 迁移到 Vaultwarden

背景

前置准备

环境初始化

部署 Vaultwarden + Caddy

PHP Migrating 8.4 to 8.5

简介

参考资源

PHP 8.5 新特性

管道运算符（Pipe Operator）

URI 扩展

Clone With 语法

#[\NoDiscard] 属性

常量表达式中的闭包

持久化 cURL Share Handles

PHP 8.5 新增函数

array_first() 和 array_last()

get_error_handler() 和 get_exception_handler()

IntlListFormatter 类

curl_multi_get_handles()

locale_is_right_to_left() / Locale::isRightToLeft()

grapheme_levenshtein()

Closure::getCurrent()

其他改进

致命错误包含堆栈跟踪

新的 DOM 方法

属性可以应用于常量

静态属性支持非对称可见性

构造函数提升支持 final 属性

setcookie() 支持 “partitioned” 选项

新的全局常量

CLI 新选项

max_memory_limit INI 指令

弃用特性

反引号运算符（shell_exec 别名）

非标准类型转换

mysqli_execute()

curl_close() 和 curl_share_close()

xml_parser_free()

socket_set_timeout()

MHASH_* 常量

__sleep() 和 __wakeup()

case 语句后使用分号

null 作为数组偏移量

移除的特性

disable_classes INI 设置

CLI -z / –zend-extension 选项

兼容性变化

类型转换警告

class_alias() 限制

总结

NGINX 启用 HTTP/3

简介

开始实验

测试

curl

浏览器

References

在本地环境使用 HTTPS

简介

开始实验

测试

浏览器

curl

深入探索

HTTP 的三大安全缺陷

为什么需要 HTTPS

MAC vs AEAD

证书类型

证书链

HTTPS 在网络堆栈中的位置

TLS 握手过程

TLS 1.3

RTT vs. 0-RTT

证书与密钥

HTTP/2

HTTP/3

References

PHP Migrating 8.3 to 8.4

sleep() 和 wakeup()