Clloz's Blog

Mihomo Mac 配置

Sun, 09 Nov 2025 22:00:00 GMT

前言

Mac 上不想要使用 Clash 客户端，大部分都不维护，直接使用 launchd 配置 mihomo 的客户端启动代理，可以自己完全控制代理工具。

创建用户

mihomo 毕竟也是一个第三方程序，为了保证安全性还是创建一个独立的用户，用户名称带前置下划线是 mac 默认的系统级用户的通用做法

| 类型 | UID/GID 范围 | 说明 | | ----------------- | ------------ | ------------------------------------------------------------------------ | | 系统保留用户 | 0~399 | macOS 自带系统用户，如 root (0)、_www、_spotlight 等；不要使用，会冲突 | | 服务/守护进程用户 | 400~499 | 推荐范围，用于自建服务用户（隐藏） | | 普通用户 | 501~ | 正常登录用户，显示在“用户与群组”界面 |

# 判断 UID 是否被占用
dscl . -list /Users UniqueID | grep 450

# 判断 GID 是否被占用
dscl . -list /Groups PrimaryGroupID | grep 450

# 列出所有 UID
dscl . -list /Users UniqueID

# 列出所有 GID
dscl . -list /Groups PrimaryGroupID

# 查看 UID 属于那个分组
id UID

# 创建 group
sudo dscl . -create /Groups/_clash
sudo dscl . -create /Groups/_clash RealName "Clash Service Group"
sudo dscl . -create /Groups/_clash gid 450

# 创建 user
sudo dscl . -create /Users/_clash
sudo dscl . -create /Users/_clash UserShell /usr/bin/false # 禁止该用户登录，使用 shell
sudo dscl . -create /Users/_clash RealName "Clash Service"
sudo dscl . -create /Users/_clash UniqueID 450
sudo dscl . -create /Users/_clash PrimaryGroupID 450
sudo dscl . -create /Users/_clash NFSHomeDirectory /var/empty # 设置家目录路径
sudo dscl . -create /Users/_clash IsHidden 1 # 不在系统设置，用户和分组中展示该分组

# 删除用户
sudo dscl . -delete /Users/_clash

# 可选：删除 home 目录或其他文件
sudo rm -rf /var/empty  # 如果 home 是 /var/empty

# 删除分组 确保没有其他用户使用该分组
sudo dscl . -delete /Groups/_clash

管理 clash

创建 /opt/clash 文件夹用来管理所有 clash 相关的可执行文件，配置和日志，内部创建三个文件夹分别用来管理可执行文件，配置和日志

最新的 mihomo 下载地址，根据官方文档 MacOS 15 选择 go122 版本

由于 mihomo 是未经第三方验证的程序，mac 默认的 Gatekeeper 默认会禁止我们运行该程序

Apple could not verify “mihomo-darwin-arm64-go122-v1.19.15” is free of malware that may harm your Mac or compromise your privacy.

遇到这种情况到 System Settings -> Privacy & Security 中滑到最下面点击 run anyway

# 创建文件夹
sudo mkdir -p /opt/clash/{bin,config,logs}
sudo mkdir /opt/clash/config/ui

# 下载最新版本的 mihomo
curl -L \
  -o mihomo-darwin-arm64-go122-v1.19.16.gz \
  https://github.com/MetaCubeX/mihomo/releases/download/v1.19.16/mihomo-darwin-arm64-go122-v1.19.16.gz

# 解压
gunzip mihomo-darwin-arm64-go122-v1.19.16.gz

# 创建软链接
sudo ln -sf /opt/clash/bin/mihomo-darwin-arm64-latest /opt/clash/bin/clash-target

# 验证软链接
ls -la /opt/clash/bin/clash-target

# 验证新版本
sudo -u _clash /opt/clash/bin/clash-target -v

# 设置正确的权限，确保二进制文件可执行
sudo chmod +x /opt/clash/bin/mihomo
sudo chmod +x /opt/clash/bin/clash-target

# 配置用户和分组
sudo chown root:wheel /opt/clash/bin/
sudo chown -R _clash:_clash /opt/clash/config/ /opt/clash/logs/

最终的目录结构如下

/opt/clash/
├── bin/
│ ├── mihomo-darwin-arm64-go122-v1.19.16 # Mihomo 可执行文件
│ ├── bin # 自定义脚本
│ └── clash-target -> /opt/clash/bin/mihomo-darwin-arm64-go122-v1.19.16 # 软链接
├── config/
│ └── config.yaml # Clash 配置文件
└── logs/
├── clash.log # 标准输出日志
└── clash-error.log # 标准错误日

更新 mihomo 版本

# 下载最新版本的 mihomo
curl -L \
  -o mihomo-darwin-arm64-go122-v1.19.16.gz \
  https://github.com/MetaCubeX/mihomo/releases/download/v1.19.16/mihomo-darwin-arm64-go122-v1.19.16.gz

# 解压
gunzip mihomo-darwin-arm64-go122-v1.19.16.gz

# 创建软链接
sudo ln -sf /opt/clash/bin/mihomo-darwin-arm64-latest /opt/clash/bin/clash-target

# 验证软链接
ls -la /opt/clash/bin/clash-target

# 验证新版本
sudo -u _clash /opt/clash/bin/clash-target -v

# 重启 mihomo
clash restart

mihomo 配置

参考官方的配置文件 config.yaml

# 检查配置是否合法
sudo -u nobody /opt/clash/bin/clash-target -t -d /opt/clash/config/

# 配置加载过程中可能由于网络问题导致 geoip.dat geoip.metadb geosite.dat 下载失败，可以手动下载然后复制到 /opt/clash/config 目录下
# 或者尝试 设置 config.yaml 中的 ipv6: false 看是否能下载成功

自定义 clash 脚本

创建一个 clash 脚本能够快速执行一些命令管理 clash

touch /opt/clash/bin/clash
sudo chmod +x /opt/clash/bin/clash

# 添加到系统环境变量
export PATH="/opt/clash/bin:$PATH"

# 也可以使用短链接
sudo ln -s /opt/clash/bin/clash /usr/local/bin/clash

完整的脚本实现如下

#!/bin/zsh
set -euo pipefail

# Clash Management Script
# Location: /opt/clash/bin/clash
# This script provides comprehensive control for Mihomo/Clash running via launchd

CLASH_BIN="/opt/clash/bin/clash-target"
CONFIG_DIR="/opt/clash/config"
CONFIG_FILE="$CONFIG_DIR/config.yaml"
LOG_DIR="/opt/clash/logs"
LAUNCHD_PLIST="/Library/LaunchDaemons/com.user.clash.plist"

# 定义颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 基础函数
print_status() { echo -e "${BLUE}[INFO]${NC} $1"; }
print_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
print_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
print_error() { echo -e "${RED}[ERROR]${NC} $1"; }

# 检查服务是否运行
is_service_running() {
    # 方法1（推荐）：直接检查是否有 clash-target 进程在运行
    if pgrep -f "clash-target" > /dev/null; then
        return 0
    else
        return 1
    fi
}

# 检查启动项是否启用
is_launchd_enabled() {
    launchctl print system/com.user.clash &>/dev/null && return 0 || return 1
}

# 验证配置文件
validate_config() {
    local validation_result

    if [[ ! -f "$CLASH_BIN" ]]; then
        print_error "Clash binary not found: $CLASH_BIN"
        return 1
    fi

    if [[ ! -f "$CONFIG_FILE" ]]; then
        print_error "Config file not found: $CONFIG_FILE"
        return 1
    fi

    # 使用更明确的错误处理
    if validation_result=$(sudo -u nobody "$CLASH_BIN" -t -d "$CONFIG_DIR" 2>&1); then
        print_success "Configuration validation passed"
        return 0
    else
        print_error "Configuration validation failed: $validation_result"
        return 1
    fi
}

# 检查系统代理状态
is_system_proxy_enabled() {
    local http_proxy=$(networksetup -getwebproxy "Wi-Fi" | grep "Enabled: Yes")
    local https_proxy=$(networksetup -getsecurewebproxy "Wi-Fi" | grep "Enabled: Yes")

    if [[ -n "$http_proxy" && -n "$https_proxy" ]]; then
        return
    else
        return 1
    fi
}

# 主功能函数
clash_enable() {
    print_status "Enabling clash auto-start on boot..."
    if sudo launchctl load -w "$LAUNCHD_PLIST" 2>/dev/null; then
        print_success "Clash auto-start enabled"
    else
        print_error "Failed to enable auto-start"
    fi
}

clash_disable() {
    print_status "Disabling clash auto-start..."
    if sudo launchctl unload -w "$LAUNCHD_PLIST" 2>/dev/null; then
        print_success "Clash auto-start disabled"
    else
        print_error "Failed to disable auto-start"
    fi
}

clash_status() {
    echo "=== Clash Service Status ==="

    # 检查启动项状态
    if is_launchd_enabled; then
        echo -e "Auto-start: ${GREEN}Enabled${NC}"
    else
        echo -e "Auto-start: ${RED}Disabled${NC}"
    fi

    # 检查服务运行状态
    if is_service_running; then
        echo -e "Service: ${GREEN}Running${NC}"
    else
        echo -e "Service: ${RED}Stopped${NC}"
    fi

    # 检查系统代理状态
    if is_system_proxy_enabled; then
        echo -e "System Proxy: ${GREEN}Enabled${NC}"
    else
        echo -e "System Proxy: ${RED}Disabled${NC}"
    fi

    # 显示文件路径
    echo "Config Path: $CONFIG_FILE"
    echo "Log Path: $LOG_DIR"
    echo "Binary Path: $CLASH_BIN"

    # 显示最新日志
    if [[ -f "$LOG_DIR/clash.log" ]]; then
        echo -e "\n=== Recent Logs ==="
        tail -5 "$LOG_DIR/clash.log" 2>/dev/null || echo "No recent logs found"
    fi
}

clash_start() {
    if is_service_running; then
        print_warning "Clash is already running"
        return
    fi

    print_status "Starting clash service..."
    validate_config || return 1

    sudo launchctl start com.user.clash
    sleep 2

    if is_service_running; then
        print_success "Clash started successfully"
    else
        print_error "Failed to start clash"
    fi
}

clash_stop() {
    if ! is_service_running; then
        print_warning "Clash is not running"
        return
    fi

    print_status "Stopping clash service..."
    sudo launchctl stop com.user.clash

    sleep 2
    if ! is_service_running; then
        print_success "Clash stopped successfully"
    else
        print_error "Failed to stop clash"
    fi
}

clash_restart() {
    clash_stop
    clash_start
}

# 需要设置所有网络的代理才能让代理生效，实测仅设置 Wifi 的代理，虽然命令行能正常走代理但是浏览器还是无法使用
clash_on() {
    print_status "Enabling system proxy for all network services..."

    # 获取当前网络端口(从配置文件中提取)
    local proxy_port=$(grep -E "^mixed-port:" "$CONFIG_FILE" 2>/dev/null | awk '{print $2}')
    if [[ -z "$proxy_port" ]]; then
        proxy_port=7890  # 默认端口
    fi

    # 1. 获取所有网络服务列表
    # 使用 networksetup 命令列出所有服务，并过滤掉已禁用的服务(名称前带*号)
    local network_services
    network_services=$(networksetup -listallnetworkservices | tail -n +2 | grep -v '^\*')

    # 2. 遍历每个网络服务并设置代理
    echo "$network_services" | while read -r service; do
        # 跳过空行
        if [[ -z "$service" ]]; then
            continue
        fi

        print_status "Setting proxy for: $service"

        # 设置HTTP/HTTPS/SOCKS代理
        sudo networksetup -setwebproxy "$service" 127.0.0.1 "$proxy_port"
        sudo networksetup -setsecurewebproxy "$service" 127.0.0.1 "$proxy_port"
        sudo networksetup -setsocksfirewallproxy "$service" 127.0.0.1 "$proxy_port"

        # 启用代理
        sudo networksetup -setwebproxystate "$service" on
        sudo networksetup -setsecurewebproxystate "$service" on
        sudo networksetup -setsocksfirewallproxystate "$service" on
    done

    print_success "System proxy enabled on port $proxy_port for all network services"
}

clash_off() {
    print_status "Disabling system proxy for all network services..."

    # 获取所有网络服务列表
    local network_services
    network_services=$(networksetup -listallnetworkservices | tail -n +2 | grep -v '^\*')

    # 遍历每个网络服务并关闭代理
    echo "$network_services" | while read -r service; do
        # 跳过空行
        if [[ -z "$service" ]]; then
            continue
        fi

        print_status "Disabling proxy for: $service"

        sudo networksetup -setwebproxystate "$service" off
        sudo networksetup -setsecurewebproxystate "$service" off
        sudo networksetup -setsocksfirewallproxystate "$service" off
    done

    print_success "System proxy disabled for all network services"
}

clash_config_edit() {
    if [[ ! -f "$CONFIG_FILE" ]]; then
        print_error "Config file not found: $CONFIG_FILE"
        return 1
    fi

    # 备份原配置
    cp "$CONFIG_FILE" "$CONFIG_FILE.bak"
    print_status "Backup created: $CONFIG_FILE.bak"

    # 使用vim编辑
    vim "$CONFIG_FILE"

    # 验证编辑后的配置
    if validate_config; then
        print_success "Configuration updated and validated"
        # 询问是否重启服务
        read -q "REPLY?Restart clash to apply changes? (y/n): "
        echo
        if [[ $REPLY =~ ^[Yy]$ ]]; then
            clash_restart
        fi
    else
        print_error "Configuration validation failed, restoring backup..."
        cp "$CONFIG_FILE.bak" "$CONFIG_FILE"
        return 1
    fi
}

clash_config_set() {
    local field="$1"
    local value="$2"

    if [[ -z "$field" || -z "$value" ]]; then
        print_error "Usage: clash config-set <field> <value>"
        return 1
    fi

    if [[ ! -f "$CONFIG_FILE" ]]; then
        print_error "Config file not found"
        return 1
    fi

    # 备份原配置
    cp "$CONFIG_FILE" "$CONFIG_FILE.bak"

    # 使用yq工具修改配置(需要先安装yq)
    if command -v yq >/dev/null 2>&1; then
        yq e ".$field = \"$value\"" -i "$CONFIG_FILE"
    else
        # 如果没有yq，使用sed简单替换（适用于简单字段）
        if grep -q "^$field:" "$CONFIG_FILE"; then
            sed -i.bak "s/^$field:.*/$field: $value/" "$CONFIG_FILE"
        else
            # 如果字段不存在，添加到文件末尾
            echo "$field: $value" >> "$CONFIG_FILE"
        fi
    fi

    # 验证配置
    if validate_config; then
        print_success "Configuration updated: $field = $value"
    else
        print_error "Configuration validation failed, restoring backup..."
        cp "$CONFIG_FILE.bak" "$CONFIG_FILE"
        return 1
    fi
}

# 模式设置函数
clash_mode_rule() { clash_config_set "mode" "rule" && clash_restart; }
clash_mode_global() { clash_config_set "mode" "global" && clash_restart; }
clash_mode_direct() { clash_config_set "mode" "direct" && clash_restart; }

# TUN模式设置函数
clash_tun_on() {
    clash_config_set "tun.enable" "true" && clash_restart;
}

clash_tun_off() {
    clash_config_set "tun.enable" "false" && clash_restart;
}

clash_validate() {
    print_status "Validating clash configuration..."

    # 检查二进制文件是否存在
    if [[ ! -f "$CLASH_BIN" ]]; then
        print_error "Clash binary not found: $CLASH_BIN"
        return 1
    fi

    # 检查配置文件是否存在
    if [[ ! -f "$CONFIG_FILE" ]]; then
        print_error "Config file not found: $CONFIG_FILE"
        return 1
    fi

    # 检查配置文件语法
    echo "=== Configuration Syntax Check ==="
    if validation_result=$(sudo -u nobody "$CLASH_BIN" -t -d "$CONFIG_DIR" 2>&1); then
        print_success "✓ Configuration syntax is valid"
    else
        print_error "✗ Configuration syntax error:"
        echo "$validation_result"
        return 1
    fi

    # 检查关键配置项
    echo -e "\n=== Key Configuration Items ==="

    # 检查端口配置
    local mixed_port=$(grep -E "^mixed-port:" "$CONFIG_FILE" 2>/dev/null | awk '{print $2}')
    local socks_port=$(grep -E "^socks-port:" "$CONFIG_FILE" 2>/dev/null | awk '{print $2}')
    local external_port=$(grep -E "^external-controller:" "$CONFIG_FILE" 2>/dev/null | awk -F: '{print $3}')

    echo -e "Mixed Port: ${mixed_port:-7890 (default)}"
    echo -e "SOCKS Port: ${socks_port:-Not set}"
    echo -e "External Controller: ${external_port:-9090 (default)}"

    # 检查模式设置
    local mode=$(grep -E "^mode:" "$CONFIG_FILE" 2>/dev/null | awk '{print $2}')
    echo -e "Mode: ${mode:-rule (default)}"

    # 检查代理组和规则
    echo -e "\n=== Proxies and Rules ==="
    # 统计 proxies 下的节点数量
    local proxy_count=$(yq e '.proxies | length' "$CONFIG_FILE" 2>/dev/null || echo "0")

    # 统计 rules 下的规则数量
    local rule_count=$(yq e '.rules | length' "$CONFIG_FILE" 2>/dev/null || echo "0")

    echo -e "Proxy count: $proxy_count"
    echo -e "Rule count: $rule_count"

    # 检查DNS配置
    local dns_enabled=$(grep -A5 "^dns:" "$CONFIG_FILE" 2>/dev/null | grep -q "enable: true" && echo "Enabled" || echo "Disabled")
    echo -e "DNS: $dns_enabled"

    # 检查TUN配置
    local tun_enabled=$(grep -A5 "^tun:" "$CONFIG_FILE" 2>/dev/null | grep -q "enable: true" && echo "Enabled" || echo "Disabled")
    echo -e "TUN: $tun_enabled"

    # 检查文件权限
    echo -e "\n=== File Permissions ==="
    if [[ -r "$CONFIG_FILE" ]]; then
        print_success "✓ Config file is readable"
    else
        print_error "✗ Config file is not readable"
    fi

    if [[ -x "$CLASH_BIN" ]]; then
        print_success "✓ Binary file is executable"
    else
        print_error "✗ Binary file is not executable"
    fi

    # 检查端口占用情况
    echo -e "\n=== Port Availability ==="
    if [[ -n "$mixed_port" ]]; then
        if sudo lsof -i :$mixed_port >/dev/null 2>&1; then
            print_warning "⚠ Port $mixed_port is already in use"
        else
            print_success "✓ Port $mixed_port is available"
        fi
    fi

    if [[ -n "$external_port" ]]; then
        if sudo lsof -i :$external_port >/dev/null 2>&1; then
            print_warning "⚠ External port $external_port is already in use"
        else
            print_success "✓ External port $external_port is available"
        fi
    fi

    # 最终验证结果 - 修复后的逻辑
    echo -e "\n=== Final Validation Result ==="
    if sudo -u nobody "$CLASH_BIN" -t -d "$CONFIG_DIR" >/dev/null 2>&1; then
        print_success "🎉 Configuration validation passed! All checks are good."
        return 0
    else
        print_error "❌ Configuration validation failed. Please check the errors above."
        return 1
    fi
}

# 主命令解析
case "$1" in
    "enable")
        clash_enable
        ;;
    "disable")
        clash_disable
        ;;
    "status")
        clash_status
        ;;
    "start")
        clash_start
        ;;
    "stop")
        clash_stop
        ;;
    "restart")
        clash_restart
        ;;
    "on")
        clash_on
        ;;
    "off")
        clash_off
        ;;
    "valid")
        clash_validate
        ;;
    "config-edit")
        clash_config_edit
        ;;
    "config-set")
        clash_config_set "$2" "$3"
        ;;
    "mode-rule")
        clash_mode_rule
        ;;
    "mode-global")
        clash_mode_global
        ;;
    "mode-direct")
        clash_mode_direct
        ;;
    "tun-on")
        clash_tun_on
        ;;
    "tun-off")
        clash_tun_off
        ;;
    *)
        echo "Clash Management Script"
        echo "Usage: clash {enable|disable|status|start|stop|restart|on|off|config-edit|config-set|mode-rule|mode-global|mode-direct|tun-on|tun-off}"
        echo ""
        echo "Commands:"
        echo "  enable        Enable auto-start on boot"
        echo "  disable       Disable auto-start"
        echo "  status        Show service status and information"
        echo "  start         Start clash service"
        echo "  stop          Stop clash service"
        echo "  restart       Restart clash service"
        echo "  on            Enable system proxy"
        echo "  off           Disable system proxy"
        echo "  valid      Validate configuration file and check for issues"
        echo "  config-edit   Edit configuration with vim"
        echo "  config-set    <field> <value>  Set specific configuration field"
        echo "  mode-rule     Set mode to Rule and restart"
        echo "  mode-global   Set mode to Global and restart"
        echo "  mode-direct   Set mode to Direct and restart"
        echo "  tun-on        Enable TUN mode and restart"
        echo "  tun-off       Disable TUN mode and restart"
        exit 1
        ;;
esac

可以使用 clash -h 命令查看用法

Clash Management Script
Usage: clash {enable|disable|status|start|stop|restart|on|off|config-edit|config-set|mode-rule|mode-global|mode-direct|tun-on|tun-off}

Commands:
enable Enable auto-start on boot
disable Disable auto-start
status Show service status and information
start Start clash service
stop Stop clash service
restart Restart clash service
on Enable system proxy
off Disable system proxy
valid Validate configuration file and check for issues
config-edit Edit configuration with vim
config-set <field> <value> Set specific configuration field
mode-rule Set mode to Rule and restart
mode-global Set mode to Global and restart
mode-direct Set mode to Direct and restart
tun-on Enable TUN mode and restart
tun-off Disable TUN mode and restart

launchd 配置

需要创建一个系统级的 plist 来管理 clash 的开机启动

sudo touch com.user.clash.plist

plist 具体内容如下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.clash</string>

    <!-- 传递给程序的参数：-d 指定配置目录 -->
    <key>ProgramArguments</key>
    <array>
        <string>/opt/clash/bin/clash-target</string>
        <string>-d</string>
        <string>/opt/clash/config</string>
    </array>

    <!-- 核心修改：指定运行身份为 _clash 用户和组 -->
    <key>UserName</key>
    <string>_clash</string>
    <key>GroupName</key>
    <string>_clash</string>

    <!-- 设置工作目录 -->
    <key>WorkingDirectory</key>
    <string>/opt/clash</string>

    <!-- 在加载服务时立即启动 -->
    <key>RunAtLoad</key>
    <true/>

    <!-- 配置基于网络状态的保活 -->
    <key>KeepAlive</key>
    <dict>
        <key>NetworkState</key>
        <true/>
    </dict>

    <!-- 标准输出和错误输出到日志文件 -->
    <key>StandardOutPath</key>
    <string>/opt/clash/logs/clash.log</string>
    <key>StandardErrorPath</key>
    <string>/opt/clash/logs/clash-error.log</string>

    <!-- 关于 LimitLoadToSessionType 的解释见下文 -->
    <key>LimitLoadToSessionType</key>
    <array>
        <string>System</string>
        <!-- 对于需要与任意用户图形会话交互的图形界面程序，可考虑添加 "Aqua" -->
        <!-- 但对于 Mihomo 这种网络代理守护进程，通常只使用 "System" -->
    </array>
</dict>
</plist>

# 1. 将 plist 文件复制到系统守护进程目录
sudo cp com.user.clash.plist /Library/LaunchDaemons/

# 2. 确保文件权限正确（root 用户和 wheel 组拥有所有权）
sudo chown root:wheel /Library/LaunchDaemons/com.user.mihomo.plist
sudo chmod 644 /Library/LaunchDaemons/com.user.mihomo.plist # 通常plist文件权限为644

# 3. 确保 /opt/clash 目录及其下文件对运行用户（nobody）有适当的访问权限
# 一种简单的方式是将配置目录的读权限赋予其他用户，但更安全的方法是更改文件所有者或设置更精细的ACL
sudo chmod o+r /opt/clash/config/config.yaml # 让其他用户能读配置（如果配置不含敏感信息）

# 4. 加载服务配置使其生效
sudo launchctl load -w /Library/LaunchDaemons/com.user.mihomo.plist

# 5. 如果服务没有因 RunAtLoad 而自动启动，或者您想立即启动它，可以使用：
sudo launchctl start com.user.mihomo

# 如果使用上面的 /bin/clash 命令
clash enable # 设置开机启动并立即启动
clash on # 设为系统代理

还需要用一个用户级的 plist 自动启动设置系统代理，否则每次重启后都需要重新运行 clash on 来开启系统代理

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.clash-on</string>

    <key>ProgramArguments</key>
    <array>
        <string>/opt/clash/bin/clash</string>  <!-- 使用绝对路径 -->
        <string>on</string>
    </array>

    <!-- 登录时自动执行 -->
    <key>RunAtLoad</key>
    <true/>

    <!-- 登录 15 秒后执行 clash on -->
    <key>StartDelay</key>
    <integer>5</integer>

    <!-- 只在图形界面会话中运行 -->
    <key>LimitLoadToSessionType</key>
    <array>
        <string>Aqua</string>
    </array>

    <!-- 可选：日志输出 -->
    <key>StandardOutPath</key>
    <string>/tmp/clash-on.log</string>
    <key>StandardErrorPath</key>
    <string>/tmp/clash-on-error.log</string>
</dict>
</plist>

sudo touch com.user.clash-on.plist

sudo cp com.user.clash-on.plist ~/Library/LaunchAgents/

chown $(whoami):staff ~/Library/LaunchAgents/com.user.clash-on.plist

# 运行，不要使用 sudo 会切换到 root
launchctl bootstrap gui/$UID ~/Library/LaunchAgents/com.user.clash-on.plist
launchctl enable gui/$UID/com.user.clash-on

# 卸载 禁用
launchctl bootout gui/$UID ~/Library/LaunchAgents/com.user.clash-on.plist
launchctl disable gui/$UID/com.user.clash-on

Tips to improve concentration

Sat, 10 May 2025 00:00:00 GMT

import { Aside } from 'astro-pure-clloz/user'

You're trying to concentrate, but your mind is wandering or you're easily distracted. What happened to the laser-sharp focus you once enjoyed? As we age, we tend to have more difficulty filtering out stimuli that are not relevant to the task at hand.

What's fogging up focus?

Like a computer that slows with use, the brain accumulates wear and tear that affects processing. This can be caused by a number of physiological stressors such as inflammation, injury to blood vessels (especially if you have high blood pressure), the buildup of abnormal proteins, and naturally occurring brain shrinkage.

The following factors can also affect your concentration.

Underlying conditions. Depression or sleep disorders (such as sleep apnea) can undermine your ability to concentrate. So can the effects of vision or hearing loss. You waste precious cognitive resources when you spend too much time trying to make out what's written on a page or just hear what someone is saying.

Medication side effects. Some drugs, especially anticholinergics (such as treatments for incontinence, depression, or allergies), can slow processing speed and your ability to think clearly.

Excessive drinking. Having too much alcohol impairs thinking and causes interrupted sleep, which affects concentration.

Information overload. We are bombarded with information from TVs, computers, and messages such as texts or emails. When there's too much material, it burdens our filtering system and it's easy to get distracted.

Strategies to stay focused

To improve attention, consider the following strategies.

Mindfulness. "Mindfulness is about focusing attention on the present moment, and practicing mindfulness has been shown to rewire the brain so that attention is stronger in everyday life," says Kim Willment, a neuropsychologist with Brigham and Women's Hospital. She recommends sitting still for a few minutes each day, closing your eyes, and focusing on your breathing as well as the sounds and sensations around you.

Cognitive training. Computerized cognitive training games aim to improve your response times and attention. Evidence that this works has been mixed. "The goal of playing these games is not to get better at them, but to get better in the cognitive activities of everyday life," Willment says. "But there is evidence that a person's ability to pay attention can be improved by progressively pushing the person to higher levels of performance. So if you reach a certain level of sustained attention, pushing it to the next level can help improve it, and this may translate to everyday life."

A healthier lifestyle. Many aspects of a healthy lifestyle can help attention, starting with sleep and exercise. There is a direct link between exercise and cognitive ability, especially attention. When you exercise, you increase the availability of brain chemicals that promote new brain connections, reduce stress, and improve sleep. And when we sleep, we reduce stress hormones that can be harmful to the brain, and we clear out proteins that injure it.

Aim for seven to eight hours of sleep each night, and 150 minutes per week of aerobic exercise, such as brisk walking.

Other healthy steps to improve focus: eat a Mediterranean-style diet, which has been shown to support brain health; treat underlying conditions; and change medications that may be affecting your ability to focus.

Getting older is out of your control, but healthier living is something you determine, and it may improve concentration.

Article from: Harvard Health Publishing

Using MDX

Sun, 01 Jun 2025 00:00:00 GMT

This theme comes with the @astrojs/mdx integration installed and configured in your astro.config.mjs config file. If you prefer not to use MDX, you can disable support by removing the integration from your config file.

Why MDX?

MDX is a special flavor of Markdown that supports embedded JavaScript & JSX syntax. This unlocks the ability to mix JavaScript and UI Components into your Markdown content for things like interactive charts or alerts.

If you have existing content authored in MDX, this integration will hopefully make migrating to Astro a breeze.

Example

Here is how you import and use a UI component inside of MDX.
When you open this page in the browser, you should see the clickable button below.

import { Button } from 'astro-pure-clloz/user'

Click Me

Markdown Syntax Support

Wed, 26 Jul 2023 08:00:00 GMT

Basic Syntax

Markdown is a lightweight and easy-to-use syntax for styling your writing.

Headers

When the content of the article is extensive, you can use headers to segment:

# Header 1

## Header 2

## Large Header

### Small Header

Header previews would disrupt the structure of the article, so they are not displayed here.

Bold and Italics

_Italic text_ and **Bold text**, together will be **_Bold Italic text_**

Preview:

Italic text and Bold text, together will be Bold Italic text

Links

Text link [Link Name](http://link-url)

Preview:

Text link Link Name

Inline Code

This is an `inline code`

Preview:

This is an inline code

Code Blocks

```js
// calculate fibonacci
function fibonacci(n) {
  if (n <= 1) return 1
  const result = fibonacci(n - 1) + fibonacci(n - 2) // [\!code --]
  return fibonacci(n - 1) + fibonacci(n - 2) // [\!code ++]
}
```

Preview:

// calculate fibonacci
function fibonacci(n) {
  if (n <= 1) return 1
  const result = fibonacci(n - 1) + fibonacci(n - 2) // [!code --]
  return fibonacci(n - 1) + fibonacci(n - 2) // [!code ++]
}

Currently using shiki as the code highlighting plugin. For supported languages, refer to Shiki: Languages.

Inline Formula

This is an inline formula $e^{i\pi} + 1 = 0$

Preview:

This is an inline formula $e^{i\pi} + 1 = 0$

Formula Blocks

$$
\hat{f}(\xi) = \int_{-\infty}^{\infty} f(x) e^{-2\pi i x \xi} \, dx
$$

Preview:

$$ \hat{f}(\xi) = \int_{-\infty}^{\infty} f(x) e^{-2\pi i x \xi} , dx $$

Currently using KaTeX as the math formula plugin. For supported syntax, refer to KaTeX Supported Functions.

Images

![CWorld](https://cravatar.cn/avatar/1ffe42aa45a6b1444a786b1f32dfa8aa?s=200)

Preview:

Strikethrough

~~Strikethrough~~

Preview:

~~Strikethrough~~

Lists

Regular unordered list

- 1
- 2
- 3

Preview:

Regular ordered list

1. GPT-4
2. Claude Opus
3. LLaMa

Preview:

GPT-4
Claude Opus
LLaMa

You can continue to nest syntax within lists.

Blockquotes

> Gunshot, thunder, sword rise. A scene of flowers and blood.

Preview:

Gunshot, thunder, sword rise. A scene of flowers and blood.

You can continue to nest syntax within blockquotes.

Line Breaks

Markdown needs a blank line to separate paragraphs.

If you don't leave a blank line
it will be in one paragraph

First paragraph

Second paragraph

Preview:

If you don't leave a blank line it will be in one paragraph

First paragraph

Second paragraph

Separators

If you have the habit of writing separators, you can start a new line and enter three dashes --- or asterisks ***. Leave a blank line before and after when there are paragraphs:

---

Preview:

Advanced Techniques

Inline HTML Elements

Currently, only some inline HTML elements are supported, including <kdb> <b> <i> <em> <sup> <sub> <br>, such as

Key Display

Use <kbd>Ctrl</kbd> + <kbd>Alt</kbd> + <kbd>Del</kbd> to reboot the computer

Preview:

Use Ctrl + Alt + Del to reboot the computer

Bold Italics

<b> Markdown also applies here, such as _bold_ </b>

Preview:

Markdown also applies here, such as bold

Other HTML Writing

Foldable Blocks

<details><summary>Click to expand</summary>It is hidden</details>

Preview:

Tables

| Header1  | Header2  |
| -------- | -------- |
| Content1 | Content2 |

Preview:

| Header1 | Header2 | | -------- | -------- | | Content1 | Content2 |

Footnotes

Use [^footnote] to add a footnote at the point of reference.

Then, at the end of the document, add the content of the footnote (it will be rendered at the end of the article by default).

[^footnote]: Here is the content of the footnote

Preview:

Use [^footnote] to add a footnote at the point of reference.

Then, at the end of the document, add the content of the footnote (it will be rendered at the end of the article by default).

[^footnote]: Here is the content of the footnote

To-Do Lists

- [ ] Incomplete task
- [x] Completed task

Preview:

[ ] Incomplete task
[x] Completed task

Symbol Escaping

If you need to use markdown symbols like _ # * in your description but don't want them to be escaped, you can add a backslash before these symbols, such as \_ \# \* to avoid it.

\_Don't want the text here to be italic\_

\*\*Don't want the text here to be bold\*\*

Preview:

_Don't want the text here to be italic_

**Don't want the text here to be bold**

Embedding Astro Components

See User Components and Advanced Components for details.

Markdown 语法支持

Wed, 26 Jul 2023 08:00:00 GMT

基本语法

Markdown 是一种轻量级且易于使用的语法，用于为您的写作设计风格。

标题

文章内容较多时，可以用标题分段：

# 标题 1

## 标题 2

## 大标题

### 小标题

标题预览会打乱文章的结构，所以在此不展示。

粗斜体

_斜体文本_

**粗体文本**

**_粗斜体文本_**

预览：

斜体文本

粗体文本

粗斜体文本

链接

文字链接 [链接名称](http://链接网址)

预览：

文字链接链接名称

行内代码

这是一条 `单行代码`

预览：

这是一条 行内代码

代码块

```js
// calculate fibonacci
function fibonacci(n) {
  if (n <= 1) return 1
  return fibonacci(n - 1) + fibonacci(n - 2)
}
```

预览：

// calculate fibonacci
function fibonacci(n) {
  if (n <= 1) return 1
  return fibonacci(n - 1) + fibonacci(n - 2)
}

当前使用 shiki 作为代码高亮插件，支持的语言请参考 shiki / languages。

行内公式

这是一条行内公式 $e^{i\pi} + 1 = 0$

预览：

这是一条行内公式 $e^{i\pi} + 1 = 0$

公式块

$$
\hat{f}(\xi) = \int_{-\infty}^{\infty} f(x) e^{-2\pi i x \xi} \, dx
$$

预览：

$$ \hat{f}(\xi) = \int_{-\infty}^{\infty} f(x) e^{-2\pi i x \xi} , dx $$

当前使用 KaTeX 作为数学公式插件，支持的语法请参考 KaTeX Supported Functions。

图片

![CWorld](https://cravatar.cn/avatar/1ffe42aa45a6b1444a786b1f32dfa8aa?s=200)

预览：

删除线

~~删除线~~

预览：

~~删除线~~

列表

普通无序列表

- 1
- 2
- 3

预览：

普通有序列表

1. GPT-4
2. Claude Opus
3. LLaMa

预览：

GPT-4
Claude Opus
LLaMa

列表里可以继续嵌套语法

引用

> 枪响，雷鸣，剑起。繁花血景。

预览：

枪响，雷鸣，剑起。繁花血景。

引用里也可以继续嵌套语法。

换行

markdown 分段落是需要空一行的。

如果不空行
就会在一段

第一段

第二段

预览：

如果不空行就会在一段

第一段

第二段

分隔符

如果你有写分割线的习惯，可以新起一行输入三个减号--- 或者星号 ***。当前后都有段落时，请空出一行：

---

预览：

高级技巧

行内 HTML 元素

目前只支持部分段内 HTML 元素效果，包括 <kdb> <b> <i> <em> <sup> <sub> <br> ，如

键位显示

使用 <kbd>Ctrl</kbd> + <kbd>Alt</kbd> + <kbd>Del</kbd> 重启电脑

预览：

使用 Ctrl + Alt + Del 重启电脑

粗斜体

<b> Markdown 在此处同样适用，如 _加粗_ </b>

预览：

Markdown 在此处同样适用，如加粗

其他 HTML 写法

折叠块

<details><summary>点击展开</summary>它被隐藏了</details>

预览：

表格

| 表头1 | 表头2 |
| ----- | ----- |
| 内容1 | 内容2 |

预览：

| 表头1 | 表头2 | | ----- | ----- | | 内容1 | 内容2 |

注释

在引用的地方使用 [^注释] 来添加注释。

然后在文档的结尾，添加注释的内容（会默认于文章结尾渲染之）。

[^注释]: 这里是注释的内容

预览：

在引用的地方使用 ^注释来添加注释。

然后在文档的结尾，添加注释的内容（会默认于文章结尾渲染之）。

To-Do 列表

- [ ] 未完成的任务
- [x] 已完成的任务

预览：

[ ] 未完成的任务
[x] 已完成的任务

符号转义

如果你的描述中需要用到 markdown 的符号，比如 _ # * 等，但又不想它被转义，这时候可以在这些符号前加反斜杠，如 \_ \# \* 进行避免。

\_不想这里的文本变斜体\_

\*\*不想这里的文本被加粗\*\*

预览：

_不想这里的文本变斜体_

**不想这里的文本被加粗**

内嵌 Astro 组件

See User Components and Advanced Components for details.

实现一个 lazyman

Sun, 01 May 2022 12:00:00 GMT

前言

开门见山，今天朋友问了我一道面试题。

实现一个 LazyMan，可以按照以下方式调用：

LazyMan('Hank')，输出：

Hi, This is Hank!

LazyMan('Hank').sleep(5).eat('dinner')，输出：

Hi, This is Hank! // 等待5秒 Weak up after 10 Eat dinner ~

LazyMan('Hank').eat('dinner').eat('supper')，输出

Hi, this is Hank! Eat dinner ~ Eat supper ~

LazyMan('Hank').sleepFirst(5).eat('supper')，输出

// 等待5秒 Wake up after 5 Hi, this is Hank! Eat supper

思路

看到这个题目首先看到链式调用，那么自然想到的是构造函数，原型方法，每个方法调用后再返回调用对象，这样可以实现链式调用，LazyMan 可以直接调用那么我们可以检测一下是否是 new 调用，不是则返回 new 调用。基本结构如下

function LazyMan(name) {
  if (!(this instanceof LazyMan)) {
    return new LazyMan(name)
  }
}

LazyMan.prototype.sleep = function (time) {
  return this
}

LazyMan.prototype.eat = function (food) {
  return this
}

LazyMan.prototype.sleepFirst = function (time) {
  return this
}

实现链式调用之后我们继续看题目，可以看到需要有等待，自然想到 setTimeout，但是这里 setTimeout 无法满足我们的要求，因为 setTimeout 本身也是同步执行的，其回调函数是异步，并且 setTimeout 没法返回 this 对象。那么我们自然想到了 Promise，async/await。

使用 Promise 或 async/await 有一个和 setTimeout 一样的问题，就是他们的返回值都是 Promise，没法返回对象。同时我们注意题目中的最后一个调用，sleepFirst 方法最后调用但是却先执行，这给了一些提示。链式调用中肯定是前面的执行完了才执行后面，sleepFirst 看上去好像先执行，只有一种可能就是前面的函数执行没有执行 console，只是将 console 放到了某个地方等待执行。

所以我们需要在对象上增加一个 tasks 队列来存放任务，每个函数执行只是将要执行的任务放到 tasks 队列中，sleepFirst 的任务则放到队列最前面。

那么这个队列怎么执行呢，我们需要一个执行函数，这里我第一时间想到的是防抖函数，在 eat，sleep 和 sleepFirst 里面都执行这个执行函数，利用防抖的机制在链式调用结束才会真正执行这个执行函数。

根据上面的思路我写了下面的代码

function LazyMan(name) {
  if (!(this instanceof LazyMan)) {
    return new LazyMan(name)
  }
  this.name = name
  console.log(`this is ${this.name}`)
  this.firstSleepTime = 0
  this.tasks = []
  // this.execute();
}

function sleep(time) {
  return new Promise((resolve) => setTimeout(resolve, time))
}

function debounce(fn, interval) {
  let timeout = null
  return function () {
    clearTimeout(timeout)
    timeout = setTimeout(() => {
      fn.apply(this, arguments)
    }, interval)
  }
}

LazyMan.prototype.execute = debounce(function () {
  sleep(this.firstSleepTime).then(async () => {
    for (let i = 0; i < this.tasks.length; i++) {
      if (typeof this.tasks[i] === 'string') {
        console.log(`Eat ${this.tasks[i]}`)
      } else {
        await sleep(this.tasks[i])
      }
    }
  })
}, 0)

LazyMan.prototype.sleep = function (time) {
  this.tasks.push(time)
  this.execute()
  return this
}

LazyMan.prototype.eat = function (food) {
  this.tasks.push(food)
  this.execute()
  return this
}

LazyMan.prototype.sleepFirst = function (time) {
  this.firstSleepTime += time
  this.execute()
  return this
}

LazyMan('clloz').eat('orange').sleep(5000).eat('apple').sleepFirst(3000)

效果是达到了，不过有点投机取巧，我这里 tasks 存的不是任务，并且 sleepFirst 也是特殊处理。后来我去网上看了看别人的实现，将所有任务逻辑统一。修改后的实现如下

function LazyMan(name) {
  if (!(this instanceof LazyMan)) {
    return new LazyMan(name)
  }
  this.name = name
  this.sayName()
  this.tasks = []
}

function sleep(time) {
  return new Promise((resolve) => setTimeout(resolve, time))
}

function debounce(fn, interval = 0) {
  let timeout = null
  return function () {
    clearTimeout(timeout)
    timeout = setTimeout(() => {
      fn.apply(this, arguments)
    }, interval)
  }
}

LazyMan.prototype.sayName = function () {
  console.log(`this is ${this.name}`)
}

LazyMan.prototype.execute = debounce(async function () {
  for (const task of this.tasks) {
    await task()
  }
})

LazyMan.prototype.sleep = function (time) {
  this.tasks.push(async () => {
    console.log(`sleep ${time}ms`)
    await sleep(time)
  })
  this.execute()
  return this
}

LazyMan.prototype.eat = function (food) {
  this.tasks.push(async () => {
    console.log(`Eat ${food}`)
  })
  this.execute()
  return this
}

LazyMan.prototype.sleepFirst = function (time) {
  this.tasks.unshift(async () => {
    console.log(`first sleep ${time}ms`)
    await sleep(time)
  })
  this.execute()
  return this
}

LazyMan('clloz').eat('orange').sleep(5000).eat('apple').sleepFirst(3000)

总结

这个题目考察了构造函数，原型，Promise，防抖等知识点，是一道不错的题目，希望本文对你有所帮助

参考文章

如何实现一个 LazyMan

拖动时禁止选中文字和元素

Mon, 10 Jan 2022 12:00:00 GMT

前言

在做一些和拖动相关的功能的时候，比如用到 mousedown 和 mousemove 的时候，会发现拖动会选中页面中的不相关的文字和图片，文字还好，就是难看一点，但是图片的选中可能会影响到我们的拖动功能。本文分享一下对于拖动时禁止选中文字和元素的方法。

Demo

可以看一下我写的这个 Demo，红色方块是用来拖动的，你可以多触发几次 mousedown，mousemove 和 mouseup，拖动几次方块穿过右边的图片，有时候会发现右侧的图片被你拖走然后红色方块就一直跟着鼠标移动，即使你已经松开鼠标。

如果页面上有文本的话你会发现拖动的时候会随着鼠标的移动选择文本，这在显示效果上也不是很好，虽然不会像上面的图片一样影响到我们的功能。

preventDefault

一个比较简单的办法就是在 mousedown 的回调函数中调用 e.preventDefault()，这样能够禁用 mousedown 的默认行为，我们的拖动不再会选中文本或者页面上的元素。

但是这个方法有一个问题，就是会导致我们的目标元素中的 input 或者 textarea 无法触发 focus，你点击输入框输入框中也不会出现光标，也就无法输入。因为输入框的 focus 就是通过 mousedown 触发的，而 mousedown 的默认行为被我们禁用了。

这当然不是一个常见的需求，一般我们拖动的元素中不太会出现输入框（不过我今天刚好就遇到了 :joy: ）。如果你需要在拖动元素中使用输入框，那么你就没法使用这个比较方便的方法了。

这里我没有找到合适的解决方案，如果你有好的解决方案，欢迎指教。

CSS

还有一种实现方式就是使用 CSS 的 user-select 属性。

* {
  -webkit-touch-callout: none; /*系统默认菜单被禁用*/
  -webkit-user-select: none; /*webkit浏览器*/
  -khtml-user-select: none; /*早期浏览器*/
  -moz-user-select: none; /*火狐*/
  -ms-user-select: none; /*IE10*/
  user-select: none;
  -webkit-user-select: none;
}

但是这样会导致文本始终不可选，我们比较想要的效果应该是拖动的时候不会选中，但在其他时候应该是可以选中的。我们可在 mousedown 触发的时候给 body 加上对应的样式，在 mouseup 触发的时候再去掉这个样式。

还有一个比较麻烦的点在于图片的可拖拽（点击图片并拖动会出现一张透明的图片）。有时我们的拖动会触发到图片的拖拽，会导致我们绑定的 mouseup 没有执行，在松开鼠标后拖动的元素还是会跟着我们的鼠标移动。-webkit-user-select 这个 css 属性可以帮我们禁止图片拖拽，但是这个属性的兼容性很不好，移动端是都不支持的。如果有兼容性要求可以使用 img 的 draggable 属性。

总结

目前测试能够使用的就这两种方法，都不够完美，如果你有好的解决方案欢迎讨论。

参考文章

动手实现一个 WebSocket 服务器

Tue, 21 Dec 2021 12:00:00 GMT

前言

现在在开发一些前后端频繁需要通信，或者需要后端主动推送消息到前端的功能时，我们一般会使用 WebSocket，基本每次项目搭建的时候都会要重新封装一个 Socket 类来创建前后端通信用的 websocket 对象。不过每次使用的时候我都要到 MDN 上看一看 WebSocket 对象的属性和方法，到网上找一找别人的封装赋值粘贴一下，可见对 websocket 协议的理解和浏览器的 WebSocket 对象的缺乏理解。并且由于前端的 WebSocket 对象比较简单，隐藏了非常多的细节，所以我决定用 NodeJS 的 Net 模块提供的 TCP 来实现一个 WebSocket 服务端来加深对 WebSocket 的理解。

实现代码在 Github，打开 index.html, 并且用 node websocket.js 启动服务端，即可进行通信。

WebSocket 简介

首先来说一说 WebSocket 协议，WebSocket 是一个在 TCP 连接上提供的一个全双工通信通道。WebSocket 协议于 2011 年被 IETF 标准化为 RFC 6455，后由 RFC 7936 补充。Web IDL 中的 WebSocket API 由 W3C 进行标准化。

RFC 指的是 Request for Comments 是一系列出版物，来自互联网的主要技术开发和标准制定机构，其中最著名的是互联网工程任务组 (IETF)。可以理解为网络相关的标准文档。 Web IDL 是指 Web interface description language，即 Web 接口描述语言，用来描述将要在浏览器中实现的 API。

WebSocket 是一个全新的协议，WebSocket 和 HTTP 是不同的，虽说他们是有交集的。他们都在网络 OSI model 的第七层应用层，都依赖于第四层传输层的 TCP。虽然两者是不同的协议，但是 RFC 6455 指出 WebSocket 被设计为工作在 HTTP 的 443 和 80 端口上，并支持 HTTP 代理和中介，使其与 HTTP 兼容。为了实现兼容性，WebSocket 的握手使用 HTTP Upgrade header 改变 HTTP 协议为 WebSocket 协议。一般我们在使用 WebSocket 的时候我们可以在 Request Header 中看到 Connection: upgrade，在 Response Header 中看到 Connection: upgrade 和 Upgrade: websocket。一般我们在 nginx 中要配置 WebSocket 代理有如下配置（字段解释可以参考 Nginx如何配置Http、Https、WS、WSS）。

map $http_upgrade $connection_upgrade {
  default upgrade;
  '' close;
}
server {
  listen 8000;
  location / {
    proxy_pass http://localhost:4000;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection $connection_upgrade;
  }
}

WebSocket 协议让我们能够以比 HTTP 轮询等方式更低的开销在 web client 和 web server 进行实时数据传输。WebSocket 使得我们能以一种标准化的方式实现服务端主动向客户端发送内容，并且允许在保持同一个连接打开的状态下来回传递数据。

在没有 WebSocket 之前，我们都是用 HTTP 进行客户端和服务端的通信，这种通信方式只能由服务端发起请求，简历连接，客户端收到请求后进行处理，将数据返回给客户端然后连接即被关闭。在很多场景下，这种通信方式并不科学，比如实时通信，我们的请求建立非常频繁，由于 HTTP 请求的建立和销毁开销是挺大的，并且请求和响应都包含比较长的头部，真正有效的数据只是整个请求中很小的一部分，会多消耗很多资源。再比如有时候我们想要实时刷新一些数据，但是客户端是不知道数据什么时候发生了更新，我们就只能以轮询的方式定时向服务器发送请求。

轮询 pooling

这里我们详细说一说轮询的方式，即轮询和长轮询。网络通信有两种方式，一种叫 push technology 或者叫 server push，就是请求由发布者或者服务器发起。与之相对的就称为 pull coding 或者 client pull，即请求由客户端发起，然后由服务端进行响应，我们的 HTTP 即是一种广泛应用的 pull technology。

在我们实际开发中，绝大多数时候我们都是用的 pull 模式的 HTTP。Push 的使用场景一般就是即时信息，因为一般信息的产生是在服务端，如果我们想在客户端第一时间显示信息的变更就需要服务端在信息发生变化的时候推送到客户端。这也是发布订阅模型的一种实现，客户端订阅了一系列服务端提供的信息频道，当某个频道有新的内容产生的时候，服务器就将这个新消息推送到客户端。

我们的轮询就是一种用 pull 来模拟 push 的技术，分为常规轮询 pooling 和长轮询 long pooling。

常规轮询非常简单，即客户端定时向服务端发出请求，时间间隔由客户端决定。常规轮询的问题在于，消息存在延迟（延迟取决于你的请求发送频率），并且我们发送了很多无用的信息，且每个客户端都在定时发送，对于服务器和网路来说这都是一个很大的负担。它的优点就是不需要额外进行支持，我们用 HTTP 即可实现。只有在我们的服务非常小，用户很少的情况这才是一个勉强可行的办法。

长轮询其实也很简单，就是服务器收到请求后在没有产生新的消息前不会关闭连接而是将连接挂起 pending，等新的连接产生时才返回给前端并关闭连接。前端收到新消息后立即发出一个新的请求，如此循环，如下图。

长轮询的缺点就是需要挂起很多连接，有些服务器架构是一个连接对应一个进程，连接数多了会消耗相当多的内存。长轮询的 demo 可以参考长轮询聊天 - JAVASCRIPT.INFO

服务端的 TCP 连接数不是问题，客户端的 TCP 连接数受限于端口最多只能有 2 ^ 16 - 1 个，但是服务端监听在固定端口，所以不会有这个限制。参考服务器最大TCP连接数及调优汇总

这也就是所谓的 comet 技术，在没有 WebSocket 之前基本都是通过这两种方式来服务器消息的推送，一般都是为了即时消息的展示。维基百科上还介绍了一种 script tag long pooling 来解决跨域情况下的长轮询，其实就是将 ajax 替换成 JSONP。

comet 还有 iframe 流和 flash socket 等实现方式，参考维基百科

本着尽量搞懂每一个遇到的知识点，我这里写了个例子试了试 iframe 流。

<iframe src="http://localhost:8080/iframe"></iframe>
<script>
  const xhr = new XMLHttpRequest()
  xhr.open('GET', 'http://localhost:8080/normal')
  xhr.send()
  xhr.onreadystatechange = () => {
    if (xhr.readyState === 4) {
      console.log(xhr.responseText)
    }
  }
</script>

const http = require('http')
const url = require('url')

http
  .createServer((req, res) => {
    const { pathname } = url.parse(req.url)
    if (pathname === '/favicon.ico') return false
    console.log(`visit: ${pathname}`)

    if (pathname === '/iframe') {
      res.setHeader('Content-Type', 'text/html;charset=utf-8')
      setInterval(() => {
        res.write(`<script>console.log('${new Date()}')</script>`)
      }, 1000)
    }

    if (pathname === '/normal') {
      res.setHeader('Access-Control-Allow-Origin', '*')
      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS')
      res.writeHead(200, { 'Content-Type': 'text/plain' })
      res.write('hello world')
      res.end()
    }
  })
  .listen(8080)

其实说简单点就是 iframe 可以不用 response.end() 来完成响应。所以我们可以一直持续发送消息，并且这个处理也不是那么灵活，基本上也只能是一个定时器持续执行一个函数（比如查询数据并返回）。（这里如有理解错误，欢迎指出）

还有个以前经常出现的概念是长连接，我一直没找到一个具体的定义，只有在维基百科上找到 HTTP keep-alive，其实本质就是传输层的 TCP 不断开，在一个 TCP 连接上进行持续的通信。HTTP持久连接

由于轮询的缺点，所以最终有了 WebSocket 和 EventSource。

在进入 WebSocket 协议细节和实现之前，我们先看一看比较简单的浏览器提供的 WebSocket API，也是我们平常接触比较多比较熟悉的对象。

浏览器端的 `WebSocket`

浏览器端的 WebSocket 对象是非常简单的，基本我们只要 new 一个 WebSocket 对象然后调用一些方法即可使用，在实现之前我们先介绍一下浏览器提供的 WebSocket API。

构造函数

一般我们使用 WebSocket 就直接 new WebSocket(url) 就可以构造出 WebSocket 对象了，不过 WebSocket 还接受一个可选参数 protocols，可以是一个字符串，或者字符串数组。所谓子协议其实就是在建立连接的时候多加了一个 header 叫做 sec-websocket-protocol，实际上就是我们可以自己商量一些解析内容的方式，看到对应的头就用对应的解析方式，一般是不需要使用的。

WebSocket.prototype.binaryType

WebSocket 可以发送两种数据，一种是 USVString，另一种是二进制数据（包括 ArrayBuffer，TypedArray，DataView 和 Blob）。

USVString 概念参考搞懂字符编码

这个属性是用来控制浏览器收到二进制数据如何处理的，该属性可以设置为 blob 和 arraybuffer，blob 是默认值。这个值不会传递给服务端，它的功能只是告诉浏览器在拿到服务器的二进制数据之后处理为哪个对象。如果你需要 blob 就默认就可以，如果你希望要读写拿到的二进制数据那么就应该使用 arraybuffer。如果对于前端的二进制处理不清楚，欢迎移步到我的另一篇博客 JS 中的二进制数据的操作

WebSocket.prototype.bufferedAmount

这个只读属性返回已经调用 send() 方法发送但还没有实际发送到网络上去的字节数，发送出去后这个值会清零。如果连接已经关闭，继续调用 send 方法，这个值会一直增长。一般来说不会使用。

WebSocket.prototype.extensions

这个只读属性返回服务器选择的 WebSocket 扩展。所谓的扩展就是对 WebSocket 协议的一种增强，比如 deflate-frame 就是告诉服务器浏览器支持数据压缩。一般来说这个值是空字符串，前端可以通过建立连接时用 Sec-Websocket-Extensions 来告诉服务器哪些扩展是被支持的，这个 header 是每次连接建立时浏览器自动生成的，告诉服务器该浏览器支持哪些扩展，服务器会选择它需要使用的扩展在 Response 的 Sec-Websocket-Extensions 头中，我们的这个只读属性就是获取的服务端返回的这个 header。

WebSocket.prototype.protocol

这个只读属性返回服务器选择的子协议，比如 soap 和 wamp。前端在建立请求的时候可以用 WebSocket 构造函数的第二个参数（本质就是添加 Sec-Websocket-Protocol 头）来告诉服务器前端支持哪些子协议，服务器会返回它决定使用的子协议并放在 Response 的 Sec-Websocket-Protocol 中来告诉客户端，我们的这个只读属性就是获取的服务端返回的这个 header。可以使用通用的子协议，也可以自定义子协议。所谓的子协议其实就是客户端和服务端商量一种通信使用的数据结构。

关于扩展和子协议我们可以举个例子：

# Request
GET /chat
Host: javascript.info
Upgrade: websocket
Connection: Upgrade
Origin: https://javascript.info
Sec-WebSocket-Key: Iv8io/9s+lYFgZWcXczP8Q==
Sec-WebSocket-Version: 13
Sec-WebSocket-Extensions: deflate-frame
Sec-WebSocket-Protocol: soap, wamp

# Response
101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: hsBlbuDTkk24srzEOTBUlZAlC2g=
Sec-WebSocket-Extensions: deflate-frame
Sec-WebSocket-Protocol: soap

WebSocket.prototype.url

这个只读属性返回 WebSocket 连接的绝对地址。

WebSocket.prototype.readyState

这个只读属性返回 WebSocket 连接的当前状态，返回值是一个unsigned short。

| Value | State | Description | | ----- | ---------- | -------------------------------------------------------- | | 0 | CONNECTING | Socket has been created. The connection is not yet open. | | 1 | OPEN | The connection is open and ready to communicate. | | 2 | CLOSING | The connection is in the process of closing. | | 3 | CLOSED | The connection is closed or couldn't be opened. |

WebSocket.prototype.send(data)

send 是我们用来发送消息的方法。send 方法将要发送给 server 的数据排入队列，同时增大 bufferedAmount。如果数据无法被发送（比如缓冲区已满），socket 会自动关闭。如果 readyState 是 CONNECTING 时调用 send 方法，浏览器会抛出一个 INVALID_STATE_ERR 异常。如果在 readyState 为 CLOSING 或者 CLOSED，浏览器会静默丢弃要发送的数据。

我们可发送的数据类型有 USVString，ArrayBuffer，Blob，TypedArray 和 DataView。简单点说我们可以发送字符串和二进制数据。USVString 会被转为 UTF-8 放入缓冲，bufferedAmount 也会按照 UTF-8 的大小增长。需要注意的是如果我们使用单个的代理平面的码点，或者错误顺序的代理平面码点都会被替换成 �，比如 ws.send('\uDC00\uD800') 我们会在后端接收到 ��，ws.send('\uDC00') 或者 ws.send('\uD800') 则都会收到 �。具体就是因为 USVString 的概念即浏览器的处理，参考搞懂字符编码

WebSocket.prototype.close

这个方法是关闭 WebSocket 连接的，可以传递两个可选参数，一个 code，表示连接关闭的状态码，默认值是 1005，其他状态码参考 CloseEvent.code 。另一个是 reason，是一个人类刻度的表示连接关闭原因的字符串，长度不能超过 123 字节的 UTF-8 文本。

Event

剩下的就是四个事件和事件监听函数，分别是 close，error，open 和 message。分别对应连接的关闭，连接报错，连接打开和信息的接受。事件监听可以用 addEventListener 或者 onEvent。

进本上前端的 WebSocket 内容就这么多，并不是很复杂。有了这个为基础我们可以开始进入 WebSocket server 实现。我们可以利用前端建立连接，发送不同的数据类型，以及用浏览器的开发者工具查看请求的 header 和 message。

实现 `WebSocket` 服务器

要用 TCP 处理连接，我们必须知道 WebSocket 连接是如何建立，以及发送的帧格式，如果你有耐心，可以去阅读 RFC6455，我在这里做一个简单的梳理。

握手

建立 WebSocket 连接客户端需要发送一个握手请求，服务端返回握手请求后连接即被建立，之后客户端和服务端就可以进行全双工通信了。WebSocket 是通过 HTTP/1.1 协议的 101 状态码进行握手。我们的请求头如下：

GET ws://localhost:3000/ HTTP/1.1
Host: localhost:3000
Connection: Upgrade
Pragma: no-cache
Cache-Control: no-cache
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36
Upgrade: websocket
Origin: http://localhost:63342
Sec-WebSocket-Version: 13
Accept-Encoding: gzip, deflate, br
Accept-Language: en,ja;q=0.9,zh;q=0.8,zh-CN;q=0.7
Sec-WebSocket-Key: hFP3hhcWJNLBqU+rCnHPng==
Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits

这其中比较关键的就是： 1. Connection: Upgrade 和 Upgrade: websocket：噶偶速服务端升级到 websocket 协议 2. Sec-WebSocket-Version：表示支持的 WebSocket 版本。RFC6455 要求使用的版本是 13，之前草案的版本均应当弃用。 3. Sec-WebSocket-Key 是随机 base64 编码的字符串，RFC6455 要其这个值必须是用一个临时创建的 16 字节的值经过 base64 编码后生成的 24 字节的值（最后两位为 ==）如果不符合这个要求，绝大多数现代 HTTP server 会拒绝请求并返回一个错误 invalid Sec-WebSocket-Key header。服务器端会用这些数据来构造出一个 SHA-1 的信息摘要。把 Sec-WebSocket-Key 加上一个特殊字符串 258EAFA5-E914-47DA-95CA-C5AB0DC85B11，然后计算 SHA-1 摘要，之后进行 Base64 编码，将结果做为 Sec-WebSocket-Accept 头的值，返回给客户端。如此操作，可以尽量避免普通 HTTP 请求被误认为 WebSocket 协议，所以这个 header 不是为了安全性考虑的，只是防止非 websocket 的客户端误发 WebSocket 请求。注意这个头是由客户端（一般是浏览器）自动添加的，我们无法通过 XMLHttpRequest.setRequestHeader() 添加 4. Sec-WebSocket-Extensions 和 Sec-Websocket-Protocol 参考上文的浏览器中的 WebSocket 对象

服务端的返回如下：

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: 8XodYgYF1B62DPQYUIi5VJu/vCI=

Sec-WebSocket-Accept 就是根据客户端的 Sec-WebSocket-Key 计算得到的值。服务端也会带上 Upgrade 和 Connection，客户端收到服务端的返回，即完成握手，连接建立成功，我们可以通过这个连接进行全双工通信，直至连接关闭。

握手中我们要处理的就是生成 Sec-WebSocket-Accept，监听 socket 的 data 事件，解析请求头，判断是否是合法的 WebSocket 请求，然后闹到 Sec-WebSocket-Key，利用 NodeJS 的 Crypto 模块可以很轻松计算出 Sec-WebSocket-Accept。

const net = require('net') // net 模块提供一个异步的网络 API 用来创建基于流的 TCP 或者 IPC(Inter Process Communication) 的服务端或者客户端 https://blog.csdn.net/manhua253/article/details/4219655
const crypto = require('crypto') // crypto 模块提供了一些加密和解密的方法
const { Buffer } = require('buffer')

// 解析请求头
function parseHeader(data) {
  const header = {}
  const lines = data.split('\r\n').filter((line) => line)
  lines.shift() // 去除第一行请求行
  lines.forEach((line) => {
    const [key, value] = line.split(': ')
    header[key.toLowerCase()] = value
  })
  return header
}

const server = net.createServer((socket) => {
  // console.log(socket);
  socket.once('data', (buffer) => {
    console.log(Object.prototype.toString.call(buffer)) // 确定 buffer 的类型 Uint8Array
    const str = buffer.toString()
    const headers = parseHeader(str) // 解析请求头
    console.log(headers) // 观察一下请求头

    if (headers.upgrade !== 'websocket') {
      console.log('不是 websocket 请求')
      socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')
    } else if (headers['sec-websocket-version'] !== '13') {
      console.log('不支持的 websocket 版本')
      socket.end('HTTP/1.1 426 Upgrade Required\r\nSec-WebSocket-Version: 13\r\n\r\n')
    } else {
      const GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
      const key = headers['sec-websocket-key']
      const acceptKey = crypto
        .createHash('sha1') // 创建 sha1 hash 对象
        .update(key + GUID) // 更新 hash 对象内容
        .digest('base64') // 生成摘要
      const response = `HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ${acceptKey}\r\n\r\n`
      socket.write(response)
      console.log(response)

      let maskingKey = []

      socket.on('data', (msgBuffer) => {
        // 监听前端发来的数据
      })

      console.log(maskingKey)
    }
  })
})
server.listen(3000) // 监听端口

解析消息帧

连接建立完成后我们就要处理消息的接收和发送了，这其中最重要的就是要理解 WebSocket 的消息帧了，对照Base Framing Protocol - RFC 6455 可以看到详细说明，我这里做一个简单的说明，如果要了解细节还是参考规范文档。

一条 WebSocket message 是可以分多帧发送的，可能我们在客户端调用的 websocket.send() 被浏览器分成了多帧发送，所以我们在实现 WebSocket 服务器的时候需要考虑多帧的问题。

这个帧格式最上面的数字表示 bit，一行一共是 32 bits，也就是 4 个字节。下面我们分别介绍各个位的含义。 1. FIN：占 1 bit，表示这是不是一条 message 的最后一个 fragment，1 就表示是最后一个片段。如果一条消息只有一个片段，那么第一个片段就是最后一个片段。 2. 连续的三个 RSV，每个都是 1 bit，除非我们使用的扩展对 RSV 的非 0 值进行了定义，否则这三个值都是 0。一般来说这三个值都是 0，如果没有使用上述扩展，并且发送了任意 RSV 非 0 的帧，那么接收端会关闭连接并且会报错。 3. Opcode： 4 bits，定义帧类型 %x0 表示一个连续帧（接续上一个帧）， %x1 为文本帧， %x2 为二进制帧， %x3-7 为未来的帧类型保留， %x8 表示连接关闭， %x9 为 ping 帧， %xA 为 pong 帧， %xB-F 保留。如果任意端（客户端或者服务端）发送了一个未知的 opcode，另一端会关闭连接。 4. MASK：1 bit，表示是否对 Payload data 使用了掩码，为 1 则表示了使用掩码，并且后面会有四个字节的掩码。 6. Payload length：可以是 7 bits，7 + 16 bits 或者是 7 + 64 bits。表示的是 payload data 的字节数，如果前 7 bit 为 0 - 125 之间，则这 7 bits 表示的数字就是 payload data 的字节数。如果前 7 bits 为 126，那么后面 2 个字节表示的 Extended payload length 表示的数作为 payload 的字节数。如果前 7 bits 的值为 127，那么后面 8 个字节表示的 Extended payload length 表示的数作为 payload 的字节数。所以 payload length 这里具体有多少 bits 取决于我们的 payload data 的长度。 7. Masking-key：如果前面我们的 MASK 那一位为 1，那么这里会有四个字节用来表示掩码，如果MASK 为 0，则这四个字节不存在。 8. Payload data：最后就是我们的实际数据，如果有 MASK，那么这个数据是经过掩码处理后的。Payload data 包含两个部分，Extension data 和 Application data，前者只有在我们 Extension 的时候会有，后者就是我们实际要发送的数据。

所谓 payload 英文翻译为有效荷载，其实就是指我们发送的内容中实际要发送的数据，或者我们程序中实际有意义的数据，因为一个帧里面除了我们要发的数据还要带很多其他信息。

socket 收到的所有消息都是 Uint8Array 类型的，如果是字符串就是 UTF-8 的，所以我们要先写一些工具函数，UTF-8 和 String 的相互转换，以及 mask 的算法。

这里单独说一下 mask 的算法，mask 的加解密算法是一样的，就是遍历 payload 的每个字节，然后依次和 Masking-Key 数组中的每一个进行按位异或就得到了掩码后或掩码前的值。特别需要注意的一点是，客户端给服务端发的消息是强制要掩码的，服务端给客户端发消息虽然没有强制规定，但很多客户端不支持，比如 chrome，所以我们给客户端发的时候不要加掩码（我在代码中的发送分别处理加掩码和不加掩码两种情况）标准中给出的说明如下：

j = i MOD 4
transformed-octet-i = original-octet-i XOR masking-key-octet-j

UTF-8 和 String 的互转就不另外说明了，大家直接看代码和注释。

// utf-8 转字符串
function utf8ToString(buffer) {
  console.log(buffer)
  let result = ''
  for (let i = 0; i < buffer.length; i += 1) {
    if (buffer[i] >> 7 === 0) {
      result += String.fromCodePoint(buffer[i])
    }
    if (buffer[i] >> 5 === 0b110) {
      const codePoint = ((buffer[i] & 0x1f) << 6) | (buffer[i + 1] & 0x3f)
      result += String.fromCodePoint(codePoint)
      i += 1
    }
    if (buffer[i] >> 4 === 0b1110) {
      const codePoint =
        ((buffer[i] & 0xf) << 12) | ((buffer[i + 1] & 0x3f) << 6) | (buffer[i + 2] & 0x3f)
      result += String.fromCodePoint(codePoint)
      i += 2
    }
    if (buffer[i] >> 3 === 0b11110) {
      const codePoint =
        ((buffer[i] & 0xf) << 18) |
        ((buffer[i + 1] & 0x3f) << 12) |
        ((buffer[i + 2] & 0x3f) << 6) |
        (buffer[i + 3] & 0x3f)
      try {
        result += String.fromCodePoint(codePoint)
      } catch (e) {
        console.log(buffer[i], buffer[i + 1], buffer[i + 2], buffer[i + 3])
      }
      i += 3
    }
  }
  return result
}

// 字符串转 utf-8
function stringToUtf8(str) {
  const { length } = str
  const result = []
  for (let i = 0; i < length; i += 1) {
    const codePoint = str.codePointAt(i)
    if (codePoint <= 0x7f) {
      result.push(codePoint & 0x7f)
    } else if (codePoint >= 0x80 && codePoint <= 0x7ff) {
      result.push(((codePoint >> 6) & 0x1f) | 0xc0)
      result.push((codePoint & 0x3f) | 0x80)
    } else if (codePoint >= 0x800 && codePoint <= 0xffff) {
      result.push(((codePoint >> 12) & 0xf) | 0xe0)
      result.push(((codePoint >> 6) & 0x3f) | 0x80)
      result.push((codePoint & 0x3f) | 0x80)
    } else if (codePoint >= 0x10000 && codePoint <= 0x10ffff) {
      result.push(((codePoint >> 18) & 0x7) | 0xf0)
      result.push(((codePoint >> 12) & 0x3f) | 0x80)
      result.push(((codePoint >> 6) & 0x3f) | 0x80)
      result.push((codePoint & 0x3f) | 0x80)
      i += 1
    }
  }
  return Uint8Array.from(result)
}

// 带掩码的数据的编解码，编解码的方式都一样的
function maskCodec(data, mask) {
  if (mask.length !== 4) return data
  const { length } = data
  const result = new Uint8Array(length)
  for (let i = 0; i < length; i += 1) {
    result[i] = data[i] ^ mask[i % 4]
  }
  return result
}

有了这些基础的方法之后就是按照帧的格式进行封装和解封了，直接上代码。

/**
 * @description: 解封数据帧，主要是根据 payloadLength 和 maskingKey 将 payload 解码为对应的 utf-8 编码或者二进制数据 TODO: 此处只是一个简单的实现，没有处理连续帧的情况
 * @param data (数据帧)
 * @return: utf-8 对应的字符串或者二进制数据
 */
function decodeWebSocketFrame(data) {
  const frame = {
    isFinal: (data[0] >> 7) & 1, // 是否为最后一帧
    rsv1: (data[0] >> 6) & 1, // 必须为0 除非扩展了非 0 值的含义的扩展
    rsv2: (data[0] >> 5) & 1, // 同上
    rsv3: (data[0] >> 4) & 1, // 同上
    opcode: data[0] & 0xf, // 帧类型 %x0 表示一个连续帧（接续上一个帧） %x1 为文本帧 %x2 为二进制帧 %x3-7 保留 %x8 表示连接关闭 %x9 为ping帧 %xA 为pong帧 %xB-F 保留
    mask: (data[1] >> 7) & 1, // 是否有掩码
    payloadLength: data[1] & 0x7f, // 帧长度 0-125 则为精确长度，如果为126 则后面两个字节为长度 如果为127 则后面8个字节为长度
    extendedPayloadLength:
      // eslint-disable-next-line no-nested-ternary
      data[1] === 0x7f ? data.readUIntBE(2, 2) : data[1] === 0xff ? data.readUIntBE(2, 8) : 0, // 扩展长度
    maskingKey: [data[2], data[3], data[4], data[5]], // 掩码
    maskedPayload: data.slice(6) // 掩码后的数据
  }

  // payloadLength 为 126 则后面 2 字节的 16 位无符号整数为 payloadLength
  if (frame.payloadLength === 0x7e) {
    frame.payloadLength = data.readUIntBE(2, 2)
    frame.maskingKey = [data[4], data[5], data[6], data[7]]
    frame.maskedPayload = data.slice(8)
  }

  // payloadLength 为 127 则后面 8 字节的 64 位无符号整数(最高位必须为 0)为 payloadLength
  if (frame.payloadLength === 0x7f) {
    frame.payloadLength = data.readUIntBE(2, 8)
    frame.maskingKey = [data[10], data[11], data[12], data[13]]
    frame.maskedPayload = data.slice(14)
  }

  frame.unMaskedPayload = maskCodec(frame.maskedPayload, frame.maskingKey) // 解码
  console.log(frame)
  return frame
}

/**
 * @description: 这里的分别测试了发送单帧和连续帧的两种情况
 * 这里我设置了封装帧的时候可以设置掩码，实际服务端向客服端发送的数据的时候浏览器不一定支持用掩码
 * 比如 chrome，如果你用掩码就会报错 `A server must not mask any frames that it sends to the client.` 参考 https://stackoverflow.com/a/16935108/8854649
 * @param maskingKey: 掩码，如果不需要用掩码则传入 [] 即可
 * @param data1: 第一帧的数据
 * @param data2: 第二帧的数据（optional）
 * @return result 封装好的帧数据
 */
function encodeWebsocketFrame(maskingKey, data1, data2) {
  let result
  const mask = maskingKey && maskingKey.length === 4 ? maskingKey : []
  if (data2) {
    const dataBuf1 = stringToUtf8(data1)
    const dataBuf2 = stringToUtf8(data2)
    const frame1 = Buffer.concat(
      [
        Buffer.from([0b00000001, dataBuf1.length + (mask.length ? 0b10000000 : 0), ...mask]),
        maskCodec(dataBuf1, mask)
      ],
      2 + mask.length + dataBuf1.length
    )
    const frame2 = Buffer.concat(
      [
        Buffer.from([0b10000000, dataBuf2.length + (mask.length ? 0b10000000 : 0), ...mask]),
        maskCodec(dataBuf2, mask)
      ],
      2 + mask.length + dataBuf2.length
    )
    result = [frame1, frame2]
  } else {
    const dataBuf = stringToUtf8(data1)
    result = Buffer.concat(
      [
        Buffer.from([0b10000001, dataBuf.length + (mask.length ? 0b10000000 : 0), ...mask]),
        maskCodec(dataBuf, mask)
      ],
      2 + mask.length + dataBuf.length
    )
  }
  console.log(result)
  return result
}

完整的代码在 Github

WebSocket 的安全

由于 WebSocket 客户端并不是局限在浏览端，所以和常规的 HTTP 请求不一样，WebSocket 没有同源策略的限制。因此，WebSocket 服务器在建立连接时必须根据预期的来源验证 Origin 头，以避免跨站点 WebSocket 劫持攻击（类似于跨站点请求伪造），当连接使用 cookie 或 HTTP 进行身份验证时可能会发生这种情况验证。当敏感（私人）数据通过 WebSocket 传输时，最好使用令牌或类似的保护机制来验证 WebSocket 连接。

参考文档

JS 中的二进制数据的操作

Mon, 06 Dec 2021 12:00:00 GMT

前言

在 JavaScript 设计的初期，没有预计到这个语言会得到如此广泛的应用和发展，也没有想过会处理如此复杂的业务，所以也没有添加对二进制数据处理的支持。但是现在很多场景需要我们处理二进制数据，比如 canvas 的图像处理，WebGL 与显卡的通信，一些音视频文件的处理（比如语音对讲的功能实现），ajax 的二进制输出传输，文件处理（创建，上传，下载）等。需求的改变必然推动 JavaScript 对二进制数据处理的支持，目前我们在 JavaScript 中处理二进制主要依赖几个对象 ArrayBuffer，TypedArray， DataView， Blob 和 File等。本文详细探索一下前端二进制处理相关的内容。

为什么用二进制

首先说两个计算机中常见的概念 stream 流和 buffer 缓冲。

stream 流

我们经常听到的字节流，视频流，文件流，这个流要怎么理解。首先这个 stream 肯定就是借用我们现实世界的流的概念来形象化地表示计算机中的抽象概念，比如世界的流入水流气流，所以抽象到计算机中其表示的就是一段连续的数据。比如水龙头，当我们打开开关（开始产生数据），流就产生了，这些数据没有绝对位置，也没有确定的开头和结尾，只是不断产生，并随着时间向前流动，你可以随时截取流中的一段数据进行处理。

buffer 缓冲

比如我们做音视频处理一般会涉及到 buffer 的设置，其实就是我们开辟了一块空间叫做 buffer，当数据流装满这个空间的时候我们在一次处理整个 buffer 中的数据。因为很多时候我们的 stream 的速度不是确定的，为了保证数据的生产和消费的速度相匹配，保证一个稳定的输出。

说完了两个概念我们来说一说为什么要使用二进制数据，可以确定的是这肯定是为了性能。因为二进制就是我们的数据在内存中的形式，直接操作内存的效率肯定是最高的。平时我们开发 web 应用基本不需要考虑性能问题，因为 Web 应用基本都是 IO 密集型的，以如今的个人电脑和移动设备的性能，绝大多数的 web 应用的数据量和数据处理都不是瓶颈，即使我们用了比较糟糕的数据结构和算法基本也不存在问题 :laughing:。但是在涉及到像是 canvas 和 webgl 这样每一帧都需要渲染大量像素的场景下，性能就非常重要，比如 webgl 我们就需要连续的内存交给底层的 C 的 API 去处理。再比如像是前端录制音频和传输，本身就是连续采样的大量的模拟转数字的数据，自然用二进制来处理是最合适的。你可以想象一下上面的这些场景如果我们把数据都存放到数组中我们需要遍历数组额外做很多操作，这样性能肯定大受影响，在这样的 CPU 密集型工作显然要优先以性能为第一优先级。

关于 JS 中为什么使用二进制和引擎的一些细节可以参考 Are the advantages of Typed Arrays in JavaScript is that they work the same or similar in C?

JS 中的二进制相关对象

JavaScript 中的二进制相关对象主要是 ArrayBuffer，TypedArray（只是一个统称，没有一个叫 TypedArray 的对象），DataView，Blob 和 File。其中前三个可以算是真正的二进制操作，后面两个是二进制大对象的操作，不能进行内部的修改。下面我们详细说一说这些对象。

ArrayBuffer

ArrayBuffer 是 JavaScript 中基础的二进制对象，是一个固定长度连续内存区域的引用，我们可以用 ArrayBuffer 构造函数来创建一个新的 ArrayBuffer。

const buffer = new ArrayBuffer(16) // 开辟了一个 16 字节的内存

注意 ArrayBuffer 虽然名字里面有 Array ，但是和 Array 没有任何关系。该构造函数只是创建一个通用的固定长度的原始二进制数据缓冲区，

ArrayBuffer 并没有暴露太多方法和属性，构造函数本身有一个静态方法，isView 用来判断所给参数是否是一个 ArrayBuffer 的视图，其实就是判断是否是一个 TypedArray 或者 DataView 的实例。

ArrayBuffer.prototype 上暴露了一个属性 byteLength 和一个方法 slice，前者很简单就是二进制缓冲区的字节数，后者是用来复制这个缓冲区的内容到一个新的 ArrayBuffer 中，接受两个参数，一个是开始的字节索引，另一个是结束的字节索引，不包括结束的这个字节。

数据的处理速度当然是越高越好的，但是此消彼长，直接操作内存当然效率很高，但是开发过程就要复杂的多，如果只是处理比较简单或者少量的数据就完全没必要，所以实际写程序实际是根据具体的场景选择合适的工具和技术。

TypedArray

ArrayBuffer 帮我们开辟了一块缓冲区，我们是不能直接对这块缓冲区进行操作，需要借助视图，也就是 TypedArray 或者 DataView，先来介绍以下 TypedArray。

首先要说的是并没有一个叫 TypedArray 的可访问对象，他是对类型化数组的一个统称，实际上标准中定义了 TypedArray 的构造函数，不过这个构造函数并没有暴露出来，不过可以通 Object.getPrototypeOf(Int8Array) 来访问到。所有我们能访问的十一种 TypedArray 构造函数比如 Int8Array 的 [[prototype]] 都指向标准中的 TypedArray 构造函数，而 Int8Array.prototype 的 [[prototype]] 则又指向标准中的 TypedArray.prototype，所以表达式 Object.getPrototypeOf(Int8Array).prototype === Int8Array.prototype.__proto__ 的结果为 true，它们的关系如下图。

一共有 11 种不同的 TypedArray，见下图。

two's complement 是补码的意思，octet 是八位字节

这 11 种 TypedArray 就是用来创建操作底层二进制缓冲区的视图的，为了处理不同数据类型的数据而被区分成了不同 size 不同含义的类型。**TypedeArray 必须使用 new 来创建，直接调用会报错！**每个 TypedArray 构造函数有多种参数搭配： 1. 无参数，相当于传入 0 作为 length

const initNoArg = new Int8Array()
console.log(initNoArg.byteLength) // 0

只传入一个 length 的时候就会创建一个 length 字节的 array buffer

const initWithLength = new Int8Array(3)
for (const byte of initWithLength) {
  console.log(byte)
}
/*
 * 0
 * 0
 * 0
 */

可以传入一个 TypedArray 的实例作为参数，新创建的 array buffer 的长度（注意是 length ，不是 byteLength）和参数是相同的，会先把参数 TypedArray 中的每一个值转为新的 TypedArray 所对应的类型然后再赋值。

const typedArray = new Int8Array(3)
for (let i = 0; i < typedArray.length; i += 1) {
  typedArray[i] = i
}
const initWithTypedArray = new Int16Array(typedArray)
for (let i = 0; i < initWithTypedArray.length; i += 1) {
  console.log(initWithTypedArray[i])
}
/*
 * 0
 * 1
 * 2
 */
console.log(typedArray.length, initWithTypedArray.length) // 3 3
console.log(typedArray.byteLength, initWithTypedArray.byteLength) // 3 6

可以传入一个对象作为参数，该对象必须为类数组对象或者可迭代对象，和 TypedArray.from 相似的结果。注意这个作为参数的对象中的迭代值如果是非数字和 BigInt 请参考下面的注意。

const obj = { length: 3 }
const initWithObj = new Int8Array(obj)
for (let i = 0; i < initWithObj.length; i += 1) {
  console.log(initWithObj[i])
}
/*
 * 0
 * 0
 * 0
 */

上面的几个都是创建新的 array buffer，我们也可以传入一个 array buffer，这样就直接生成了这个指定 array buffer 视图，还有两个可选的参数 byteOffset 和 length，我们可以用这两个参数选择 ArrayBuffer 的指定区域建立视图。这样我们就可以在一段 ArrayBuffer 上使用不同类型的 TypedArray，因为很多时候我们的 ArrayBuffer 中不都是相同类型的数据。

**注意：**如果我们给 TypedArray 赋值的时候使用的不是数字，比如构造函数传入类数组对象，比如 TypedArray.from，根据标准，这些值会先转为数字或者 BigInt，然后用 NumericToRawBytes 方法转为 RowBypte，这里不同的 RowByte 类型的处理可能略有不同，比如 Int8 类型将 NaN, +0, -0, +∞, or -∞ 全部处理为 +0，具体细节参考标准

我们可以像数组一样直接用 index 索引访问 TypedArray，也可以对其进行赋值。正常情况下我们使用 Number 和 BigInt 来赋值，BigInt 主要是为了处理 BigInt64Array 和 BigUnit64Array，他们都是 8 字节 64 位的，超出了 JavaScript 能表示的最大安全整数 2 ^ 53 - 1，所以要使用 BigInt 类型。使用除了这两个类型的其他类型并没有实际意义，如果你对其他类型的行为感兴趣，还是参考上面的 注意 中给出的标准中的链接。

TypedArray 有两个静态属性，BYTES_PER_ELEMENT 和 name，前者就是每个索引对应的字节数，参考上面的那张表，第二个就是实例对应的构造函数的名字。还有两个静态方法，TypedArray.from 和 TypedArray.of 可以类比 Array.from 和 Array.of。

关于挂载在 TypedArray 上的属性和方法我就不一一介绍了，很多都可以和数组进行类比，详细内容查阅 MDN，我这里主要介绍两个普通数组中没有的方法。

其实 TypedArray 就是给了我们一个在 JavaScript 中以类似数组的方式来查看和操作二进制数据（也可以理解为我们在操作 C 语言中的数据类型），所以才被称为类型化数组 TypedArray。

TypedArray.prototype.set()

这个方法是用数组或者 TypedArray 作为参数来设置 TypedArray 的值，语法如下：

set(array)
set(array, offset)

set(typedarray)
set(typedarray, offset)

const buffer = new ArrayBuffer(8)
const uint8 = new Uint8Array(buffer)
uint8.set([1, 2, 3], 3)
console.log(uint8)
// Uint8Array(8) [
//     0, 0, 0, 1,
//    2, 3, 0, 0
// ]

第一个参数就是我们的复制源，第二个参数表示复制的目标 TypedArray 的起始位置。如果复制源（参数）的长度加上 offset 已经超出了复制目标的长度，则会抛出错误。

浏览器没有提供像 NodeJS 的 Buffer 类一样的对 TypedArray 类的扩展，所以操作起来比较麻烦的，主要是前端一般使用 TypedArray 的场景并不多，比如 concat 这样的操作都得要借助 set 方法。

TypedArray.prototype.subarray()

这个方法是赋值 TypedArray 的一部分，和被复制的 TypedArray 所对应的 ArrayBuffer 是同一个，所以我们通过任意一个视图修改 ArrayBuffer 也会影响到另一个视图，因为我们修改的是同一个 ArrayBuffer。需要特别注意的是和 TypedArray.prototype.slice 的区别，他们都是通过 begin 和 end 索引（左闭右开）生成新视图，但是 slice 生成的视图会同时生成一个新的 ArrayBuffer，而 subarray 不会。

const uint8 = new Uint8Array([10, 20, 30, 40, 50])
const array1 = uint8.slice(1)
const array2 = uint8.subarray(1)
uint8[1] = 100
console.log(array1)
console.log(array2)

字节序的影响

平时我们编写 JavaScript 代码不会关心 endianness 字节顺序，但是在进行操作二进制数据的时候字节顺序就非常重要了。字节顺序分为两种: 1. Big-Endian 大端序：数据的低位字节存放在内存的高位地址，高位字节存放在内存的低位地址。 2. Little-Endian 小端序：数据的低位存放在内存的低位地址处，高位存放在内存的高位地址。

注意是字节顺序，而不是 bit 顺序，也就是对于字节内的位的排列还是按照正常的右侧为低位，左侧为高位，因为字节才是计算机寻址的最小单位。

大端序比较符合我们人类的阅读习惯，简单来说就是把数据按照我们的书写方式依次存入内存中，但是这不符合计算机的读取方式，因为计算机的计算都是从低位开始的，而内存的读取肯定是从低到高的，所以把低位存放到内存的低位肯定是更高效的，所以现在的计算机 CPU 一般都采取的小端序存入内存，但是在网络传输则使用大端序。关于字节顺序参考什么是大端序和小端序，为什么要有字节序和字节序 - wikipedia

我们现在使用的 CPU 基本都是 x86 或者 ARM 架构的，x86 使用的小端序，ARM 是可以配置的，所以我们一般认为 TypedArray 工作在小端序下即可，看下面这段代码。

const buffer = new ArrayBuffer(8)
const int8Array = new Int8Array(buffer)
int8Array[0] = 30
int8Array[1] = 41
const int16Array = new Int16Array(buffer)
console.log(int16Array[0])

我们创建了一个 8 字节的 ArrayBuffer，然后用一个 Int8Array 的视图将 ArrayBuffer 的第一和第二字节分别写入了 30 和 41，也就是分别是二进制的 00011110 和 00101001，如果按照我们人类的思维模式，也就是大端序，此时 ArrayBuffer 的前两个字节也就是 0001111000101001，也就是 7721。但是我们用一个 Int16Array 一次读取两个字节，可以发现得到的结果是 10526。其实这就是因为计算机是用小端序来进行处理的，也就是实际上 ArrayBuffer 中的前两字节是 01111000 和 10010100，合并为 0111100010010100，然后我们读取的时候最右侧才是最高位，也就是取反一下，得到 0010100100011110，结果正好就是 10526。

这里顺便说一下 NodeJS 中的 Buffer 类就是继承自 Uint8Array，提供了一些浏览器端没有的 API，比如读写多字节 readUIntBE writeUIntBe 等，NodeJS 虽然也支持 Uint8Array，但是可以使用更好用的 Buffer 子类。

DataView

DataView 是另一种形式的视图，它相当于把我们的 TypedArray 中的各个类型变成方法，我们可以在一个视图中读取和写入各种类型的二进制数据。并且在 DataView 中我们可以自己配置字节序。

和 TypedArray 一样，DataView 必须通过 new 操作符作为构造函数来调用，直接调用会报错。和 TypedArray 不同的是，new DataVIew 必须有一个 ArrayBuffer 作为参数，如果第一个参数不是 ArrayBuffer 同样会报错。另外还有两个可选参数，byteOffset 表示从 ArrayBuffer 的第几个字节开始建立 DataView 视图（如果没传则从第一个字节开始），ByteLength 表示 DataView 的字节数（如果没有传则和 ArrayBuffer 相同，byteOffset 和 byteLength 之和不能超过 ArrayBuffer 的 byteLength）

const buffer = new ArrayBuffer(16)
const view1 = new DataView(buffer)
const view2 = new DataView(buffer, 5)
const view3 = new DataView(buffer, 8, 2)
const view4 = new DataView(buffer, 8, 9) // 报错
console.log(view1)
console.log(view2)
console.log(view3)
// DataView {
//     byteLength: 16,
//     byteOffset: 0,
//     buffer: ArrayBuffer {
//     [Uint8Contents]: <00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00>,
//         byteLength: 16
//     }
// }
// DataView {
//     byteLength: 11,
//     byteOffset: 5,
//     buffer: ArrayBuffer {
//     [Uint8Contents]: <00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00>,
//         byteLength: 16
//     }
// }
// DataView {
//     byteLength: 2,
//     byteOffset: 8,
//     buffer: ArrayBuffer {
//     [Uint8Contents]: <00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00>,
//         byteLength: 16
//     }
// }

从上面的输出我们也可以看到 DataView 有三个属性 buffer，byteLength 和 byteOffset，对应的就是我们构造函数中的三个参数，这三个属性都是在 DataView.prototype 上。

DataView.prototype 上共有十对用来读写的 get 和 set 方法，get 方法接受一个 byteOffset 作为参数，set 方法接受 byteOffset 和 value 作为参数，get 和 set 都能传一个可选的 littleEndian 参数，如果为 true 则为小端序，如果为 false 或者 undefined 则为大端序，见下表。

| 方法名 | 功能 | | ------------ | ------------------------------------------------------------------------------------------ | | getInt8 | 在指定的 byteOffset 读取一个字节，返回该字节表示的 8 位有符号整数 | | getUint8 | 在指定的 byteOffset 读取一个字节，返回该字节表示的 8 为无符号整数 | | getInt16 | 在指定的 byteOffset 读取两个字节，返回该字节表示的 16 位有符号整数 | | getUint16 | 在指定的 byteOffset 读取两个字节，返回该字节表示的 16 位无符号整数 | | getInt32 | 在指定的 byteOffset 读取四个字节，返回该字节表示的 32 位有符号整数 | | getInt32 | 在指定的 byteOffset 读取四个字节，返回该字节表示的 32 位无符号整数 | | getFloat32 | 在指定的 byteOffset 读取四个字节，返回该字节表示的 32 位有符号IEEE-754 浮点数 | | getFloat64 | 在指定的 byteOffset 读取八个字节，返回该字节表示的 64 位有符号IEEE-754浮点数 | | getBigInt64 | 在指定的 byteOffset 读取八个字节，返回该字节表示的 64 位有符号整数 | | getBigUint64 | 在指定的 byteOffset 读取八个字节，返回该字节表示的 64 位无符号整数 | | setInt8 | 在指定的 byteOffset 写入一个字节，写入值为 value 转换的 8 位有符号整数 | | setUint8 | 在指定的 byteOffset 写入一个字节，写入值为 value 转换的 8 为无符号整数 | | setInt16 | 在指定的 byteOffset 写入两个字节，写入值为 value 转换的 16 位有符号整数 | | setUint16 | 在指定的 byteOffset 写入两个字节，写入值为 value 转换的 16 位无符号整数 | | setInt32 | 在指定的 byteOffset 写入四个字节，写入值为 value 转换的 32 位有符号整数 | | setInt32 | 在指定的 byteOffset 写入四个字节，写入值为 value 转换的 32 位无符号整数 | | setFloat32 | 在指定的 byteOffset 写入四个字节，写入值为 value 转换的 32 位有符号IEEE-754 浮点数 | | setFloat64 | 在指定的 byteOffset 写入八个字节，写入值为 value 转换的 64 位有符号IEEE-754浮点数 | | setBigInt64 | 在指定的 byteOffset 写入八个字节，写入值为 value 转换的 64 位有符号整数 | | setBigUint64 | 在指定的 byteOffset 写入八个字节，写入值为 value 转换的 64 位无符号整数 |

在读取或者写入超过一个字节的时候，字节序是非常重要的，如果字节序搞错了很可能导致非常离谱的结果，例子可以看上面的 TypedArray 讲字节序时举的例子。

对于不支持 BigInt 的浏览器，getBigInt64, getBigUint64，setBigInt64 和 setBigUint64 无法使用，具体的兼容办法参考 MDN

Blob

上面介绍的操作二进制的对象你可能没有接触过，但是只要你处理过和文件相关的 API，比如上传下载文件，你肯定接触过 Blob 对象。

注意 Blob 是只有浏览器中才有的对象，在 NodeJS 中是没有这个对象的。

blob 的全称是 Binary Large Object，也就是二进制大对象的意思（作为单个实体存储的二进制数据的集合），最早是用在数据库管理系统中，一般是用来存储音频视频和其他多媒体文件，也有一些二进制可执行代码被存储为一个 blob。

在 JavaScript 中，Blob 对象代表一个 blob, 它是一个类似文件的不可变原始数据对象；它们可以作为文本或二进制数据读取，或转换为 ReadableStream 以便其方法可用于处理数据。Blobs 可以用来表示没有采用 JavaScript 原生格式的数据，File 接口就是继承自 Blob 并进行了扩展来支持用户系统中的文件。

从上面的描述我们可以看出，Blob 对象也是二进制数据的集合，但是它是一个不可变的对象，我们不能像 ArrayBuffer 一样利用视图对其进行读写。

我们可以用 Blob 构造函数创建一个新的 Blob 对象，这个构造函数接受一个 array 作为必选参数，可以理解为构建 Blob 的数据源，这个数据源的格式必须是数组，数组中的元素必须是 ArrayBuffer，TypedArray，Blob，USVString 对象。另一个可选参数是 options，是一个独享，其中比较重要的一个属性就是 type，默认值是 ""，这个值是表名这个 blob 数据的 MIME type。

USVString 的概念可以参考搞懂字符编码

const text = new Blob(['clloz'], { type: 'text/plain' })
console.log(text)
//Blob {size: 5, type: 'text/plain'}
//size: 5
//type: "text/plain"

我们可以看到 Blob 有两个属性 size 和 type，这两个属性都是在 Blob.prototype 上，分别表示 Blob 对象中的数据的字节数和 Blob 对象的 MIME type。

原型上还有几个方法

Blob.prototype.arrayBuffer()

该方法返回一个 Promise，这个 Promise 的状态是 resolve，resolve 的值是一个包含 blob 中的二进制数据的 ArrayBuffer。

const blob = new Blob(['123'])
const bufferPromise = blob.arrayBuffer()
const buffer = await blob.arrayBuffer()
const view = new Int8Array(buffer)
for (const item of view) {
  console.log(item)
}
// 49
// 50
// 51

字符串中的 123 被保存为 unicode 中的 codepoint，对应的就是 49， 50，51。

Blob.prototype.slice()

看到 slice 自然明白就是切片，接受三个可选参数 start，end 和 contentType。start 和 end 是左闭右开的截取范围，默认截取全部，如果 start 大于 blob 的 size 则返回一个 size 为 0 的 blob。start 或者 end 如果为负值则从最后一个字节向前计算。contentType 默认为 ""。

const blob = new Blob(['123'])
const newBlob = blob.slice(1)
const bufferPromise = newBlob.arrayBuffer()
const buffer = await newBlob.arrayBuffer()
const view = new Int8Array(buffer)
for (const item of view) {
  console.log(item)
}
// 50
// 51

Blob.prototype.stream()

这个方法返回一个 ReadableStream 来读取 Blob 对象中的内容，ReadableStream 的相关内容可以参考文档，是 Fetch API 在 Response 中提供的一个对象，这里给大家一个例子。

const blob = new Blob(['123'])
blob
  .stream()
  .getReader()
  .read()
  .then(({ done, value }) => {
    console.log(done)
    console.log(value)
  })
// Uint8Array(3) [49, 50, 51, buffer: ArrayBuffer(3), byteLength: 3, byteOffset: 0, length: 3]

Blob.prototype.text()

这个方法返回一个 Promise，将 Blob 对象中的内容转为 UTF-8 返回。

const view = new Int8Array([67, 108, 108, 111, 122])
const blob = new Blob([view])
blob.text().then((val) => console.log(val))
// Clloz

应用

字符串和 ArrayBuffer 的转换

在能够确定字符的编码的时候（确定了编码我们就知道字符串在内存中的存储形式），我们可以在字符串和 ArrayBuffer 之间进行互相转换，比如 UTF-16 可以用如下代码转换：

// ArrayBuffer转为字符串，参数为ArrayBuffer对象
function ab2str(buf) {
  return String.fromCharCode.apply(null, new Uint16Array(buf))
}

// 字符串转为ArrayBuffer对象，参数为字符串
function str2ab(str) {
  var buf = new ArrayBuffer(str.length * 2) // 每个字符占用2个字节
  var bufView = new Uint16Array(buf)
  for (var i = 0, strLen = str.length; i < strLen; i++) {
    bufView[i] = str.charCodeAt(i)
  }
  return buf
}

播放 PCM

之前做过一个语音对讲的需求，一般来说录音设备直接录制的音频是未经压缩的音频采样数据裸流 PCM（Pulse Code Modulation），这个 PCM 格式是不能直接在前端播放的，我采用的方式是添加一个 wav 的 header 转成 wav 后进行播放，大致的做法如下。

// 将后端传递的 PCM 字符串转为 buffer 并添加 wav header UTF-16格式字符串
export function addWavHeader(str) {
  const WAV_HEAD_SIZE = 44
  const buffer = new ArrayBuffer(str.length * 2 + WAV_HEAD_SIZE)
  const view = new DataView(buffer)

  // 为 PCM 添加 wav header 转为 wav
  // RIFF chunk descriptor/identifier
  writeUTFBytes(view, 0, 'RIFF')
  // RIFF chunk length
  view.setUint32(4, 44 + str.length * 2, true)
  // RIFF type
  writeUTFBytes(view, 8, 'WAVE')
  // format chunk identifier
  // FMT sub-chunk
  writeUTFBytes(view, 12, 'fmt ')
  // format chunk length
  view.setUint32(16, 16, true)
  // sample format (raw)
  view.setUint16(20, 1, true)
  // stereo (2 channels)
  view.setUint16(22, 1, true)
  // sample rate
  view.setUint32(24, 8000, true)
  // byte rate (sample rate * block align)
  view.setUint32(28, 8000 * 2, true)
  // block align (channel count * bytes per sample)
  view.setUint16(32, 2, true)
  // bits per sample
  view.setUint16(34, 16, true)
  // data sub-chunk
  // data chunk identifier
  writeUTFBytes(view, 36, 'data')
  // data chunk length
  view.setUint32(40, str.length * 2, true)

  const length = str.length
  let index = 44
  for (let i = 0; i < length; i++) {
    view.setInt16(index, str.charCodeAt(i), true)
    index += 2
  }
  return buffer
}

// 生成 wav 并用 audio 播放
export function genWavAndPlay(buffer) {
  const blob = new Blob([new Uint8Array(buffer)])
  const blobUrl = URL.createObjectURL(blob)
  if (!blobUrlList.length) {
    audioEl.src = blobUrl
    audioEl.play()
  } else {
    blobUrlList.push(blobUrl)
  }
}

发送接收二进制数据

JavaScript 接收发送二进制数据

参考资料

设置 Apple Music 全局快捷键

Wed, 01 Dec 2021 12:00:00 GMT

前言

以前写过 Mac设置terminal快捷键讲了一下用 automator 来添加 quick action 来用快捷键启动终端，今天在讲一下如何设置 Apple Music 的全局快捷键来执行上一曲，下一曲和播放暂停。

添加 Quick Action

整个操作过程和添加终端的快捷键差不多，不过现在 automator 的界面和原来有些不同，原来齿轮图标是叫 Service，现在叫 Quick Action。我们打开 automator，然后在顶部任务栏中选择 File -> New 或者直接点解弹出界面的 New Docment，然后选择其中的 Quick Action，如下图

然后将右侧的 Workflow Recieve 选择为 no input，在左侧的 Actions 中找到 Run AppleScript，然后双击，在右侧弹出的脚本输入框中输入脚本即可。

脚本如下：

# 下一首
tell application "Music"
    if it is running then
        play (next track)
    end if
end tell

# 上一首
tell application "Music"
    if it is running then
    play (previous track)
    end if
end tell

# 播放暂停
tell application "Music"
    if it is running then
        set isPlaying to the player state
        if (isPlaying = playing) then
            pause
        else
            play
        end if
    end if
end tell

注意，这里我把三个脚本写在一起了，请根据注释分别创建三个 Quick Action，注意不要把注释复制进去

粘贴好脚本后可以点击一下 ▶️ 按钮看看脚本能不能生效，如果没问题就可以保存脚本了，保存一个自己喜欢的名字。Quick Action 的保存路径在 /Users/Clloz/Library/Services，可以进去重命名。

之后就是设置快捷键了，和设置 terminal 快捷键一样，我们可以进入 System Preferences->Keyboard->Shortcuts->Services->General，在里面找到刚刚创建的三个 Quick Action 的名字，设置快捷键即可。需要注意的是，由于这里设置的是全局快捷键，建议设置得复杂一点，如果设置的太简单很可能和其他应用的快捷键冲突导致不生效。

参考文章

不使用第三方程序在 mac 上用快捷键全局控制 Spotify

执行上下文和词法环境

Sat, 27 Nov 2021 12:00:00 GMT

前言

我之前曾经写过 JS 中的执行环境和作用域链和 var，let，const和变量提升（hoist）两篇文章来总结 JavaScript 中代码执行和作用域的一些知识点，最近在读 JavaScript 忍者秘籍（第二版）的第五章的时候结合最新版的 Spec 将这部分知识又复习梳理了一遍，进行一个新的总结。

ECMAScript 的标准只是一份文档，具体的引擎实现并不完全参照标准，我们只是借助标准来理解引擎的一些行为，除非翻引擎的源码，否则我们很难确定底层的实现细节，首要的目的还是理解行为和机制。对绝大多数前端程序员来说，并没有了解底层实现的必要，如果确有需要并且有实力可以去阅读源码，否则只要大致理解机制即可，不必花费过多时间钻牛角尖。本文所讨论的 ECMAScript 规范的版本范围从 2011 年的 5.1 版本到最新的 2021版本，其他版本不在讨论范围内

环境记录 Environment Record 和词法环境 Lexical Environment

这两个概念联系很紧密，它们都是标准中核心章节 Executable Code and Execution Contexts 中的重要概念。这两个概念一直都是存在的，从 ES 5.1 的 10.2 小节可以看出此时的 Environment Records 只是 Lexical Environment 下的一个概念，或者说是 Lexical Environment 中的一个组成部分，基本到 ES2020之前，这两个概念在标准中都没什么变化，最新的 ES 2021 我们会发现 Lexical Environment 已经放到了 Execution Contexts 中，成了执行上下文中的一个概念，而 Environment Records 则是和执行上下文同级的一个小节，不过它们两个概念依然有很紧密的联系。

注意：规范中也明确说了 Lexical Environments 和 Environment Record 是纯粹的规范内的机制并没有对应某个特定的实现，我们无法在程序中对这些值进行访问。

在 2020 之前的版本中对 Environment Record 和 Lexical Environment 的描述就是一个 Specification Tpyes 就是规范中的类型，规范类型对应于在算法中使用的元值，用于描述 ECMAScript 语言构造和 ECMAScript 语言类型的语义。

Lexical Environment 和 Environment Record 类型是用来解释嵌套的方法和代码块的标识符解析的行为的。Lexical Environment 的作用是根据代码的词法嵌套结构来定义标识符和特定的变量或方法的关联。Lexical Environment 由 Environment Record 和一个可能为空的外层 Lexical Environment 组成。通常 Lexical Environment 和特定的语法结构相关联，比如函数声明，块语句，Try 语句的 Catch 子句，每次这些代码执行都会创建一个新的 Lexical Environment。Lexical Environment 由该环境的 Environment Record 和一个可能为 null 的指向其外部 Lexical Environment 的引用组成（我们下面称这个引用为 OuterEnv）。

这里有两个比较疑惑的点，一个是这里说的是 FunctionDeclaration，在规范中 FunctionDeclaration 和 FunctionExpression 也是不同的，按理说函数声明和函数表达式的执行应该是没本质区别的（虽然有提升的区别）但对于代码的执行应该是一样的，不过标准中在说特定的语法结构用的是 such as 姑且认为只是列出了部分。另一个是为什么要单独说 Catch 子句，根据规范的定义，Catch 子句已经是 Block 了，有没有必要单独列出来。

而一个 Environment Record 用来记录其所在的 Lexical Environment 的作用域中创建的标识符绑定。根据规范，Environment Records 有两种主要的类型 declarative Environment Records 和 object Environment Records，前者就是我们常见的函数声明，便令声明等，包括了 variable，constant，let，class，module，import 和 function declarations，后者则是主要用来关联 WithStatement。

关于 Environment Records 在规范中还介绍了抽象类和实体子类的细节，这里就不展开了，不影响我们理解，有兴趣可以阅读规范。

Lexical Environment 的嵌套自然就和我们上面说道的会产生 Lexical Environment 的结构的嵌套紧密相关，当我们定义了嵌套的函数或者 BlockStatement，自然会发生 Lexical Environment 的嵌套，所以 Lexical Environment 就有一个 Outer Environment 引用指向其定义时所在的 Lexical Environment。

下面的这部分内容都是我根据标准还有一些资料对引擎实现的一些猜想和推测，我对编译原理是一点不了解，只是把自己的一些想法记录一下

这里有一个点需要注意，Lexical Environment 是由代码的执行产生的，但是产生的 Lexical Records 其内部的 Outer Environment 确是由定义的位置确定的。至于引擎是如何实现这种定位位置的跟踪，我是比较好奇内部的实现的，我猜想应该是预编译的时候再任何函数对象产生的时候，比如说声明提升或者是函数表达式赋值的时候，给内存中产生的函数对象加上一个内部属性 [[OuterEnv]] 指向当前所在的 Lexical Environment。

在学习这部分内容的时候我还有一个疑问就是闭包和 with的问题，Lexical Environment 是在函数执行的时候创建的，那如果我们的函数是从某个内部函数返回的，当这个函数执行的时候，其定义时所在的环境的闭包以及其 Lexical Environment 是如何保存的，是所有的标识符解析都保存着还是说只保留了这个函数引用的部分，我个人倾向于是值保留了还需要使用的那部分，毕竟内存的消耗肯定是越小越好，当然这就需要预编译的时候引擎做更多事情。我们可以找一段简单的闭包代码来分析一下。

outerVar = 1
function outerFn() {
  const uselessVar = 'useless'
  const innerVar = 10
  return function inner() {
    console.log(innerVar)
  }
}
const innerFn = outerFn()
innerFn()

在分析之前我还是先说一下我对闭包 closure 的理解，其实并不是一个复杂的概念，主要是用在函数式编程语言中的一个概念，由于函数式编程中的函数是 first-class object，可以作为一个普通对象使用（作为参数，返回值等），所以其作用域的工作方式产生了闭包。在 JavaScript 中我们定义的函数可以在任何地方调用，如果按照调用的位置确定作用域，那么其作用域会变得不确定，所以函数式编程语言的作用域采用的是函数内定义的参数，变量，方法在函数外不可访问，只有内部定义的方法可以访问（隐藏状态是实现 OOP 的一个重要特性），一个函数能访问的作用域由其定义的位置确定，所以我们可以说闭包就是函数和其能访问的作用域构成的。我们可以看出无论是 Lexical Environment，Environment Record 还是 Closure 的概念都是在解释函数式编程语言的标识符绑定也就是作用域的问题。

维基百科的解释：闭包在实现上是一个结构体，它存储了一个函数（通常是其入口地址）和一个关联的环境（相当于一个符号查找表）。环境里是若干对符号和值的对应关系，它既要包括约束变量（该函数内部绑定的符号），也要包括自由变量（在函数外部定义但在函数内被引用），有些函数也可能没有自由变量。闭包跟函数最大的不同在于，当捕捉闭包的时候，它的自由变量会在捕捉时被确定，这样即便脱离了捕捉时的上下文，它也能照常运行。捕捉时对于值的处理可以是值拷贝，也可以是名称引用，这通常由语言设计者决定，也可能由用户自行指定（如C++）。

继续分析上面的代码，我们假设 outer 函数定义在全局中，并且全局环境中只有这段代码，我们分三个时间点来分析代码，第一个时间点是全局环境装载的时候，第二个时间点是 outerFn 执行的时候，第三个时间点是 innerFn 执行的时候。

我们先来看全局环境装载，也就是我们代码开始执行的时候，此时的执行上下文栈只有一个全局执行上下文，全局代码的执行也会创建全局的 Lexical Environment，Global Lexical Environment 的 OuterEnv 是 null，Environment Record 则记录了全局环境中的标识符绑定，在这段代码中有两个 constant：outerVar 和 innerFn，还有一个 FunctionDeclaration：OuterFn。从上面我作的这个图可以看出全局的 Lexcial Environment 和 Environment Record 的关系。这里我有个推测就是当全局环境或者函数进行预编译的时候，检测到函数声明的时候会给函数加上一个 [[Environment]] 字段，后面函数执行的时候就是用这个字段作为新生成的 Lexical Environment 的 OuterEnv。如果是函数表达式，这个操作应该是在执行到函数表达式赋值的时候进行的。有了这个 [[Environment]] 属性之后，无论之后的函数在哪里执行，我们都知道其 OunterEnv 是哪个，逻辑上没什么问题。这里也只是个人的想法，引擎的具体实现不一定是这样，但整个思路应该是没有问题的

下面我们进入第二个时间点，就是 outerFn 执行的时候。如上图所示，outerFn 的执行创建了一个新的 Lexical Environment，这个新的 Lexical Environment 的 outerEnv 就会拿我们放在函数上的 [[Environemnt]] 属性，也就是 GlobalLexicalEnvironment。outerFn Lexical Environmet 的 Environment Record 中就放着函数中的标识符绑定，uselessVar，innerVar 和一个函数声明 innerFn。和全局环境装在时一样，我们会在 outerFn 预编译的时候给 innerFn 上加一个 [[Environment]] 属性指向 outerFn Lexical Envrionment。

最后一个时间点是全局的 innerFn 的执行，此时的 outerFn Execution Context 已经执行完毕出栈销毁了，但是由于其内部定义的 innerFn 仍然在全局环境中有引用，该 innerFn 可以通过闭包访问到 outerFn 中定义的变量，现在这些内部变量只有 innerFn 能够访问到了。所以我们可以看到 outerFn Lexical Environment 并不会销毁，当 innerFn 执行过程中进行标识符检索的时候会现在当前的 innerFn Lexical Environment 中的 Environment Record 中进行检索，找不到会到 innerFn Lexical Environment 中的 OuterEnv 指向的 outerFn Lexical Environment 中进行检索，如果还找不到就继续按相同的规则向上找，直到到达 Global Lexical Environment，这也就是以前一个比较流行的概念作用域链的本质。

这里我又一个疑问就是 outerFn Lexical Environment 中的之后不会用到的变量比如图中我用虚线标出来的 uselessVar 是否会在执行上下文销毁的时候被销毁，毕竟这能节省不必要浪费的内存，也就是闭包中是否只保存会被再次用到的变量，我个人认为不会再次被使用的变量是会销毁的。

ES2021

在 ES 2021 中，标准有了一个较大的变动，Environment Record 的概念被升级，而 LexicalEnvironment 则放到了 Execution Contexts 中和 VariableEnvironment 同级，并且标准中说了 The LexicalEnvironment and VariableEnvironment components of an execution context are always Environment Records.，我个人认为相当于把 Lexical Environment 和 Environment Record 两个概念合并了，相当于把我们上面图中的 Lexical Environment 换成 Environment Record，然后 Environment Record 引用的内容直接放到当前的 Environment Record 下，OuterEnv 不变。其实他们的本质没什么变化，只是表述上有些不同，毕竟 JavaScript 引擎已经比较稳定，像作用域这种底层核心设施应该不会有什么颠覆性的变化。

忍者秘籍

虽然忍者秘籍也是 18 年的书了，可能有些人觉得有些过时，但我觉得 JavaScript 的基础内容都还是值得一看的，特别是对有一定基础，想继续夯实的并且能够自己区分哪些内容是不需要看的同学，看一看没什么坏处。第五章的内容我个人觉得讲的还是挺不错的，一些例子（比如那个定时器的例子）和图都能很好的帮助理解。不过我强烈建议有英文阅读能力的去读英文，中文版我真不知道说啥，看到 in a nutshell 被翻译成 在果壳之下 我也是醉了。

对于书籍的阅读我一直建议的是自己去看一看再说有没有用，这东西很主观，有些人说一些东西过时了，那可能是他掌握的很好，未必对你没用，更何况还有很多跟风的。具体到自己的情况，还是自己去读一下才能确定，如果读个几页发现确实没用，也浪费不了什么时间，而且很多书温故而知新，在不同的阶段再去读一读也能有不少收获。总之我还是建议大家多自己看，少听人说。

总结

本文就是根据标准对 Lexical Environment 和 Environment Record 以及闭包的一些解读，如有错漏，欢迎指正和交流。

m1 芯片的 node 版本问题

Wed, 27 Oct 2021 12:00:00 GMT

前言

昨天早上新的 MBP 到了，花了一天的时间差不多把开发环境部署的差不多了，今天开始把公司的项目拉下来跑了跑，结果还是遇到了一些问题，总结一下。

node 版本

关于 M1 芯片的支持情况可以参考这个网站 doesitarm，从网站给出的 Github issue 和 version support，我们可以知道 v15.3.0 之后都是原生支持 M1 的，之前的版本则需要通过 Rosetta 2 将 x86 指令翻译成 ARM 指令。

我是用的 NVM 来进行 node 的版本管理，NVM 的安装和之前并没有什么太大的差别。我第一个安装的版本是一个 v15 的版本，装了非常长的时间，并且 CPU 满负荷在运行，不过最后还是装好了。但是安装 v16 之后的版本就和原来非 M1 的安装差不多，非常迅速。根据 Node.js 16 introduces Apple Silicon support 和上面的兼容性网站，我估计是 v15 的版本还是兼容性不太好的，v16 是第一个为 M1 提供预构建的二进制的版本。

我目前安装了三个版本： 1. 14.16.0：这是我之前一直使用的版本，原来的项目都是在这个版本下构建和运行的 2. 16.13.0：该版本是目前原生支持 M1 的版本中唯一的 LTS 版本 3. 17.0.1: 最新版本，我用 brew 安装 yarn 的时候 brew 还安装了一个最新版的 node，导致我的 NVM 版本切换无效了，之后我卸载了 brew 的，用 NVM 重装了一个

如果你原本使用的就是 v16 版本，那么就建议无缝切换到 v16.13.0。如果和我一样原来使用的是比较低的版本，就需要在 Rosetta 2 的终端中安装低版本 node。

安装低版本

参考 install node under v15，简单来说就是在终端执行 arch -x86_64 zsh 让当前终端运行在 Rosetta 2 下，然后就可以用 nvm 安装低版本 node 了，之后我们可以在非 Rosetta 2 的终端下任意切换和使用任意版本的 nodejs。

如果你使用 homebrew 安装了最新的 zsh，那么这个 zsh 的版本是 zsh 5.8 (arm-apple-darwin21.1.0)，而 mac 自带的 zsh 版本是 zsh 5.8 (x86_64-apple-darwin21.1.0)。这是如果我们执行 arch x86_64 zsh 会报错 arch: posix_spawnp: zsh: Bad CPU type in executable，因为我们的 zsh 此时已经是 arm 架构了，不能切换。如果是这种情况要安装老版本的 nodejs 就需要在启动 iTerm 或者 terminal 之前在 get info（⌘ + I）勾选上 open using Rosetta，之后启动终端就能正常安装老版本的 node 了。

高版本遇到的问题

我一开始不想安装低版本的需要 Rosetta 2 的 node，但是在给几个项目安装依赖的时候发现出了很多问题，还是装了原来的 14.16.0 的版本。

canvas 包安装不上

首先遇到的是 canvas 包装不上，最后在 Google 上找到的解决方案就是 brew install pkg-config cairo pango libpng jpeg giflib librsvg，参考解决m1的mac 无法安装 canvas 包

node-sass 问题

接下来就是 node-sass 的问题，首先我们要明确自己的 node 版本和所需的 node-sass 的版本，参考 node-sass - Github，这里我使用的是 v16，所以我需要的 node-sass 版本是 6.0+，但是 6.0+ 的 node-sass 又需要 11.0+ 的 sass-loader，而 vue 2.6 又不支持这么高版本的 sass-loader，这变成一个无解的问题了，所以最后我只能选择切换成一个低版本。

关于 node-sass 的讨论可以参考 node-sass - issue

不过在我用 v15 版本的时候似乎 npm i 成功并且项目成功跑起来过，在我切换到 v16 安装好依赖 npm run serve 后一直提示 Error: vue-loader requires @vue/compiler-sfc to be present in the dependency tree.，目前我还没搞清楚什么问题。安装 @vue/compiler-sfc 能够把项目跑起来，不过 package.json 和 package-lock.json 都发生变化了。

总结

目前遇到的问题就这些，后面会持续更新遇到的问题和解决方法。

网站的免费 https 证书申请和更新

Sun, 21 Mar 2021 12:00:00 GMT

前言

网站的 HTTPS 现在基本已经是必须的了，不过对于个人网站而言，一年几百块的 SSL 证书显然是没有必要的，我们需要的是比较方便的免费证书。我之前一直是申请的阿里云的免费证书，不过阿里云的免费证书的有效期为一年，并且每次快过期了都要手动进行部署，修改 nginx 配置，比较麻烦。之前在 V2Ray 的配置中用了 certbot 来免费申请 Let's Encrypt 的证书，虽然有效期只要三个月，但是可以配置自动续签，所以还是比较方便的。本文就介绍以下配置过程。

配置

Let's Encrypt 是一家免费，开放，自动化的证书颁发机构，官方文档参考 Let's Encrypt 快速入门。Let's Encrypt 官方建议使用 certbot 来进行证书的获取。安装 certbot 需要先安装 epel 仓库，命令如下：

sudo yum install epel-release

sudo yum install certbot

安装完成后我们就可以运行 certbot 命令来获取证书了，certbot 命令的详细参数说明可以参考 Certbot命令行工具使用说明。我们这里为我们的网站进行证书的申请主要是下面的命令：

certbot certonly --webroot -m youremail@email.com -w your-root-path -d your-domain.com

certonly 表示获取证书，但是不安装，我们手动进行配置。 --webroot 表示把身份认证文件放置在服务器的网页根目录下，这样可以让我们在更新证书的时候不用关闭 nginx。 -m 输入自己的邮箱用来接收 Let's Encrypt 的邮件，比如证书要过期了等。 -d 输入自己要申请帧数的域名，如果不输入会在命令执行后要你手动填，也可以选择跳过 -w 网站的根目录

生成好的证书文件路径如下：

/etc/letsencrypt/live/example.com/fullchain.pem
/etc/letsencrypt/live/example.com/privkey.pem

在我们的 nginx 配置文件中配置

ssl_certificate       /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key   /etc/letsencrypt/live/example.com/privkey.pem;

然后重启 nginx 就完成配置了。

你可以使用 certbot certificates 来查看你已经申请的证书信息，你也可以多次运行上面的命令为多个域名创建证书，如果要更新单个证书就重新运行创建证书的命令，如果要一次更新所有域名的证书可以使用 certbot renew。

自动更新证书

证书的自动更新需要安装 crontabs，安装命令如下

yum -y install vixie-cron

yum -y install crontabs

安装完成后 service crond start 启动 crond 服务，然后用 crontab -e 来创建自动更新的命令 30 0 15 * * /usr/bin/certbot renew --post-hook "systemctl restart nginx" >> /var/log/le-renew.log，该命令表示每个月 15 号的 0:30 执行 certbot renew 进行证书的更新，你也可以根据自己的需求写 cron 表达式，--pre-hook 和 --post-hook 则是证书更新前后的两个命令钩子，这里我们不需要像配置 v2ray 证书里面那样先停止自己的 nginx，因为那里我们没有一个真的 web 服务供 Let's Encrypt 进行检测，而是用 certbot --standalone 启动了一个独立的 80 端口服务来进行验证，这里我们有自己的 nginx 可以提供验证，所以不需要用 --pre-hook 先关闭 nginx。最好自己先执行以下 certbot renew --dry-run 来测试一下命令是否能正常运行。

还有一点需要注意的是，证书的默认有效期是 90 天，默认情况下只有有效期小于 30 天的时候才可以进行证书的更新，否则更新会失败。

遇到的问题

2021-12-15 收到 Let's Encrypt 的邮件说是证书还有一天就过期了，上服务器上执行 certbot renew 发现报错 Failed to renew certificate with error: __str__ returned non-string，在 Let's Encrypt 社区里找到类似的问题用 pip 安装 urllib3 和 requests 后由报了一个新的错误 Failed to renew certificate with error: ("bad handshake: Error([('SSL routines', 'ssl3_get_server_certificate', 'certificate verify failed')],)",)，没找到答案，最后只能按社区里说的加上 --no-verify-ssl 参数，更新成功了。看情况应该是 Let's Encrypt 的什么证书过期了，暂时就先这么解决了。

尝试了如下这些方法，不过都没有效果： 1. Old Let’s Encrypt Root Certificate Expiration and OpenSSL 1.0.2 2. Centos7 don't trust certificate issued by lets encrypt 3. Certbot 0.31.0 renew failed, peer’s certificate issuer not recognized 4. Chain of Trust

总结

以上就是配置 Let's Encrypt 证书并设置自动更新的方法了，如果有问题，欢迎留言讨论。

对 Promise 的一些新的思考

Thu, 18 Mar 2021 12:00:00 GMT

前言

我之前在阅读 《ECMAScript 6 入门》 的时候曾经写过一篇深入 Promise，从 Promise 实现的角度对 Promise 的机制进行了一点探究，我自己认为理解的还可以，不过昨天同事给了我一道 Promise 的执行顺序题，让我久违的复习了一下 Promise，发现之前的理解还是存在一些问题。

题目分析

Promise.resolve()
  .then(() => {
    console.log('0')
    return Promise.resolve('4')
  })
  .then((res) => {
    console.log(res)
  })
Promise.resolve()
  .then(() => {
    console.log('1')
  })
  .then(() => {
    console.log('2')
  })
  .then(() => {
    console.log('3')
  })
  .then(() => {
    console.log('5')
  })
  .then(() => {
    console.log('6')
  })

就是这样一个 Promise 的执行顺序题，我当时的第一反应是 0 1 4 2 3 5 6，我在 code runner 里面跑了一下也没问题，但是后来到浏览器控制台以及 node 中跑了一下代码，发现输出都是 0 1 2 3 4 5 6，就让我非常迷茫，后面我又把我那篇深入 Promise 看了一遍，发现了一些问题。

首先是对 then 的理解，我在之前的文章中也写了 new Promise 和 then 本身都是同步执行的，但我还是认为 Promise 变为 settled 状态以后才会执行 then，但这显然是不太可能，也不符合 JS 引擎的执行规律。在 Promise 的实现中 then 本身就是 Promise 类的一个方法，其执行会返回一个 Promise 对象，既然是方法并且是同步代码，then 肯定会同步执行。只不过如果上级 Promise 如果是 pending 状态，then 的参数方法会被缓存到上级 Promise 的回调函数队列中而已，上级 Promise 已经 resolved 进入 fulfilled 状态，则 then 的参数方法直接进入微任务队列。

但是 then 还有一个细节就是如果我们在 then 中返回的是一个 Promise，会调用这个 Promise 的 then 方法，并且在这个 then 当中进行父级 Promise 的 resolve 或者 reject，细节参考深入 Promise 的源码实现中的 resolvePromise方法。其实解释这个也很简单，当我们返回的是一个 Promise 的时候，我们需要在这个 Promise 的状态 settled 之后才能对父级的这个 then 进行 resolve，所以当 then 中返回的是一个 Promise 的时候会存在一次隐式的 then 调用。我们来看下面四段代码的输出：

// 第一段代码
Promise.resolve()
  .then(() => {
    console.log('0')
    return new Promise((resolve) => {
      return resolve(10)
    })
  })
  .then((res) => {
    console.log(res)
  })
Promise.resolve()
  .then(() => {
    console.log('1')
  })
  .then(() => {
    console.log('2')
  })
  .then(() => {
    console.log('3')
  })
  .then(() => {
    console.log('5')
  })
  .then(() => {
    console.log('6')
  })

// 0
// 1
// 2
// 3
// 10
// 5
// 6

// 第二段代码
Promise.resolve()
  .then(() => {
    console.log('0')
    return new Promise((resolve) => {
      return resolve(4)
    }).then(() => 11)
  })
  .then((res) => {
    console.log(res)
  })
Promise.resolve()
  .then(() => {
    console.log('1')
  })
  .then(() => {
    console.log('2')
  })
  .then(() => {
    console.log('3')
  })
  .then(() => {
    console.log('5')
  })
  .then(() => {
    console.log('6')
  })

// 0
// 1
// 2
// 3
// 11
// 5
// 6

// 第三段代码
Promise.resolve()
  .then(() => {
    console.log('0')
    return new Promise((resolve) => {
      return resolve(4)
    })
      .then(() => 11)
      .then(() => 12)
  })
  .then((res) => {
    console.log(res)
  })
Promise.resolve()
  .then(() => {
    console.log('1')
  })
  .then(() => {
    console.log('2')
  })
  .then(() => {
    console.log('3')
  })
  .then(() => {
    console.log('5')
  })
  .then(() => {
    console.log('6')
  })

// 0
// 1
// 2
// 3
// 5
// 12
// 6

// 第四段代码
Promise.resolve()
  .then(() => {
    console.log('0')
    return new Promise((resolve) => {
      return resolve(4)
    })
      .then(() => 11)
      .then(() => 12)
      .then(() => 13)
  })
  .then((res) => {
    console.log(res)
  })
Promise.resolve()
  .then(() => {
    console.log('1')
  })
  .then(() => {
    console.log('2')
  })
  .then(() => {
    console.log('3')
  })
  .then(() => {
    console.log('5')
  })
  .then(() => {
    console.log('6')
  })

// 0
// 1
// 2
// 3
// 5
// 6
// 13

第一段代码中我们返回了一个直接 resolve 的 Promise，我们发现和 Promise.reslove() 效果是一样的。我们可以看到返回的这个 Promise 它只是 resolve 了它自己，而父级的 then 状态改变必然要在这个返回的 Promise 状态确定之后才能确定是 resolve 还是 reject，所以在 Promise 实现的源码中我们可以发现，如果 then 的返回是一个 Promise，会在这个 Promise 的 then 中进行 resolve 和 reject。

第二段代码中我们对返回的 Promise 进行了 then，结果和第一段代码的执行结果是相同的。这段代码的过程比较好分析（以打印的值来标志代码段，比如 console.log(0) 这段代码我们就称为 0）： 1. 执行所有同步代码，两个 Promise.resolve() 直接 resolved，所以 0 和 1 都被加入微任务队列。 2. 同步代码执行完成，开始执行微任务，先执行 0，打印 0，然后执行 new Promise 并直接 resolve，将这个新的 Promise 的 then 中的 11 加入微任务队列。 3. 执行下一个 1 微任务，打印 1，并把 2 加入微任务队列。 4. 执行 11 微任务，并隐式调用返回的 Promise 的 then，隐式调用的 then 的回调函数加入微任务队列 5. 执行 2，打印 2，将 3 加入微任务队列， 6. 执行隐式调用的 then 微任务，在这个 then 中 resolve 父级的 then，同时将 console.log(res) 这段代码加入微任务队列 7. 执行 3，打印 3，将 5 加入微任务队列 8. 执行 console.log(res)，打印 11 9. 执行 5，打印 5，将 6 加入微任务队列 10. 执行 6，打印 6

这个过程逻辑没有什么问题，但是第一段代码比第二段少一个 then 执行结果依然是一样的，感觉就像是隐式调用了两次 then，这里我没有找到具体的原因，去翻了翻 v8 的 Promise 源码也没有找到合适的解释（源码参考从Google V8引擎剖析Promise实现。

后面的两段代码用上面的理论也比较好解释，每多一个 then 就推迟一次打印结果。有了这几个例子，上面的 Promise.resolve 那一个问题也是一样的思考逻辑。

总结

本文对 Promise 特别是 then 的执行细节进行了更深入的探究，但还是有一个问题没有解决，如果你知道答案欢迎回复评论。这里在分享几个跟 Promise 相关的题目关于 ES6 中 Promise 的面试题，第五题和第七题还是有点意思的。

JS 强制转 Number 的方法研究

Wed, 17 Mar 2021 12:00:00 GMT

前言

我在深入Javascript类型转换一文中从标准的角度对 JavaScript 中的类型转换的部分内容进行解读，主要是 Number，String 和 Boolean 这三个日常经常遇到的类型。昨天在阅读 lodash 的 slice 源码看到用无符号右移 start >>> 0 来确保 start 是一个 Number 类型的正整数。在 JavaScript设计模式与开发实践 中也看到了 +new Date 这样转换日期毫秒数的。我日常转换日期毫秒数都是用的 Date.prototype.getTime() 方法，强制转换数字我经常使用 Number() 构造器。在经过一番搜索之后发现很多文章说 Number() 是效率最低的一种方式，于是我决定自己对强制转换为 Number 类型的多种方法进行一下探究。

转换方法

一元操作符

一元操作符有 ++, --, +, -, ~, !，我在深入Javascript类型转换中已经写过，除了 !，其他一元操作符都是会将类型转换为 Number 类型，MDN 中也推荐用一元 + 来讲其他类型转为 Number：一元正号是转换其他对象到数值的最快方法，也是最推荐的做法，因为它不会对数值执行任何多余操作。它可以将字符串转换成整数和浮点数形式，也可以转换非字符串值 true，false 和 null。小数和十六进制格式字符串也可以转换成数值。负数形式字符串也可以转换成数值（对于十六进制不适用）。如果它不能解析一个值，则计算结果为 NaN。

位运算

对于 JavaScript 中的位运算不熟悉的同学可以先去看一看 JavaScript 中的按位操作符。JavaScript 中的按位操作符会将操作数转换成 32 位的二进制整数，所以也可以用来进行 Number 转换。但是需要注意的是 32 位有符号二进制整数所能表示的最大值为 $2^32 - 1$，即 4294967295，如果数字超过这个范围则会出错，超出 32 位的部分会直接被丢弃。所以我们使用连续的按位非 ~~，或者无符号右移 >>>，以及 |0 都要注意操作数的范围。比如上面说的用 +new Date 可以获得毫秒数，如果使用 >>> 将会得到错误结果。

const time = +new Date()
console.log(+new Date()) // 1615946620311
const time_binary = time.toString(2)
console.log(time_binary, time_binary.length) // 10111100000111101111011001100010001011011 41
const time_bit = time >>> 0
console.log(time_bit) // 1038988502
console.log(parseInt(`${time_binary}`.slice(8), 2)) // 1038988502

我们可以看到上面的代码 time 为当前时间毫秒数，是用 + 进行转换的，time_binary 是用 Number.prototype.toString 转换的二进制字符串，time_bit 则是用无符号右移获得的 Number。我们可以看到无符号右移只能保留低位的 32 位二进制，超出的高位都被丢弃。

关于 JavaScript 中的进制的一些细节参考我的另一篇文章 JS 中的数字进制

parseInt

parseInt 是一个内置的全局函数，也是我们使用频率比较高的一个方法，但是 parseInt 的机制还是比较复杂的，这里我来详细总结一下。

parseInt 的语法是 parseInt(string, radix)，接受两个参数，第一个参数是一个字符串，如果不是字符串会强制转换为 String，字符串开头的空白符会被忽略。第二个参数为可选参数，表示字符串的基数，范围为 2-36。虽然看起来很简单，但是由于 JavaScript 中的类型转换规则比较复杂，所以第一个参数的 toString 会产生很多奇怪的结果。比如下面：

console.log(parseInt('012')) // 12
console.log(parseInt(012)) // 10
console.log(parseInt('012', 8)) // 10
console.log(parseInt(012, 8)) // 8

console.log(parseInt('0o12')) // 0
console.log(parseInt(0o12)) // 10
console.log(parseInt('0o12', 8)) // 0
console.log(parseInt(0o12, 8)) // 8

这里我选了八进制作为示例，注意八进制的两种表示方式 0 和 0o，前者是不推荐使用了，ES5 本身也是不支持八进制的，我们使用的 0 开头的八进制是浏览器厂商自己支持的，ES6 中则使用 0o 对八进制进行了支持。ECMAScript 5 规范也不允许 parseInt 函数的实现环境把以 0 字符开始的字符串作为八进制数值。所以我们在编码中尽量用复合标准的 0o，虽然 0 也能得到大部分浏览器的支持。

这里我们在说一下 radix 的规定，注意，radix 的默认值不是 10，如果 radix 是 undefined、0 或未指定的，JavaScript 会假定以下情况：

如果输入的 string 以 0x 或 0x 开头，那么 radix 被假定为 16，字符串的其余部分被当做十六进制数去解析。如果输入的 string 以任何其他值开头， radix 是 10。如果 radix 的范围超出 2-36，那么 parseInt 表达式直接返回 NaN

如果输入的 string 以 0 开头， radix 被假定为八进制或十进制。具体选择哪一个 radix 取决于实现。ECMAScript 5 规定了应该使用十进制，但不是所有的浏览器都支持。因此，在使用 parseInt 时，一定要指定一个 radix。

讲完了规则，我们一条一条来分析： parseInt('012') 的结果是 12，这是因为 chrome 对于 0 开头的字符串的 parseInt 实现遵循了 ES5 标准，即没有传入 radix 的时候，0 开头的字符串会被作为一个十进制数。

parseInt(012)，这里我们直接传入了一个八进制数 012，即十进制的 10，我们看到结果成功返回了 10。我们分析一下过程，我们传入的是一个 Number，所以会先调用 012 .toString()(注意数字和小数点之间有空格，这是 JS 的一个 bug，否则 . 会被解释为一个小数点，而不是成员访问)，012 被 toString 转为十进制的字符串 '10' (toString d的默认参数是 10)，所以我们的该条表达式最后实际被转化为 parseInt('10')，自然能够得到 10。

parseInt('012', 8) 是一个推荐的标准写法，即我们传入一个个指定进制的字符串，同时传入该进制的基数，能够得到一个确定的正确结果，日常编码中我们应该采用这种写法，以免出现意想不到的结果。

parseInt(012, 8) 得到了一个让我们以外的结果 8，但其实结合 parseInt(012) 的分析过程我们可以发现这个语句被转换成了 parseInt('10', 8)，这样得到 8 就不足为奇了。

后面四条语句我是使用的 ES6 标准的 0o 表示的八进制数，我们主要来看第一条和第三条表达式。 parseInt('0o12') 和 parseInt('0o12', 8) 得到了两个相同的结果 0，这主要是因为这条规则

如果 parseInt 遇到的字符不是指定 radix 参数中的数字，它将忽略该字符以及所有后续字符，并返回到该点为止已解析的整数值。 parseInt 将数字截断为整数值。允许前导和尾随空格。如果第一个空白字符不能转换为数字则 parseInt 表达式返回 NaN。

结合上面的 radix 的规则，我们可以得出结论，除了十六进制字符串能够被准确识别出 radix，其他字符串的 radix 都默认是 10，而且 parseInt 对字符串是否是数字不是做一个整体的判断，而是从低位开始解析，解析到不是数字的位置停止，并返回已经解析的结果。这就导致了像 123sdfds 这样的数字字符混合的字符串我们不能得到 NaN，这是我们使用 parseInt 需要注意的一个问题。MDN 上给出了一个严格解析函数来应对这个问题：

function filterInt(value) {
  // 正则表达式判断是否只有正负号数字以及 Infinity，否则返回 NaN
  if (/^[-+]?(\d+|Infinity)$/.test(value)) {
    return Number(value)
  } else {
    return NaN
  }
}

parseInt 可以识别 + 和 -。 parseInt 不应用于科学计数法，类似 6.022e23 这样的数字，对于科学计数法应当使用 Math.floor。

parseFloat

parseFloat 和 parseInt 一样是个全局函数,不属于任何对象。它只接受一个 String 作为参数，如果参数不是 String，会强制转换为 String，开头的空白符会被忽略，解析规则如下：

如果 parseFloat 在解析过程中遇到了正号 +、负号 -、数字、小数点、或者科学记数法中的指数（e 或 E）以外的字符，则它会忽略该字符以及之后的所有字符，返回当前已经解析到的浮点数。
第二个小数点的出现也会使解析停止（在这之前的字符都会被解析）。
参数首位和末位的空白符会被忽略。
如果参数字符串的第一个字符不能被解析成为数字,则 parseFloat 返回 NaN。
parseFloat 也可以解析并返回 Infinity。
parseFloat 解析 BigInt 为 Numbers, 丢失精度。因为末位 n 字符被丢弃。

考虑使用 Number(value) 进行更严谨的解析，只要参数带有无效字符就会被转换为 NaN 。

Number

作为原始包装对象，使用 Number() 可以将参数转换为 Number，转换规则参考类型转换细节

性能

上面分析了这些方法的细节，那么这些方法的性能到底如何呢，是不是真的如有些文章说的 Number 的性能很差呢？我分别用 benchmarkjs 在本地的 node 环境中和 jsbench 上各跑了几次。benchmarkjs 的代码如下：

const Benchmark = require('benchmark')

const suite = new Benchmark.Suite()

suite
  .add('parseInt', () => {
    parseInt('4294967295')
  })
  .add('parseFloat', () => {
    parseFloat('4294967295')
  })
  .add('unary', () => {
    ;+'4294967295'
  })
  .add('bit', () => {
    '4294967295' >>> 0
  })
  .add('Number', () => {
    Number('4294967295')
  })
  // add listeners
  .on('cycle', function (event) {
    console.log(String(event.target))
  })
  .on('complete', function () {
    console.log('Fastest is ' + this.filter('fastest').map('name'))
  })
  // run async
  .run({ async: true })

跑的结果如下：

parseInt x 8,844,909 ops/sec ±3.67% (86 runs sampled)
parseFloat x 12,166,845 ops/sec ±1.11% (91 runs sampled)
unary x 838,130,806 ops/sec ±0.92% (86 runs sampled)
bit x 839,113,877 ops/sec ±0.88% (89 runs sampled)
Number x 838,017,789 ops/sec ±0.96% (87 runs sampled)
Fastest is bit,unary,Number

jsbench 网站上的结果如下图

从两个结果上看我们可以看出一元操作符，位运算符和 Number 的性能是很接近的，而 parseInt 的性能则要差很多。而位操作符又有范围限制。所以最后的结论解释我们可以使用一元 + 或者 Number 都可以。

总结

本文我们详细分析了几种将值转为 Number 的方法的细节，可能有错漏之处，欢迎指出。

token 机制和实现方式

Mon, 14 Dec 2020 12:00:00 GMT

前言

之前在面试的时候被问到过刷新 token 的问题，其实我对 token 验证机制的细节一直不清楚。新项目和后端的同学商量后使用刷新 token 来实现。本文主要分享一下对 token 机制的理解和实现方式。

登录验证的方式

登录验证一般来说有两个目的，一个是为了安全，一个是为了用户方便。因为 HTTP 是无状态的，所以后端在接受到请求之后并不能知道请求是从哪里来的，但是很多时候我们有验证用户身份的需求，同时前端又有保存用户登录状态的需求。而如果将用户信息保存在前端，必然是非常危险的，很容易被获取，所以就有了在后端进行非对称加密的方式来实现登录的验证和保存。

目前主要的登录验证方式有 cookie + session，token，单点登录和 OAuth 第三方登录。本文我们主要讲一讲 token 登录验证。

什么是 token

token 直译就是令牌的意思，其实就是后端将用户信息进行非对称加密，然后将加密后的内容保存在前端，当发送请求的时候带上这个令牌来实现身份验证。大致的过程是第一次登录用户输入用户名和密码，服务器验证无误后会对用户的信息进行非对称加密生成一个令牌返回给前端，前端可以存入 cookie 或者 localStorage 等，以后每次发送请求带上这个令牌，后端通过对令牌的验证来识别用户的身份以及请求的合法性。

token 的优点是服务端不需要保存 token，只需要验证前端传过来的 token 即可，所以几遍是分布式部署也可以使用这种方式。token 的缺点就是，由于服务器不保存 session 状态，因此无法在使用过程中废止某个 token，或者更改 token 的权限。也就是说，一旦 token 签发了，在到期之前就会始终有效，除非服务器部署额外的逻辑。

目前比较常用的 token 加密方式是 JWT JSON Web Token，关于 JWT 可以参考阮一峰老师的 JSON Web Token 入门教程

token 刷新

按照上面的 token 逻辑，前端只要保存一个后端传过来的 token，每次请求附上即可。当令牌过期有两种选择，我们可以让用户冲洗你登录，或者后端生成一个新的令牌，前端保存新的令牌并重新发送请求。但是这两种方式都有问题，如果让用户重新登录，用户体验不是很好，频繁的重新登录并不是一种比较好的交互方式。而如果自动生成新的令牌则会出现安全问题，比如黑客获取了一个过期的令牌并向后端发送请求，则也可以获得一个更新的令牌。

为了权衡上面的问题，产生了一种刷新 token 的机制，当用户第一次登录成功，后端会返回两个 token，一个 accessToken 用来进行请求，也就是我们每次请求都附上 accessToken，而 refreshToken 则是用来在 accessToken 过期的时候进行 accessToken 的刷新。一般来说，accessToken 由于每次请求都会附上，所以安全风险比较高，所以过期时间较短，而 refreshToken 则只有在 accessToken 过期的时候才会发送到后端，所以安全风险相对较低，所以过期时间可以长一点。

当我们的 accessToken 过期之后，我们会向后端的 token 刷新接口请求并传入 refreshToken，后端验证梅雨问题之后会给我们一个新的 accessToken，我们保存后就可以保证访问的连续性。当然，这也并非绝对安全的，只是一种相对安全一点的做法。一般我们将两个 token 保存在 localStorage 中。

刷新 token 的实现

在项目中我主要使用的是 axios，所以 token 的刷新以及请求附带 token 都是使用的 axios 的拦截器完成的。这其中需要注意的地方有三点：

不要重复刷新 token，即一个请求已经刷新 token 了，此时可能新的 token 还没有回来，其他请求不应该重复刷新。
当新的 token 还没有回来的时候，其他的请求应该进行暂存，等新的 token 回来以后再一次进行请求。
如果请求是由登录页面或者请求本身就是刷新 token 的请求则不需要拦截，否则会陷入死循环。

第一个问题用一个 Boolean 字段加锁即可，第二个问题将请求新 token 过程中发起的请求用状态为 pendding 的 Promise 进行暂存，放到一个数组中，当新的 token 回来的时候依次 resolve 每一个 pendding 的 Promise 即可。具体的代码细节我直接贴上项目上的源码：

import axios, * as AxiosInterface from 'axios';

// Token 接口，访问 token，刷新 token 和过期时
const instance = axios.create({
    // baseURL: ''
    timeout: 300000,
    headers: {
        'Content-Type': 'application/json',
        'X-Requested-With': 'XMLHttpRequest',
    },
});

async function refreshAccessToken(): Promise<AxiosInterface.AxiosResponse<AxiosData>> {
    return await instance.post('api/refreshtoken');
}

let isRefreshing = false;
let requests: Array<Function> = []; // 若在 token 刷新过程中进来多个请求则存入 requests 中
// axios.defaults.baseURL = 'http://127.0.0.1:8888/api/private/v1/';
// 设置请求拦截器，若 token 过期则刷新 token
axios.interceptors.request.use(config => {
    const tokenObj = JSON.parse(window.localStorage.getItem('token') as string);
    if (config.url === 'api/login' || config.url === 'api/refreshtoken') return config;
    let accessToken = tokenObj.accessToken;
    let expireTime = tokenObj.expireTime;
    const refreshToken = tokenObj.refreshToken;

    config.headers.Authorization = accessToken;

    let time = Date.now();
    console.log(time, expireTime);
    if (time > expireTime) {
        if (!isRefreshing) {
            isRefreshing = true;
            refreshAccessToken()
                .then(res => {
                    ({ accessToken, expireTime } = res.data.data);
                    time = Date.now();
                    const tokenStorage = {
                        accessToken,
                        refreshToken,
                        expireTime: Number(time) + Number(expireTime),
                    };
                    window.localStorage.setItem('token', JSON.stringify(tokenStorage));
                    isRefreshing = false;
                    return accessToken;
                })
                .then((accessToken: string) => {
                    requests.forEach(cb => {
                        cb(accessToken);
                    });
                    requests = [];
                })
                .catch((err: string) => {
                    throw new Error(`refresh token error: ${err}`);
                });
        }

        // 如果是在刷新 token 时进行的请求则暂存在 requests 数组中，这里需要使用一个 pendding 的 Promise 来确保拦截的成功
        const parallelRequest: Promise<AxiosInterface.AxiosRequestConfig> = new Promise(resolve => {
            requests.push((accessToken: string) => {
                config.headers.Authorization = accessToken;
                console.log(accessToken + Math.random() * 1000);
                resolve(config);
            });
        });

        return parallelRequest;
    }

    return config;
});

export default (vue: Function) => {
    vue.prototype.$http = axios;
};

总结

以上就是我对刷新 token 的实现，如果有什么错误之处欢迎指正交流。

参考文章

Vue 响应式原理

Sun, 22 Nov 2020 12:00:00 GMT

前言

Vue3 将双向数据绑定的实现由 Object.defineProperty() 换成了 Proxy。本文我们来深入研究一下这两种方法分别如何实现双向数据绑定，并且他们的区别和优劣在哪里。

本文所有代码均在 clloz-vue - Github

双向数据绑定原理

双向数据绑定的概念其实很简单，比如你在页面上有一个 input，你将这个 input 的 value 和你在 JavaScript 中的一个值打个比方，你声明了一个对象 obj，用其中的 getVal 属性来保存这个 input 的 value，通过一段代码进行了绑定。达到的效果就是，当你在页面上的 input 进行输入的时候（即改变了 input 的 value），此时你 JavaScript 中的 getVal 这个属性就自动发生变化了。同样当你在 JavaScript 中修改了 getVal 的值的时候，页面上的 input 中的 value 也会自动改变。

想一想如何用最简单的方法实现这个功能，用 Object.defineProperty 将 obj 的 getVal 属性的 set 和 get 进行重写，在 set 中我们将 set 的值也设置到 input 的 value 中去，这样就打到了修改数据，页面上的元素自动改变的效果。而修改元素改变数据，只要给 input 添加一个事件即可。实现效果如下：

代码如下：

<body>
  <input id="be-watch" type="text" />
  <p id="show"></p>
</body>
<script>
  let obj = {
    getVal: 0
  }

  let cache = obj.getVal

  let input = document.getElementById('be-watch')
  let p = document.getElementById('show')
  input.addEventListener('input', (e) => {
    obj.getVal = e.target.value
  })

  Object.defineProperty(obj, 'getVal', {
    enumerable: true,
    configurable: true,
    get() {
      return cache
    },
    set(val) {
      cache = val
      input.value = val
      p.innerHTML = val
    }
  })
</script>

这里我们可以发现 Object.defineProperty 的一个问题，由于我们使用这个方法监听属性，相当于把属性从数据属性变成了访问器属性，此时我们就无法用这个访问器属性来保存 value 了。为了保证对象的正常访问，我们需要找另一个地方将变量保存起来，当执行 get 的时候我们会返回那个保存的变量，也就是上面代码中的 cache。注意，这里的 get 和 set 方法中不要使用 obj.getValue 保存 value，此时他们是访问器属性，如果你这么做会报栈溢出，因为你 set 的时候执行 obj.getValue = val，此时相当于执行了 getter，而 getter 返回的又是 obj.getValue，然后又会执行 getter，一直递归下去，自然就栈溢出了。

优化和应用

上面的代码是最简单的双向数据绑定，也是其核心原理。但是在实际的项目中我们不可能这么使用，因为实际的项目中要监听的对象和属性非常多，元素也各不相同，事件也各不相同，如果用上面的这种方法实现每一个属性和对应的元素事件我们都要单独绑定太麻烦了，而且所有的代码都耦合在一起，肯定是非常难以维护的。所以要把这个技术真的应用的到工程中去我们必须抽象出它的一套可行的逻辑。这其中最主要的就是发布订阅模式，不太清楚发布订阅模式的同学可以参考我的文章深入发布订阅模式。

我们来重新理一下需求，我们希望我们声明的对象和某些方法关联起来。在上面的例子中，我们是希望对象属性变化的的时候能够改变 input 的 value，并显示到一个 p 标签中，其实就是执行了一个简单的方法，虽然这个方法只有两行代码。即我希望对象的属性变化的时候，让用到这个属性的方法能够执行。最简单的做法就是像上面的例子中，将这个方法的代码直接放到 setter 中，那么在属性改变的时候自然就会执行对应的代码。

但是上面这种实现在项目中肯定是无法实现的，我们每有一个地方用到了某个属性就要去它对应的 Object.defineProperty 的位置加上变更的代码，而且每个属性都要有一个不一样的 defineProperty 的代码，肯定是没法实现的。

这个时候就要用到发布订阅模式了，我们把调用属性的方法放一边，单独抽象出对象属性的逻辑。我们对对象的包装就两件事，设置 setter 和 getter，在 setter 中通知变化，至于通知给谁，这里我们就要通知给发布订阅模式的事件中心，这里我们称为依赖中心 Dep，我们为每一个属性单独建立一个 Dep，当属性变化我们就告诉 Dep 就可以了，至于 Dep 要怎么做我们后面再讨论。这样我们就将把普通 object 变为一个可侦测监听的 object 这个逻辑分离成一个可以复用的逻辑，我们将这个逻辑抽象出一个 Observer 类，它通过 setter 发布变化给事件中心 Dep，也就是发布订阅模式中 发布者。下面给出一个 Observer 类的简单骨架：

import Dep from './dep.mjs'

export class Observer {
  constructor(data) {
    this.data = data
    if (!Array.isArray(data)) {
      this.walk(data)
    }
  }

  /* eslint-disable */
  walk(obj) {
    Object.keys(obj).forEach((key) => {
      let dep = new Dep()
      let val = obj[key]

      observe(val)
      Object.defineProperty(obj, key, {
        enumreable: true,
        configurable: true,
        get() {
          if (Dep.target) {
            dep.depend()
          }
          return val
        },
        set(newValue) {
          if (val === newValue) return
          val = newValue
          dep.notify()
        }
      })
    })
  }
}

export function observe(val) {
  if (!val || typeof val !== 'object') {
    return
  }
  return new Observer(val)
}

我们再去思考调用到属性的方法那边，我们要解决的一个主要问题就是知道方法用了哪些属性，这些属性变化后我们要做些什么。这一步我们自然是要对代码进行分析，我们这里暂时不讨论模版解析的问题，我们就以一个简单的场景来看这个问题，比如我们在 vue 中常用的 $watch，我们需要在属性 a 变化的时候执行某个方法就是 vm.$watch('a', function(newVal, oldVal){ ... }，这是最简单的监听需求。其实无论什么样复杂的代码，简化到最后的逻辑都是这样，就是上面的例子是修改一个 input 的 value，或者改变一个元素的样式，它也只是想在某个属性变化的时候执行一个回调函数，它就是我们发布订阅模式中的 订阅者。那我们可以将这个逻辑抽象成一个 Watcher 类，每一个监听和回调都是一个 Watcher 实例。

Watcher 实例主要做什么呢？分析要访问的属性（比如上面的 a，这里路径可能有嵌套表达式等情况），访问该属性触发 getter，我们将会在 getter 中进行依赖的收集。提供一个 update 函数，当依赖的属性发出变化通知的时候（setter 中的逻辑），外部会调用实例内部的 update 方法，执行回调函数。下面给出一个简单的 Watcher 骨架：

import Dep from './dep.mjs'

export default class Watcher {
  constructor(gb, exp, cb) {
    this.gb = gb
    this.data = this.gb.data
    this.exp = exp
    this.cb = cb
    this.value = this.get()
  }

  // 访问属性，添加订阅
  get() {
    Dep.target = this // 设置 Dep.target 为当前 watcher，让 Dep 知道添加谁
    let value = this.data[this.exp]
    Dep.target = null // getter 触发结束成功添加注册后设置 Dep.target 为 null，防止非 watcher 的属性访问也添加订阅
    return value
  }

  addDep(dep) {
    dep.addSub(this) // 进行订阅
  }

  // 给 Dep 调用的更新方法
  update() {
    const oldVal = this.value
    const newVal = this.get()
    if (oldVal !== newVal) {
      this.cb.call(this.gb, this.newVal, oldVal)
    }
  }
}

总结一下 Observer 和 Wathcer 两个类，Observer 是用来将属性用 Object.defineProperty 进行重写的，让每一个属性都有 getter 和 setter，在 getter 和 setter 中分别完成依赖的收集和属性变更的发布，即通过 Observer 我们将一个普通的 object 变成了一个可以被侦测监听的 object 了。

而 Watcher 就是我们将想要订阅属性变更的一些方法的抽象，即每一个方法都是一个 Watcher 实例，它通过访问对应的属性触发 getter 来实现依赖的注入（注入到 Dep 中），同时提供一个 update()，让 Dep 能在属性变化的时候调用从而执行回调函数。在实际的 Vue 代码中，Watcher 是在模版的解析过程中生成的，这个我们在后面讨论。

剩下的就是依赖调度中心 Dep 了，每一个被侦测的属性都会有一个 Dep 实例，Dep 的主要任务管理该属性依赖，即将收集到的依赖保存，当该属性变化的时候调用对应 Watcher 的 update 执行回调函数。

依赖的收集是依靠 Watcher 访问属性触发 getter 来实现的，也就是我们在 getter 中要将对应的 Watcher 实例写入 Dep 实例中去，这里就有一个问题了，getter 只知道属性被调用的，但是无法确定是谁调用了属性，我们怎么将 Watcher 传递进去呢？这个当然只能依赖一个 Observer 类和 Watcher 类都能访问到的外部属性了，Vue 的做法是用一个 Dep 上的静态属性 target。也就是当 Watcher 进行属性访问之前会先设置这个 Dep.target 为自己这个 Watcher 实例，然后出发 getter 的时候 getter 内部会告诉 Dep 实例需要添加依赖的。最后当然 Dep 当中还有有一个 notify 方法通知保存的每个依赖 Watcher 实例执行实例中的 update 方法。下面是一个 Dep 的示例：

function remove(arr, item) {
  if (arr.length) {
    let index = arr.indexOf(item)
    if (index > -1) {
      return arr.splice(index, 1)
    }
  }
  return false
}

export default class Dep {
  constructor() {
    this.subs = []
  }

  // 调用订阅者 Watcher 的 addDep 方法添加订阅，实际内部调用的就是下面的 addSub
  depend() {
    Dep.target.addDep(this)
  }

  // 添加订阅
  addSub(sub) {
    this.subs.push(sub)
  }

  // 移除订阅
  removeSub(sub) {
    remove(this.subs, sub)
  }

  // 接收到来自 setter 的属性变化的消息则执行所有订阅者的 update 方法
  notify() {
    this.subs.forEach((sub) => sub.update())
  }
}

Dep.target = null

这张图来自《深入浅出 vue.js》，可以帮助大家理解这里的逻辑：

最后我们写一个例子来测试上面的逻辑是否能够运行：

import { observe } from './observer.mjs'
import Watcher from './watcher.mjs'

let obj = {
  data: {
    name: 'clloz',
    age: '28'
  }
}

observe(obj)

/* eslint-disable */
new Watcher(obj, 'name', function () {
  console.log('reactive successful')
})

obj.data.name = 'clloz1992' // reactive successful
console.log(obj.data.name) // clloz1992

在例子中我们用 observe 方法来对 obj 对象进行改造，然后用一个 watcher 示例来注册 name 属性，当我们给 name 属性赋值的时候，我们发现 reactive successful 成功输出了。

Vue 的双向绑定

上面我们已经基本实现了一个还算不错的双向绑定，但是在 Vue 中要还需要处理的更加细致，比如 Watcher 中的 exp，它可能是一个函数，函数不需要特别处理，执行就可以了。也有可能是 a.b.c 这样的嵌套形式，我们必须得对这个字符串进行解析，将它的访问层级区分开来。Vue 的处理如下：

export const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/
const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`)
export function parsePath (path: string): any {
  if (bailRE.test(path)) {
    return
  }
  const segments = path.split('.')
  return function (obj) {
    for (let i = 0; i < segments.length; i++) {
      if (!obj) return
      obj = obj[segments[i]]
    }
    return obj
  }
}

这个 ParsePath 就是用来处理 exp 的，在我上面写的例子中，我是直接访问 this.data[exp]，如果是有嵌套的对象这样肯定行不通。通过上面的函数。用 . 将嵌套的访问进行分割，然后沿着 obj 一层一层向下访问即可。添加了这个逻辑之后我们就可以访问嵌套的逻辑了。当然了我们的属性访问还可以通过 [] 运算符，如果使用了 [] 就必须要转换成 . 的访问形式。

Vue 还为 Watcher 和 Dep 实例添加了 id 和 hash，防止重复的订阅添加。以及在 Observer 的 setter 中对新添加的属性执行了 observe，应该是为了处理设置的属性是一个对象的情况。想要详细了解可以去看 Vue 的源码 Vue Souce Code。

vue 的双向绑定原理图（来自 vue双向数据绑定原理图(简易) - zhangjinpei，可以帮助大家理解整个执行过程。

Object.defineProperty 的局限

使用 Object.defineProperty 实现双向绑定大致就这些内容，但是 Object.defineProperty 有一些局限。比如我们是通过改写对象的属性，添加 getter 和 setter 实现属性监听的。如果我们是在对象已经用 observe 包装完成后再向其中添加属性，这些属性由于没有进行 getter 和 setter 的设置，自然是无法追踪的。而且 Object.defineProperty 也无法侦测到对象的删除。

总的来说 Object.defineProperty 只能通过将数据属性转换为访问器属性来实现数据变化的追踪，它只能监听数据的变化，而不是对对象进行监听，属性的增加删除它是不知道的。Vue2 的解决方式主要是通过 vm.$set 和 vm.$delete 解决的，这里不讨论。

Object.defineProperty 的另一个缺陷就是无法监听数组的变化，这里的不能监听主要是不能监听 Array.prototype 上的方法，数组元素的变化还是能监听的，比如一个数组 [1,2,3]，我们还是能通过 arr.0 监听数组元素的变化。但是像 push，pop 等方法就无能为了。因为这些方法不需要经过 getter 和 setter，而是数组原型上的方法。

虽然数组的元素是能够实现监听的，但是实际上 vue2 中并没有对数组的元素进行监听，即我们直接对数组元素修改是不会有任何响应式的行为，因为在 JavaScript 中数组的操作非常频繁，不像对象一样只有 key-value 的变化，如果对每一个元素都进行响应式的绑定在数组非常大并且操作非常频繁的的时候是很可能影响性能，所以 vue2 采取的是比较折中的方法，只是对数组的 7 中操作进行了监听：

push()
pop()
shift()
unshift()
splice()
sort()
reverse()

主要的方法就是在 Array 实例和 Array.prototype 之间添加了一个拦截器，当我们访问这些方法的时候，实际上访问的是拦截器上的方法。依赖的收集和 Object 一样，都是在 Observer 中的 getter 中进行收集，在拦截器中触发依赖（这部分等以后有时间展开）

Vue 3.0 的 Proxy 实现

关于 Proxy 的响应式，可以先看一个 Proxy 实现的调色器的例子：

代码在调色盘 - Proxy，具体如何进行绑定的参考代码。

Vue 3 的源码阅读中，有时间补上。

参考文章

githubusercontent curl 无法连接的解决办法

Fri, 20 Nov 2020 12:00:00 GMT

前言

今天在安装 wakatime 的 Xcode 插件的时候发现 curl 返回 Failed to connect to raw.githubusercontent.com port 443: Connection refused。相信也有小伙伴遇到过这种情况，并且开启了代理也依然无法访问。这主要原因是 raw.githubusercontent.com 的 DNS 被污染了，也就是 DNS 服务器没有解析正确的 IP 给我们，所以结果自然是访问失败 😏 。

解决办法

解决办法就是修改 hosts 文件，直接在本地完成 DNS 的解析就不需要去访问上层的 DNS 服务器了。DNS 解析一般是先查看本机的 hosts，然后是查看路由器，如果都没查到就要访问 DNS 服务器了。

我们先去 IP Address 查询一下域名定义的 IP，然后在 hosts 中添加一条解析记录即可。最后查询到的 IP 是 199.232.96.133，所以我们用 sudo vim /etc/hosts 编辑 hosts 文件，然后添加一条 199.232.68.133 raw.githubusercontent.com 解析记录即可。

JavaScript 面向对象

Sun, 08 Nov 2020 12:00:00 GMT

前言

想写这篇文章很久了，虽然现在都 ES6 已经相当普及了，大家都已经开始用 class 来定义类了。不过 class 关键字也可以看做是一个语法糖（Syntactic sugar），它的绝大部分功能，ES5 都可以做到，新的 class 写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。不过我认为对于整个 javascript 的继承机制还是应该更加深入了解比较好。

语法糖（英语：Syntactic sugar）是由英国计算机科学家彼得·兰丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性。

什么是面向对象

https://www.zhihu.com/question/305042684 面向对象这个名词从大学开始就一直接触，它的核心似乎很简单，但又模模糊糊。我个人觉得产生这种感觉的原因就是面向对象不是一个数学或物理概念，不是一个定理。它是一种设计模式，没有一个确定的描述，它是从实践中总结出的一种比较优秀的设计程序的模式，所以要学会它，只能不断的从实践中去验证，采坑。

我个人的理解面向对象就是对问题的抽象，将问题抽象成一个个小的模块分而治之，模块之间的关系尽量单一清晰，这样代码在扩展和维护的时候所花费的精力最小，也就是所谓的高内聚，低耦合。之所以它并不容易掌握，就是这个抽象能力是需要通过各种复杂的问题不断训练的。很多时候我们只是想着将写出来的代码进行复用，不要写出重复的代码，但其实最重要的是对问题的抽象，划分出合理的模块和设计模块之间的耦合关系，代码复用只是这个过程中自然而然产生的现象，我们应该明白问题的本质。

面向对象设计原则

| 缩写 | 英文名称 | 中文名称 | 概念 | | ----- | ----------------------------------------------- | -------------------------------------------------------------- | ------------------------------------------------------------------------ | | SRP | Single Responsibility Principle | 单一职责原则 | 对象应该仅具有一种单一功能 | | OCP | Open Close Principle | 开闭原则 | 软件体应该是对于扩展开放的，但是对于修改封闭的 | | LSP | Liskov Substitution Principle | 里氏替换原则 | 程序中的对象应该是可以在不改变程序正确性的前提下被它的子类所替换的 | | LoD | Law of Demeter （ Least Knowledge Principle） | 迪米特法则（最少知道原则） | 一个对象应该对尽可能少的对象有接触，也就是只接触那些真正需要接触的对象。 | | ISP | Interface Segregation Principle | 接口分离原则 | 多个特定客户端接口要好于一个宽泛用途的接口 | | DIP | Dependency Inversion Principle依赖倒置原则 | 一个方法应该遵从依赖于抽象而不是一个实例依赖注入是一种实现方式 | |

对于面向对象设计原则的解读可以参考面向对象设计的六大设计原则

创建对象

在 ES6 之前，语言的标准中没有一个正式的面向对象的构造和继承的支持，我们的对象继承机制都是基于原型的。在 ES6 之后，标准中引进了更类似传统面向对象于洋的 class 和继承方式，如今已经得到广泛的支持。也许你觉得只要学会 class 的用法就可以了，但其实 class 也只是对原型继承的一个语法层面的包装，搞清楚 class 背后的原型继承的整个机制，我们才能写出更好的代码。

我们知道在 JavaScript 创建一个普通的对象可以使用 Object 构造函数，对象字面量 {} 。但是如果我们想要批量创建一些具有相同属性的对象，这些方法就不太适合了，我们会写出许多重复的代码。这当然是面向对象中一个很重要的问题，即如何封装对象属性方法，用一个比较高效的方式创建对象。在 JavaScript 的发展过程中，有很多种创建对象的方式，有些可能现在不会使用了，但还是了解一下。

由于 JavaScript 的面向对象是基于原型的，所以如果你对 JavaScript 的原型还不是很了解，建议你先看一下 JavaScript 原型机制

工厂模式

工厂模式是在软件工程中非常有名的设计模式，它将创建对象的具体过程抽象了出来。将创建对象，添加属性的过程封装为一个函数，属性值作为函数的参数传入，当我们想要一个对象的时候，就执行这个函数即可。

function createPerson(name, age, job) {
  let o = new Object()
  o.name = name
  o.age = age
  o.job = job
  o.sayName = function () {
    console.log(this.name)
  }
  return o
}

let person1 = createPerson('Nicholas', 29, 'Software Engineer')
let person2 = createPerson('Greg', 27, 'Doctor')

工厂模式创建的对象有很多问题，一个最基本的就是不同的工厂模式函数创建出来的对象都是 Object 构造的，我们没有办法区分它们。

构造函数模式

在 JavaScript 中，构造函数用来创建特定类型的对象。JavaScript 引擎给我们提供了非常多的内置构造函数，比如 Array 和 Object 等等。我们也可以通过 function 定义自己的构造函数，在构造函数中我们可以定义我们的对象需要的属性和方法。

比如上面的那个 createPerson 的例子我们可以用构造函数进行如下改写：

function Person(name, age, job) {
  this.name = name
  this.age = age
  this.job = job
  this.sayName = function () {
    console.log(this.name)
  }
}

let person1 = new Person('Nicholas', 29, 'Software Engineer')
let person2 = new Person('Greg', 27, 'Doctor')

person1.sayName() // Nicholas
person2.sayName() // Greg

使用构造函数和上面的工厂模式的区别是，我们不在需要手动创建一个对象，所有的属性和对象都赋值到了 this 对象上，我们也不需要返回语句。还有一个小区别就是，我们创建构造函数一般首字母会大写，这是一个大多数面向对象语言的一个规定，用来区分普通函数和构造函数，特别是在 JavaScript 中构造函数其实就是一个普通的函数。

之所以有上面这些区别，是因为 new 操作符帮我们做了很多事情，关于 new 操作符我在另一片文章 JavaScript中new操作符的解析和实现

构造函数可以是函数声明，也可以是函数表达式。相比于工厂模式，构造函数模式让我们能够以一个固定的类型创建对象，并且所有对象都会是 Object 构造函数的实例。实例化的时候，new 后面的函数名可以带括号也可以不带括号，如果你不需要传入参数，可以省略括号。

需要注意的是，构造函数和其他的函数没有本质的不同，唯一的区别就是调用方式。任何函数通过 new 操作符调用就是作为一个构造函数，没有用 new 进行调用就是作为一个普通的函数。当然还有一个区别就是我们会将构造函数的首字母大写，但这不是强制性的，只是一种约定。

构造函数模式创建对象也有自己的缺点，那就是构造函数中的方法会在每个实例上都创建一遍，比如例子中的 sayName 方法，但是实际上我们并不需要在每个实例上都创建这个方法，特别是在我们有 this 对象的情况下。我们需要有一种方式让我们的实例能够共用某些方法。

这里提一点，我在 JavaScript中的this指向一文中曾经说过不要将箭头函数使用在对象的方法或者构造函数原型的方法上，因为它没有自己的 this。但是在构造函数中定义的实例的方法（绑定在 this 上的）可以使用箭头函数，this 能正确返回。

原型模式

如果你对 JavaScript 的原型还不是很了解，请先看 JavaScript 原型机制。

原型机制是整个 JavaScript 继承的核心。每一个函数创建的时候就会有一个 prototype 属性指向一个对象，用该构造函数创建的每一个对象都可以共享这个 prototype 上的属性和方法，一般我们就称 prototype 对应的对象为实例的原型对象。

有了原型机制，我们可以把那些每个实例都通用的属性和方法放到原型对象中去，而不必在每个实例上都创建。

function Person() {}

Person.prototype.name = 'Nicholas'
Person.prototype.age = 29
Person.prototype.job = 'Software Engineer'
Person.prototype.sayName = function () {
  console.log(this.name)
}

let person1 = new Person()
person1.sayName() // "Nicholas"

let person2 = new Person()
person2.sayName() // "Nicholas"

console.log(person1.sayName == person2.sayName) // true

原型机制是贯穿整个 JavaScript 核心的一个机制，所有内置对象都基于这个机制创建，我们之所以能在自己创建的对象，数组字符串上使用内置的 API，就是因为原型机制的存在，所以一定要搞清楚这个机制的细节。当然，不建议直接修改内置对象的原型，除非你确定不会引发命名冲突和兼容性问题。

尽管原型模式非常有用，但是如果只是单纯使用原型模式还是存在问题。在构造函数模式中，我们可以通过向构造函数传入参数，让最后生成的对象的属性值是由我们自定义的，每个实例都可以通过参数直接设定属性值。而在原型模式中，访问每个实例的同一个属性返回值都是相同的。

但是这还是个小问题，最关键的问题是所有实例共享属性。对于函数的共享来说，这当然是一个理想的解决方案。对于一个原型类型的值也还说得过去。但是如果对象的属性是一个引用类型，那么问题就出现了，我在 A 实例中修改了这个引用类型的值，当 B 实例去取这个引用类型中的属性的时候，这个引用类型已经发生了变化。

function Person() {}

Person.prototype = {
  constructor: Person,
  name: 'Nicholas',
  age: 29,
  job: 'Software Engineer',
  friends: ['Shelby', 'Court'],
  sayName() {
    console.log(this.name)
  }
}

let person1 = new Person()
let person2 = new Person()

person1.friends.push('Van')

console.log(person1.friends) // "Shelby,Court,Van"
console.log(person2.friends) // "Shelby,Court,Van"
console.log(person1.friends === person2.friends) // true

上面的例子我们可以看到，实例 person1 修改了原型上的 friends 属性，该属性是个引用类型。当 person2 去取这个属性的时候，这个变化也出现了。这是因为引用类型保存的只是一个指向对象的指针。如果我们确实希望 person1 的修改反映到 person2 中，这样做没有问题，但是大部分时候我们希望实例化对象的时候，它们的属性都是独立的。所以我们很少单独使用原型模式创建对象。

继承

继承是面向语言中的一个最为人津津乐道的概念。许多面向对象语言都支持两种继承方式: 接口继承和实现继承。接口继承只继承方法签名，而实现继承则继承实际的方法。如前所述，由于函数没有签名，在 ECMAScript 中无法实现接口继承。ECMAScript 只支持实现继承，而且其实现继承主要是依靠原型链来实现的。

一个函数签名 (或类型签名，或方法签名) 定义了函数或方法的输入与输出。一个签名可以包括：

参数及参数的类型
一个返回值及其类型
可能会抛出或传回的异常
有关面向对象程序中方法可用性的信息 (例如关键字 public、static 或 prototype)。

原型链的内容这里不重复讲了，还是看上面说的那篇文章，讲的很详细了。这里说一说原型链继承方式的问题。上面的小结已经介绍了一个问题，就是原型中共享的引用类型的修改会反映到每个实例中，这也就是为什么大部分属性我们都是在构造函数中定义。并且在实际的编码中，我们的构造函数的原型常常是另一个构造函数的实例，即使我们原先是用构造函数创建的实例属性，也成了另一个实例的原型属性。可以看一看下面的原型继承的例子：

function SuperType() {
  this.colors = ['red', 'blue', 'green']
}

function SubType() {}

// inherit from SuperType
SubType.prototype = new SuperType()

let instance1 = new SubType()
instance1.colors.push('black')
console.log(instance1.colors) // "red,blue,green,black"

let instance2 = new SubType()
console.log(instance2.colors) // "red,blue,green,black"

SubType.prototype 是 SuperType 的一个实例，SuperType 构造函数中定义的 colors 属性也就成了 SubType 实例的原型属性而被每个实例共享，最后的问题就还是和上面一样，每个实例对该属性的修改都会反映在其他实例上。原型继承还有个问题就是我们在实例化 SubType 的时候没法向 SuperType 构造函数传递参数。

原型继承的所有问题的根源就是所有实例共享属性，属性的变化会反映到每个实例中，这在实践中是非常糟糕的，所以我们很少单独使用原型链来实现继承。为了解决这个问题，实现一个比较好用又稳定的继承，有很多种继承方式被提出来。

借用构造函数

借用构造函数 constructor stealing，也被称为对象伪造 object masquerading 或者经典继承 classical inheritance。它的实现原理很简单，在子类型 SubType 的构造函数中调用超类型 SuperType 的构造函数。这种思想的本质就是实例化的过程即 new 的过程还是指定 this 执行构造函数，如果我们希望超类型的属性也被实例创建，在子类型构造函数中通过 apply 或者 call 指定 this执行超类型即可。

function SuperType() {
  this.colors = ['red', 'blue', 'green']
}

function SubType() {
  // inherit from SuperType
  SuperType.call(this)
}

let instance1 = new SubType()
instance1.colors.push('black')
console.log(instance1.colors) // "red,blue,green,black"

let instance2 = new SubType()
console.log(instance2.colors) // "red,blue,green"

上面的代码就是接用构造函数的一种实现，你甚至可以简单的理解为，把 SuperType 中的代码移到 SubType 中执行，就像把它的代码 “借” 过来一样，所以取名叫借用构造函数，本质上相当于将构造函数中可以复用的属性定义提取成一个函数，方便复用。比如你的需求中有很多构造函数都需要 name，age 和 sex 属性，你不需要在每个构造函数中都写上 this.name = xxx，this.age = xxx 等，把他们提取出来写成一个函数，然后在构造函数中调用即可。

这样 SuperType 中定义的属性，SubType 的每一个实例都有自己的副本而不是指向同一个对象。并且我们可以直接在 SubType 的构造过程中传递参数给 SuperType。

借用构造函数本质还是构造函数，只是优化了构造函数的结构而已，并没有什么革新。所以构造函数的问题它自然也没有解决，那就是定义的属性和方法没法复用。而且我们在子类构造的时候虽然调用了 SuperType，但是 SuperType 中的属性和方法对 SubType 完全是不可见的，我们也没法操作这些方法和属性，这样灵活性就大打折扣。

组合继承

组合继承 combination inheritance 有时也称为伪经典继承 pseudoclassical inheritance，它的思路就是将借用构造函数和原型链结合起来（由于借用构造函数本质就是构造函数，可以理解为构造函数和原型链的结合），使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承。这样，既通过在原型上定义方法实现了函数复用，又能够保证每个实例都有它自己的属性。

function SuperType(name) {
  this.name = name
  this.colors = ['red', 'blue', 'green']
}

SuperType.prototype.sayName = function () {
  console.log(this.name)
}

function SubType(name, age) {
  // inherit properties
  SuperType.call(this, name)

  this.age = age
}

// inherit methods
SubType.prototype = new SuperType()

SubType.prototype.sayAge = function () {
  console.log(this.age)
}

let instance1 = new SubType('Nicholas', 29)
instance1.colors.push('black')
console.log(instance1.colors) // "red,blue,green,black"
instance1.sayName() // "Nicholas";
instance1.sayAge() // 29

let instance2 = new SubType('Greg', 27)
console.log(instance2.colors) // "red,blue,green"
instance2.sayName() // "Greg";
instance2.sayAge() // 27

上面的例子中我们将共用的方法写在 SuperType.prototype 上通过原型链实现继承，不需要共用的属性如 name 和 colors 则放到构造函数中，让每一个实例都有独立的副本。组合模式结合了借用构造函数和原型链的优点而避开了它们的缺点，是比较常用的实现继承的方式。这种实现方式也能够使用 instanceof 和 isPrototypeOf() 来进行继承关系的判断。

组合式继承的一个缺点就是它调用了两次构造函数，一次在子类的构造函数中借用父类的构造函数。一次是在创建子类的 prototype 的时候是用实例化父类来实现的，这样创建的 prototype 里面可能会有一些没用的实例属性，而且如果构造函数很复杂，也会影响一些性能，这完全是可以规避的，用我们下面介绍的两种继承方式。

function SuperType(name) {
  this.name = name
  this.colors = ['red', 'blue', 'green']
}

SuperType.prototype.sayName = function () {
  console.log(this.name)
}

function SubType(name, age) {
  SuperType.call(this, name)

  this.age = age
}
SubType.prototype = new SuperType()

SubType.prototype.sayAge = function () {
  console.log(this.age)
}

let instance1 = new SubType('Nicholas', 29)
console.log(instance1.__proto__) // SuperType {name: undefined, colors: [ 'red', 'blue', 'green' ], sayAge: [Function]}

原型式继承

原型式继承 prototypal inheritance 是 Douglas Crockford（《JavaScript语言精粹》作者，JSON 的创建者）提出的一种继承方式，他的思路是通过一个中间函数来实现继承：

function object(o) {
  function F() {}
  F.prototype = o
  return new F()
}

在 object 函数中塔创建了一个临时的函数，将这个函数的 prototype 指向要继承的对象，然后用这个函数作为构造函数生成一个新的实例对象并返回。如果熟悉 Object.create() 的话，你会发现这就是 Object.create() 方法的 polyfill 实现中的核心代码，它相当于对传入的对象实现了一个浅复制。

let person = {
  name: 'Nicholas',
  friends: ['Shelby', 'Court', 'Van']
}

let anotherPerson = object(person)
anotherPerson.name = 'Greg'
anotherPerson.friends.push('Rob')

let yetAnotherPerson = object(person)
yetAnotherPerson.name = 'Linda'
yetAnotherPerson.friends.push('Barbie')

console.log(person.friends) // "Shelby,Court,Van,Rob,Barbie"

我们可以发现，原型式继承从语法上相当于直接指定某个对象作为新对象的原型，但是本质上只是它内部帮我们把构造函数这一步做了（只不过这个构造函数是个空函数），我需要我们再创建对象。当我们只是想实现对某个对象的属性方法继承的时候，这是一个非常实用并且方便的方法，所以 ES5 中也提供了 Object.create() 方法，其核心就是原型式继承，只不过 Object.create() 方法还能传递第二个参数，为新对象添加独立的属性。

一般来说，我们在实际编码中想要继承的只是一个对象的属性和方法，而该对象并没有对应的构造函数，这个时候原型式继承就是最合适的方式。

需要注意的是一个原型创建的多个对象，原型上的引用类型属性还是共享的，一个实例的对引用类型的修改会反映到另一个实例中（他们本质就是同一个对象），不过实际编码中不太会出现这样的情况，一般一个原型进行 create 只会使用一次。

Object.create() 方法参考 MDN 和 Object.create(null) 和 {…}

寄生式继承

寄生式继承 parasitic inheritance 其实就是对原型式继承的一个包装，因为我们用原型式继承生成对象以后可能还要为这个新对象添加一些新的属性或者方法，寄生式继承就是将这些过程进行一个封装而已，没有什么特别的内容，是原型式继承和工厂模式的一种结合。之所以叫寄生式继承，可以理解为它将继承的过程寄生在了一个函数里面。

function createAnother(original) {
  let clone = Object.create(original) // create a new object by calling a function
  clone.sayHi = function () {
    // augment the object in some way
    console.log('hi')
  }
  return clone // return the object
}
let person = {
  name: 'Nicholas',
  friends: ['Shelby', 'Court', 'Van']
}

let anotherPerson = createAnother(person)
anotherPerson.sayHi() // "hi"

寄生组合式继承

组合式继承已经是一种比较不错的继承实现方式，但是它有一个问题就是父类 SuperType 的构造函数调用了两次，一次是创建子类 SubType 的原型 prototype 时，一次是在子类的构造函数中借用构造时。为了优化这个过程，就有了寄生组合式继承 parasitic combination inheritance。

寄生组合式继承其实就是把创建子类原型 SubType.prototype 从 new SuperType 换成了原型式继承的方式，现在我们一般就是使用 Object.create()。

function SuperType(name) {
  this.name = name
  this.colors = ['red', 'blue', 'green']
}

SuperType.prototype.sayName = function () {
  console.log(this.name)
}

function SubType(name, age) {
  SuperType.call(this, name)

  this.age = age
}

SubType.prototype = Object.create(SuperType.prototype)
SubType.prototype.constructor = SubType

SubType.prototype.sayAge = function () {
  console.log(this.age)
}

ES5 面向对象总结

上面我们介绍了几乎关于 ES5 的全部面向对象内容，主要是基于《JavaScript 高级程序设计》第四版来写的。说实话，我个人认为用这样的方式区分继承的模式是非常不合理的，既不符合使用习惯，也很难记忆，特别是对于初学者（如果不是初学者，也不会看这些内容，瞄一下就行了）。之所以我还是按照书上的内容来介绍，是因为你可能在面试的时候被问到，比如如何实现寄生组合式继承。

我这里说一下我自己的理解，关于 ES5 的对象创建和继承方式，我们只要记住三个，构造函数，原型链和 Object.create()（它的本质就是构造函数和原型链的结合）。上面提到的所有创建对象和继承对象的方式都是这三种的方法的排列组合以及包装。比如组合继承，就是构造函数和原型链的组合，原型式继承已经通过 Object.create() 写入标准。寄生组合式继承则是构造函数，原型链和 Object.create() 三者的继承。借用构造函数则只是构造函数的一个变体而已，本质没有区别。

我们在实际的工作中根据我们的需要进行三者的组合，完全没有必要用一个个模式进行束缚。它们三者的功能我进行一个简单的归纳：

构造函数：为实例创建独立的属性和方法。
原型链：为实例创建共享的属性和方法。
Object.create()：本质就是构造函数和原型链的一个封装，当我们不需要构造函数希望直接继承某个对象的属性和方法时，使用这个方法最便捷。

弄懂原型机制是搞懂 JavaScript 面向对象的关键。

ES6 面向对象

在 ES6 之前，我们用原型链和构造函数来模拟 class 风格的面向对象。但是显而易见，这样的实现方式有很多问题，也必须进行一些折衷，因为没有语法层面的支持，我们要实现面向对象只能这么做。最重要的是，这样的实现是非常不优雅的，逻辑混乱，代码冗长。特别是如果你使用过其他面向对象语言。

为了解决这个问题，ES6 标准正式引入了 class 关键字让我们能够定义类。class 的是 ECMAScript 引入的一个全新语法，目的就是为了拥有和传统面向对象语言相似的使用方式。虽然它看上去和传统的面向对象编程的语法很相似，但是其实在底层，依然是使用的构造函数和原型，class 只是一个语法层面的包装，也就是一个语法糖（当然还是有一些不一样的东西），它的绝大部分功能，用 ES5 完全可以做到，新的 class 写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。

class 基础定义

class 的定义非常简单，和函数类似，可以使用声明也可以使用表达式。

// class declaration
class Person {}

// class expression
const Animal = class {}

其实 class 本质就是一个构造函数，看下面的代码：

class Point {}
console.log(typeof Point) // "function"
console.log(Object.prototype.toString.call(Point)) //[object Function]
console.log(Point === Point.prototype.constructor) // true

但是它又和函数有些不同，普通的函数无论是函数声明还是函数表达式，都会在所在执行环境进行提升 hoist，而类不存在提升行为，必须在声明之后调用。函数声明会在提升时同时用函数体赋值，函数表达式则和普通的变量提升表现一致（只提升不赋值，如果在赋值之前使用该变量，则返回 undefined。关于变量和函数的提升，参考我的另一篇文章 var，let，const和变量提升（hoist）

class 和函数的首先一点不同就是类声明没有提升行为，不能在声明前使用，会报错。当然类表达式的提升和变量一样。另一个不同就是类只能作为构造函数进行 new 调用，直接调用将会报错。

console.log(FunctionExpression) // undefined
var FunctionExpression = function () {}
console.log(FunctionExpression) // function() {}

console.log(FunctionDeclaration) // FunctionDeclaration() {}
function FunctionDeclaration() {}
console.log(FunctionDeclaration) // FunctionDeclaration() {}

console.log(ClassExpression) // undefined
var ClassExpression = class {}
console.log(ClassExpression) // class {}

// console.log(ClassDeclaration); // ReferenceError: ClassDeclaration is not defined
class ClassDeclaration {}
console.log(ClassDeclaration) // class ClassDeclaration {}

ClassDeclaration() //TypeError: Class constructor ClassDeclaration cannot be invoked without 'new'

当然了，普通函数也可以处理成只只能用 new 进行调用：

function Constructor() {
  if (!(this instanceof Constructor)) {
    throw new TypeError('Constructor cannot be invoked without "new"')
  }
}
Constructor() //TypeError: Constructor cannot be invoked without "new"

还有一个不同就是函数声明和类声明在块级作用域中的表现不同，非严格模式下，函数声明在块级作用域中会被同时提升到当前块的顶部和当前执行环境的顶部，在当前执行环境中使用，其值是 undefined，在当前块级作用域中则整个函数声明会被提升到顶部。 class 则遵循块级作用域。具体提升行为参考 var，let，const和变量提升（hoist）

{
  function FunctionDeclaration() {}
  class ClassDeclaration {}
}

console.log(FunctionDeclaration) // FunctionDeclaration() {}
console.log(ClassDeclaration) // ReferenceError: ClassDeclaration is not defined

//函数声明在块级作用域中的奇特行为，类似于函数声明变成了用 `var` 定义的函数表达式
function test() {
  console.log(a) //undefined
  {
    console.log(a) //undefined
    function a() {
      console.log('a')
    }
  }
  console.log(a) //[Function a]
  a() //a
}
test()
console.log(a) //ReferenceError: a is not defined

class 的组成

class 中可以包含构造函数，实例继承的方法，getter 和 setter 以及静态方法。这些组成部分都不是必须的，即使是一个空的 class 声明在语法上也是没有错误的。class 中的所有方法都是在严格模式下执行。和构造函数一样，一般我们将类的首字母大写，用来和实例作区分（比如一个 class Foo{} 可能有一个实例 foo）。

// Valid empty class definition
class Foo {}

// Valid class definition with constructor
class Bar {
  constructor() {}
}

// Valid class definition with getter
class Baz {
  get myBaz() {}
}

// Valid class definition with static method
class Qux {
  static myQux() {}
}

和函数表达是一样，类表达式可以匿名也可以命名，如果命名，该标识符的仅在类的作用域内可访问。

let Person = class PersonName {
  identify() {
    console.log(Person.name, PersonName.name)
  }
}

let p = new Person()

p.identify() // PersonName, PersonName

console.log(Person.name) // PersonName
console.log(PersonName) // ReferenceError: PersonName is not defined

constructor

constructor 关键字在 class 定义块中使用，用来表示 class 的构造函数。当使用 new 进行实例化的时候，就会调用这个 constructor 方法。一个类必须有 constructor 方法，如果没有显式定义，一个空的 constructor 方法会被默认添加。实例化一个 class 和一个普通的构造函数没有区别，只是把构造函数中的语句挪到 class 中的 constructor 方法中而已，new 的过程还是一样。如果你不了解 new 的行为，请看我的另一篇文章 JavaScript中new操作符的解析和实现。

类的 constructor 和普通构造函数不同的是，在实例化之后，它可以作为实例的一个属性访问，我们可以用它来创建新的对象。实际上这是通过类的原型 prototype 进行访问的，因为类的 prototype 上有 constructor 指向类。这与 ES5 的行为是一致的。

class Person {}

// Create a new instance using the class
let p1 = new Person()

p1.constructor()
// TypeError: Class constructor Person cannot be invoked without 'new'

// Create a new instance using the reference to the class constructor
let p2 = new p1.constructor()

constructor 中用 this 定义的实例属性还有另一种写法，就是写到 class 的顶部。

class foo {
  bar = 'hello'
  baz = 'world'
}

let a = new foo()
console.log(a) //foo { bar: 'hello', baz: 'world' }

理解 class 是一个特殊函数

我上面已经说过 class 本质是一个构造函数，那么它自然也有 prototype 属性指向一个对象，该 prototype 对象的 constructor 属性指向 class。

class Person {}

console.log(Person.prototype) // { constructor: f() }
console.log(Person === Person.prototype.constructor) // true

和普通的构造函数一样，我们可以用 instanceof 操作符来检测对象是否是某个 class 的实例。

class Person {}

let p = new Person()

console.log(p instanceof Person) // true

class 内部的 constructor 方法可以被当做实例的一个方法调用，但是如果你用这种方式创建对象，这个对象的构造函数是 class 内部的那个 constructor 方法，而不是 class，class 的 prototype 不会在这个实例的原型链上。也就是如果你使用 class，那么 class 才是构造函数，而不是内部的 constructor 方法（虽然 new 的时候确实是执行的 constructor 方法内的内容），这一点非常重要。

class Person {}

let p1 = new Person()

console.log(p1.constructor === Person) // true
console.log(p1 instanceof Person) // true
console.log(p1 instanceof Person.constructor) // false

let p2 = new Person.constructor()

console.log(p2.constructor === Person) // false
console.log(p2 instanceof Person) // false
console.log(p2 instanceof Person.constructor) // true

class 和对象一样是 JavaScript 中的一等公民，意味着它可以作为对象的属性和函数的参数。

// Classes may be defined anywhere a function would, such as inside an array:
let classList = [
  class {
    constructor(id) {
      this.id_ = id
      console.log('instance ${this.id_}')
    }
  }
]

function createInstance(classDefinition, id) {
  return new classDefinition(id)
}

let foo = createInstance(classList[0], 3141) // instance 3141

和函数表达式一样我们可以对类表达式进行立即调用来生成对象：

let a = new (function (name) {
  this.name = name
})('clloz')
console.log(a) //{ name: 'clloz' }

// Because it is a class expression, the class name is optional
let p = new (class Foo {
  constructor(x) {
    console.log(x)
  }
})('bar') // bar

console.log(p) // Foo {}

类是一个特殊的函数还体现在它也有 name 属性，和函数一样，name 属性返回的是紧跟在 class 后面的标识符的名称。

let a = class B {}
console.log(a.name) //B
new B() //ReferenceError: B is not defined

let fn = function func() {}
console.log(fn.name)
func() //func is no defined

类的 prototype

为了能让实例间共享属性和方法，class 自然也提供了在 prototype 上添加方法和属性的功能。我们可以在 class 中定义方法和 getter，setter 属性访问器，注意，不能定义对象或者原始数据类型。也就是 class 中定义的方法除了 constructor，其他非静态方法都相当于定义在了 prototype 上(实际上 constructor 也能从 prototype 上访问到)，并且所有方法都可以使用 String，Symbol 和计算属性作为方法名。虽然不能直接定义原始数据类型或者对象作为属性，但是我们可以用 getter 和 setter 进行属性设定。

**注意：**和 ES5 不同的是，类内部定义的所有方法，默认都是不可枚举的。

class Person {
    constructor() {
        // Everything added to 'this' will exist on each individual instance
        this.locate = () => console.log('instance');
    }

    // Everything defined in the class body is defined on the class prototype object
    locate() {
        console.log('prototype');
    }
}

let p = new Person();

p.locate(); // instance
Person.prototype.locate(); // prototype

//不能定义原始数据类型和对象
class Person {
    // name: 'Jake', //SyntaxError: Unexpected identifier
    test: {}; //SyntaxError: Unexpected identifier
    test: {};
}

//方法名可以使用 String Symbol 和 计算属性
const symbolKey = Symbol('symbolKey');
class Person {
 stringKey() {
  console.log('invoked stringKey');
 }
 [symbolKey]() {
  console.log('invoked symbolKey');
 }
 ['computed' + 'Key']() {
  console.log('invoked computedKey');
 }
}
let p = new Person();
p.stringKey();   // invoked stringKey
p[symbolKey]();  // invoked symbolKey
p.computedKey(); // invoked computedKey

//访问器属性
class Person {
    set name(newName) {
        this.name_ = newName;
    }
    get name() {
        return this.name_;
    }
}
let p = new Person();
p.name = 'Jake';
console.log(p.name); // Jake

注意，class 中的方法间不能有逗号，否则会报错。

我们也可以在 class 之外为 class 或者 prototype 添加属性，但这是不推荐的，实例的属性应该统一由 this 引用，而 prototype 上的共享方法也统一在 class 中定义时比较好的实践。这是一种反模式，在类外进行变量或者方法的声明很容易被忽略，也不易维护。

class Person {
  sayName() {
    console.log('${Person.greeting} ${this.name}')
  }
}

// Define data member on class
Person.greeting = 'My name is'

// Define data member on prototype
Person.prototype.name = 'Jake'

let p = new Person()
p.sayName() // My name is Jake

类中的方法也可以使用简写，和对象的方法一样，简写的方法不能作为构造函数调用，简写方法没有内部 [[construct]] 方法。当然我们一般不需要对静态方法或者原型上的方法使用 new，所以直接使用简写即可。

class Parent {
  constructor(a, b) {
    this.a = a
    this.b = b
  }
  pFn1 = function () {} //能够作为构造函数
  pFn2() {} //TypeError: p.pFn2 is not a constructor
}

let p = new Parent()
new p.pFn1()
new p.pFn2()

静态方法和访问器属性

静态方法是所有面向对象都提供的一种设施。为什么需要这种设施，是有些方法并不需要创建实例使用，比如我们熟悉的 Math 对象的方法，我们希望能够直接使用，于是就有了静态方法这种机制，它们不属于实例，而是属于类，我们不需要实例化就能直接使用。静态方法与非静态方法的本质区别：静态方法在程序初始化后会一直贮存在内存中，不会被垃圾回收器回收，非静态方法只在该类初始化后贮存在内存中，当该类调用完毕后会被垃圾回收器收集释放。

在 class 中定义静态方法和其他面向对象语言类似，使用 static 关键字，和 prototype 上的方法一样，他们只会创建一次。看看下面的例子可以看到构造函数中的方法，prototype 上的方法和静态方法的区别。

class Person {
  constructor() {
    // Everything added to 'this' will exist on each individual instance
    this.locate = () => console.log('instance', this)
  }

  // Defined on the class prototype object
  locate() {
    console.log('prototype', this)
  }

  // Defined on the class
  static locate() {
    console.log('class', this)
  }
}

let p = new Person()

p.locate() // instance, Person {}
Person.prototype.locate() // prototype, {constructor: … }
Person.locate() // class, class Person {}

静态属性

静态属性指的是 Class 本身的属性，即 Class.propName，而不是定义在实例对象（this）上的属性。使用方法和静态方法一样，就是用 static 关键字。它不需要像实例属性一样写在顶部，可以在类里面的任何位置。

class foo {
  static bar = 'hello'
  baz = 'world'
  test() {
    console.log('haha')
  }
  static m = 'm'
}

let a = new foo()
console.log(a) //foo { bar: 'hello', baz: 'world' }
console.log(foo.bar, foo.m)

私有方法和属性

私有方法和私有属性，是只能在类的内部访问的方法和属性，外部不能访问。这是常见需求，有利于代码的封装，但 ES6 目前还不支持，只能通过变通方法模拟实现。

一种实现方式是用命名区分，在私有方法和属性前面加上下划线，当然这只是一个约定，在类的外部依然可以调用对应的方法和属性。

另一种是将方法移出类外，然后在类内部用 call 或者 apply 进行调用。

class Widget {
  foo(baz) {
    bar.call(this, baz)
  }
}

function bar(baz) {
  return (this.snaf = baz)
}

最后还有一种就是利用 Symbol 的唯一性来做变量名，降低属性或者方法被外部访问的可能，但是要注意 Reflect.ownKeys() 方法或者 Object.getOwnPropertySymbols 方法都可以遍历到 Symbol 属性。

ES2020 的草案已经正式提出了私有属性和方法的支持，使用方式就是在属性或者方法之前加上 #，当然目前支持的只有高版本的 edge，chrome 和 opera 浏览器。所以在得到普遍的支持之前，我们还是要使用不安全的模拟私有属性。

new.target

new.target 属性允许你检测函数或构造方法是否是通过 new 运算符被调用的。在通过 new 运算符被初始化的函数或构造方法中，new.target 返回一个指向构造方法或函数的引用。在普通的函数调用中，new.target 的值是 undefined。

new.target 语法由一个关键字 new，一个点，和一个属性名 target 组成。通常 new. 的作用是提供属性访问的上下文，但这里 new. 其实不是一个真正的对象。不过在构造方法调用中，new.target 指向被 new 调用的构造函数，所以 new. 成为了一个虚拟上下文。

在 arrow functions 中，new.target 指向最近的外层函数的 new.target，箭头函数没有自己的 new.target。

new.target 可以用在任何函数中，函数不是通过 new 或者 Reflect.construct() 调用的则返回 undefined。如果是通过 new 调用的则返回该函数，注意函数表达式的如果不是匿名函数则返回的函数名称是函数表达式定义的函数名。

function Target() {
  console.log(new.target)
}
Target() //undefined
new Target() //[Function: Target]

//函数表达式
let Target = function targetName() {
  console.log(new.target)
}
Target() //undefined
new Target() //[Function: targetName]

在类的 constructor 中使用则返回该类（类只能通过 new 调用），子类继承父类的时候，super() 会执行父类的 constructor，如果内部有 new.target 返回的是子类而不是父类。如果是在类的其他函数中使用（如果不是通过 new 调用的话，一般不是）则和普通函数一样返回 undefined。

class Rectangle {
  constructor() {
    console.log(new.target === Rectangle)
  }
}
class Square extends Rectangle {}
var obj = new Square() // 输出 false

我们可以利用 new.target 让类必须继承后才能创建实例。

class Shape {
  constructor() {
    if (new.target === Shape) {
      throw new Error('本类不能实例化')
    }
  }
}

class Rectangle extends Shape {
  constructor(length, width) {
    super()
  }
}

var x = new Shape() // Error: 本类不能实例化
var y = new Rectangle(3, 4) // 正确

ES6 继承

上面我们介绍了 ES5 的继承，基本都是需要些很长的原型和构造函数逻辑，并不是很方便。在 ES6 有了 class 之后，也原生提供了继承的语法，当然这个继承与法的背后还是原型继承。

ES6 的继承是使用 extends 关键词，我们可以用 extends 关键词继承任何有 [[constructor]]（这是一个内部属性，表示可以作为一个构造函数）属性和 prototype 的对象，这种形式保证了向后兼容，让 ES5 的构造函数也能使用这种语法继承。

class Vehicle {}

// Inherit from class
class Bus extends Vehicle {}

let b = new Bus()
console.log(b instanceof Bus) // true
console.log(b instanceof Vehicle) // true

function Person() {}

// Inherit from function constructor
class Engineer extends Person {}

let e = new Engineer()
console.log(e instanceof Engineer) // true
console.log(e instanceof Person) // true

派生类可以继承父类的所有方法，包括类本身的静态方法和 prototype 上的方法。

class Vehicle {
  identifyPrototype(id) {
    console.log(id, this)
  }

  static identifyClass(id) {
    console.log(id, this)
  }
}

class Bus extends Vehicle {}

let v = new Vehicle()
let b = new Bus()

b.identifyPrototype('bus') // bus, Bus {}
v.identifyPrototype('vehicle') // vehicle, Vehicle {}

Bus.identifyClass('bus') // bus, class Bus {}
Vehicle.identifyClass('vehicle') // vehicle, class Vehicle {}

extends 也可以用在类表达式中，let Bar = class extends Foo {} 是一个合法的语句。

其实我们仔细分析一下 ES6 的继承，和寄生组合式继承只有一些细节不同，只是对寄生组合式继承的一种包装，把原来我们要写的逻辑帮我们封装好了而已。

class Parent {
  constructor(a, b) {
    this.a = a
    this.b = b
  }
  pFn() {}
}
class Child extends Parent {
  constructor(a, b) {
    super(a, b)
  }
  cFn() {}
}

let c = new Child(1, 2)
console.log(c) //Child { a: 1, b: 2 }
console.log(Reflect.ownKeys(c.__proto__)) //[ 'constructor', 'cFn' ]
console.log(Reflect.ownKeys(c.__proto__.__proto__)) //[ 'constructor', 'pFn' ]

我们可以看到，子类的构造函数中调用 super() 就有点借用构造函数的感觉，只不过这里细节有所不同。在 ES5 中我们是直接在调用子类构造函数的时候创建一个新的对象作为 this，而 ES6 中是在 super() 中创建 this，然后用这个 this 执行 super()，所以我们在子类中只有执行完了 super() 才有 this。

prototype 的机制和 ES5 的原型式继承没什么不同，看下面的代码：

class Parent {
  constructor(a, b) {
    this.a = a
    this.b = b
  }
  pFn() {}
}
class Child extends Parent {
  constructor(a, b) {
    super(a, b)
  }
  cFn() {}
}

let c = new Child(1, 2)
console.log(c) //Child { a: 1, b: 2 }
console.log(Reflect.ownKeys(c.__proto__)) //[ 'constructor', 'cFn' ]
console.log(Reflect.ownKeys(c.__proto__.__proto__)) //[ 'constructor', 'pFn' ]

我们可以看到子类实例的 [[prototype]] 有 constructor 和 cFn 两个属性，也就是 Child.prototype。而我们看到原型的原型，有两个属性 constructor 和 pFn，也就是 Parent.prototype，这就跟我们上面原型式继承 Object.create(Parent.prototype) 效果相同。所以我们通过访问子类实例的原型的原型是可以修改父类实例的原型的。

上面的例子是说的 class 的实例的原型链，其实 class 本身的 [[prototype]] 也和 ES5 中的构造函数有些不同。在 ES5 中，每个函数都是 Function 的实例，所以自然其 [[prototype]] 指向的是 Function.prototype。在 ES6 中，如果 class 没有继承其他类，那么他的 [[prototype]] 也是指向 Function.prototype，但是如果 class 是一个子类，那么它的 [[prototype]] 指向的是其父类。

class Parent {
  constructor(a, b) {
    this.a = a
    this.b = b
  }
  pFn() {}
}
console.log(Parent.__proto__ === Function.prototype) //true
console.log(Parent.prototype) //{constructor: ƒ, pFn: ƒ}

class Child extends Parent {
  constructor(a, b) {
    super(a, b)
  }
  cFn() {}
}
console.log(Child.__proto__) //class Parent {}
console.log(Child.prototype) //Parent {constructor: ƒ, cFn: ƒ}

结合类和实例的继承关系，我们可以将 class 的继承进行如下理解：

class A {}

class B {}

// B 的实例继承 A 的实例
Object.setPrototypeOf(B.prototype, A.prototype)

// B 继承 A 的静态属性
Object.setPrototypeOf(B, A)

const b = new B()

所以被继承的基类不一定是一个类，只要是一个有 prototype 的函数就可以被继承，由于函数都有 prototype 属性（除了 Function.prototype函数），因此任意函数都可以作为基类被继承。

super

想要在派生类中访问父类，ES6 提供了 super 关键字。super 关键字有多种不同的用法，还是比较复杂的，总结一下如下：

只有派生类中能使用 super（即使用了 extends 的类或者设置了 [[prototype]] 的对象的方法中）。
当 super 作为方法调用时，只能是在派生类的构造函数中。
在派生类的构造函数中，如果没有定义 constructor 方法，会有一个默认的 constructor 方法被创建，内部会执行 super()。
派生类的构造函数中的 super() 会创建子类构造函数的 this，然后用这个 this 执行 super()。所以在执行 super() 之前派生类的构造函数中没有 this，所有用到 this 的语句都要写在 super() 之后。
派生类如果显示的定义了一个 constructor 则必须在其中调用 super 或者返回一个对象。
super 还可以作为对象，在普通的方法中（包括 constructor），这个对象指向父类的 prototype，在静态方法中指向父类。注意，父类 constructor 中定义的实例的属性和方法是无法访问的，只能访问在 constructor 之外定义的静态方法或者 prototype 上的方法和访问器属性。
在派生类的普通方法中使用 super 对象中的方法时，其中的 this 指向子类实例。
在派生类的静态方法中使用 super 对象中的方法时，方法内部的 this 指向当前的派生类而不是父类。
在派生类的普通方法或静态方法中使用 super 时，必须调用 super 的某个属性或者方法，不能直接使用 super。
你不能使用 delete 操作符加 super.prop 或者 super[expr] 去删除父类的属性，这样做会抛出 ReferenceError。
super 作为对象使用时我们只能对其进行读操作，当对 super 进行写操作时，所有的操作都发生在 this 上。

class A {
  fn() {
    console.log('A')
  }
}
A.prototype.x = 10

class B extends A {
  constructor() {
    super()
    //super 在赋值的时候相当于 this，在读取的时候则是指向父类的 prototype
    this.x = 2
    console.log(this.x)
    console.log(super.x)
    super.x = 3
    console.log(this.x)
    console.log(super.x)

    //父类 prototype 上的方法和属性的行为一样，读操作时指向是父类的 prototype，写操作则是写在 this 上
    this.fn() //A
    super.fn() //A
    console.log(this.hasOwnProperty('fn')) //false
    super.fn = function () {
      console.log('B')
    }
    this.fn() //B
    super.fn() //A
    console.log(this.hasOwnProperty('fn')) //true
  }
}

let b = new B()

super 的规则非常复杂，网络上的相关内容也不多，这里的主要规则来源于《JavaScript 高级程序设计第四版》和《ES6 标准入门》。当然你也可以看标准，看起来比较吃力，而且我没有找到 static 相关的规定。不过记住这些总结的规则基本上就没有问题了。

原生构造函数的继承

在 ES5 中我们无法继承原生构造函数，因为原生构造函数无法像普通函数一样用借用构造函数的方法传入 this 执行，原生构造函数会忽略 apply 或者 call 设置的 this。比如下面的 ES5 尝试继承 Array 的代码，它的表现和数组并不相同。

function MyArray() {
  Array.apply(this, arguments)
}

MyArray.prototype = Object.create(Array.prototype, {
  constructor: {
    value: MyArray,
    writable: true,
    configurable: true,
    enumerable: true
  }
})

var colors = new MyArray()
colors[0] = 'red'
colors.length // 0

colors.length = 0
colors[0] // "red"

ES5 是先新建子类的实例对象 this，再将父类的属性添加到子类上，由于父类的内部属性无法获取，导致无法继承原生的构造函数。比如，Array 构造函数有一个内部属性 [[DefineOwnProperty]]，用来定义新属性时，更新 length 属性，这个内部属性无法在子类获取，导致子类的 length 属性行为不正常。

ES6 的 class 让我们能够实现对原生构造函数的继承，主要原因就是 class 的 super() 让子类能够用自己的的 this 执行构造函数，也支持原生构造函数。

class MyArray extends Array {
  constructor(...args) {
    super(...args)
  }
}

var arr = new MyArray()
arr[0] = 12
arr.length // 1

arr.length = 0
arr[0] // undefined

有了这个功能之后，JavaScript 变得更灵活，我们可以在原生数据结构的基础上定义自己的数据结构。比如下面实现了一个带版本功能的数组：

class VersionedArray extends Array {
  constructor() {
    super()
    this.history = [[]]
  }
  commit() {
    this.history.push(this.slice())
  }
  revert() {
    this.splice(0, this.length, ...this.history[this.history.length - 1])
  }
}

var x = new VersionedArray()

x.push(1)
x.push(2)
x // [1, 2]
x.history // [[]]

x.commit()
x.history // [[], [1, 2]]

x.push(3)
x // [1, 2, 3]
x.history // [[], [1, 2]]

x.revert()
x // [1, 2]

再来看一自定义 Error 的例子：

class ExtendableError extends Error {
  constructor(message) {
    super()
    this.message = message
    this.stack = new Error().stack
    this.name = this.constructor.name
  }
}

class MyError extends ExtendableError {
  constructor(m) {
    super(m)
  }
}

var myerror = new MyError('ll')
console.log(myerror.message) // "ll"
console.log(myerror instanceof Error) // true
console.log(myerror.name) // "MyError"
console.log(myerror.stack)
// Error
//     at MyError.ExtendableError
//     ...

需要注意的是 Object 构造函数和其他内置构造函数的行为不同：

class NewObj extends Object {
  constructor() {
    super(...arguments)
  }
}
var o = new NewObj({ attr: true })
o.attr === true // false

上面代码中，NewObj 继承了 Object，但是无法通过 super 方法向父类 Object 传参。这是因为 ES6 改变了 Object 构造函数的行为，一旦发现 Object 方法不是通过 new Object() 这种形式调用，ES6 规定 Object 构造函数会忽略参数。

有些内置类型的构造函数（比如 Array）的方法会返回一个新的实例（比如 Array 的 map 和 filter 等方法），如果我们用的是 Array 的派生类创建的实例再调用 map 等方法返回的新实例其原型是派生类而不是 Array。

class SuperArray extends Array {}

let a1 = new SuperArray(1, 2, 3, 4, 5)
let a2 = a1.filter((x) => !!(x % 2))

console.log(a1) // [1, 2, 3, 4, 5]
console.log(a2) // [1, 3, 5]
console.log(a1 instanceof SuperArray) // true
console.log(a2 instanceof SuperArray) // true

如果你不希望方法调用返回的对象是派生类的实例，希望是 Array 的实例，你需要重写内置的 Symbol.species 访问器，这个内置 Symbol 就是用来确定返回实例的构造函数的。

class SuperArray extends Array {
  get [Symbol.species]() {
    return Array
  }
}

let a1 = new SuperArray(1, 2, 3, 4, 5)
let a2 = a1.filter((x) => !!(x % 2))

console.log(a1) // [1, 2, 3, 4, 5]
console.log(a2) // [1, 3, 5]
console.log(a1 instanceof SuperArray) // true
console.log(a2 instanceof SuperArray) // false

总结

本文主要是讲了 ES5 和 ES6 的对象和继承，以及其中的一些细节，面向对象的学习需要在实践中不断的探索和练习。

参考文章

《ES6 标准入门》 —— 阮一峰
《JavaScript 高级程序司机 4th Edition》

深入扩展运算符

Thu, 05 Nov 2020 12:00:00 GMT

前言

扩展运算符 (spread syntax) 是 ES6 提供的一种非常便捷的新语法，给我们操作数组和对象带来了非常大的便利，我在很多文章中也提到了这个语法。但是其实扩展运算符的用法还是比较多比较杂的，我用一篇文章来做一下总结，梳理一下扩展运算的语法和使用细节。

基础用法

扩展运算符 spread syntax 又叫展开语法，写法是 ...，顾名思义，其实是用来展开字符串，数组和对象的一种语法，可以在函数调用/数组构造时, 将数组表达式或者 string 在语法层面展开；还可以在构造字面量对象时, 将对象表达式按 key-value 的方式展开。常用的语法如下：

//函数调用：
myFunction(...iterableObj)

//字面量数组构造或字符串：
;[...iterableObj, '4', ...'hello', 6]

// 构造字面量对象时,进行克隆或者属性拷贝（ECMAScript 2018规范新增特性）：
let objClone = { ...obj }

在函数调用时使用扩展运算符相当于使用 Function.prototype.apply：

function myFunction(x, y, z) {}
var args = [0, 1, 2]
myFunction(...args)

//相当于
function myFunction(x, y, z) {}
var args = [0, 1, 2]
myFunction.apply(null, args)

和 apply 不同的是，我们不仅可以将全部参数放到一个数组中，还可以只将其中几个参数用扩展运算符展开，并且可以再一次调用中多次使用扩展运算符。

function myFunction(a, b, c, d, e) {
  console.log(a, b, c, d, e) //-1 0 1 2 3
  console.log(arguments) //[Arguments] { '0': -1, '1': 0, '2': 1, '3': 2, '4': 3 }
}
var args = [0, 1]
myFunction(-1, ...args, 2, ...[3])

使用 new 关键字来调用构造函数时，不能直接使用数组加上 apply 的方式（apply 执行的是调用 [[Call]] , 而不是构造 [[Construct]]）。有了展开语法, 将数组展开为构造函数的参数就很简单了：

var dateFields = [1970, 0, 1] // 1970年1月1日
var d = new Date(...dateFields)

如果想要不使用扩展运算符实现同样的效果，我们必须用一个函数包装构造函数，将这个新的构造函数的 prototype 设为原构造函数的实例，用 Object.create(constructor.prototype)（这里主要是为了新构造函数原型的修改不影响原构造函数的原型，直接用 constructor.prototype 作为新构造函数的原型也可以实现）。

function applyAndNew(constructor, args) {
  function partial() {
    return constructor.apply(this, args)
  }
  if (typeof constructor.prototype === 'object') {
    partial.prototype = Object.create(constructor.prototype)
  }
  return partial
}

function myConstructor() {
  console.log('arguments.length: ' + arguments.length)
  console.log(arguments)
  this.prop1 = 'val1'
  this.prop2 = 'val2'
}

var myArguments = ['hi', 'how', 'are', 'you', 'mr', null]
var myConstructorWithArguments = applyAndNew(myConstructor, myArguments)

console.log(new myConstructorWithArguments())
// (myConstructor构造函数中):           arguments.length: 6
// (myConstructor构造函数中):           ["hi", "how", "are", "you", "mr", null]
// ("new myConstructorWithArguments"中): {prop1: "val1", prop2: "val2"}

当然用的最多的还是在字面量数组上，没有展开语法的时候，只能组合使用 push, splice, concat 等方法，来将已有数组元素变成新数组的一部分。有了展开语法, 通过字面量方式, 构造新数组会变得更简单、更优雅：

var parts = ['shoulders', 'knees']
var lyrics = ['head', ...parts, 'and', 'toes']
// ["head", "shoulders", "knees", "and", "toes"]

可以用来实现数组浅拷贝：

var arr = [1, 2, 3]
var arr2 = [...arr] // like arr.slice()
arr2.push(4)

// arr2 此时变成 [1, 2, 3, 4]
// arr 不受影响

连接多个数组：

var arr1 = [0, 1, 2]
var arr2 = [3, 4, 5]
var arr3 = [...arr1, ...arr2]

扩展运算符还可以将已有对象的所有可枚举(enumerable)属性拷贝到新构造的对象中。该方法为浅拷贝，可以拷贝 Symbol 属性，但不包含原型上的属性和方法。如果同时拷贝多个对象，后面的对象会覆盖前面对象的同名属性。

var obj1 = { foo: 'bar', x: 42, [Symbol('a')]: 123 }
var obj2 = { foo: 'baz', x: 100, y: 13 }

var clonedObj = { ...obj1 }
console.log(clonedObj) //{ foo: 'bar', x: 42, [Symbol(a)]: 123 }

var mergedObj = { ...obj1, ...obj2 }
console.log(mergedObj) //{ foo: 'baz', x: 100, y: 13, [Symbol(a)]: 123 }

该方法的性质和 Object.assign 类似，但是 Object.assign() 函数会触发 setters，而展开语法则不会。

扩展运算符用于展开对象的时候可以发生覆盖，后面展开的或声明的属性会覆盖前面的。

const test = {
    name: 'clloz',
    age: 29
}
{...test, age: 30} // {name: "clloz", age: 30}

注意事项

在数组或函数参数中使用展开语法时, 扩展运算符只能用于可迭代对象。
只有函数调用时，扩展运算符才可以放在圆括号中，否则会报错。
只能用在函数调用，字面量数组（可以在数组中展开字符串），字面量对象中。
用于数组的解构赋值的时候，扩展运算符只能处于最后一个。
展开对象可以是任意可迭代对象。

剩余参数

剩余参数语法允许我们将一个不定数量的参数表示为一个数组。如果函数的最后一个命名参数以 ... 为前缀，则它将成为一个由剩余参数组成的真数组，其中从 0（包括）到 theArgs.length（排除）的元素由传递给函数的实际参数提供。

剩余语法(Rest syntax) 看起来和展开语法完全相同，不同点在于, 剩余参数用于解构数组和对象。从某种意义上说，剩余语法与展开语法是相反的：展开语法将数组展开为其中的各个元素，而剩余语法则是将多个元素收集起来并“凝聚”为单个元素。扩展运算符是用在函数调用，而剩余参数是用在函数声明。

剩余参数和 arguments 对象之间的区别主要有三个：

剩余参数只包含那些没有对应形参的实参，而 arguments 对象包含了传给函数的所有实参。
arguments 对象不是一个真正的数组，而剩余参数是真正的 Array 实例，也就是说你能够在它上面直接使用所有的数组方法，比如 sort，map，forEach 或 pop。
arguments 对象还有一些附加的属性（如 callee 属性）。

如果剩余参数（包括在解构赋值中）右侧有逗号，会抛出 SyntaxError，因为剩余元素必须是函数的最后一个参数或者数组的最后一个元素。

深入 aync/await

Mon, 02 Nov 2020 12:00:00 GMT

前言

ES 2017 引入了 async 函数，它使得异步操作更加便捷。async 是生成器函数的语法糖，我们可以理解成一个结合了 Promise 和 Generator 的自动执行的生成器。它让我们可以用一种更简洁的方式写出基于 Promise 的异步行为，而无需刻意地链式调用 promise。

语法

回忆一下 co 自动执行生成器函数的方式（生成器 Generator 的异步应用）：

var gen = function* () {
  var f1 = yield readFile('/etc/fstab')
  var f2 = yield readFile('/etc/shells')
  console.log(f1.toString())
  console.log(f2.toString())
}
co(gen)

async 函数的使用方法类似：

var asyncReadFile = async function () {
  var f1 = await readFile('/etc/fstab')
  var f2 = await readFile('/etc/shells')
  console.log(f1.toString())
  console.log(f2.toString())
}
asyncReadFile()

可以看出 async 函数其实就是把 * 和 yield 换成了 async 和 await。async 对 Generator 函数的改进有以下几点：

内置执行器：Generator 函数的执行必须依赖执行器（比如 co），否则需要手动调用 next 才能执行。async 函数则像一个普通函数一样执行即可。
更好的语义：async 和 await 比 * 和 yield 语义更清楚。
适用性更广：我们编写 Generator 的自动执行器需要将 yield 后的值包装成一个 Thunk 函数或者 Promise，co 模块就是包装成 Promise。async 则支持 Promise 和原始数据类型，不需要我们手动转换，开箱即用。
和 co 模块一样，async 函数的返回值是一个 Promise，我们可以用 then 指定下一步操作。

async 函数完全可以看作多个异步操作，包装成的一个 Promise 对象，而 await 命令就是内部 then 命令的语法糖。

async 函数是 AsyncFunction 构造函数的实例，我们无法直接访问 AsyncFunction，因为它不是一个全局对象，但是我们可以通过 Object.getPrototypeOf(async function(){}).constructor 得到它，并且可以用它来构造 async 函数 new AsyncFunction([arg1[, arg2[, ...argN]],] functionBody)。

async 有很多使用形式，既可以用作函数声明，也可以用作函数表达式，还可以作为对象的方法。

// 函数声明
async function foo() {}

// 函数表达式
const foo = async function () {}

// 对象的方法
let obj = { async foo() {} }
obj.foo().then((val) => val)

// Class 的方法
class Storage {
  constructor() {
    this.cachePromise = caches.open('avatars')
  }
  async getAvatar(name) {
    const cache = await this.cachePromise
    return cache.match(`/avatars/${name}.jpg`)
  }
}
storage.getAvatar('jake').then((val) => val)

// 箭头函数
const foo = async () => {}

async 函数返回一个 Promise 对象（如果一个 async 函数的返回值看起来不是 promise，那么它将会被隐式地包装在一个 promise 中)，可以使用 then 方法添加回调函数。当函数执行的时候，一旦遇到 await 就会先返回，等到异步操作完成，再接着执行函数体内后面的语句。async 函数返回一个 Promise 对象。async 函数内部 return 语句返回的值，会成为 then 方法回调函数的参数。

await 操作符用于等待一个 Promise 对象。它只能在异步函数 async function 中使用。await 表达式会暂停当前 async function 的执行，等待 Promise 处理完成。若 Promise 正常处理(fulfilled)，其回调的 resolve 函数参数作为 await 表达式的值，继续执行 async function。若 Promise 处理异常(rejected)，await 表达式会把 Promise 的异常原因抛出。另外，如果 await 操作符后的表达式的值不是一个 Promise，await 会把该值转换为已 resolve 的 Promise，然后等待其处理结果。

使用 async / await 关键字就可以在异步代码中使用普通的 try / catch 代码块。因为同步或者异步代码出错都会将 Promise 进行 reject 返回。

async/await 的目的为了简化使用基于 promise 的 API 时所需的语法。async/await 的行为就好像搭配使用了生成器和 promise。

async 函数的函数体可以被看作是由 0 个或者多个 await 表达式分割开来的。从第一行代码直到（并包括）第一个 await 表达式（如果有的话）都是同步运行的。这样的话，一个不含 await 表达式的 async 函数是会同步运行的。然而，如果函数体内有一个 await 表达式，async 函数就一定会异步执行。

async function k() {
  console.log(123)
  let m = await 3
  return m
}

k().then((val) => console.log(val))

console.log('end')
// 123
// end
// 3

async 函数内部抛出错误，会导致返回的 Promise 对象变为 reject 状态。抛出的错误对象会被 catch 方法回调函数接收到。

async function f() {
  throw new Error('出错了')
}
f().then(
  (v) => console.log(v),
  (e) => console.log(e)
)
// Error: 出错了

async 函数返回的 Promise 对象，必须等到内部所有 await 命令后面的 Promise 对象执行完，才会发生状态改变，除非遇到 return 语句或者抛出错误。也就是说，只有 async 函数内部的异步操作执行完，才会执行 then 方法指定的回调函数。

async function getTitle(url) {
  let response = await fetch(url)
  let html = await response.text()
  return html.match(/<title>([\s\S]+)<\/title>/i)[1]
}
getTitle('https://tc39.github.io/ecma262/').then(console.log)
// "ECMAScript 2017 Language Specification"

上面代码中，函数 getTitle 内部有三个操作:抓取网页、取出文本、匹配页面标题。只有这三个操作全部完成，才会执行 then 方法里面的 console.log。

await 命令后面是一个 Promise 对象。如果不是，会被转成一个立即 resolve 的 Promise 对象。

async function f() {
  return await 123
}
f().then((v) => console.log(v)) // 123

await 命令后面的 Promise 对象如果变为 reject 状态，则 reject 的参数会被外部的 catch 方法的回调函数接收到。reject 的 Promise 不需要 return，catch 也能接收到 reject 的参数，在 await 前加上 return 效果一样。

async function f() {
  await Promise.reject('出错了')
}
f()
  .then((v) => console.log(v))
  .catch((e) => console.log(e)) // 出错了

只要一个 await 语句后面的 Promise 变为 reject ，那么整个 async 函数都会中断执行。

async function f() {
  await Promise.reject('出错了')
  await Promise.resolve('hello world') // 不会执行
}

如果我们希望一个 await 即使 reject 了也不要中断执行，那么我们有两种解决办法，一种是将这个 await 包裹早一个 try ... catch 中。另一种方法是将 await 后面的 Promise 用一个链式的 catch 捕捉 reject。

async function f() {
  try {
    await Promise.reject('出错了')
  } catch (e) {}
  return await Promise.resolve('hello world')
}
f().then((v) => console.log(v)) // hello world

async function f() {
  await Promise.reject('出错了').catch((e) => console.log(e))
  return await Promise.resolve('hello world')
}
f().then((v) => console.log(v)) // 出错了
// hello world

如果 await 后面的异步操作抛错，那么等同于 async 函数返回的 Promise 对象被 reject。要防止 async 因为抛错而中断执行，解决方法依然和上面一样用 try ... catch 包裹，或者对 await 后面的 Promise 加上 catch。

async function f() {
  await new Promise(function (resolve, reject) {
    throw new Error('出错了')
  })
}
f()
  .then((v) => console.log(v))
  .catch((e) => console.log(e)) // Error:出错了

还有一个注意要点就是 await 只能在 async 函数中使用，这里要注意嵌套关系。比如下面这种情况：

async function dbFuc(db) {
    let docs = [{}, {}, {}];
    // 报错
    docs.forEach(function (doc) {
        await db.post(doc);
    });
}

await 实际上是写在 forEach 的回调函数中，虽然外层的函数是 async，但是 forEach 的回调函数并不是 async 函数。同时我们还要注意，上面的这种 forEach 写法最后所有的任务是并发执行的，而不是继发。因为 forEach 的每个回调函数都是立即执行的，是同步的，如果我们想要实现继发的效果，需要使用 for 循环。

async function dbFuc(db) {
  let docs = [{}, {}, {}]
  for (let doc of docs) {
    await db.post(doc)
  }
}

想要实现并发，还是像上面一样同步执行异步任务，await 异步任务返回的 Promise 或者直接使用 Promise.all。

async/await 原理

我们已经可以很明显的看出，async 是结合了 Promise 和生成器的一个语法糖，它的目的就是为了优化 Promise 的使用方法。async 函数的实现原理，就是将 Generator 函数和自动执行器，包装在一个函数里。

async function fn(args) {
  // ...
}
// 等同于
function fn(args) {
  return spawn(function* () {
    // ...
  })
}

function spawn(genF) {
  return new Promise(function (resolve, reject) {
    var gen = genF()
    function step(nextF) {
      try {
        var next = nextF()
      } catch (e) {
        return reject(e)
      }
      if (next.done) {
        return resolve(next.value)
      }
      Promise.resolve(next.value).then(
        function (v) {
          step(function () {
            return gen.next(v)
          })
        },
        function (e) {
          step(function () {
            return gen.throw(e)
          })
        }
      )
    }
    step(function () {
      return gen.next(undefined)
    })
  })
}

这个 spawn 就是一个自动执行器，它是对 co 的一个简化，关于 co 的源码分析可以看生成器 Generator 的异步应用。所有的 async 函数都可以写成上面的第二种形式，其中的 spawn 函数就是自动执行器。

继发和并发问题

我在上文已经说了一些继发和并发的例子和处理方式，这里在详细说一下这个比较重要的问题。

由于 await 是有先后执行顺序的，也就是继发的。但我们的业务逻辑并不会是简单的继发或者并发，很可能是比较混杂的，我们需要自己分析好依赖关系然后再用 async 函数处理。比如如下的例子：

;(async () => {
  const listData = await getList()
  const anotherListData = await getAnotherList()

  // do something

  await submit(listData)
  await submit(anotherListData)
})()

getList 和 getAnotherList 是没有依赖关系的，但是 submit 需要依赖两者返回的数据，这种情况我们需要像如下处理：

async function handleList() {
  const listPromise = await getList()
  // ...
  await submit(listData)
}

async function handleAnotherList() {
  const anotherListPromise = await getAnotherList()
  // ...
  await submit(anotherListData)
}

// 方法一
;(async () => {
  const handleListPromise = handleList()
  const handleAnotherListPromise = handleAnotherList()
  await handleListPromise
  await handleAnotherListPromise
})()(
  // 方法二
  async () => {
    Promise.all([handleList(), handleAnotherList()]).then()
  }
)()

也就是分析清除依赖关系，把不相关的逻辑分开，并发执行。只有互相依赖的异步任务采用 await 进行继发执行。

一把来说，实现继发我们就依次写 await 就行了。并发则是直接执行或者用 Promise.all。比如给定一个 url 数组如何实现继发和并发的请求。

// 继发一
async function loadData() {
  var res1 = await fetch(url1)
  var res2 = await fetch(url2)
  var res3 = await fetch(url3)
  return 'whew all done'
}

// 继发二
async function loadData(urls) {
  for (const url of urls) {
    const response = await fetch(url)
    console.log(await response.text())
  }
}

// 并发一
async function loadData() {
  var res = await Promise.all([fetch(url1), fetch(url2), fetch(url3)])
  return 'whew all done'
}
// 并发二
async function loadData(urls) {
  // 并发读取 url
  const promises = urls.map((url) => {
    return fetch(url)
  })

  // 按次序输出
  for (const promise of promises) {
    console.log(await promise)
  }
}

异步遍历器

未完待续...

参考文章

我们来聊聊 async
《ES6 标准入门》—— 阮一峰
MDN

JavaScript 各异步方式比较

Mon, 02 Nov 2020 12:00:00 GMT

前言

学习完了 Promise，Generator 和 async 之后，用法基本都掌握了，也都理解了他们是如何实现的，但是对于为什么要有它们，在什么时候使用等问题似乎还是云里雾里，本文写一写我对几个异步处理方法的理解。

如果你对 ES6 的异步解决方案还不熟悉，请看之前的几篇文章：

异步处理的方式

在 JS 中异步是非常重要的概念，因为 JS 的执行时单线程的，所以有些需要等待的任务必须要异步。比如我们请求一个文件，如果是同步的情况下，我们在等待请求这段时间线程是卡死的，我们什么也不能做，并且我们不确定什么时候请求成功。这就必须要异步，异步就是将执行分为两个阶段，第一个阶段同步执行，然后等第一个阶段的代码出结果了，在执行第二个阶段。在等待的这段时间，我们可以先处理其他任务。

回调函数

最早的异步处理方式自然是回调函数，我们将一个函数作为参数，当某个事件触发了，再执行这个函数。这是最简单的异步方式。包括浏览器的时间，定时器，AJAX 请求都是这个思路。

回调函数有很多问题，比较有名的就是回调地狱。当多个异步任务存在依赖关系的时候，我们只能等一个异步任务完成了，然后在回调函数中发起下一个异步任务。如果嵌套的任务非常多的话就会变成如下情况：

ajax('XXX1', () => {
  // callback 函数体
  ajax('XXX2', () => {
    // callback 函数体
    ajax('XXX3', () => {
      // callback 函数体
    })
  })
})

由于我们写代码的缩进关系，代码变成了横向发展，而不是纵向发展。最关键的是，这段代码可读性很差，非常难以维护，耦合度非常高，一旦这段逻辑要进行修改，就会牵一发而动全身。

但是在我看来回调函数还有一些其他问题，就是我们必须在回调函数内处理逻辑。使用回调函数的异步任务没有返回值，异步任务的处理结果是作为回调函数的参数传入的，而回调函数也是异步任务的一个参数。我们想要到外部处理异步任务的结果，只能在外部申请变量，然后将异步任务的结果赋值给变量。换言之，我们是“配合”回调函数来写自己的业务逻辑。

并且使用回调函数的异步任务，无法使用 try ... catch 来进行错误处理，回调函数不会将错误向外层抛出，我们只能将错误处理写到回调函数中。

// try catch 无法捕获到内部的错误
try {
  setTimeout(() => {
    console.log(aa)
  }, 1000)
} catch (error) {
  console.log(error)
}

Promise

Promise 是 ES6 引入的一个新的内置对象，它本质是对回调函数的一个封装。Promise 的每一个方法返回的都还是一个 Promise 对象，所以它能实现链式调用，这样就解决了回调地狱的问题。

对于错误处理，Promise 中测错误必须要用 .catch 来捕获，它也不会抛到外层。

我认为 Promise 还有一点对回调函数的优化就是它将异步任务的状态和结果保存在了 Promise 对象中，我们不再像回调函数一样，异步任务已完成就要执行对应的逻辑。只要有 Promise 对象，我们随时都可以用 .then，.catch 来执行后面的逻辑。

Promise 也有自己的缺点，我们无法中断一个 Promise 的执行，一个 Promise 一旦开就无法取消。换言之我们无法介入一个已经开始执行的 Promise 进行交互。还有一个问题就是上面说道的错误处理，和回调函数一样，Promise 也不能通过外层的 try ... catch 捕获错误，必须用 .catch 来捕获内部的 reject（抛错在 Promise 中和 reject 是一样的）。

还有一个小问题就是 Promise 的语义并不是很明确，我们的代码逻辑被隐藏在了 Promise 的 API 之后，并不是很容易阅读。

Generator

Generator 函数是 ES6 对协程的实现，但属于不完全实现。Generator 函数被称为“半协程”(semi-coroutine)，意思是只有 Generator 函数的调用者，才能将程序的执行权还给 Generator 函数。如果是完全执行的协程，任何函数都可以让暂停的协程继续执行。

如果将 Generator 函数当作协程，完全可以将多个需要互相协作的任务写成 Generator 函数，它们之间使用 yield 表示式交换控制权。协程的过程可以模拟如下：

第一步，协程 A 开始执行。
第二步，协程 A 执行到一半，进入暂停，执行权转移到协程 B 。
第三步，(一段时间后)协程 B 交还执行权。
第四步，协程 A 恢复执行。

在有生成器之前，我们处理异步主要依靠的就是回调函数和 Promise。不同的环境提供了不同的异步功能，比如 node 的文件操作，浏览器的 DOM 事件，以及网络请求等，都提供了异步的支持。我们在执行代码的时候声明一个 callback，引擎会在事件完成的时候调用我们的回调函数。

当然也有不依赖系统 API 的异步方式，比如发布订阅模式，我们将我们要执行代码交给一个事件管理中心（可能是存在一个数组中），这个过程称为订阅。当我们想要执行某段回电函数的时候就通知事件管理中心，让它执行对应的函数，这叫做发布。实际上 Promise 的实现也用到了这个模式。

生成器可以说完全是一种全新的机制，它让我们能够让一个函数分段执行，并且函数内外能够在暂停和恢复的时候进行数据交换。内部的错误可以被外部捕获，也提供了从外部向内部跑错的 throw 方法。

虽然 Generator 不是只能用来进行异步处理，但是它在异步处理上是进行了革新的，提供了一种全新的形式，也就是协程的概念，我们可以堆函数的执行流程进行控制。

生成器的缺点就是需要手动执行，我们必须手动调用 next。所以需要我们自己写自动执行器，也就是 co 模块，并且需要 yield 后面的表达式返回一个 Promise 对象（co 模块还能够接受函数，生成器，数组和对象，数组和对象是为了并发执行）。

生成器还有一些其他作用，比如将普通对象变为可迭代对象，惰性求值等。

async/await

async 函数是生成器的语法糖，其实它就是自动执行的生成器和 Promise 的结合。不过它比 co 更好的地方是 await 后面可以跟原始数据类型。

其实 async 函数和用 co 包装过的生成器没有什么区别，不过它的语义化更好，async 和 await 非常容易理解，我们可以把我们一步任务像写同步任务一样用 await 继发执行。Async 函数的实现最简洁，最符合语义，几乎没有语义不相关的代码。它将 Generator 写法中的自动执行器，改在语言层面提供，不暴露给用户，因此代码量最少。如果使用 Generator 写法，自动执行器需要用户自己提供。

async 有一个问题就是我们需要理清楚自己异步任务之间的依赖，如果你将两个不互相依赖的异步任务写在同一个 async 的连续 await 中，他们将会继发执行，降低效率。我们需要的是并发执行，可以用 Promise.all 实现。

错误处理机制

Promise 的错误只能用 .catch 捕获，如果没有 .catch，那么错误不会冒泡到外层，代码也不会中断执行。

var someAsyncThing = function () {
  return new Promise(function (resolve, reject) {
    // 下面一行会报错，因为x没有声明
    console.log('throw error')
    resolve(x + 2)
  })
}
try {
  someAsyncThing()
    .then(function () {
      console.log('everything is great')
    })
    .catch((e) => {
      console.log('promise catch: ' + e) //promise catch: ReferenceError: x is not defined
    })

  console.log(123123) //123123
} catch (e) {
  console.log('outer: ' + e)
}

Generator 内层抛错可以被外层接受（如果内层没有写 catch），外层抛错可以用 Generator.prototype.throw 方法传递给内层。一旦抛错被外层接收处理，则生成器的执行立即结束，done 变为 true。

function* gen() {
  yield 1
  try {
    throw new Error('error1')
  } catch (e) {
    console.log('inner: ' + e)
  }
  yield 2
  throw new Error('error2')
}
let g = gen()
try {
  console.log(g.next())
  console.log(g.next())
  console.log(g.next())
} catch (e) {
  console.log('outer: ' + e)
}
// { value: 1, done: false }
// inner: Error: error1
// { value: 2, done: false }
// outer: Error: error2

async 函数返回的是一个 Promise，所以内部一旦抛错，这个 Promise 的状态就立即变为 rejected，错误信息会被传递给 .catch。这就让我们能够在 async 中使用普通的 try ... catch。因为同步和异步的代码出错都会 rejected。

async function test() {
  console.log(x)
}
test()
  .then((val) => console.log(val))
  .catch((reason) => {
    console.log('reason: ' + reason) //reason: ReferenceError: x is not defined
  })

async function test() {
  console.log(1)
  await new Promise((resolve) => {
    throw new Error('promise error')
  })
}
test()
  .then((val) => console.log(val))
  .catch((reason) => {
    console.log('reason: ' + reason) //reason: Error: promise error
  })

读取最大文件实现

有两个异步操作 fs.readdir 和 fs.stat，看看四种方式最后实现的结构如何。

回调函数实现

var fs = require('fs')
var path = require('path')

function findLargest(dir, cb) {
  // 读取目录下的所有文件
  fs.readdir(dir, function (er, files) {
    if (er) return cb(er)

    var counter = files.length
    var errored = false
    var stats = []

    files.forEach(function (file, index) {
      // 读取文件信息
      fs.stat(path.join(dir, file), function (er, stat) {
        if (errored) return

        if (er) {
          errored = true
          return cb(er)
        }

        stats[index] = stat

        // 事先算好有多少个文件，读完 1 个文件信息，计数减 1，当为 0 时，说明读取完毕，此时执行最终的比较操作
        if (--counter == 0) {
          var largest = stats
            .filter(function (stat) {
              return stat.isFile()
            })
            .reduce(function (prev, next) {
              if (prev.size > next.size) return prev
              return next
            })

          cb(null, files[stats.indexOf(largest)])
        }
      })
    })
  })
}
// 查找当前目录最大的文件
findLargest('./', function (er, filename) {
  if (er) return console.error(er)
  console.log('largest file was:', filename)
})

Promise 实现

var fs = require('fs')
var path = require('path')

var readDir = function (dir) {
  return new Promise(function (resolve, reject) {
    fs.readdir(dir, function (err, files) {
      if (err) reject(err)
      resolve(files)
    })
  })
}

var stat = function (path) {
  return new Promise(function (resolve, reject) {
    fs.stat(path, function (err, stat) {
      if (err) reject(err)
      resolve(stat)
    })
  })
}

function findLargest(dir) {
  return readDir(dir)
    .then(function (files) {
      let promises = files.map((file) => stat(path.join(dir, file)))
      return Promise.all(promises).then(function (stats) {
        return { stats, files }
      })
    })
    .then((data) => {
      let largest = data.stats
        .filter(function (stat) {
          return stat.isFile()
        })
        .reduce((prev, next) => {
          if (prev.size > next.size) return prev
          return next
        })

      return data.files[data.stats.indexOf(largest)]
    })
}

findLargest('./')
  .then(function (filename) {
    console.log('largest file was:', filename)
  })
  .catch(function (error) {
    console.log(error)
  })

Generator 实现

var fs = require('fs')
var path = require('path')

var co = require('./co')

var readDir = function (dir) {
  return new Promise(function (resolve, reject) {
    fs.readdir(dir, function (err, files) {
      if (err) reject(err)
      resolve(files)
    })
  })
}

var stat = function (path) {
  return new Promise(function (resolve, reject) {
    fs.stat(path, function (err, stat) {
      if (err) reject(err)
      resolve(stat)
    })
  })
}

function* findLargest(dir) {
  var files = yield readDir(dir)
  var stats = yield files.map(function (file) {
    return stat(path.join(dir, file))
  })

  let largest = stats
    .filter(function (stat) {
      return stat.isFile()
    })
    .reduce((prev, next) => {
      if (prev.size > next.size) return prev
      return next
    })

  return files[stats.indexOf(largest)]
}

co(findLargest, './')
  .then(function (filename) {
    console.log('largest file was:', filename)
  })
  .catch(function (error) {
    console.log(error)
  })

var fs = require('fs')
var path = require('path')

var readDir = function (dir) {
  return new Promise(function (resolve, reject) {
    fs.readdir(dir, function (err, files) {
      if (err) reject(err)
      resolve(files)
    })
  })
}

var stat = function (path) {
  return new Promise(function (resolve, reject) {
    fs.stat(path, function (err, stat) {
      if (err) reject(err)
      resolve(stat)
    })
  })
}

async function findLargest(dir) {
  var files = await readDir(dir)

  let promises = files.map((file) => stat(path.join(dir, file)))
  var stats = await Promise.all(promises)

  let largest = stats
    .filter(function (stat) {
      return stat.isFile()
    })
    .reduce((prev, next) => {
      if (prev.size > next.size) return prev
      return next
    })

  return files[stats.indexOf(largest)]
}

findLargest('./')
  .then(function (filename) {
    console.log('largest file was:', filename)
  })
  .catch(function (error) {
    console.log(error)
  })

事件循环 Event Loop

Sun, 01 Nov 2020 12:00:00 GMT

前言

本文分析 JavaScript 的事件循环 Event Loop 的执行机制和细节。Event Loop 标准文档见 Event Loop - whatwg

基础概念

为了协调事件、用户交互、脚本、UI 渲染、网络请求，用户代理必须使用 Event Loop。

Event Loop 是 JS 宿主环境的一个设施（浏览器和 nodejs 都实现了），它不是 JS 引擎的一部分。JS 引擎负责 JS 代码的执行，主要包括了一个内存堆和一个调用栈。而 Event Loop 的主要作用就是对异步任务何时进入引擎执行进行管理。

先了解三种数据结构

栈( stack )：栈在计算机科学中是限定仅在表尾进行插入或删除操作的线性表。栈是一种数据结构，它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据。栈是只能在某一端插入和删除的特殊线性表。
堆( heap )：堆是一种数据结构，是利用完全二叉树维护的一组数据，堆分为两种，一种为最大堆，一种为最小堆，将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。堆是线性数据结构，相当于一维数组，有唯一后继。
队列( queue )：特殊之处在于它只允许在表的前端（ front ）进行删除操作，而在表的后端（ rear ）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（ FIFO—first in first out ）。

javaScript 是单线程，也就是说只有一个主线程，主线程有一个栈，每一个函数执行的时候，都会生成新的execution context （执行上下文），执行上下文会包含一些当前函数的参数、局部变量之类的信息，它会被推入栈中， running execution context（正在执行的上下文）始终处于栈的顶部。当函数执行完后，它的执行上下文会从栈弹出。把 JS 执行设施再细分有三个部分（1 和 2 为 JS 引擎中的）：

Stack ：主线程的函数执行都压在这个栈中。
Heap ：存放对象，数据。没有引用的对象会被垃圾回收。
Task Queue ：执行栈为空的时候从任务队列中取一个任务执行，再次为空时再次到任务队列中取任务执行，如此循环，所以称为 Event Loop。

理解事件循环

理解事件循环机制首先要理解浏览器的组成，可以参考我的另一片文章：浏览器渲染过程，这里我就做一个简短的说明。

以 Chorme 为例，每一个页面（一个 tab）都是一个独立的进程，我们的浏览器内核也就是渲染引擎就在其中工作。渲染引擎包括了如下一些部分：GUI 渲染线程，JavaScript 引擎，事件触发线程，定时器触发线程，异步请求线程等。我们的 JavaScript 引擎是工作在渲染引擎之下的。事件循环就可以理解为渲染引擎和 JavaScript 引擎之间为了协调工作而创造的一种模式。

首先在浏览器中，我们的 JavaScript 脚本最终运行的目标都是改变页面，无论是改变页面的效果还是改变页面上的数据，所有的改动（不管是复杂的还是简单的）都会直接或间接的为页面上的某个或某些元素服务的。JavaScript 和渲染引擎的交互主要是依靠浏览器提供的一系列 Web APIs（可以参考 Web API 接口参考 - MDN），而渲染引擎和 JavaScript 引擎的交互就是依靠事件循环。

用实际的例子来说明，我们打开一个 tab，输入一个网址回车。网络进程像服务器发起请求。获得请求的内容之后开一个新的渲染进程，渲染引擎开始工作。GUI 渲染线程进行 HTML，CSS 的解析，解析到 <script> 交给 JavaScript 引擎处理。JavaScript 创建全局环境，全局环境压入执行栈开始执行代码，当遇到 setTimeout 等定时器代码，交给定时器触发线程，遇到 ajax 请求交给异步请求线程，遇到事件绑定交给事件触发线程。按照这个逻辑，一直执行下去。我们可以看到，我们写的 JavaScript 代码利用浏览器提供的 Web API 把很多异步任务交给渲染引擎的其他线程进行处理。

当这些异步任务完成之后，渲染引擎的其他线程需要通知 JavaScript 引擎执行回调函数。异步任务的完成事件是不确定的，可能同时有很多任务完成了，而 JavaScript 引擎是单线程的，所以必然要有一个机制让引擎能够依次执行异步任务的回调函数。这就是要有任务队列的原因。

所以事件循环本质是渲染引擎和 JavaScript 引擎为了处理异步任务而设计的一种有效率的模式。

可以借助下图理解：

规范

Event Loop - whatwg 规范对 Event Loop 进行了严格的定义。我们从规范来解读 Event Loop 的细节。这里我们直接把最关键的几步列出来（翻译来自深入探究 eventloop 与浏览器渲染的时序问题）：

1-5 条：从 task 队列（一个或多个）中选出最老的一个 task，执行它。
第 6 条：执行 microtask 检查点。简单说，会执行 microtask 队列中的所有 microtask，直到队列为空。如果 microtask 中又添加了新的 microtask，直接放进本队列末尾。
7：执行 UI render 操作：
- 7.1-7.4：判断 document 在此时间点渲染是否会『获益』。浏览器只需保证 60Hz 的刷新率即可（在机器负荷重时还会降低刷新率），若 eventloop 频率过高，即使渲染了浏览器也无法及时展示。所以并不是每轮 eventloop 都会执行 UI Render。
- 7.5-7.9：执行各种渲染所需工作，如触发 resize、scroll 事件、建立媒体查询、运行 CSS 动画等等
- 7.10：执行 animation frame callbacks
- 7.11：执行 IntersectionObserver callback
- 7.12：渲染 UI

任务队列

从标准中我们看出，一共有两种任务 task 和 microtask，task 很多时候也被称为 macrotask。关于 task 标准中有详细定义。

An event loop has one or more task queues. For example, a user agent could have one task queue for mouse and key events (to which the user interaction task source is associated), and another to which all other task sources are associated. Then, using the freedom granted in the initial step of the event loop processing model, it could give keyboard and mouse events preference over other tasks three-quarters of the time, keeping the interface responsive but not starving other task queues. Note that in this setup, the processing model still enforces that the user agent would never process events from any one task source out of order.

一个 eventloop 有一或多个 task 队列。每个 task 由一个确定的 task 源提供。从不同 task 源而来的 task 可能会放到不同的 task 队列中。例如，浏览器可能单独为鼠标键盘事件维护一个 task 队列，所有其他 task 都放到另一个 task 队列。通过区分 task 队列的优先级，使高优先级的 task 优先执行，保证更好的交互体验。

task 源包括（ generic-task-sources）：

DOM 操作任务源：如元素以非阻塞方式插入文档
用户交互任务源：如鼠标键盘事件。用户输入事件（如 click）必须使用 task 队列
网络任务源：如 XHR 回调
history 回溯任务源：使用 history.back() 或者类似 API
setTimeout、setInterval、IndexDB

所以常见的 task 任务包括：

script 代码
事件回调
XHR 回调
IndexDB 数据库操作等 I/O
setTimeout / setInterval
history.back
postMessage

下面讲一讲微任务 microtask，每一个 eventloop 都有一个 microtask 队列。microtask 会排在 microtask 队列而非 task 队列中。一般微任务包括：

Promise.then，Promise.catch，Promise.finally
MutationObserver
process.nextTick

目前浏览器暴露了一个 WindowOrWorkerGlobalScope.queueMicrotask() 让我们能够用微任务执行我们的代码。

为什么有宏任务和微任务

其实网上关于宏任务微任务的讲解非常多，基本都是讲一讲哪些属于宏任务，哪些属于微任务，然后执行顺序。但是几乎没有人说为什么要设计成这两种模式。

其实如果我们仔细想一想，为什么需要宏任务和微任务？任何设计都是有原因的，浏览器内核发展了这么多年，有这种设计必然就有需求，比如我上面讲的事件循环解决的问题，那么微任务也必然有其解决的问题。

我这里先说我的结论，宏任务和微任务的区分主要还是为了给任务一个优先级的区分，让一些有优先级要求或者连续执行需求的任务优先执行。

我们来看一看 MDN 上对于宏任务和微任务的说明：

一个微任务（microtask）就是一个简短的函数，当创建该函数的函数执行之后，并且只有当 Javascript 调用栈为空，而控制权尚未返还给被 user agent 用来驱动脚本执行环境的事件循环之前，该微任务才会被执行。事件循环既可能是浏览器的主事件循环也可能是被一个 web worker 所驱动的事件循环。这使得给定的函数在没有其他脚本执行干扰的情况下运行，也保证了微任务能在用户代理有机会对该微任务带来的行为做出反应之前运行。JavaScript 中的 promises 和 Mutation Observer API 都使用微任务队列去运行它们的回调函数，但当能够推迟工作直到当前事件循环过程完结时，也是可以执行微任务的时机。
一个任务就是由执行诸如从头执行一段程序、执行一个事件回调或一个 interval/timeout 被触发之类的标准机制而被调度的任意 JavaScript 代码。这些都在任务队列（task queue）上被调度。在以下时机，任务会被添加到任务队列：
- 一段新程序或子程序被直接执行时（比如从一个控制台，或在一个 <script> 元素中运行代码）。
- 触发了一个事件，将其回调函数添加到任务队列时。
- 执行到一个由 setTimeout() 或 setInterval() 创建的 timeout 或 interval，以致相应的回调函数被添加到任务队列时。

MDN 也给出了使用微任务的建议：因为微任务自身可以入列更多的微任务，且事件循环会持续处理微任务直至队列为空，那么就存在一种使得事件循环无尽处理微任务的真实风险。如何处理递归增加微任务是要谨慎而行的。如果可能的话，大部分开发者并不应该过多的使用微任务。在基于现代浏览器的 JavaScript 开发中有一个高度专业化的特性，那就是允许你调度代码跳转到其他事情之前，而那些事情原本是处于用户计算机中一大堆等待发生的事情集合之中的。滥用这种能力将带来性能问题。

所以微任务的处理方式本质还是提供了一个优先执行任务的通道，让一些有需要的任务优先执行，不过我们需要正确地使用。

这里属于我个人的理解，如果有错误或者意见，欢迎讨论。

事件循环过程

简化标准中的执行流程如下：

取一个宏任务来执行。执行完毕或没有宏任务，进入下一步。执行过程中触发的微任务会直接放入微任务队列，会在本轮执行。
取一个微任务来执行，执行完毕后，再取一个微任务来执行。直到微任务队列为空，执行下一步。执行过程中遇到的微任务也会放到队列后在本轮执行。
更新UI渲染。

Event Loop 会无限循环执行上面3步，这就是 Event Loop 的主要控制逻辑。其中第三部 UI 渲染不是每次事件循环都进行的。

这个可视化 JS 执行过程可以帮助你理解。

从逻辑上来看，浏览器倾向于尽可能快地执行完微任务，当全局任务（其实是全局函数中的同步任务）执行完之后，会立即执行微任务队列，即使微任务队列执行完了，在每次执行完一个宏任务之后都会检查微任务队列，如果就微任务就一直执行到微任务队列为空才会执行宏任务。

console.log('script start');

// 微任务
Promise.resolve().then(() => {
    console.log('p 1');
});

// 宏任务
setTimeout(() => {
    console.log('setTimeout');
}, 0);

var s = new Date();
while(new Date() - s < 50); // 阻塞50ms

// 微任务
Promise.resolve().then(() => {
    console.log('p 2');
});

console.log('script ent');

/*** output ***/
// one macro task
script start
script ent

// all micro tasks
p 1
p 2

// one macro task again
setTimeout

什么时候触发 UI render

按照标准中的说明：如果浏览器试图实现 60Hz 的刷新率，那么 UI Render 只需要每秒执行 60 次（每 16.7 ms）。如果浏览器发现『顶层浏览器上下文』无法维持住这个频率，可能会下调到可维持的 30Hz，而不是掉帧。（本规范并不对何时进行 render 做任何规定。）类似的，如果一个顶层浏览器上下文在后台运行，用户代理可能决定将该页面的刷新率降到 4Hz，甚至更低。

如果满足以下条件，也会跳过渲染：浏览器判断更新渲染不会带来视觉上的改变。map of animation frame callbacks 为空，也就是帧动画回调为空，可以通过 requestAnimationFrame 来请求帧动画。

这里要说一说 requestAnimationFrame，window.requestAnimationFrame() 告诉浏览器——你希望执行一个动画，并且要求浏览器在下次重绘之前调用指定的回调函数更新动画。该方法需要传入一个回调函数作为参数，该回调函数会在浏览器下一次重绘之前执行。根据标准中的定义 requestAnimationFrame 也是 UI Render 的其中一步，所以 requestAnimationFrame 的回调函数的执行时跟 UI render 是同步的。但是我们上面说了，UI render 的频率是不确定的，所以我们不能明确知道 requestAnimationFrame 会在哪一次 Event Loop 执行。既有可能出现每一轮 eventloop 后都 render 的现象，也有可能出现几十轮 eventloop 都不 render 的情况，根据浏览器的实现不同和使用的电脑状况不同都有可能出现差异。比如下面这个题目：

setTimeout(function () {
  console.log(1)
}, 1)
setTimeout(function () {
  console.log(2)
}, 2)
setTimeout(function () {
  console.log(3)
}, 3)
requestAnimationFrame(function () {
  console.log(4)
})

这道题的输出可能是 4123，1423，1243 或者 1234，主要愿意就是我们不知道浏览器在哪一次 Event Loop 进行渲染，所以 requestAnimationFrame 可能在任意一个 setTimeout 后面执行。

再比如下面这题求输出：

console.log('1')

setTimeout(function () {
  console.log('2')
  process.nextTick(function () {
    console.log('3')
  })
  new Promise(function (resolve) {
    console.log('4')
    resolve()
  }).then(function () {
    console.log('5')
  })
})
process.nextTick(function () {
  console.log('6')
})
new Promise(function (resolve) {
  console.log('7')
  resolve()
}).then(function () {
  console.log('8')
})

setTimeout(function () {
  console.log('9')
  process.nextTick(function () {
    console.log('10')
  })
  new Promise(function (resolve) {
    console.log('11')
    resolve()
  }).then(function () {
    console.log('12')
  })
})
//1，7，6，8，2，4，3，5，9，11，10，12

NodeJs 的 Event Loop

Node 端事件循环中的异步队列也是这两种：macro（宏任务）队列和 micro（微任务）队列。

常见的 macro-task 比如：setTimeout、setInterval、 setImmediate、script（整体代码）、 I/O 操作等。常见的 micro-task 比如: process.nextTick、new Promise().then(回调)等。

在 Event Loop 之前会先做这些工作： 1. 初始化 Event Loop 2. 执行主代码。这里同样，遇到异步处理，就会分配给对应的队列。直到主代码执行完毕。 3. 执行主代码中出现的所有微任务：先执行完所有nextTick()，然后在执行其它所有微任务。 4. 开始 Event Loop

Event Loop分为6个阶段： 1. timers : 这个阶段执行 setTimeout() 和 setInterval() 设定的回调。 2. pending callbacks : 上一轮循环中有少数的 I/O callback 会被延迟到这一轮的这一阶段执行。 3. idle , prepare : 仅内部使用。 4. poll : 执行 I/O callback，在适当的条件下会阻塞在这个阶段 5. check : 执行 setImmediate()设定的回调。 6. close callbacks : 执行比如 socket.on('close', ...) 的回调。

在 Node 11 之前每个阶段执行完毕后，才会执行所有微任务（先 nextTick，后其它），然后再进入下一个阶段。在 Node 11 之后，就和浏览器一样，在每一个宏任务执行之后，执行所有微任务队列中的微任务。

总结

关于事件循环，网络上的文章都差不多，不过今天看了两篇文章：深入探究 eventloop 与浏览器渲染的时序问题和深入解析 EventLoop 和浏览器渲染、帧动画、空闲回调的关系发现自己懂得并不是很透彻。从标准的角度看，事件循环的逻辑也还是挺复杂的，其中还有很多细节没有掌握。当然，这也可能是事件循环还没有一个确定的标准导致的，各个浏览器的实现还不完全一致，包括 ECMAScript 关于 Job 的一些规定和 HTML5 标准对于时间循环的定义都是有冲突的，Node 的实现也和浏览器不同，还是要继续摸索。

参考文章

生成器 Generator 的异步应用

Sun, 01 Nov 2020 12:00:00 GMT

前言

生成器有一个问题就是需要我们手动调用 next 来执行，这就表示我们需要单独写一段代码来管理生成器的执行与暂停，这是比较麻烦的。如何让我们写的生成器能够自动执行，本文就来讨论实现方法。

如果你对生成器 Generator 还不了解，请先看另一篇详细介绍生成器的文章 ES6 生成器 Generator

生成器的关键

生成器之所以能够比 Promise 更好的封装异步任务，首先是它可以利用 yield 和 next 来暂停和回复函数的执行。但是还有两个重要的特性让它能够更好的完成这个任务，那就是 yield 和 next 能够实现函数体内外的数据交换，以及函数体内外能够互相进行错误捕获。

封装异步任务的一个关键就是，当函数暂停执行之后，我们如何知道异步任务完成了，然后调用 next 执行下一步？对于异步任务，只有通过回调函数才能知道任务是否完成。所以要封装异步任务，我们就要保证回调函数是在生成器外部执行的，我们可以在回调函数中执行 next。所以我们要封装异步任务最主要的一个任务就是让回调函数在生成器外声明和执行。这就是核心思想。

Thunk 函数

我们先来看看一般异步任务的形式，比如异步读取文件 fs.readFile(fileName, callback);，我们执行这个函数后悔立即根据第一个文件名参数读取文件，读取成功后执行 callback，根据 API 的不同，callback 会被传入相应的参数。如果我们直接把这么一个函数放到生成器的 yield 后面我们是无法处理的。因为我们肯定是希望 callback 执行以后再执行下一步，但是这样的调用方式，我们不可能知道 callback 何时执行，此时我们在生成器外部实际已经丢失了对异步任务的控制。

var gen = function* () {
  yield readFile('/etc/filea')
}

let g = gen()
let filea = g.next() //此时我们实际已经丢失了异步任务的控制

所以我们要对异步任务进行封装。封装的目标是什么？我们希望在生成器内部传入文件名，在生成器外部传入 callback。形式如下：

var gen = function* () {
  yield readFileThunk('/etc/filea')
}

let g = gen()
let filea = g.next()
filea.value(function (err, data) {
  //your code
  g.next(data)
})

其实我们可以看出，内部的封装函数执行只不过是传入了一个参数，真正的查询文件操作并没有执行，只是返回了一个带参数的函数而已，真正的执行还是在外部我们传入了 callback 之后，所以我们能够在 callback 中将控制权传回生成器内。这就是 Thunk 的目标，逻辑也非常简单。

一个 Thunk 函数我们大概要封装三层，第一层传入那个待执行的异步函数，然后传入参数，最后在生成器外部传入 callback。封装的实现我们可以参考 tj 实现的 thunkify。

function thunkify(fn) {
  return function () {
    var args = new Array(arguments.length)
    var ctx = this
    for (var i = 0; i < args.length; ++i) {
      args[i] = arguments[i]
    }
    return function (done) {
      var called
      args.push(function () {
        if (called) return
        called = true
        done.apply(null, arguments)
      })
      try {
        fn.apply(ctx, args)
      } catch (err) {
        done(err)
      }
    }
  }
}

我们可以看到整个代码非常短，内部有两个 return，连上最外层的函数调用，一共三层，分别传入异步函数，参数，和回调函数。

简要分析一下流程，传入异步函数（比如 fs.readFile）执行 thunkify 会返回一个函数。返回的函数是一个中间层，供我们传入参数，比如 fs.readFile 的文件名，这个函数也就是我们写在 yield 后面的函数。实际这一层的主要操作就是对 arguments 的操作，它将我们传入的参数保存到了一个数组中，同时保存了 this。

这个函数执行后返回一个函数，也就是被保存在 yield 返回的对象的 value 属性中。于是在生成器外，我们可以获得这个函数，然后就可以传入回调函数执行了。最后返回的这个函数内部主要的处理就是把新传入的回调函数放到刚刚保存的参数的数组的最后，然后用保存的 this 和这个参数数组执行异步函数 fn。这里它赌回调函数进行了一个封装，就是确保回调函数值执行一次。

有了这个 thunkify 函数对异步函数进行封装以后我们就可以向如下使用 Generator 封装异步任务了：

var fs = require('fs')
var thunkify = require('thunkify')
var readFileThunk = thunkify(fs.readFile)
var gen = function* () {
  var r1 = yield readFileThunk('/etc/fstab')
  console.log(r1.toString())
  var r2 = yield readFileThunk('/etc/shells')
  console.log(r2.toString())
}

var g = gen()
var r1 = g.next()
r1.value(function (err, data) {
  if (err) throw err
  var r2 = g.next(data)
  r2.value(function (err, data) {
    if (err) throw err
    g.next(data)
  })
})

不过仔细看这个代码，好像比我们直接执行 fs.readFile() 复杂多了，而且最后的执行还是个回调嵌套，既不方便，也不优雅，兜了个大圈子还是跟原来一样。但其实我们仔细想一想，这里的回调函数不用像我们平时的嵌套回调一样，把所有的逻辑都写上，我们要做的就两件事，用 next 将回调结果传递到生成器内（数据处理的逻辑完全可以放到生成器内），同时将执行权交给生成器，当生成器返回一个新的异步任务后我们再重复这个步骤。也就是说每个回调的逻辑都是相同的。

既然每个回调的逻辑都相同，我们完全可以用递归来实现。比如实现如下这个 run 函数。

function run(fn) {
  var gen = fn()
  function next(err, data) {
    var result = gen.next(data)
    if (result.done) return
    result.value(next)
  }
  next()
}
run(gen)

这个 run 函数就能实现生成器的自动执行。run 的参数 fn 就是生成器函数，内部的逻辑就是用一个 next 函数进行递归。在 next 函数中，我们调用生成器的 next 的方法恢复生成器执行，同时传入上次异步的结果 data。当生成器返回的时候，我们对返回的对象进行分析，如果 done 是 true 就直接 return。如果 done 为 false 就将 next 作为回调函数执行返回对象的 value。

所以这里的 next 函数就是我们上面说的，每个回调的逻辑都相同。它只做了两件事，传入 data 执行生成器的 next，将执行权交给生成器，在生成器返回新的函数后重复上述步骤，一直到所有异步任务完成，从而实现自动执行。当然这样的自动执行器有一个前提就是，每一个 yield 后面都是用 thunkify 封装好的 Thunk 函数。

现在我们的异步任务的写法已经和同步任务完全一样了，比如我们要异步读取 n 个文件。

var g = function* () {
  var f1 = yield readFileThunk('fileA')
  var f2 = yield readFileThunk('fileB')
  // ...
  var fn = yield readFileThunk('fileN')
}
run(g)

代码逻辑非常清晰，看上去就和同步代码一样。

其实总结一下，要让生成器自动执行最重要的一点就是我们要在异步任务完成之后将执行权还给生成器，同时把异步任务的结果传递到生成器中。

co 源码解读

其实包装 Thunk 函数还是有一点麻烦的，有没有其他更好的方法呢？当然可以，除了利用回调函数（thunkify 本身就是利用回调函数，在回调函数中将执行权交给生成器并且传递异步操作的记过），另一种就是 Promise。

Promise 的详细介绍请看我的另一篇文章深入 Promise，Promise 本身就是对回调函数形式的异步任务的一种封装，它让嵌套的异步操作不再是回调地狱，而是以一种接近于同步的形式来编写。所以可以使用回调函数自然能够使用 Promise 来实现。而且 Promise 比回调函数更好的是，我们可以直接在生成器内部执行异步任务，只要返回 Promise 对象即可，因为 Promise 对象会保存异步任务的状态和结果，我们随时可以取到，而不是像回调函数一样，你错过了就无法再获得这个回调的结果。

这里我们主要通过研究 co 模块的源码来理解其中的实现细节。co 模块是著名程序员 TJ Holowaychuk 在 2013 年编写的一个用于 Generator 自动执行的小工具。最初 co 是同时支持 Thunk 函数和 Promise 的，4.0 之后只支持 Promise了，我们这里主要从源码的角度看看它是如何基于 Promise 实现生成器的自动执行的。

先看下面这个例子：

const co = require('./co')
const fs = require('fs')
var gen = function* () {
  var f1 = yield readFile('/Users/clloz/code/testing/.eslintrc.js')
  var f2 = yield readFile('/Users/clloz/code/testing/package.json')
  console.log(f1.toString()) //正常输出
  console.log(f2.toString()) //正常输出
}
co(gen).then(function () {
  console.log('Generator 函数执行完成')
})

function readFile(filename) {
  return new Promise(function (resolve, reject) {
    fs.readFile(filename, function (err, data) {
      resolve()
    })
  })
}
//Generator 函数执行完成

我们可以看到，我们直接用 co 调用生成器函数，就直接自动执行了，最后返回了一个 Promise 对象。我们也可以模仿上面的 run 写一个自动执行的函数。

function run(gen) {
  var g = gen()
  function next(data) {
    var result = g.next(data)
    if (result.done) return result.value
    result.value.then(function (data) {
      next(data)
    })
  }
  next()
}
run(gen)

co 其实就是对这个 run 的扩展，我们可以看一看源码，源码去掉注释一共不到 130 行。其中大部分都是一些判断和转 Promise 代码，co 函数大概就 40 行。

co 函数内的结构是获取除了生成器函数以后的参数，然后返回一个 Promise，主要的逻辑都在 Promise 中完成。

function co(gen) {
  var ctx = this
  var args = slice.call(arguments, 1)

  return new Promise(function (resolve, reject) {})
}

在返回的 Promise 中，首先是判断传入的参数是不是一个 Generator 函数。它的逻辑是，如果第一个参数是一个函数，先用保存的参数执行这个传入的函数，并保存执行结果。然后判断这个执行结果有没有 next 方法，如果没有直接 resolve 执行结果。如果有 next 的方法，那么我们已经获得了生成器，就是 gen。

if (typeof gen === 'function') gen = gen.apply(ctx, args)
if (!gen || typeof gen.next !== 'function') return resolve(gen)

注意这里 resolve 前面加了 return，表示后面的代码都不会执行了.这是一个小技巧，Promise 默认会执行到 return 或者到函数结束（如果没有 return），如果我们不想执行 resolve 或者 reject 之后的代码可以在他们之前加上 return。

接下来是一个 onFulfilled 函数，这个函数内部用 try ... catch 来执行 gen.next(res)，目的就是为了捕获错误，生成器内部的错误也能捕获（如果生成器内部没有定义 catch，错误会抛到外面），如果抛错就直接 reject(e)。当生成器抛出的错误被外部的 catch 捕获，生成器就不会在执行了，其返回的对象的 done 会变成 true，相当于生成器执行完毕了，这个我在 ES6 生成器 Generator 有详细说明。这里在执行 gen.next 的时候像生成器内部传入了数据 res。

function onFulfilled(res) {
  var ret
  try {
    ret = gen.next(res)
  } catch (e) {
    return reject(e)
  }
  next(ret)
  return null
}

用 try ... catch 执行完 gen.next 之后是用 yield 返回的结果作为参数执行了一个 next 函数。

function next(ret) {
  if (ret.done) return resolve(ret.value)
  var value = toPromise.call(ctx, ret.value)
  if (value && isPromise(value)) return value.then(onFulfilled, onRejected)
  return onRejected(
    new TypeError(
      'You may only yield a function, promise, generator, array, or object, ' +
        'but the following object was passed: "' +
        String(ret.value) +
        '"'
    )
  )
}

next 函数的 ret 就是 yield 返回的结果。next 方法主要做了以下几件事：

判断返回对象的 done 是不是 true，如果是 true 直接 resolve 返回对象的 value。
如果返回对象的 done 不是 true，也就是生成器还没有执行完，就将返回对象的 value 包装成一个 Promise。
如果 value 成功包装成一个 Promise，那么就执行 value.then(onFulfilled, onRejected)。这里就相当于递归调用 onFulfilled 方法，实现自动执行。
如果包装 Promise 失败，则用 onRejected 方法进行抛错。

我们可以看到，co 的做法就是在我们上面实现的 run 函数外面多加了一层，目的就是为了实现错误的抛出和捕获。这里我们也可以看出 Promise 相比于回调函数的优势，我们不需要思考回调函数什么时候触发，直接丢进 Promise 就可以了。Promise 会帮我们保存回调函数的状态和结果，我们用 then 来获取异步任务的状态和结果。

这里顺便说一下 onRejected 函数：

function onRejected(err) {
  var ret
  try {
    ret = gen.throw(err)
  } catch (e) {
    return reject(e)
  }
  next(ret)
}

它其实是用 gen.throw 进行抛错，这个方法我们也在 ES6 生成器 Generator 进行了详细说明。简单的来说就是错误如果被生成器内部 catch 了，那么生成器还能继续执行，生成器会执行到下一个 yield 然后暂停。如果是被外部的 catch 捕获了，那么生成器就执行结束了。

这就是 co 的主要执行逻辑，当然后面还有一些判断和转换 Promise 的方法，这里我们说一说比较重要的并发实现。

对象转 Promise 方法 objectToPromise(obj)。

function objectToPromise(obj) {
  var results = new obj.constructor()
  var keys = Object.keys(obj)
  var promises = []
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i]
    var promise = toPromise.call(this, obj[key])
    if (promise && isPromise(promise)) defer(promise, key)
    else results[key] = obj[key]
  }
  return Promise.all(promises).then(function () {
    return results
  })

  function defer(promise, key) {
    // predefine the key in the result
    results[key] = undefined
    promises.push(
      promise.then(function (res) {
        results[key] = res
      })
    )
  }
}

它的处理逻辑是，把每一个键值包装成一个 Promise，这个 Promise 的 then 就是将 Promise 执行成功的结果放入一个新的对象中（这个对象是用传入对象的构造函数构造的一个空对象）。然后把这么多 Promise.then 放入一个数组然后执行 Promise.all()。

这么做的目的是啥呢？就是为了实现并发操作，有时候我们的异步不一定是一个等一个，可能有些任务可以同步执行，这些同步执行的任务如果一个等一个就太浪费时间了，co 就是通过上面对象的这种处理实现并发的。传入的 obj 的每一个键值都是一个异步任务，我们创建一个和这个 obj 同构造函数的空对象 result，然后把每个键值都包装成一个 Promise，只有这个 Promise 完成 resolve(res) 之后，我们才将 Promise 的结果 res 保存到 result 对象中，键名还是和 obj 的键名一样。将所有的键值都这么包装完成后，用 Promise.all 执行这个 Promise 数组，就实现了并发。

数组也是同样的逻辑，用 Promise.all 实现并发。

拖动旋转的 3D 骰子效果

Wed, 28 Oct 2020 12:00:00 GMT

前言

用 CSS 实现一个 3d 的骰子，然后实现用鼠标拖动旋转的效果。实现的效果如下，可以拖动这个骰子进行旋转。

CSS 实现 3D 骰子

想要实现一个 3d 的骰子，肯定是要使用 transform。关于 transform 的细节本文就不多讲了，可以参考 MDN 和深入理解CSS变形transform(3d)。我们主要讲讲如何实现效果。

HTML 的结构很简单，我们需要一个包含块（最后我们旋转的就是这个包含块），和 6 个子元素作为骰子的六个面。

<ul id="dice">
  <li class="front">1</li>
  <li class="back">2</li>
  <li class="right">3</li>
  <li class="left">4</li>
  <li class="top">5</li>
  <li class="bottom">6</li>
</ul>

父元素的处理非常简单，主要的属性就是 transform-style: preserve-3d，因为我们的子元素是在 3d 空间中的。

ul {
  display: block;
  width: 100px;
  height: 100px;
  margin: 100px auto;
  padding: 0;
  list-style: none;
  transform-style: preserve-3d;
}

六个面的 transform

在处理 transform 之前我们用绝对定位把六个面的元素都固定到父元素的 top left 位置，这样六个面的 transform 的坐标就都相同了。每个面的 transform 都不相同，我们需要在脑海中模拟一下从当前位置到目标位置的移动过程。这里需要注意两点，第一点是坐标轴的方向，z 轴是垂直屏幕向外的的，也就是向外移动是正，向内移动是负，同理 x 轴是左为正，y 轴是下为正；第二点就是元素拥有独立的坐标系，而不是共用同一个坐标自，当一个元素发生了旋转，他的坐标系也在旋转。比如我将一个元素以 x 轴为旋转轴旋转了 180deg，那么此时他的 z 轴就不在是垂直屏幕向外，而是垂直屏幕向内的，这一点要注意一下。根据这些规则我们来总结一下各个面需要如何移动，我们以骰子的边长为 100px 为例。

front：沿着 z 轴向外移动 50px。
back：沿着 z 轴向内移动 50px。
right：以 y 轴为旋转轴顺时针旋转 90deg，然后向右移动 50px。
left：以 y 轴为旋转轴逆时针旋转 90deg，然后向左移动 50px。
top：以 x 轴为旋转轴顺时针旋转 90deg，然后向上移动 50px。
bottom：以 x 轴为旋转轴逆时针旋转 90deg，然后向下移动 50px。

这里的顺时针逆时针我个人总结就是从旋转轴的正方向向负方向看，比如 x 轴是从右往左看，y 轴是从下网上看，如果方向看反的话，顺时针逆时针也会搞反。这里的旋转需要一点空间想象力，特别是刚刚接触 3d 的 transform。

根据上面总结的各个面的移动方式，我们就可以写出我们的代码了。

ul li {
  position: absolute;
  display: block;
  width: 100%;
  height: 100%;
  font-size: 30px;
  color: white;
  line-height: 100px;
  text-align: center;
  backface-visibility: visible;
}
.front {
  background-color: rgba(90, 90, 90, 0.7);
  transform: translateZ(50px);
}
.back {
  background-color: rgba(0, 210, 0, 0.7);
  transform: rotateY(180deg) translateZ(50px);
}
.right {
  background-color: rgba(210, 0, 0, 0.7);
  transform: rotateY(90deg) translateZ(50px);
}
.left {
  background-color: rgba(0, 0, 210, 0.7);
  transform: rotateY(-90deg) translateZ(50px);
}
.top {
  background-color: rgba(210, 210, 0, 0.7);
  transform: rotateX(90deg) translateZ(50px);
}
.bottom {
  background-color: rgba(210, 0, 210, 0.7);
  transform: rotateX(-90deg) translateZ(50px);
}

此时我们就已经得到一个 3d 的骰子了。我们可以给它一个初始的角度或者加上透视，就能够看到 3d 的效果。

旋转动画

在实现拖动旋转之前，我们先做一个旋转动画来了解 3d 旋转。我们实现将这个骰子立起来，然后进行旋转，效果如下。

如何实现这样的效果呢，我们要做的就是先将筛子立起来。其实就是以 z 轴顺时针旋转 45deg，然后以 x 轴逆时针旋转 45deg。最后的旋转方向我们使用 rotate3d(1, 1, 1, ndeg) 来实现，这里的三个 1 可以理解成向量，我们的旋转轴就是原点到这个向量的连线，原点默认在中心，而 1，1，1 的位置就相当于在 xyz 的坐标系中取点 (1, 1, 1)（这里注意坐标轴的方向和我们平时数学题中的方向不同），他们的连线就是一个垂直穿过的对角的轴。最后的效果就是一个立起来的骰子沿着垂直方向旋转。

safari，firefox 以及 iOS 上的 chrome 都不支持 keyframe 只写两帧（也就是 from - to 和 0% - 100% 的形式）我最终尝试只有 0% 25% 50% 75% 100% 这种形式能正常工作。

拖动旋转

把旋转的原理搞清楚了，实现拖动旋转就非常简单了。我们要做的就是触发 mousemove 的时候就重新计算我们的 transform 的值，这个值的计算就根据 mousedown 时候的 clientX clientY 和 mousemove 时候的 clientX clientY 的差值进行计算，比如移动 10 个像素就转动一度。这里需要注意的一点是，我们鼠标在垂直方向上移动的距离影响的是 rotateX 而不是 rotateY，因为初始方向移动相当于绕着 X 轴旋转。

最后就是当 mouseup 的时候记录当前的 rotateX 和 rotateY 的值，让下次点击事件发生的时候从上次结束的状态开始旋转而不是回到初始状态。最后的代码如下。

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Spin Dice</title>
    <style>
      ul {
        display: block;
        width: 100px;
        height: 100px;
        margin: 100px auto;
        padding: 0;
        list-style: none;
        /* perspective: 550px; */
        transform-style: preserve-3d;
        /* transition: all 0.3s ease-in; */
        /* animation: spin 5s infinite linear; */
        transform: rotateX(13deg) rotateY(13deg);
      }
      ul li {
        position: absolute;
        display: block;
        width: 100%;
        height: 100%;
        font-size: 30px;
        color: white;
        line-height: 100px;
        text-align: center;
        backface-visibility: visible;
      }
      .front {
        background-color: rgba(90, 90, 90, 0.7);
        transform: translateZ(50px);
      }
      .back {
        background-color: rgba(0, 210, 0, 0.7);
        transform: rotateY(180deg) translateZ(50px);
      }
      .right {
        background-color: rgba(210, 0, 0, 0.7);
        transform: rotateY(90deg) translateZ(50px);
      }
      .left {
        background-color: rgba(0, 0, 210, 0.7);
        transform: rotateY(-90deg) translateZ(50px);
      }
      .top {
        background-color: rgba(210, 210, 0, 0.7);
        transform: rotateX(90deg) translateZ(50px);
      }
      .bottom {
        background-color: rgba(210, 0, 210, 0.7);
        transform: rotateX(-90deg) translateZ(50px);
      }
    </style>
  </head>
  <body>
    <ul id="dice">
      <li class="front">1</li>
      <li class="back">2</li>
      <li class="right">3</li>
      <li class="left">4</li>
      <li class="top">5</li>
      <li class="bottom">6</li>
    </ul>
    <script>
      let dice = document.getElementById('dice')
      let baseX = 13
      let baseY = 13
      dice.addEventListener('mousedown', (e) => {
        let rotateX = e.clientX
        let rotateY = e.clientY

        let move = (e) => {
          // console.log(baseX, rotateX, e.clientX);
          // console.log(baseY, rotateY, e.clientY);
          dice.style.transform = `rotateX(${baseX - (((e.clientY - rotateY) / 10) % 360)}deg) rotateY(${
            baseY + (((e.clientX - rotateX) / 10) % 360)
          }deg)`
          // console.log(dice.style.transform);
        }
        let up = (e) => {
          baseX = baseX - (((e.clientY - rotateY) / 10) % 360)
          baseY = baseY + (((e.clientX - rotateX) / 10) % 360)
          // console.log(baseX, baseY);
          document.removeEventListener('mousemove', move)
          document.removeEventListener('mouseup', up)
        }
        document.addEventListener('mousemove', move)
        document.addEventListener('mouseup', up)
      })
      document.addEventListener('selectstart', (e) => e.preventDefault())
    </script>
  </body>
</html>

注意要把 CSS 代码中的 transition 注释掉，否则影响旋转效果。

前端模块化

Fri, 23 Oct 2020 12:00:00 GMT

前言

本文主要讲一讲和前端模块化相关的一些历史和知识

为什么要模块化

可以看一看这个 JavaScript 模块化七日谈，了解一下模块化的发展历史。

一切工程相关的概念都是为了效率诞生的。如何在多人开发的较大的项目中保持开发的效率以及降低维护成本，就是问题的核心。在前端中 js 的依赖关系和代码复用就是其中的两个核心问题。如果你只是写一个几十行的小 demo，并且确定不会复用，你完全不需要任何的模块化和设计模式的概念，就结构化的代码就可以了。比如让你写一个斐波那契数列，你不会想什么模块化，面向对象，一个递归或者循环就可以了。所以一切都是需求决定的，我们也要根据需求选择开发方式，效率是第一位的。有几个原因：

语言特性：html/css/js 都是比较高“容错”的，高自由度的，没有非常明确的规范。比如 html 的标签是否闭合，大小写都是可兼容的，相同的功能可以用各种形式的标签组合来实现。css 是全局的并且属性之间非正交，css 的行为想要搞清楚并不容易。javascript 作为一个弱类型动态语言，也是相当自由的，你可以定义一堆全局变量结构化地实现你的功能；也可以进行模块化编写易于维护和复用的代码。自由度和容错率高，并且没有一个明确的 好 的标准，导致前端的代码参差不齐。

浏览器渲染机制，js 引擎是单线程的，这主要是因为它主要是用在浏览器上和 UI 交互而不得不做的选择。这种单线程也意味着，js 的依赖是线性的，早期的模式其实就可以理解为只有一个很大的 js 文件，我们的所写的一段段代码在其中依次排开。当代码量上升的时候，几十个 js 文件之间的依赖关系很难搞清楚，并且大家共享一个作用域，很容易造成全局变量的污染。如何对 js 进行按需的加载，以及保持各模块独立的作用域就是模块化不断发展的方向。

模块化需求是随着前端不断发展而产生的，前端应用变得越来越庞大和复杂，自然就因为效率的问题而产生了模块化的需求。

模块化的历史

在我们刚学习 JavaScript 的时候，我们都是用一个个函数拼凑出我们的功能，代码大概都是下面这个样子（其实无论学什么语言都是一样，人的思维就是结构化的）：

function foo() {
  //...
}
function bar() {
  //...
}

这样做的缺陷就是所有的函数都是定义在全局中的，如果是多人开发很可能发生冲突。当然这个问题有很多种解决办法，比如将函数都写成一个对象的方法，这样就大大减少了全局中的变量名，减小了冲突的可能性。但是我们定义的方法依然是能在全局访问的，并不足够安全。

var MYAPP = {
  foo: function () {},
  bar: function () {}
}

MYAPP.foo()

后面就发展到了以前经常被问到的一个问题 IIEF，立即执行函数。在 ES6 之前，JS 没有块级作用域，函数很多时候就被当成了块级作用域的替代品。在函数外部只能访问我们返回的值，而我们在函数内部定义的变量方法是无法被访问到的。函数的作用相当于产生一个局部作用域。同时我们可以通过 IIEF 向函数内部传递参数，相当于一种引入依赖的方式，这样做除了保证模块的独立性，还使得模块之间的依赖关系变得明显。

var Module = (function ($) {
  var _$body = $('body') // we can use jQuery now!
  var foo = function () {
    console.log(_$body) // 特权方法
  }

  // Revelation Pattern
  return {
    foo: foo
  }
})(jQuery)

Module.foo()

发展到这里的时候我们实际上已经实现了模块化的主要目的，就是将对应的功能封装到一个局部作用于中，我们可以向其中注入依赖，我们也只能使用它返回给我们的内容，而不关心它内部如何实现的。模块就相当于一个黑盒，我们只关心它的输入输出，而不关心它如何实现。

后面出现的问题就是当项目庞大以后，可能有几十个 js 文件需要加载，而 DOM 文档中加载顺序就是执行顺序，这么多文件之间的依赖关系会非常复杂。比如一个文件的执行可能都要依赖好几个文件，那么这些依赖的文件必须在这个文件执行之前加载完毕，这在文件比较少的时候还好处理，但是一旦文件增多依赖关系将错综复杂，很容易出错。如果要对其中的功能进行修改，处理依赖的关系都会花很长时间，而且每一个文件都是一个 HTTP 请求，文件过多也会造成请求过多。

为了解决依赖问题产生了很多工具，比如 Yahoo 的 YUI，关于 YUI 的原理可以参考 YUI模块开发原理详解

进行一个总结，其实模块化的目标就是把页面的功能进行分割，不同的功能之间解耦独立，互不干扰。并且模块能够按需加载，根据模块的依赖进行整合让请求数量变少。但是由于浏览器的特性，很多问题并不能得到根本性的解决，所以后面的模块化思路就跳出浏览器了。这也是现在还在流行的模块化方案。

模块化规范

CommonJS

CommonJS 就是如今 NodeJS 在使用的模块化标准，它的大致使用方式如下：

// math.js
exports.add = function (a, b) {
  return a + b
}

// main.js
var math = require('math') // ./math in node
console.log(math.add(1, 2)) // 3

每个文件就是一个模块，有自己的作用域。在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见。在服务器端，模块的加载是运行时同步加载的；在浏览器端，模块需要提前编译打包处理。所有代码都运行在模块作用域，不会污染全局作用域。模块可以多次加载，但是只会在第一次加载时运行一次，然后运行结果就被缓存了，以后再加载，就直接读取缓存结果。要想让模块再次运行，必须清除缓存。模块加载的顺序，按照其在代码中出现的顺序。

require 有一个 main 属性，其实就是入口文件的意思，和我们在 package.json 中使用的 main 字段含义类似，如果该文件是我们直接用 node 命令运行的，那么 request.main 的值就是文件对应的 module。我们可以用 require.main === module 来判断当前文件是不是直接运行的

模块导入规则：假设以下目录为 src/app/index.js 的文件调用 require()

以 ./moduleA 相对路径开头，在没有指定后缀名的情况下先去寻找同级目录同级目录：src/app/

src/app/moduleA 无后缀名文件，按照 javascript 解析
src/app/moduleA.js js文件，按照 javascript 解析
src/app/moduleA.json json 文件，按照 json 解析
src/app/moduleA.node node 文件，按照加载的编译插件模块 dlopen

同级目录没有 moduleA 文件会去找同级的 moduleA 目录：src/app/moduleA

src/app/moduleA/package.json 判断该目录是否有 package.json 文件，如果有找到 main 字段定义的文件返回，如果 main 字段指向文件不存在或 main 字段不存在或 package.json 文件不存在向下执行
src/app/moduleA/index.js
src/app/moduleA/index.json
src/app/moduleA/index.node

这里讲一讲 module.exports 和 exports，在 CommonJS 中有 module 模块标识，exports 模块定义，require 模块引用。其中 module 有一个 exports 属性，该属性最初是一个空对象。而 exports 是 module.exports 的一个引用。require 能看到的只有 module.exports，它并不能看到 exports，所以尽量使用 module.exports，不要使用 exports。

require 命令的基本功能是，读入并执行一个 JavaScript 文件，然后返回该模块的 exports 对象（这里指的就是 module 的 exports 对象）。如果没有发现指定模块，会报错。

其实 node 中的模块原理还是和我们前面的立即执行函数一样的，我们的模块中的代码也是被放在一个函数中，而 module 对象就是传入这个函数的一个参数，然后再把我们的每个模块的输出统一进行保存。当我们 require 的时候他就到保存的输出中找对应模块的输出即可。

// 准备module对象:
var module = {
  id: 'hello',
  exports: {}
}
var load = function (module) {
  // 读取的模块代码并执行

  module.exports = obj
  // 模块代码结束 返回module.exports
  return module.exports
}
var exported = load(module)
// 保存module:
save(module, exported)

所以在模块中我们打印 module.exports 是一个空对象，其 [[prototype]] 是 Object.prototype。我们也可以直接将 module.exports 赋值为一个基本类型，因为最终保存的知识这个返回值，是不是对象都可以。

AMD Async Module Definition

CommonJS 规范加载模块是同步的，只有加载完成，才能执行后面的操作。AMD 规范则是非同步加载模块，允许指定回调函数。由于 Node.js 主要用于服务器编程，模块文件一般都已经存在于本地硬盘，所以加载起来比较快也很稳定，不用考虑非同步加载的方式，所以 CommonJS 规范比较适用。但是，如果是浏览器环境，我们需要引用的脚本一般都是直接写到 HTML 中，而想要实现模块化只能在 JS 中异步加载脚本。AMD 就是用来实现这个效果的一种规范。此外 AMD 规范比 CommonJS 规范在浏览器端实现更早。AMD 的实现方案主要是 require.js。

AMD 的诞生，就是为了解决这两个问题： 1. 实现 js 文件的异步加载，避免网页失去响应 2. 管理模块之间的依赖性，便于代码的编写和维护

AMD (异步模块定义)主要为前端 JS 的表现指定规范。它采用异步方式加载模块，模块的加载不影响它后面语句的运行。所有依赖这个模块的语句，都定义在一个回调函数中，等到加载完成之后，这个回调函数才会运行。那么这是如何实现的呢，其实就是创建 script 标签，然后用 onload 事件来处理回调函数（所以需要一个模块一个文件）。也就是说当我们执行到一个有依赖的函数时，require.js 会创建依赖的标签，然后浏览器会请求标签，当触发 onload 之后再利用回调函数执行之前的函数。那么多个依赖如何解决呢，多个依赖是无法确定哪个先加载完哪个后加载完的，虽然不知道 require.js 是怎么执行，但是想一想可以用一个属性做标记，每触发一个 onload 标记加一，在每个 onload 中判断是否全部请求回来了即可。

下面给出一个 require.js 的小例子：

//index.html
<!DOCTYPE html>
<html>
    <head>
        <title>Modular Demo</title>
    </head>
    <body>
        <!-- 引入require.js并指定js主文件的入口 -->
        <script data-main="./index" src="require.js"></script>
    </body>
</html>

//index.js
(function () {
    require.config({
        baseUrl: './', //基本路径 出发点在根目录下
        paths: {
            //映射: 模块标识名: 路径
            alerter: './alerter', //此处不能写成alerter.js,会报错
            dataService: './dataService',
        },
    });
    require(['alerter'], function (alerter) {
        alerter.showMsg();
    });
})();

//dataService.js
define(function () {
    let msg = 'https://www.clloz.com';
    function getMsg() {
        return msg.toUpperCase();
    }
    return { getMsg }; // 暴露模块
});

//alerter.js
define(['dataService'], function (dataService) {
    let name = 'Tom';
    function showMsg() {
        alert(dataService.getMsg() + ', ' + name);
    }
    // 暴露模块
    return { showMsg };
});

浏览器打开 index.html 将能看到打印信息，文件全在同一级目录。我们可以看出 require.js 在 script 标签中用一个 data-main 属性设置了程序的入口，然后用 define 来创建模块，define 的第一个参数可以接受一个数组，传入依赖的模块。也有语法糖可以让它换成类似 CommonJS 的写法：

define(function (require) {
  var dependency1 = require('dependency1'),
    dependency2 = require('dependency2')

  return function () {}
})

// parse out require...
define(['require', 'dependency1', 'dependency2'], function (require) {
  var dependency1 = require('dependency1'),
    dependency2 = require('dependency2')

  return function () {}
})

比较 require.js 和 CommonJS，两者一个是用于浏览器，一个是用于 Node，写法上 CommonJS 是依赖就近（需要时再写也可以），require.js 是依赖前置。并且前者是同步加载，而后者是异步加载，在 CommonJS 中，当执行到 require 语句的时候才会去加载执行模块，而在 require.js 中，在执行到 require 之前依赖的模块就已经加载并执行完毕了，这是浏览器特性所致。

尽管 AMD 的设计理念很好，但是与同步加载的模块标准相比其语法更冗长，另外加载的方式不如同步显得清晰，容易造成回调地狱。所以在目前的实际应用中已经越来越少，大多数的开发者还是会选择 CommonJS 或者 ES6 Module。

CMD Common Module Definition

CMD 规范专门用于浏览器端，模块的加载是异步的，模块使用时才会加载执行。CMD 规范整合了 CommonJS 和 AMD 规范的特点，主要的实现就是 Sea.js。在 Sea.js 中，所有 JavaScript 模块都遵循 CMD 模块定义规范。看一个 Sea.js 的例子。

//index.html
;<body>
  <script type='text/javascript' src='sea.js'></script>
  <script type='text/javascript'>seajs.use('./index');</script>
</body>

//index.js
define(function (require) {
  var m1 = require('./module1')
  var m4 = require('./module4')
  m1.show()
  m4.show()
})

//module1.js
define(function (require, exports, module) {
  //内部变量数据
  var data = 'clloz.com'
  //内部函数
  function show() {
    console.log('module1 show() ' + data)
  }
  //向外暴露
  exports.show = show
})

//module2.js
define(function (require, exports, module) {
  module.exports = {
    msg: 'I Will Back'
  }
})

//module3.js
define(function (require, exports, module) {
  const API_KEY = 'clloz1992'
  exports.API_KEY = API_KEY
})

//module4.js
define(function (require, exports, module) {
  //引入依赖模块(同步)
  var module2 = require('./module2')
  function show() {
    console.log('module4 show() ' + module2.msg)
  }
  exports.show = show
  //引入依赖模块(异步)
  require.async('./module3', function (m3) {
    console.log('异步引入依赖模块3  ' + m3.API_KEY)
  })
})

//输出
//module1 show() clloz.com
//module4 show() I Will Back
//异步引入依赖模块3  clloz1992

我们可以看出 sea.js 的语法更接近 CommonJS，它的设计原则也是就近依赖，在用到某个模块的时候再去 require。对 CMD 来说代码在运行时，首先是不知道依赖的，需要遍历所有的 require 关键字，找出后面的依赖。具体做法是将 function toString 后，用正则匹配出 require 关键字后面的依赖。显然，这是一种牺牲性能来换取更多开发便利的方法。所以对比一下两者的实现方式，在模块的加载上并没有什么太大的区别，但是回调函数执行时机不一样的。打个比方有一个模块 a.js 依赖 require1.js, require([require1], callback() {})，代码必然是先执行 a.js，然后生成一个 src 为 require1.js 的 script 标签 append 到 body 上，同时把 a.js 的 callback 函数放到全局的一个 module 对象的对应属性上，这个 module 对象给每个模块一个 id，也就是说 a.js 的 callback 就在 modules[id].callback，当 require1.js 的 onload 触发之后，就会执行 modules[id].callback()。大概原理就是这样，AMD 和 CMD 的区别就在于，在 AMD 中，当 onload 一触发立即执行 modules[id].callback()，而在 CMD 中，执行到 require 才会执行 modules[id].callback()。这就是他们本质的区别，其他都只是一些语法上的差别，在模块的加载和运行上是没有本质区别的。

打包工具

在讲 ES6 的模块之前先说一说打包工具。打包工具是解决模块化的另一个方案，打包工具有很多种，目前最流行的就是 webpack。打包工具在服务端帮我们做好依赖分析，然后根据依赖把所有的 js （webpack 可以利用 loader 打包其他类型文件）都打包到一个文件中，同时还能够扩展非常多的功能，包括代码的压缩混淆，代码分割，基础库分离，服务端渲染等等，对于开发有 webpack-dev-server 这样的热更新机制，压缩混淆后的文件也能够用 source map 进行调试。有了打包工具，配合 babel，eslint 还有各种 loader，plugin 就已经能够实现我们之前的模块化目标了。

ES6

ES6 模块化早期叫做 ES Harmony，现在一般就叫做 ES6 模块。这很可能成为浏览器和服务端的最终模块化方案，目前的支持已经越来越好，不过还是要借助一些工具和特殊语法。兼容性可以查看 Can I use。我们平时在 Webpack 中使用的 export 和 import，会经过 Babel 转换为 CommonJS 规范。在使用上的差别主要有：

ES6 的模块主要是用 import 和 export 两个命令来导入和导出模块。表面上看和 CommonJS 并没有什么不同，但是实际上它们的原理并不相同。它们的不同点主要有以下：

CommonJS 是运行时才能确定依赖，进行加载；ES6 模块是编译时输出接口。
CommonJs 是动态语法可以写在判断里（运行时加载），ES6 Module 静态语法只能写在顶层（编译时加载，有提升机制）。
CommonJS 模块输出的是一个值的拷贝（模块就是对象，输入时必须查找对象属性），ES6 模块不是对象，而是通过 export 命令显式指定输出的代码，再通过 import 命令输入。
CommonJs 是单个值导出，ES6 模块可以导出多个。
CommonJs 的 this 是当前模块，ES6 模块的 this 是 undefined。
ES6 的模块自动采用严格模式。
require() 是同步加载，后面的代码必须等待这个命令执行完，才会执行。import 命令则是异步加载，或者更准确地说，ES6 模块有一个独立的静态解析阶段，依赖关系的分析是在那个阶段完成的，最底层的模块第一个执行。
import 和 export 的变量或方法名要对应，CommonJS 的 require 和 module.exports 则不必。主要原因就是 ES6 是根据对应的标识符去模块中找，而 require 只是到保存模块返回值的对象中找对应的模块。

ES6 模块的设计思想，是尽量的静态化，使得编译时就能确定模块的依赖关系，以及输入和输出的变量。这样当然效率更高，但是相应的就是所有的依赖就要在模块顶部声明，且不能按需加载（将依赖写进判断中），CommonJS 的 require 则可以按需加载。为了解决这个问题，也提出了动态 import() 的概念，不过目前还没有很好的兼容性，兼容性查看 Can I use。

还有一点很重要的区分就是 CommonJS 中我们输出的其实就是 module.exports 这个对象，而 ES6 模块不是对象，而是通过 export 命令显式指定输出的代码，再通过 import 命令输入。

export

一个模块就是一个独立的文件。该文件内部的所有变量，外部无法获取。如果你希望外部能够读取模块内部的某个变量，就必须使用 export 关键字输出该变量。

// profile.js
export var firstName = 'Michael'
export var lastName = 'Jackson'
export var year = 1958

export { firstName, lastName, year }

上面的代码就是模块的输出接口，我们可以看到有两种写法，一种是单独 export 每一个变量，还有一种是一次 export 多个变量。尽量使用后一种，这样我们能在脚本中很清晰的了解到输出了哪些变量和方法。

我们还可以利用 as 关键字来给输出的变量或者方法重命名，同一个变量可以重命名为不同的分别输出。

function v1() { ... } function v2() { ... }
export {
  v1 as streamV1,
  v2 as streamV2,
  v2 as streamLatestVersion
};

export 和 CommonJS module.exports 以及 exports 是完全不同的。它输出的不是一个对象，而只是模块的一个接口，这个接口必须和导出的变量名有一一对应的关系，所以一般我们只有两种写法，一种是在声明前加 export，另一种就是用大括号将要输出的接口包裹起来。下面的代码中报错的两种写法相当于直接输出常量，不是一个合法的接口。

// 报错
export 1;
// 报错
var m = 1; export m;

// 写法一
export var m = 1;
// 写法二
var m = 1; export {m};
// 写法三
var n = 1; export {n as m};

// 报错
function f() {}
export f;
// 正确
export function f() {};
// 正确
function f() {}
export {f};

其实所谓的输出接口不是很好理解，下面一个例子可以帮助大家理解。在 CommonJS 中，我们引入一个模块的输出的非引用类型的值，这个值就和原来的模块没有关系了，CommonJS 模块输出的是值的缓存。但是在 ES6 Module 中我们取到的就是原模块中的值，所以想修改依赖模块中的 const 变量将会报错。可以看下面的例子：

import { foo } from './export.js'

setTimeout(() => {
  console.log(foo)
}, 500)
//123
//baz

//export.js
console.log(123)
export let foo = 'bar'
setTimeout(() => (foo = 'baz'), 0)

我们在依赖的模块 export.js 中异步修改 foo 的值，最后我们在执行输出的时候，发现这个值也随着元模块的改变而改变了。使用 CommonJS 则依然会输出 bar。当然如果输出的本身是一个引用类型，但让指向的都是同一个对象。

最后， export 命令可以出现在模块的任何位置，只要处于模块顶层就可以。如果处于块级作用域内，就会报错，下一节的 import 命令也是如此。这是因为处于条件代码块之中，就没法做静态优化了，违背了 ES6 模块的设计初衷。

import

使用 export 命令定义了模块的对外接口以后，其他 JS 文件就可以通过 import 命令加载这个模块。import 命令接受一对大括号，里面指定要从其他模块导入的变量名。大括号里面的变量名，必须与被导入模块对外接口的名称相同。和 export 一样，import 也支持 as 关键字，如果你想要一个新的名字可以用 as 重新命名。

import 后面的 from 指定模块文件的位置，可以是相对路径，也可以是绝对路径， .js 后缀可以省略。如果只是模块名，不带有路径，那么必须有配置文件，告诉 JavaScript 引擎该模块的位置。

import 命令具有提升效果，会提升到整个模块的头部，首先执行。比如下面的写法并不会报错，这种行为的本质是， import 命令是编译阶段执行的，在代码运行之前。

import { foo } from 'my_module'

foo()

由于 import 存在静态分析，所以不能使用表达式和变量，这些只有在运行时才能得到结果的语法结构。下面三种写法都会报错，因为它们用到了表达式、变量和 if 结构。在静态分析阶段，这些语法都是没法得到值的。

// 报错
import { 'f' + 'oo' } from 'my_module';
// 报错
let module = 'my_module';
import { foo } from module;
// 报错
if (x === 1) {
  import { foo } from 'module1';
} else {
  import { foo } from 'module2';
}

import 和 require 都会执行加载的模块。多次执行同一句 import 或者 require 都只会执行一次对应的模块。对于同一个模块中输出的不同变量，可以在一条 import 中引入，也可以分多条引入，他们是等价的。

// 等同于
import { bar, bar, foo, foo } from 'my_module'

import 支持用 * 指定一个对象，所有输出值都加载在这个对象上面。使用 * 用 as 指定一个生成的对象名。使用 * 整体载入的对象，应该是可以静态分析的，所以不允许运行时改变。下面的写法都是不允许的（一般会提示，The members of xxx are read-only。

import * as circle from './circle'

// 下面两行都是不允许的
circle.foo = 'hello'
circle.area = function () {}

关于 import 的 from 后面引入的模块是不是要加 .js 后缀的问题，我在 node 中测试是不加会报错。这一点我也感觉很奇怪。

export default

前面的例子可以看出，和 require 不一样，我们使用 import 必须知道对应的模块输出的变量的名字，否则无法进行 import。不过 ES6 Module 也提供了一种让我们直接加载模块的方法，就是 export default，指定模块的默认输出。

export default 有几个特别的地方： 1. 我们在 import 的时候可以自己定义引入的变量名，类似 require，并且不需要使用大括号。 2. export default 的变量不会出现在 * 中。 3. 不能使用 export default let a = 10 这样的形式，必须先声明变量，再导出 let a; export default a = 10，函数和类的声明可以直接导出。

export default 命令用于指定模块的默认输出。显然，一个模块只能有一个默认输出，因此命令只能使用一次。所以， import 命令后面才不用加大括号，因为只可能对应一个方法。本质上，export default 就是输出一个叫做 default 的变量或方法，然后系统允许你为它取任意名字。所以，下面的写法是有效的。

// 等同于 export default add;

// app.js
import { default as xxx } from 'modules'

// modules.js
function add(x, y) {
  return x * y
}
export { add as default }

// 等同于  import xxx from 'modules';

正是因为 export default 命令其实只是输出一个叫做 default 的变量，所以它后面不能跟变量声明语句。

// 正确
export var a = 1;
// 正确
var a = 1;
export default a;
// 错误
export default var a = 1;

同样地，因为 export default 本质是将该命令后面的值，赋给 default 变量以后再默认，所以直接将一个值写在 export default 之后。

// 正确
export default 42;
// 报错
export 42;

如果想在一条 import 语句中同时引入默认方法可其它接口，可以写成这样：import _, { each, each as forEach } from 'lodash';

如果在一个模块之中，先输入后输出同一个模块， import 语句可以与 export 语句写在一起。

export { foo, bar } from 'my_module';
// 等同于
import { foo, bar } from 'my_module';
export { foo, bar };

//模块的接口改名和整体输出，也可以采用这种写法。
// 接口改名
export { foo as myFoo } from 'my_module';
// 整体输出
export * from 'my_module';

//默认输出也可以使用这种写法
export { default } from 'foo';

//具名接口输入改为默认接口输出
export { es6 as default } from './someModule';
// 等同于
import { es6 } from './someModule';
export default es6;

//默认接口输入改为具名接口输出
export { default as es6 } from './someModule';

还有三种语句不具备复合写法：

import * as someIdentifier from 'someModule'
import someIdentifier from 'someModule'
import someIdentifier, { namedIdentifier } from 'someModule'

import()

动态 import 的语法是 import()，静态的 import 没法像 require 那样按需加载，写在条件语句中。ES6 Module 要取代 CommonJS 这也是必须解决的一个问题，所以提出了动态 import。比如下面的代码，require 可以进行动态加载，要加载哪个模块只有运行时才知道。

const path = './' + fileName
const myModual = require(path)

import() 是一个函数，返回一个 Promise 对象。下面是一个例子。

const main = document.querySelector('main')
import(`./section-modules/${someVariable}.js`)
  .then((module) => {
    module.loadPageInto(main)
  })
  .catch((err) => {
    main.textContent = err.message
  })

import() 函数可以用在任何地方，不仅仅是模块，非模块的脚本也可以使用。它是运行时执行，也就是说，什么时候运行到这一句，也会加载指定的模块。另外，import() 函数与所加载的模块没有静态连接关系，这点也是与 import 语句不相同。import() 类似于 Node 的 require 方法，区别主要是前者是异步加载，后者是同步加载。

import() 可以用于动态加载，条件加载和动态的模块路径。

import() 加载模块成功以后，这个模块会作为一个对象，当作 then 方法的参数。因此，可以使用对象解构赋值的语法，获取输出接口。

import('./myModule.js').then(({ export1, export2 }) => {
  // ...·
})

//default
import('./myModule.js').then((myModule) => {
  console.log(myModule.default)
})

目前在浏览器中使用 ES6 Module 必须要增加一个标签属性 type="module"，并且要启动 web 服务器进行访问，否则会有跨域报错。ES6 Module 的加载机制和加了 defer 的标签一样，不会堵塞 DOM 的解析和渲染，在 DOM 构建完成，触发 DOMContentLoaded 事件以后按照标签的顺序执行对应的模块。

<script type="module" src="foo.js"></script>
<!-- 等同于 -->
<script type="module" src="foo.js" defer></script>
```html

`<script>` 标签的 `async` 属性也可以打开，这时只要加载完成，渲染引擎就会中 断渲染立即执行。执行完成后，再恢复渲染。关于 `defer`，`async` 和资源加载的阻塞机制可以参考我的另一篇文章：[浏览器渲染过程及Event Loop浅析](https://www.clloz.com/programming/front-end/js/2019/04/25/how-browser-work-2/ "浏览器渲染过程及Event Loop浅析")

`ES6` 模块也允许内嵌在网页中，语法行为与加载外部脚本完全一致。

```javascript
<script type="module">
    import utils from "./utils.js";
    // other code
</script>

对于外部加载的模块脚本，有几点需要注意：

代码是在模块作用域之中运行，而不是在全局作用域运行。模块内部的顶层变量，外部不可见。
模块脚本自动采用严格模式，不管有没有声明
模块之中，可以使用 import 命令加载其他模块( .js 后缀不能省略，需要提供绝对 URL 或相对 URL)，也可以使用 export 命令输出对外接口。
模块之中，顶层的 this 关键字返回，而不是指向 window 。也就是说，在模块顶层使用 this 关键字，是无意义的。
同一个模块如果加载多次，将只执行一次。

严格模式限制：

变量必须声明后再使用
函数的参数不能有同名属性，否则报错
不能使用 with 语句
不能对只读属性赋值，否则报错
不能使用前缀 0 表示八进制数，否则报错
不能删除不可删除的属性，否则报错
不能删除变量，只能删除对象属性
eval 不会在它的外层作用域引入变量
eval 和 arguments 不能被重新赋值
arguments 不会自动反映函数参数的变化
不能使用 a'r'guments.callee 和 arguments.caller
禁止 this 指向全局对象
不能使用 fn.caller 和 fn.callee 获取函数的调用堆栈。
增加了保留字（比如 protected，static 和 interface）

umd 模块（通用模块）

;(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined'
    ? (module.exports = factory())
    : typeof define === 'function' && define.amd
      ? define(factory)
      : (global.libName = factory())
})(this, function () {
  'use strict'
})

如果你在 js 文件头部看到这样的代码，那么这个文件使用的就是 UMD Universal Module Definition 规范。实际上就是 amd + commonjs + 全局变量 这三种风格的结合。

这段代码就是对当前运行环境的判断，如果是 Node 环境就是使用 CommonJs 规范，如果不是就判断是否为 AMD 环境，最后导出全局变量。

有了 UMD 后我们的代码和同时运行在 Node 和浏览器上，所以现在前端大多数的库最后打包都使用的是 UMD 规范。

需要注意的问题是，UMD 模块一般都先判断 AMD 环境，也就是全局下是否有 defined 函数，通过 AMD 定义的模块是无法使用 CommondJS 或 ES6 Module 的形式正确引入的。在 webpack 中由于它同时支持 AMD 和 CommonJS，如果你的工程中的所有模块都是 CommonJS，但是通过了 AMD 检测（全局有 define 函数），那么就会使用 AMD 的方式导出，遇到这样的情况我们可以更改 UMD 的判断顺序即可。

ES6 Module 和 CommonJS 差异

上面已经说过一些不同，这里进行一下总结。最主要的两点不同：

CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用。
CommonJS 模块是运行时加载，ES6 模块是编译时输出接口。

先说一说第一个差异，这里主要说的是原始数据类型，对于输出的原始数据类型，require 进一个新的模块后相当于复制了一个副本，对这个副本的操作不会影响到原来模块中的值，而 import 则不同。对于引用类型，require 过来的就是一个对象的引用，所以对对象的修改自然会对被引入模块有影响。import 对引用类型的引入虽然表现和 require 类型，但是他们底层的机制是完全不同的。

//a.js
const { bar } = require('./b.js')

console.log(bar.count)
bar.count++

//b.js
exports.bar = {
  count: 0
}

setTimeout(() => {
  console.log(exports.bar.count)
}, 1000)

//运行 a.js 得到的结果是 1 2，可见 a.js 中的 bar.count++ 还是传递到了 b.js 中

第二个差异是因为 CommonJS 加载的是一个对象(即 module.exports)，该对象只有在脚本运行完才会生成。而 ES6 模块不是对象，它的对外接口只是一种静态定义，在代码静态解析阶段就会生成。

第一个差异是 ES6 模块的运行机制与 CommonJS 不一样。**JS 引擎对脚本静态分析的时候，遇到模块加载命令 import ，就会生成一个只读引用。等到脚本真正执行时，再根据这个只读引用，到被加载的那个模块里面去取值。**换句话说，ES6 的 import 有点像 Unix 系统的“符号连接”，原始值变了， import 加载的值也会跟着变。因此， ES6 模块是动态引用，并且不会缓存值，模块里面的变量绑定其所在的模块。

// main.js
import { counter, incCounter } from './lib'

// lib.js
export let counter = 3
export function incCounter() {
  counter++
}

console.log(counter) // 3
incCounter()
console.log(counter) // 4

ES6 模块不会缓存运行结果，而是动态地去被加载的模块取值，并且变量总是绑定其所在的模块。由于 ES6 输入的模块变量，只是一个“符号连接”，所以这个变量是只读的，对它进行重新赋值会报错。

// main.js
import { obj } from './lib'

// lib.js
export let obj = {}

obj.prop = 123 // OK
obj = {} // TypeError: Assignment to constant variable.

上面代码中， main.js 从 li'b.js 输入变量 obj ，可以对 obj 添加属性，但是重新赋值就会报错。因为变量 obj 指向的地址是只读的，不能重新赋值，这就好比 main.js 创造了一个名为 obj 的 const 变量。

最后， export 通过接口，输出的是同一个值。不同的脚本加载这个接口，得到的都是同样的实例。

在 `node` 中使用 `ES6` 模块

目前在 NodeJS 中直接使用 ES6 有两种方式，一种是在 package.json 中添加字段 type="module"，另一种是设置文件后缀为 mjs。模块寻找顺序：

import './foo'
// 依次寻找
// ./foo.js
// ./foo/package.json
// ./foo/index.js

import 'baz'

// 依次寻找
// ./node_modules/baz.js
// ./node_modules/baz/package.json
// ./node_modules/baz/index.js
// 寻找上一级目录
// ../node_modules/baz.js
// ../node_modules/baz/package.json
// ../node_modules/baz/index.js
// 再上一级目录

用 import 加载 CommonJS 模块的时候 module.exports 会被当做 export default 处理，如果使用 * 则会在新的变量名上添加一个 default 属性指向 module.exports。比如 import * as clloz from 'xxx'，则 clloz.default 即指向 module.exports。CommonJS 模块的输出缓存机制，在 ES6 加载方式下依然有效。使用 import 引入 CommonJS 的模块的时候只能使用 default 或者 * 的形式，不能使用 import {readfile} from 'fs'; 这种形式。

采用 require 命令加载 ES6 模块时，ES6 模块的所有输出接口，会成为输入对象的属性。

// es.js
let foo = { bar: 'my-default' }
export default foo
foo = null

// cjs.js
const es_namespace = require('./es')
console.log(es_namespace.default)
// {bar:'my-default'}

上面代码中，接口变成了 es_namespace.default 属性。另外，由于存在缓存机制，e's.js 对 foo 的重新赋值没有在模块外部反映出来。

循环加载

循环加载(circular dependency)指的是， a 脚本的执行依赖 b 脚本，而 b 脚本的执行又依赖 a 脚本。CommonJS 和 ES6，处理循环加载的方法是不一样的，返回的结果也不一样。

CommonJS 上面也已经讲过其原理，一个模块就是一个脚本文件。 require 命令第一次加载该脚本，就会执行整个脚本，然后在内存生成一个对象。

{
    id: '...',
    exports: { ... },
    loaded: true,
...
}

该对象的 id 属性是模块名， exports 属性是模块输出的各个接口， loaded 属性是一个布尔值，表示该模块的脚本是否执行完毕。其他还有很多属性，这里都省略了。以后需要用到这个模块的时候，就会到 exports 属性上面取值。即使再次执行 require 命令，也不会再次执行该模块，而是到缓存之中取值。也就是说， CommonJS 模块无论加载多少次，都只会在第一次加载时运行一次，以后再加载，就返回第一次运行的结果，除非手动清除系统缓存。

CommonJS 模块的重要特性是加载时执行，即脚本代码在 require 的时候，就会全部执行。一旦出现某个模块被"循环加载"，就只输出已经执行的部分，还未执行的部分不会输出。

//a.js
exports.done = false
var b = require('./b.js')
console.log('在 a.js 之中，b.done = %s', b.done)
exports.done = true
console.log('a.js 执行完毕')

//b.js
exports.done = false
var a = require('./a.js')
console.log('在 b.js 之中，a.done = %s', a.done)
exports.done = true
console.log('b.js 执行完毕')

上面的例子是 NodeJS 官方给出的例子，当执行 a 时执行到 require b 会立即执行 b，在 b 中执行到 require a 的时候只会直接返回当前 a 已经执行的部分，系统也只能取到第一个 exports.done = false 交给 b，然后 b 继续执行，执行完之后再把执行权交给 a。如果我们这里连 exports.done 都没有，那么 b 拿到的就是一个空对象，因为实际上取得就是 module.exports 对象。

执行下面的 main.js 最后的输出如下：

//main.js
var a = require('./a.js')
var b = require('./b.js')
console.log('在 main.js 之中, a.done=%s, b.done=%s', a.done, b.done)

//在 b.js 之中，a.done = false
//b.js 执行完毕
//在 a.js 之中，b.done = true
//a.js 执行完毕
//在 main.js 之中, a.done=true, b.done=true

上面的代码证明了两件事。一是，在 b.js 之中， a.js 没有执行完毕，只执行了第一行。二是， main.js 执行到第二行时，不会再次执行 b.js ，而是输出缓存的 b.js 的执行结果（每个模块只会执行一次），即它的第四行。

ES6 处理“循环加载”与 CommonJS 有本质的不同。ES6 模块是动态引用，如果使用 import 从一个模块加载变量(即 import foo from 'foo' )，那些变量不会被缓存，而是成为一个指向被加载模块的引用，需要开发者自己保证，真正取值的时候能够取到值。

// a.js如下

// b.js
import { foo } from './a.js'
import { bar } from './b.js'

console.log('a.js')
console.log(bar)
export let foo = 'foo'

console.log('b.js')
console.log(foo)
export let bar = 'bar'

//执行a.js 后输出如下
//b.js
//undefined
//a.js
//bar

执行 a.js，第一行就是 import 加载 b.js，所以进入会执行 b.js。b.js 的第一行是加载 a.js，这时由于 a.js 已经执行，所以不会把执行权交给 a，而是继续执行 b，此时 b 中的 import 相当于记录了 a 中的一个接口 foo，等到代码调用到这个接口的时候，会到 a 的执行环境中去找这个接口对应的值。当执行到 console.log(foo) 的时候，引擎会去找 a 中有没有 export 的 foo（注意，此时引擎肯定已经完成了对 a 的静态分析和执行环境的生成，也就是变量提升都完成了），如果我们在 a 中的 foo 是用 let 声明的，那么这里会报错 ReferenceError: Cannot access 'foo' before initialization，因为 let 的暂时性死区。如果是用 var 声明的，那么我们会获得 undefined。执行完 b 之后回到 a 执行，一切恢复正常。

这里我总结一下，当一个模块开始执行，那么它的静态分析和执行上下文（即环境记录 environment records 已经生成，新标准中称为环境记录，你也可以用以前的变量对象活动对象理解，即变量声明提升已经完成）肯定都构建完成了，而当我们执行到 import 的时候主要就是做两件事，一件就是去执行引入的模块（如果模块正在执行栈中就略过这一步），另一件事就是将引入的接口保存，比如 a 中的 bar，这一步不会去访问这个 bar 是什么，只是记住有这个 bar，下面调用这个 bar 的时候才会去 b 的环境记录中去取。如果你对变量提升的细节不清楚，可以看我的另一篇文章 var，let，const和变量提升（hoist），主要要注意的就是每一个模块都是一个单独的环境，在浏览器中我们只有一个全局环境，和块级作用域，函数作用域，在 node 中每个模块都会是一个单的的作用域，var 声明的全局变量也只在这个模块下生效（注意 es6 module 自动运行在严格模式下，模块环境下 this 指向 undefined）。

这里我之前对模块执行完之后垃圾回收有点疑问，不过我后来的理解就是模块也是一个单独的环境，就是比原来浏览器环境的 js 多了一个模块级作用域，垃圾回收机制还是一样，只要存在引用就不会回收。

再来一个复杂一点的例子，求执行 a.js 的输出

// a.js

// b.js
import { foo } from './a.js'
import { bar } from './b.js'

export function foo() {
  console.log('foo')
  bar()
  console.log('执行完毕')
}
foo()

export function bar() {
  console.log('bar')
  if (Math.random() > 0.5) {
    foo()
  }
}

如果这段代码使用的 require 那么肯定会报错，因为 b 中的 foo 是 undefined，执行 foo 肯定会报错（当然，如果没有进入 bar 中执行 foo 的逻辑就不会报错，50% 的概率。

//a.js
const { bar } = require('./b.js')
function foo() {
  console.log('foo')
  bar()
  console.log('执行完毕')
}
foo()
module.exports.foo = foo

//b.js
const { foo } = require('./a.js')
function bar() {
  console.log('bar')
  if (Math.random() > 0.5) {
    console.log(foo)
    foo()
  }
}
module.exports.bar = bar

但是在 ES6 的模块机制中这段代码使能执行的。为什么呢，其实我们就把 ES6 中的 import 看得简单一点，import 语句的功能就是执行对应模块，然后留下一个接口。**最关键的地方就是当这个接口被使用时，才会去对应的模块 export 的变量方法中找这个接口对应的变量或方法，记住这个接口只是对模块的一个引用。**这是我个人的理解。

把这个理解带入到代码中就能得到，a 中先执行 import b，会立即执行 b 同时添加一个 b 中的引用 bar（注意此时无所谓这个引用是什么，只有下面的语句执行用到 bar 的时候才会去到 b 里面找有没有 export 的 bar）。执行 b 的过程也一样，第一句是 import a，和上一个例子一样，此时 a 已经在执行了，所以这一句只是添加一个叫 foo 的指向 a 的引用。b 执行完之后回到执行权交回 a，在 a 中执行到 foo() 会执行 foo 方法，foo 方法内部再调用 bar，此时就会去 b 中找有没有 export 的 bar，找到后执行 bar。执行 bar 的过程一样，，不过这里加了个随机数，如果执行到 foo 就会去 a 中找有没有 export 的 foo，所以这段代码的执行次数是不确定的，最少两次，多的话多少次都有可能。

其实我们还可以再深入一点，如果在 b 中直接加一句 foo() 会怎么样呢？我们将代码变成如下情况：

//a.js

// b.js
import { foo } from './a.js'
import { bar } from './b.js'

export function foo() {
  console.log('foo')
  console.log('执行完毕')
}

export function bar() {
  console.log('bar')
}
foo()

//执行结果
//foo
//bar
//执行完毕

我们可以发现，在 b 中直接执行 foo() 依然能够正常执行，虽然此时 a 中只执行到第一句 import。我们再深入一点，我们在 a 中 export 出各种不同的数据类型看看会有什么现象：

//a.js

// b.js
import { m, name, obj, str } from './a.js'
import { bar } from './b.js'

bar()

export function m() {
  return {
    name: 'clloz'
  }
}
var name = m()
export let str = 'clloz'
export let obj = {}
export { name }

export function bar() {
  console.log('bar')
}
console.log(m) //[Function: m]
console.log(str) //ReferenceError: Cannot access 'str' before initialization
console.log(obj) //ReferenceError: Cannot access 'obj' before initialization
console.log(name) //undefined

这里面 m 是一个函数声明，str 是一个 let 声明的字符串，obj 是一个 let 声明的对象，name 是一个 var 声明的变量，它的值是执行 m 后返回的对象。最后在 b 中的执行结果看上面的代码，m 成功输出 a 中的 m 函数；str 和 obj 都是 ReferenceError，name 是 undefined。看出来了没有，他们都是根据变量提升的规则获得了对应的值。

当执行 b 的时候，模块 a 中的代码其实只执行了一句，就是 import 语句，但此时模块内的变量提升肯定已经完成了（变量提升在执行之前），关于变量提升的规则这里不细讲了，不清楚的同学看另一片文章 var，let，const和变量提升（hoist）。

这里我补充一个我发现的循环依赖的问题，是关于 export default 的。看下面这个例子：

//a.mjs
import bar from './b.mjs';

function foo(invoker) {
    console.log(invoker + ' invokes foo.js');
    bar('foo.js');
}

foo('index.js');
export default foo;

//b.mjs
import foo from './a.mjs';
let invoked = false;
// console.log(foo);
function bar(invoker) {
    if (!invoked) {
        invoked = true;
        console.log(invoker + ' invokes bar.js');
        foo('bar.js');
    }
}
export default bar;

执行 a.mjs，在执行到 bar 函数中调用 foo 的地方报错：ReferenceError: Cannot access 'foo' before initialization。把 a.mjs 中的 foo() 调用移动到 export default 之后能正常运行，或者把 export default 改成普通的 export {} 形式也可以。

这里我猜想是不是 export default 也只是把后面的值传给 default（假想成一个变量之类的），然后这个 default 类似于 let 有暂时性死区，只有执行到 export default 这一句时才给 default 赋值，所以会造成上面的现象。我们在 b 中加一句 console.log(foo); 的话，即使把 foo() 移动到 export default 下面，也会报错，因为执行 b.mjs 的时候，export default 还没有执行，这也印证了我的想法。

通过这几个例子，ES6 的模块规则其实已经非常清晰了。当我们执行 import 的时候，会做两件事：执行 import 的模块，在当前模块添加一个指向依赖模块的引用，比如上面的例子中，import {bar} from 'b.js'，就是在 a 中添加了一个 b 的引用 bar，当后面用到这个 bar 的时候会去 b 中找。注意一点，这个引用在没有使用之前，不必关心它是什么，a 也不知道 bar 是什么。当 a 的语句执行用到 bar 的时候，引擎就会去 b 的当前环境中去找有没有 export 的 bar，找到则返回，找不到则抛错。注意这个当前环境，这是循环加载的中点，上面的例子 a 的 import 后面的语句并没与执行，但是此时由于变量提升机制，我们已经能取到这些值了，所以成功返回。只是由于 str 和 obj 是用 let 声明的，所以不能在声明语句前使用。其实我们完全可以把那几句 console.log 语句放到 a 中的 import 语句下方执行，得到的结果是相同的。

总之记住一点，ES6 的模块机制，引入的别的模块的变量都是要到对应的模块中去找，并且是去对应模块的变量对象中去找，记住这个原则，一般的问题应该都能够理清楚，还有就是记住 export default 的情况。

关于模块的 gc 我认为就是添加一个模块级作用域即可（和函数作用域类比），它是一个单独的环境，只有内部的变量或者方法被外部引用，就不会释放其环境记录，

非模块化文件的使用

非模块化文件指的是并不遵循任何一种模块化标准的文件。如果你维护的是一个几年前的项目，那么极有可能里面会与非模块化文件，最常见的就是在 script 标签中引入的 jQuery 及其各种插件。

对于这类文件，我们如果想用打包工具进行处理，直接引入即可：

import './jquery.min.js'

require('./jquery.min.js')

其实不止这些非模块化文件，我们如果有什么不需要明确导出值，而只是要其执行的 js，甚至是一些静态文件（比如图片），都可以这样引入。一般来说，jQuery 这类库都会将其接口绑定在全局（我们可以通过 window.jQuery 获取 jQuery），因此无论从 script 标签引入，还是使用 webpack 打包引入，效果都是一样的，即只要在使用前执行即可。

但是有一点需要注意，webpack 会将模块都包裹在一层函数中，如果你的非模块化文件中的接口暴露是用的 var 这种隐式全局变量声明的方式，则无法在全局访问到。

总结

这篇文章从模块化的冬季和历史为切入点，讲了模块化发展历史上几个比较重要的模块化规范的使用方式和原理。其实我们现在主要掌握 CommonJS 和 ES6 Module 即可，它们两个是现在最主流的模块化方案，我们需要深入了解它们的设计思路和原理。童颜 CMD 和 AMD 的设计思路和思想还是值得看一看的。希望这篇文章对你有帮助，如果有错误，欢迎指正。

参考文章

AMD，CMD 规范详解
从 RequireJs 源码剖析脚本加载原理
模块化之AMD与CMD原理(附源码)
使用 AMD、CommonJS 及 ES Harmony 编写模块化的 JavaScript
《ES6 标准入门》 —— 阮一峰
深入 CommonJs 与 ES6 Module

Proxy ，Reflect，代理和反射

Mon, 19 Oct 2020 12:00:00 GMT

前言

本文主要说一说 ES6 添加的新内置对象，Proxy 和 Reflect，一般中文翻译为代理和反射。在编程语言中普遍存在的一个概念，JavaScript 在 ES6 中也引入了。

Proxy

Proxy 是代理的意思，简单一点说就是我们用 Proxy 对对象进行一层包装，返回一个新的代理对象。通过这个代理对象，我们可以对原来我们操作 Object 对象的很多属性方法进行定制。比如普通的 Object 对象的属性访问，我们就用 . 操作符或者 [] 进行成员访问，但是我们没办法对这个访问进行定制，比如我希望访问对象的时候通知其他对象，这在没有 Proxy 的时候是非常不方便的，我们可以通过 Object.definedProperty() 设置访问器属性，但是每个属性都要单独设置，而 Proxy 是对属性访问这个行为进行定制。

从上面的描述我们可以看出，Proxy 是对 JavaScript 中的对象的一种增强，我们拥有了更强的对象定制功能。Proxy 能够修改某些操作的默认行为，等同于在语言层面做出修改，所以属于一种“元编程”(meta programming)，即对编程语言进行编程。看一个最简单的例子：

let o = {
  name: 'clloz',
  age: '28',
  site: 'clloz.com'
}

let p = new Proxy(o, {
  get: function (target, property, receiver) {
    console.log(target)
    console.log(property)
    console.log(receiver)
    return target[property]
  }
})

console.log(o.name) //clloz
console.log(p.name)
//{ name: 'clloz', age: '28', site: 'clloz.com' }
//name
//{ name: 'clloz', age: '28', site: 'clloz.com' }
//clloz
console.log(p) //{ name: 'clloz', age: '28', site: 'clloz.com' }

这是一个用 Proxy 代理 Object 的属性访问行为的例子，我们可以看到 Proxy 接受两个参数，一个是代理的目标对象，另一个是一个对象，其中放着我们定制的代理方法，Proxy 提供了非常丰富的方法，这里我只是使用了我们比较熟悉的属性访问。我们可以看到 get 方法传入了三个参数，分别对应目标对象，我们访问的属性，和 Proxy 对象。例子中 receiver 就是我们定义的 p 对象，receiver === p 将返回 true，但是 receiver 不一定是 Proxy 下面介绍 handler 会详细说明。

只有通过代理进行访问才能出发我们定制的行为，比如例子中我们直接访问 o.name 就只是访问对象属性。而我们打印 Proxy 对象，和普通的对象看上去也没有区别。我试了 Objec.prototype.toString.call(p)，得到的结果只是 [object Object]，所以目前应该没有方法直接能够判断一个对象是代理还是普通对象。

Proxy 是一个构造函数，并且不能直接调用，直接调用会报错：TypeError: Constructor Proxy requires 'new'。Proxy 没有 prototype，Proxy.prototype 将返回 undefined。Proxy.[[prototype]] 为 Function.protoyep，这一点和其他所有函数相同。

用法

Proxy 对象只有一种用法就是 let proxy = new Proxy(target, handler)，以构造函数的形式创建目标对象的代理，两个参数都是必须的，缺少参数将抛错 TypeError: Cannot create proxy with a non-object as target or handler。target 是要使用 Proxy 包装的目标对象（可以是任何类型的对象，包括原生数组，函数，甚至另一个代理）。我们主要控制的就是 handler，所有的代理逻辑都在 handler 中。如果 hanlder 为空对象，那么就相当于我们没有任何代理逻辑，通过代理访问和访问源对象就没区别，不过这样做并没有什么实际意义。

let o = {
  name: 'clloz',
  age: '28',
  site: 'clloz.com'
}

let p = new Proxy(o, {})

console.log(p.name) //clloz

有一个小技巧是我们可以将代理对象设置为目标对象的一个属性，这样我们可以在目标对象上直接访问到代理对象。let object = { proxy: new Proxy(target, handler) };

代理对象也可以作为其他对象的原型：

let o = {
  name: 'clloz',
  age: '28',
  site: 'clloz.com'
}

let p = new Proxy(o, {})

let m = Object.create(p)
console.log(m.name) //clloz

console.log(p.__proto__ === Object.prototype)

上面我们说过，Proxy.prototype 是 undefined，按照通常的原型链规则推断，p 的 [[prototype]] 应该是指向其构造函数的 prototype 属性，但是在 Proxy 这里，p 的 [[prototype]] 指向的是 Object.prototype。

综合上面的一些结论，其实我们完全可以把代理理解为一个功能更强大的**“普通对象”**，只是他的一些行为可能不完全和普通对象一致，比如 this 的指向。

Proxy 代理的核心就是 handler，handler 对象是一个容纳一批特定属性的占位符对象。它包含有 Proxy 的各个捕获器（trap）。所有的捕捉器是可选的。如果没有定义某个捕捉器，那么就会保留源对象的默认行为。所以下面我们介绍一下 Proxy 都提供了哪些捕获器。

handler.get()

handler.get(target, key, receiver) 拦截属性读取操作。target 为代理的目标对象，property 为被读取的属性名。第三个参数 receiver 为最初被调用的对象，即让我们在 getter 知道是谁在访问。通常是 proxy 本身，但 handler 的 get 方法也有可能在原型链上，或以其他方式被间接地调用（因此不一定是 proxy 本身）看下面的例子：

let o = {
  name: 'clloz',
  age: '28',
  site: 'clloz.com'
}

let p = new Proxy(o, {
  get: function (target, property, receiver) {
    console.log(receiver === m) //true
    return target[property]
  }
})

let m = Object.create(p)
console.log(m.name) //clloz

我们可以看到，我们以 Proxy 为原型创建了一个对象 m，当访问 m 上没有的属性的时候就会到原型链上查找，就触发了 get 捕捉器，我们在其中的 receiver === m 将返回 true。这里要特别注意，不要直接执行 console.log(receiver)，否则将会出现栈溢出的状况。其中原因就是，receiver 是一个对象，我们输出这个对象，又会执行对象的 get 操作，进入无限的循环。不过如果我们直接输出 p.name 则不会有这个错误，可能是因为 Proxy 本身没有 get 操作。从这个例子中我们也可以看到，get 方法是可以继承的。

get 方法会拦截目标对象的以下操作:

访问属性: proxy[foo]和 proxy.bar
访问原型链上的属性: Object.create(proxy)[foo]
Reflect.get()

如果违背了以下的约束，proxy 会抛出 TypeError:

如果要访问的目标属性是不可写以及不可配置的，则返回的值必须与该目标属性的值相同。
如果要访问的目标属性没有配置访问方法，即 get 方法是 undefined 的，则返回值必须为 undefined。

利用代理的 get 捕捉器我们可以实现很多有趣的功能，比如用负数索引读取数组：

function createArray(...elements) {
  let handler = {
    get(target, propKey, receiver) {
      let index = Number(propKey)
      if (index < 0) {
        propKey = String(target.length + index)
      }
      return Reflect.get(target, propKey, receiver)
    }
  }
  let target = []
  target.push(...elements)
  return new Proxy(target, handler)
}
let arr = createArray('a', 'b', 'c')
console.log(arr[-1]) // c

利用 Proxy，可以将读取属性的操作( get )，转变为执行某个函数，从而实现属性的链式操作。

var pipe = (function () {
  return function (value) {
    var funcStack = []
    var oproxy = new Proxy(
      {},
      {
        get: function (pipeObject, fnName) {
          if (fnName === 'get') {
            return funcStack.reduce(function (val, fn) {
              return fn(val)
            }, value)
          }
          funcStack.push(window[fnName])
          return oproxy
        }
      }
    )
    return oproxy
  }
})()
var double = (n) => n * 2
var pow = (n) => n * n
var reverseInt = (n) => n.toString().split('').reverse().join('') | 0
pipe(3).double.pow.reverseInt.get // 63

如果一个属性不可配置(configurable)和不可写(writable)，则该属性不能被代理，通过 Proxy 对象访问该属性会报错。

const target = Object.defineProperties(
  {},
  {
    foo: {
      value: 123,
      writable: false,
      configurable: false
    }
  }
)
const handler = {
  get(target, propKey) {
    return 'abc'
  }
}
const proxy = new Proxy(target, handler)
proxy.foo // TypeError: Invariant check failed

handler.set()

handler.set(target, key, value, receiver) 属性设置操作的捕捉器，返回一个布尔值。返回 true 代表属性设置成功。在严格模式下，如果 set() 方法返回 false，那么会抛出一个 TypeError 异常。

该方法会拦截目标对象的以下操作:

指定属性值：proxy[foo] = bar 和 proxy.foo = bar
指定继承者的属性值：Object.create(proxy)[foo] = bar
Reflect.set()

如果违背以下的约束条件，proxy 会抛出一个 TypeError 异常：

若目标属性是一个不可写及不可配置的数据属性，则不能改变它的值。
如果目标属性没有配置存储方法，即 [[Set]] 属性的是 undefined，则不能设置它的值。
在严格模式下，如果 set() 方法返回 false，那么也会抛出一个 TypeError 异常。

利用 set 可以进行数据验证，还可以进行数据绑定，即每当对象发生变化时，会自动更新 DOM。有时，我们会在对象上面设置内部属性，属性名的第一个字符使用下划线开头，表示这些属性不应该被外部使用。结合 get 和 set 方法，就可以做到防止这些内部属性被外部读写。

var handler = {
  get(target, key) {
    invariant(key, 'get')
    return target[key]
  },
  set(target, key, value) {
    invariant(key, 'set')
    target[key] = value
    return true
  }
}
function invariant(key, action) {
  if (key[0] === '_') {
    throw new Error(`Invalid attempt to ${action} private "${key} " property`)
  }
}
var target = {}
var proxy = new Proxy(target, handler)
proxy._prop
// Error: Invalid attempt to get private "_prop" property
proxy._prop = 'c'
// Error: Invalid attempt to set private "_prop" property

set 可以监听数组的变化，包括一些 Array.prototype 上的方法，这也是 vue3.0 要使用 Proxy 来替换 Object.defineProperty 来实现响应式的原因之一。看下面的代码：

let a = [1, 2, 3]
let p = new Proxy(a, {
  get(target, key, receiver) {
    console.log('this is getter ' + key)
    return Reflect.get(target, key)
  },
  set(target, key, val, receiver) {
    console.log('this is setter ' + key)
    return Reflect.set(target, key, val, receiver)
  }
})
p.push(10)
//this is getter push
//this is getter length
//this is setter 3
//this is setter length

console.log(p)
//[ 1, 2, 3, 10 ]

console.log(p[0])
//this is getter 0
//1

console.log(p.length)
//this is getter length
//3

p.length = 0 // this is setter length

可以看到我们调用 push 方法，访问了两次 getter，第一次访问的 key 是 push，第二次则是 length。我们访问 p 从外部看到的效果和访问 a 没有区别，甚至我们直接访问和操作 length 也能够触发 getter 和 setter，因为 push 方法和 length 也是数组的属性和方法（虽然方法是在原型上的，但依然是通过该数组访问的），这就是 Proxy 提供的元编程的强大能力。

handler.apply()

handler.apply(target, thisArg, argumentsList) 方法用于拦截函数的调用。该捕捉器接受三个参数：target 目标对象，thisArg 被调用时的 this 上下文，argumentsList 被调用时的参数数组。

该方法会拦截目标对象的以下操作:

proxy(...args)
Function.prototype.apply() 和 Function.prototype.call()
Reflect.apply()

如果违反了以下约束，代理将抛出一个 TypeError：target 必须是可被调用的。也就是说，它必须是一个函数对象。

var p = new Proxy(function () {}, {
  apply: function (target, thisArg, argumentsList) {
    console.log('called: ' + argumentsList.join(', ')) // "called: 1, 2, 3"
    return argumentsList[0] + argumentsList[1] + argumentsList[2]
  }
})

console.log(p(1, 2, 3)) // 6

handler.has()

handler.has(target, prop) 该方法用来拦截 HasProperty 操作，即判断对象是否具有某个属性时，这个方法会生效。典型的操作就是 in 运算符。handler.has 方法可以看作是针对 in 操作的钩子。

这个钩子可以拦截下面这些操作:

属性查询: foo in proxy
继承属性查询: foo in Object.create(proxy)
with 检查: with(proxy) { (foo); }
Reflect.has()

如果违反了下面这些规则, proxy 将会抛出 TypeError:

如果目标对象的某一属性本身不可被配置，则该属性不能够被代理隐藏.
如果目标对象为不可扩展对象，则该对象的属性不能够被代理隐藏

var p = new Proxy(
  {},
  {
    has: function (target, prop) {
      console.log('called: ' + prop) // "called: a"
      return true
    }
  }
)

console.log('a' in p) // true
console.log(Reflect.has(p, 'a')) //和上一句代码一样被拦截

对象不可扩展或属性不可配置拦截 has 将抛错，所以如果我们不希望抛错可能需要对属性或者对象进行判断：

var obj = { a: 10 }
Object.preventExtensions(obj)
var p = new Proxy(obj, {
  has: function (target, prop) {
    return false
  }
})

'a' in p // TypeError: 'has' on proxy: trap returned falsish for property 'a' but the proxy target is not extensible

注意的是 has 方法拦截的是 hasProperty，而不是 hasOwnProperty，也就是说原型上的属性访问也会拦截。还有一点就是虽然 for ... in 虽然也用到了 in 运算符，但是 has 方法不会拦截 for ... in 循环。

handler.construct()

handler.construct(target, argumentsList, newTarget) 方法用于拦截 new 操作符. 为了使 new 操作符在生成的 Proxy 对象上生效，用于初始化代理的目标对象自身必须具有 [[Construct]] 内部方法（即 new target 必须是有效的）。

三个参数将被传入 construct 方法：target 目标对象，argumentsList 构造函数的参数列表，newTarget 最初被调用的构造函数。

该拦截器可以拦截以下操作:

new proxy(...args)
Reflect.construct()

如果违反以下约定，代理将会抛出错误 TypeError: 必须返回一个对象。target 必须由一个有效的 constructor 供 new 调用，一般情况下，目标对象要是一个函数。

两个简单的示例，演示拦截 new 操作以及违反约定的情况：

//拦截new操作
var p = new Proxy(function () {}, {
  construct: function (target, argumentsList, newTarget) {
    console.log('called: ' + argumentsList.join(', ')) // "called: 1"
    return { value: argumentsList[0] * 10 }
  }
})

console.log(new p(1).value) // 10

//违反约定，没有返回对象将抛错
var p = new Proxy(function () {}, {
  construct: function (target, argumentsList, newTarget) {
    return 1
  }
})

new p() // TypeError is thrown

//目标对象不能new
var p = new Proxy(
  {},
  {
    construct: function (target, argumentsList, newTarget) {
      return {}
    }
  }
)

new p() // TypeError is thrown, "p" is not a constructor

handler.deleteProperty()

handler.deleteProperty(target, property) 方法用于拦截对对象属性的 delete 操作。deleteProperty 必须返回一个 Boolean 类型的值，表示了该属性是否被成功删除。如果这个方法抛出错误或者返回 false ，当前属性就无法被 delete 命令删除。

该方法会拦截以下操作:

删除属性: delete proxy[foo] 和 delete proxy.foo
Reflect.deleteProperty()

如果违背了以下不变量，proxy 将会抛出一个 TypeError: 如果目标对象的属性是不可配置的，那么该属性不能被删除。

var p = new Proxy(
  {},
  {
    deleteProperty: function (target, prop) {
      console.log('called: ' + prop)
      return true
    }
  }
)

delete p.a // "called: a"

handler.defineProperty()

handler.defineProperty(target, property, descriptor) 该方法用于拦截对对象的 Object.defineProperty() 操作。该方法接受三个参数：target 目标对象，prop 待检索其描述符的属性名，descriptor 属性描述符。defineProperty 方法必须以一个 Boolean 返回，表示定义该属性的操作成功与否。

该方法会拦截目标对象的以下操作 :

Object.defineProperty()
Reflect.defineProperty()
proxy.property='value'

如果违背了以下的不变量，proxy 会抛出 TypeError:

如果目标对象不可扩展，将不能添加属性。
不能添加或者修改一个属性为不可配置的，如果它不作为一个目标对象的不可配置的属性存在的话。
如果目标对象存在一个对应的可配置属性，这个属性可能不会是不可配置的。
如果一个属性在目标对象中存在对应的属性，那么 Object.defineProperty(target, prop, descriptor) 将不会抛出异常。
在严格模式下， false 作为 handler.defineProperty 方法的返回值的话将会抛出 TypeError 异常。

var p = new Proxy(
  {},
  {
    defineProperty: function (target, prop, descriptor) {
      console.log('called: ' + prop)
      descriptor.value = 'clloz' //修改数据属性值
      descriptor.configurable = true //如果该属性不可配置，则这一句将抛错
      return Reflect.defineProperty(target, prop, descriptor)
    }
  }
)

var desc = { configurable: true, enumerable: true, value: 10, writable: true }
Object.defineProperty(p, 'a', desc) // "called: a"

console.log(p.a)

当调用 Object.defineProperty() 或者 Reflect.defineProperty()，传递给 defineProperty 的 descriptor 有一个限制 - 只有以下属性才有用，非标准的属性将会被无视 :

enumerable
configurable
writable
value
get
set

handler.getOwnPropertyDescriptor()

handler.getOwnPropertyDescriptor(target, prop) 方法是 Object.getOwnPropertyDescriptor() 的钩子。getOwnPropertyDescriptor 方法必须返回一个 object 或 undefined。

这个捕捉器可以拦截这些操作：

Object.getOwnPropertyDescriptor()
Reflect.getOwnPropertyDescriptor()

如果下列不变量被违反，代理将抛出一个 TypeError：

getOwnPropertyDescriptor 必须返回一个 object 或 undefined。
如果属性作为目标对象的不可配置的属性存在，则该属性无法报告为不存在。
如果属性作为目标对象的属性存在，并且目标对象不可扩展，则该属性无法报告为不存在。
如果属性不存在作为目标对象的属性，并且目标对象不可扩展，则不能将其报告为存在。
属性不能被报告为不可配置，如果它不作为目标对象的自身属性存在，或者作为目标对象的可配置的属性存在。
Object.getOwnPropertyDescriptor(target)的结果可以使用 Object.defineProperty 应用于目标对象，也不会抛出异常。

var p = new Proxy(
  { a: 20 },
  {
    getOwnPropertyDescriptor: function (target, prop) {
      console.log('called: ' + prop) // "called: a"
      return { configurable: true, enumerable: true, value: 10 }
    }
  }
)

console.log(Object.getOwnPropertyDescriptor(p, 'a').value) // 10

//属性存在，不能返回 undefined
var obj = { a: 10 }
Object.preventExtensions(obj)
var p = new Proxy(obj, {
  getOwnPropertyDescriptor: function (target, prop) {
    return undefined
  }
})

Object.getOwnPropertyDescriptor(p, 'a') // TypeError is thrown

handler.getPrototypeOf()

handler.getPrototypeOf(target) 该方法当读取代理对象的原型时，该方法就会被调用。getPrototypeOf 方法的返回值必须是一个对象或者 null。

在 JavaScript 中，下面这五种操作（方法/属性/运算符）可以触发 JS 引擎读取一个对象的原型，也就是可以触发 getPrototypeOf() 代理方法的运行：

Object.getPrototypeOf()
Reflect.getPrototypeOf()
__proto__
Object.prototype.isPrototypeOf()
instanceof

如果遇到了下面两种情况，JS 引擎会抛出 TypeError 异常：

getPrototypeOf() 方法返回的不是对象也不是 null。
目标对象是不可扩展的，且 getPrototypeOf() 方法返回的原型不是目标对象本身的原型。

//五种触发 getPrototypeOf() 的方式
var obj = {}
var p = new Proxy(obj, {
  getPrototypeOf(target) {
    return Array.prototype
  }
})
console.log(
  Object.getPrototypeOf(p) === Array.prototype, // true
  Reflect.getPrototypeOf(p) === Array.prototype, // true
  p.__proto__ === Array.prototype, // true
  Array.prototype.isPrototypeOf(p), // true
  p instanceof Array // true
)

//异常情况
var obj = {}
var p = new Proxy(obj, {
  getPrototypeOf(target) {
    return 'foo'
  }
})
Object.getPrototypeOf(p) // TypeError: "foo" is not an object or null

var obj = Object.preventExtensions({})
var p = new Proxy(obj, {
  getPrototypeOf(target) {
    return {} // 想要正确返回这里应该是 Object.prototype
  }
})
Object.getPrototypeOf(p) // TypeError: 'getPrototypeOf' on proxy: proxy target is non-extensible but the trap did not return its actual prototype

handler.isExtensible()

handler.isExtensible(target) 该方法用于拦截对对象的 Object.isExtensible()。isExtensible 方法必须返回一个 Boolean 值或可转换成 Boolean 的值。

该方法会拦截目标对象的以下操作:

Object.isExtensible()
Reflect.isExtensible()

如果违背了以下的约束，proxy 会抛出 TypeError: Object.isExtensible(proxy) 必须同 Object.isExtensible(target)返回相同值。也就是必须返回 true 或者为 true 的值,返回 false 和为 false 的值都会报错。

var p = new Proxy(
  {},
  {
    isExtensible: function (target) {
      console.log('called') // "called"
      return true //也可以return 1;等表示为true的值
    }
  }
)

console.log(Object.isExtensible(p)) // true

//违反约束
var p = new Proxy(
  {},
  {
    isExtensible: function (target) {
      return false //return 0;return NaN等都会报错
    }
  }
)

Object.isExtensible(p) // TypeError is thrown

handler.ownKeys()

handler.ownKeys(target) 方法用来拦截对象自身属性的读取操作。this 被绑定在 handler 上。ownKeys 方法必须返回一个可枚举对象。

该拦截器可以拦截以下操作::

Object.getOwnPropertyNames()
Object.getOwnPropertySymbols()
Object.keys()
Reflect.ownKeys()

如果违反了下面的约束，proxy 将抛出错误 TypeError:

ownKeys 的结果必须是一个数组.
数组的元素类型要么是一个 String ，要么是一个 Symbol.
结果列表必须包含目标对象的所有不可配置（non-configurable ）、自有（own）属性的 key.
如果目标对象不可扩展，那么结果列表必须包含目标对象的所有自有（own）属性的 key，不能有其它值.

使用 Object.keys 方法时，有三类属性会被 ownKeys 方法自动过滤，不会返回。

目标对象上不存在的属性
属性名为 Symbol 值
不可遍历( enumerable )的属性

let target = {
  a: 1,
  b: 2,
  c: 3,
  [Symbol.for('secret')]: '4'
}
Object.defineProperty(target, 'key', {
  enumerable: false,
  configurable: true,
  writable: true,
  value: 'static'
})
let handler = {
  ownKeys(target) {
    return ['a', 'd', Symbol.for('secret'), 'key']
  }
}
let proxy = new Proxy(target, handler)
console.log(Object.keys(proxy)) // ['a']

上面代码中，ownKeys 方法之中，显式返回不存在的属性( d )、Symbol 值 (Symbol.for('secret'))、不可遍历的属性( key )，结果都被自动过滤掉。

//拦截 Object.getOwnPropertyNames()
var p = new Proxy(
  {},
  {
    ownKeys: function (target) {
      console.log('called') // "called"
      return ['a', 'b', 'c']
    }
  }
)

console.log(Object.getOwnPropertyNames(p)) // [ 'a', 'b', 'c' ]

//违反约定
var obj = {}
Object.defineProperty(obj, 'a', {
  configurable: false,
  enumerable: true,
  value: 10
})

var p = new Proxy(obj, {
  ownKeys: function (target) {
    return [123, 12.5, true, false, undefined, null, {}, []]
  }
})

console.log(Object.getOwnPropertyNames(p))

// TypeError: proxy [[OwnPropertyKeys]] 必须返回一个数组
// 数组元素类型只能是String或Symbol

//必须包含目标对象的所有不可配置属性
var obj = {}
Object.defineProperty(obj, 'a', {
  configurable: false,
  enumerable: true,
  value: 10
})
var p = new Proxy(obj, {
  ownKeys: function (target) {
    return ['b']
  }
})
Object.getOwnPropertyNames(p)
// Uncaught TypeError: 'ownKeys' on proxy: trap result did not i nclude 'a'

//若对象不可配置，ownKeys 方法返回的数组之中，必须包含原对象的所有属性，且不能包含多余的属性，否则报错
var obj = { a: 1 }
Object.preventExtensions(obj)
var p = new Proxy(obj, {
  ownKeys: function (target) {
    return ['a', 'b']
  }
})
Object.getOwnPropertyNames(p)
// Uncaught TypeError: 'ownKeys' on proxy: trap returned extra k eys but proxy target is non-extensible

handler.preventExtensions()

handler.preventExtensions(target) 方法用于设置对 Object.preventExtensions() 的拦截.该方法必须返回一个布尔值，否则会被自动转为布尔值。

这个捕捉器可以拦截这些操作:

Object.preventExtensions()
Reflect.preventExtensions()

如果违反了下列规则, proxy 则会抛出一个 TypeError: 如果目标对象是可扩展的，那么只能返回 false。

var p = new Proxy(
  {},
  {
    preventExtensions: function (target) {
      console.log('called') // "called"
      Object.preventExtensions(target)
      return true
    }
  }
)

console.log(Object.preventExtensions(p)) // false

//违反约定
var p = new Proxy(
  {},
  {
    preventExtensions: function (target) {
      return true
    }
  }
)

Object.preventExtensions(p) // 抛出类型错误

handler.setPrototypeOf()

handler.setPrototypeOf(target, prototype) 方法主要用来拦截 Object.setPrototypeOf()。如果成功修改了[[Prototype]], setPrototypeOf 方法返回 true,否则返回 false。

这个方法可以拦截以下操作:

Object.setPrototypeOf()
Reflect.setPrototypeOf()

如果违反了下列规则，则 proxy 将抛出一个 TypeError: 如果 target 不可扩展, 原型参数必须与 Object.getPrototypeOf(target) 的值相同.

Proxy.revocable()

Proxy.revocable() 方法可以用来创建一个可撤销的代理对象。该方法的返回值是一个对象，其结构为： {"proxy": proxy, "revoke": revoke}，proxy 表示新生成的代理对象本身，和用一般方式 new Proxy(target, handler) 创建的代理对象没什么不同，只是它可以被撤销掉。revoke 表示撤销方法，调用的时候不需要加任何参数，就可以撤销掉和它一起生成的那个代理对象。

一旦某个代理对象被撤销，它将变得几乎完全不可调用，在它身上执行任何的可代理操作都会抛出 TypeError 异常（注意，可代理操作一共有 13 种，执行这 13 种操作以外的操作不会抛出异常）。一旦被撤销，这个代理对象便不可能被直接恢复到原来的状态，同时和它关联的目标对象以及处理器对象都有可能被垃圾回收掉。再次调用撤销方法 revoke() 则不会有任何效果，但也不会报错。

Proxy.revocable 的一个使用场景是，目标对象不允许直接访问，必须通过代理访问，一旦访问结束，就收回代理权，不允许再次访问。

var revocable = Proxy.revocable(
  {},
  {
    get(target, name) {
      return '[[' + name + ']]'
    }
  }
)
var proxy = revocable.proxy
proxy.foo // "[[foo]]"

revocable.revoke()

console.log(proxy.foo) // 抛出 TypeError
proxy.foo = 1 // 还是 TypeError
delete proxy.foo // 又是 TypeError
typeof proxy // "object"，因为 typeof 不属于可代理操作

this 问题

在 let p = new Proxy(target, handler) 中，我们上面介绍的 handler 中的捕捉器中的 this 都是指向 handler 对象。而通过代理访问的 target 中的的方法如果有 this，指向的则是生成的 Proxy 对象。

const target = {
  m: function () {
    console.log(this === proxy)
  }
}
const handler = {}
const proxy = new Proxy(target, handler)
target.m() // false
proxy.m() // true

所以虽然 Proxy 可以代理针对目标对象的访问，但它不是目标对象的透明代理，即不做任何拦截的情况下，也无法保证与目标对象的行为一致。主要原因就是在 Proxy 代理的情况下，目标对象内部的 this 关键字会指向 Proxy 代理。

const _name = new WeakMap()
class Person {
  constructor(name) {
    _name.set(this, name)
  }
  get name() {
    return _name.get(this)
  }
}
const jane = new Person('Jane')
jane.name // 'Jane'
const proxy = new Proxy(jane, {})
proxy.name // undefined

console.log(Object.getOwnPropertyDescriptor(jane.__proto__, 'name'))
//{
//  get: [Function: get name],
//  set: undefined,
//  enumerable: false,
//  configurable: true
//}

上面代码中，目标对象 jane 的 name 属性，实际保存在外部对象 _name 上面，通过 this 键区分。由于通过 proxy.name 访问时，this 指向 proxy，导致无法取到值，所以返回 undefined。

所以当我们使用代理的时候需要注意源对象方法中的 this。此外，有些原生对象的内部属性，只有通过正确的 this 才能拿到，所以 Proxy 也无法代理这些原生对象的属性。

const target = new Date()
const handler = {}
const proxy = new Proxy(target, handler)
proxy.getDate()
// TypeError: this is not a Date object.

const target = new Date('2015-01-01')
const handler = {
  get(target, prop) {
    if (prop === 'getDate') {
      return target.getDate.bind(target)
    }
    return Reflect.get(target, prop)
  }
}
const proxy = new Proxy(target, handler)
proxy.getDate() // 1

Reflect 反射

所谓的 Reflect 反射，一般是用在静态语言中的概念。在计算机学中，反射（英语：reflection）是指计算机程序在运行时（runtime）可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说，反射就是程序在运行的时候能够“观察”并且修改自己的行为。这是维基百科给出的定义。

比如我们经常使用的 Object.getOwnPropertyDescriptor，Object.keys() 在其他语言中都会被归类于反射的范畴。那么为什么 ES6 要推出一个 Reflect 对象呢，而且这个对象的方法也都是一些原本就存在的方法。我个人认为是早期的 JavaScript 标准设计没有想到这个问题，在逐步推出一些比较重要的静态方法的过程中就直接通过 Object，Function 等内置对象暴露出来（为什么是它们，因为他们在所有对象和函数的原型链上，几乎所有对象都能通过原型链访问到他们的方法），在 API 逐渐增多的过程中，让这些原本功能比较明确的对象越来越冗余，API 结构也非常不清晰，甚至有些混乱。

所以到了 ES6 大概制定委员会决定解决这个问题，把一些应该归类于反射机制的方法单独用一个对象来暴露，于是就有了 Reflect。以下是阮一峰老师的《ES6标准入门》总结的 Reflect 的设计目的：

将 Object 对象的一些明显属于语言内部的方法（比如 Object.defineProperty），放到 Reflect 对象上。目前，因为兼容性的问题，很多方法在 Object 和 Reflect 上同时存在，但是以后还会推出新的方法，到时候只会在 Reflect 对象上添加。
修改某些不合理的 API，比如 Object.defineProperty(obj, name, desc)，在无法定义属性时，会抛出一个错误，而 Reflect.defineProperty(obj, name, desc) 则会返回 false。
让 Object 操作都变成函数行为。某些 Object 操作是命令式，比如 name in obj 和 delete obj[name]，而 Reflect.has(obj, prop) 和 Reflect.deleteProperty(obj, prop) 是函数行为。
Reflect 的方法和 Proxy 的方法一一对应，它们将成为我们进行元编程修改默认行为的固定搭档。无论我在在 Proxy 内部如何设计逻辑，我们总能通过 Reflect 获取默认行为。

我个人进行一个总结就是，让 JavaScript 的 API 设计更规范，保持风格的统一，让每个对象都更纯粹，各司其职，更好记更好用。

Reflect 用法

与大多数全局对象不同 Reflect 并非一个构造函数，所以不能通过new运算符对其进行调用，或者将 Reflect 对象作为一个函数来调用。Reflect 的所有属性和方法都是静态的（就像 Math 对象）。

Reflect 对象提供了 13 种静态方法，这些方法与 proxy handler methods 的命名相同.其中的一些方法与 Object 相同, 尽管二者之间存在某些细微上的差别，差别可以参考比较 Reflect 和 Object 方法

Reflect.apply(target, thisArg, args)
Reflect.construct(target, args)
Reflect.get(target, name, receiver)
Reflect.set(target, name, value, receiver)
Reflect.defineProperty(target, name, desc)
Reflect.deleteProperty(target, name)
Reflect.has(target, name)
Reflect.ownKeys(target)
Reflect.isExtensible(target)
Reflect.preventExtensions(target)
Reflect.getOwnPropertyDescriptor(target, name)
Reflect.getPrototypeOf(target)
Reflect.setPrototypeOf(target, prototype)

Reflect.get()

Reflect.get(target, propertyKey[, receiver]) 方法与从对象 (target[propertyKey]) 中读取属性类似，但它是通过一个函数执行来操作的。第三个可选参数表示如果 target 对象中指定了 getter，receiver 则为 getter 调用时的 this 值。该方法查找并返回 target 对象的 name 属性，如果没有该属性，则返回 undefined 。如果目标值类型不是 Object，则抛出一个 TypeError。

// Object
var obj = { x: 1, y: 2 }
Reflect.get(obj, 'x') // 1

// Array
Reflect.get(['zero', 'one'], 1) // "one"

// Proxy with a get handler
var x = { p: 1 }
var obj = new Proxy(x, {
  get(t, k, r) {
    return k + 'bar'
  }
})
Reflect.get(obj, 'foo') // "foobar"

关于第三个参数 receiver，我们需要注意，如果 target 是一个 Proxy 并且拦截了 get 方法，那么这里的 receiver 是不会生效的，Proxy 中的 get 还是指向 handler 对象。其实只要属性是通过 Proxy 的 get 访问到的都是一样的效果，Proxy 是可以被继承的。

let thisObj = { a: 1, b: 2 }
let a = {
  get name() {
    console.log(this)
  }
}
let p = new Proxy(a, {
  get(target, key, receiver) {
    console.log(this)
  }
})

let b = Object.create(p)

Reflect.get(a, 'name', thisObj) // { a: 1, b: 2 }
Reflect.get(p, 'name', thisObj) // { get: [Function: get] }
Reflect.get(b, 'name', thisObj) // { get: [Function: get] }

Reflect.set()

静态方法 Reflect.set(target, propertyKey, value[, receiver]) 工作方式就像在一个对象上设置一个属性。最后一个可选参数表示如果遇到 setter，receiver 则为 setter 调用时的 this 值。返回一个 Boolean 值表明是否成功设置属性。如果目标值类型不是 Object，则抛出一个 TypeError。它的作用和属性访问器形式的赋值一样，但是是以函数的形式。

// Object
var obj = {}
Reflect.set(obj, 'prop', 'value') // true
obj.prop // "value"

// Array
var arr = ['duck', 'duck', 'duck']
Reflect.set(arr, 2, 'goose') // true
arr[2] // "goose"

// It can truncate an array.
Reflect.set(arr, 'length', 1) // true
arr // ["duck"];

// With just one argument, propertyKey and value are "undefined".
var obj = {}
Reflect.set(obj) // true
Reflect.getOwnPropertyDescriptor(obj, 'undefined')
// { value: undefined, writable: true, enumerable: true, configurable: true }

receiver 的处理和 Reflect.get() 类似。

Reflect.has()

Reflect.has(target, propertyKey) 的功能和 in 操作符完全相同，如果指定的属性在指定的对象或其原型链中，返回 true。如果第一个参数不是对象， Reflect.has 和 in 运算符都会报错。返回值是一个 Boolean 指示是否存在此属性。

Reflect.has({ x: 0 }, 'x') // true
Reflect.has({ x: 0 }, 'y') // false

// 如果该属性存在于原型链中，返回true
Reflect.has({ x: 0 }, 'toString')

// Proxy 对象的 .has() 句柄方法
obj = new Proxy(
  {},
  {
    has(t, k) {
      return k.startsWith('door')
    }
  }
)
Reflect.has(obj, 'doorbell') // true
Reflect.has(obj, 'dormitory') // false

Reflect.deleteProperty()

Reflect.deleteProperty(target, propertyKey) 方法等同于 delete obj[name] ，用于删除对象的属性，区别就是该方法是一个函数。返回值是一个 Boolean 值表明该属性是否被成功删除，如果删除成功，或者被删除的属性不存在，返回 true，删除失败，被删除的属性依然存在，返回 false。如果目标值类型不是 Object，则抛出一个 TypeError。

Reflect.getPrototypeOf({}) // Object.prototype
Reflect.getPrototypeOf(Object.prototype) // null
Reflect.getPrototypeOf(Object.create(null)) // null

// 如果参数为 Object，返回结果相同
Object.getPrototypeOf({}) // Object.prototype
Reflect.getPrototypeOf({}) // Object.prototype

// 在 ES5 规范下，对于非 Object，抛异常
Object.getPrototypeOf('foo') // Throws TypeError
Reflect.getPrototypeOf('foo') // Throws TypeError

// 在 ES2015 规范下，Reflect 抛异常, Object 强制转换非 Object
Object.getPrototypeOf('foo') // String.prototype
Reflect.getPrototypeOf('foo') // Throws TypeError

// 如果想要模拟 Object 在 ES2015 规范下的表现，需要强制类型转换
Reflect.getPrototypeOf(Object('foo')) // String.prototype

var obj = { x: 1, y: 2 }
Reflect.deleteProperty(obj, 'x') // true
obj // { y: 2 }

var arr = [1, 2, 3, 4, 5]
Reflect.deleteProperty(arr, '3') // true
arr // [1, 2, 3, , 5]

// 如果属性不存在，返回 true
Reflect.deleteProperty({}, 'foo') // true

// 如果属性不可配置，返回 false
Reflect.deleteProperty(Object.freeze({ foo: 1 }), 'foo') // false

Reflect.construct()

Reflect.construct(target, argumentsList[, newTarget]) 方法的行为有点像 new 操作符构造函数，相当于运行 new target(...args)，这提供了一种不使用，来调用构造函数的方法。target 是被运行的目标构造函数，argumentsList 是目标构造函数调用时的参数，第三个可选参数 newTarget，作为新创建对象的原型对象的 constructor 属性，参考 new.target 操作符，默认值为 target。

返回值是以 target（如果 newTarget 存在，则为 newTarget）函数为构造函数，argumentList 为其初始化参数的对象实例。如果 target 或者 newTarget 不是构造函数，抛出 TypeError 异常。

使用 Reflect.construct 和 Object.create() 创建对象有如下不同：当使用 Object.create() 和 Function.prototype.apply() 时，如果不使用 new 操作符调用构造函数，构造函数内部的new.target 值会指向 undefined。当调用 Reflect.construct() 来创建对象，new.target 值会自动指定到 target（或者 newTarget，前提是 newTarget 指定了）。

Reflect.getPrototypeOf()

静态方法 Reflect.getPrototypeOf(target) 与 Object.getPrototypeOf() 方法几乎是一样的。都是返回指定对象的原型（即内部的 [[Prototype]] 属性的值）。返回值为给定对象的原型。如果给定对象没有继承的属性，则返回 null。如果目标值类型不是 Object，则抛出一个 TypeError。

Reflect.getPrototypeOf({}) // Object.prototype
Reflect.getPrototypeOf(Object.prototype) // null
Reflect.getPrototypeOf(Object.create(null)) // null

// 如果参数为 Object，返回结果相同
Object.getPrototypeOf({}) // Object.prototype
Reflect.getPrototypeOf({}) // Object.prototype

// 在 ES5 规范下，对于非 Object，抛异常
Object.getPrototypeOf('foo') // Throws TypeError
Reflect.getPrototypeOf('foo') // Throws TypeError

// 在 ES2015 规范下，Reflect 抛异常, Object 强制转换非 Object
Object.getPrototypeOf('foo') // String.prototype
Reflect.getPrototypeOf('foo') // Throws TypeError

// 如果想要模拟 Object 在 ES2015 规范下的表现，需要强制类型转换
Reflect.getPrototypeOf(Object('foo')) // String.prototype

Reflect.setPrototypeOf()

除了返回类型以外，静态方法 Reflect.setPrototypeOf() 与 Object.setPrototypeOf() 方法是一样的。它可设置对象的原型（即内部的 [[Prototype]] 属性）为另一个对象或 null，如果操作成功返回 true，否则返回 false。

返回一个 Boolean 值表明是否原型已经成功设置。如果 target 不是 Object ，或 prototype 既不是对象也不是 null，抛出一个 TypeError 异常。

Reflect.setPrototypeOf({}, Object.prototype) // true

// It can change an object's [[Prototype]] to null.
Reflect.setPrototypeOf({}, null) // true

// Returns false if target is not extensible.
Reflect.setPrototypeOf(Object.freeze({}), null) // false

// Returns false if it cause a prototype chain cycle.
var target = {}
var proto = Object.create(target)
Reflect.setPrototypeOf(target, proto) // false

Reflect.apply()

Reflect.apply(target, thisArgument, argumentsList) 方法等同于 Function.prototype.apply.call(func, thisArg, args),用于绑定 this 对象后执行给定函数。返回值是调用完带着指定参数和 this 值的给定的函数后返回的结果。如果 target 对象不可调用，抛出 TypeError。

原来我们要指定 this 执行函数，需要 fn.apply(thisArg, args)，如果函数重写了 apply 方法，就需要这样 Function.prototype.apply.call(fn, thisArg, args)，使用 Reflect.apply 方法会使代码更加简洁易懂。

Reflect.apply(Math.floor, undefined, [1.75])
// 1;

Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111])
// "hello"

Reflect.apply(RegExp.prototype.exec, /ab/, ['confabulation']).index
// 4

Reflect.apply(''.charAt, 'ponies', [3])
// "i"

Reflect.defineProperty()

Reflect.defineProperty(target, propertyKey, attributes) 基本等同于 Object.defineProperty() 方法，唯一不同是返回 Boolean 值。未来，后者会被逐渐废除，请从现在开始就使用 Reflect.defineProperty 代替它。返回值是一个 Boolean 值指示了属性是否被成功定义。如果 target 不是 Object，抛出一个 TypeError。

Reflect.getOwnPropertyDescriptor()

该方法与 Object.getOwnPropertyDescriptor() 方法相似，用于得到指定属性的描述对象，将来会替代掉后者。。如果属性在对象中存在，则返回给定的属性的属性描述符。否则返回 undefined。该方法和 Object.getOwnPropertyDescriptor() 的区别是如果第一个参数不是对象，Object.getOwnPropertyDescriptor() 返回 undefined，而 Reflect.getOwnPropertyDescriptor 会抛出错误。

Reflect.getOwnPropertyDescriptor({ x: 'hello' }, 'x')
// {value: "hello", writable: true, enumerable: true, configurable: true}

Reflect.getOwnPropertyDescriptor({ x: 'hello' }, 'y')
// undefined

Reflect.getOwnPropertyDescriptor([], 'length')
// {value: 0, writable: true, enumerable: false, configurable: false}

Reflect.isExtensible()

Reflect.isExtensible(target) 判断一个对象是否可扩展（即是否能够添加新的属性）。与它 Object.isExtensible() 方法相似，但有一些不同，如果对象是可扩展的，则 Object.isExtensible() 返回 true，否则返回 false。如果第一个参数不是对象（原始值），则在 ES5 中抛出 TypeError。在 ES2015 中，它将被强制为不可扩展的普通对象并返回 false。如果对象是可扩展的，则 Reflect.isExtensible() 返回 true，否则返回 false。如果第一个参数不是对象（原始值），则抛出 TypeError。

// New objects are extensible.
var empty = {}
Reflect.isExtensible(empty) // === true

// ...but that can be changed.
Reflect.preventExtensions(empty)
Reflect.isExtensible(empty) // === false

// Sealed objects are by definition non-extensible.
var sealed = Object.seal({})
Reflect.isExtensible(sealed) // === false

// Frozen objects are also by definition non-extensible.
var frozen = Object.freeze({})
Reflect.isExtensible(frozen) // === false

Reflect.preventExtensions()

静态方法 Reflect.preventExtensions(target) 方法阻止新属性添加到对象 (例如：防止将来对对象的扩展被添加到对象中)。该方法与 Object.preventExtensions() 相似，但有一些不同点。返回一个 Boolean 值表明目标对象是否成功被设置为不可扩展。抛出一个 TypeError 错误，如果 target 不是 Object。

// Objects are extensible by default.
var empty = {}
Reflect.isExtensible(empty) // === true

// ...but that can be changed.
Reflect.preventExtensions(empty)
Reflect.isExtensible(empty) // === false

Reflect.ownKeys()

方法用于返回对象的所有属性，基本等同于 Object.getOwnPropertyNames() 与 Object.getOwnPropertySymbols 之和。由目标对象的自身属性键组成的 Array，它的返回值等同于Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))。如果目标不是 Object，抛出一个 TypeError。

Reflect.ownKeys({ z: 3, y: 2, x: 1 }) // [ "z", "y", "x" ]
Reflect.ownKeys([]) // ["length"]

var sym = Symbol.for('comet')
var sym2 = Symbol.for('meteor')
var obj = { [sym]: 0, str: 0, 773: 0, 0: 0, [sym2]: 0, '-1': 0, 8: 0, 'second str': 0 }
Reflect.ownKeys(obj)
// [ "0", "8", "773", "str", "-1", "second str", Symbol(comet), Symbol(meteor) ]
// Indexes in numeric order,
// strings in insertion order,
// symbols in insertion order

总结

Proxy 在我们的日常编码中使用不是很多，由于他提供的功能能够让我们对语言的行为进行定制，所以很多框架和底层库都会使用，比如 Vue3 就把双向数据绑定从 Object.defineProperty 改成了用 Proxy 实现，理解代理行为有助于我们理解这些框架和库。而 Reflect 中的很多方法将会逐步取代 Object，所以我们应该尽量使用。

参考文章

《ES6标准入门》 —— 阮一峰
MDN

JavaScript 大数相加相乘实现

Sun, 18 Oct 2020 12:00:00 GMT

前言

JavaScript 中的最大安全整数是 $2 ^{53} - 1$，即 9007199254740991，当我们进行超出这个范围的数值计算的时候就无法得到精确的值，而是一个近似值，比如我们计算 9007199254740991 + 10 得到的结果是 9007199254741000。本文讲一下如何利用字符串在 JavaScript 中实现大数相加相乘。

相加

用字符串实现相加相乘基本思路就是按照我们在纸上进行竖式运算一样。对于加法，我们需要将两个数 num1 和 num2 上下对齐，然后从个位开始计算两个数对应位的和，循环到最高位，将每一次运算的结果保存到一个数组 result 中去，最终用 Array.prototype.join() 方法还原成一个数组。

这里为了保持循环的正常进行，我们需要保证两个字符串位数相等，所以我们要用 String.prototpye.padStart() 方法将位数比较小的那一个字符串的前面用 '0' 补齐。

按位相加有个问题就是进位如何保存，我的思路是这样的。当我们相加 num1[i] 和 num2[i] 的时候，得到的最多是一个两位数，它将影响 result 的两位，即当前的 result[0] 位置和即将 unshift 到 result 中的一位。当前的 result[0] 位置的数就是计算 [i -1] 是得到的数的高位（即进位），我们将我们计算的值加上进位，得到的数在分成两位分别放到 result 中。

所以总结一下就是我们计算 num1[i] + num2[i] 得到一个两位数，这个两位数要先和 num1[i-1] + num2[i-1] 的结果的进位（即 result[0] 相加，然后在分成 high 和 low 两位，将 result[0] 的值用 low 位替换，然后将 high 位 unshift 到 result 最前面。可以参考下图理解。

所以我们每次计算都是确定一位和下一位的进位。最后代码如下：

let add = function (num1, num2) {
  if (isNaN(num1) || isNaN(num2)) return ''
  if (num1 === '0' || num2 === '0') return num1 === '0' ? num2 : num1

  let len = Math.max(num1.length, num2.length)
  num1 = num1.padStart(len, '0')
  num2 = num2.padStart(len, '0')

  let result = []

  for (let i = len - 1; i >= 0; i--) {
    let sum = Number(num1[i]) + Number(num2[i]) + (result[0] || 0)
    let low = sum % 10
    let high = Math.floor(sum / 10)

    result[0] = low
    result.unshift(high)
  }
  return result.join('')
}

console.log(add('10', '9007199254740991')) //09007199254741001

代码中我们加了两个判断，判断两个参数是否是合法数字格式，以及如果一个数是 '0' 则直接返回另一个数。

相乘

相乘的逻辑要比相加复杂一点，但是总体思路还是根据竖式来实现算法，我画了一张图，我们借助图来说明。

相乘是一个两层循环，我们要循环一个数的位，每一位再与另一个数循环的每一位相乘。我们每次相乘的结果最多是一个两位数。但是与相加不同的是，相加的 high 每次都是 unshift 进去即可，而相乘的高位也要与 result 的位进行运算。

我们来看一看相乘的规律，当我们用 num1[i] * num2[j] 的时候，可能得到两位数，也可能得到一位数，我们都统一算作两位数，高位没有的就用 0 补齐，那么最后我们得到的结果将是一个 i + j 位的数（开头可能存在补齐的 0）。而我们每次计算 num1[i] * num2[j] 的结果影响到的都是 result 中的 i + j 和 i + j + 1 位。

和加法中逻辑一样，我们将 num1[i] * num2[j] 的结果和 result[i + j + 1] 相加，得到的结果分为 low 和 high 分别存入 reslut 的 [i + j +1] 和 [i +j] 中。但是这里要注意，和加法不同，加法的高位直接存入就可以，我们这里的 high 对应的 result[i + j] 可能已经有值了，我们需要将已经存在的值加上。

high 和 result[i +j] 的相加可能存在进位怎么办呢，看上图中右边的当前 result 值中我们可以看到有些位存了不止一位数，我们将 high + result[i +j] 的值直接连进位一起保存到 result[i + j] 中。为什么能这样做呢，因为下次计算 num1[i] * num2[j - 1] 的时候（注意我们是从后往前遍历），会把 result[i + j]和 low 相加，进位自然能被处理，这也是这个算法比较重要的地方。

最后的代码：

let multiply = function (num1, num2) {
  if (isNaN(num1) || isNaN(num2)) return ''
  if (num1 === '0' || num2 === '0') return '0'

  let l1 = num1.length,
    l2 = num2.length

  let result = []

  for (let i = l1 - 1; i >= 0; i--) {
    for (let j = l2 - 1; j >= 0; j--) {
      let index1 = i + j
      let index2 = i + j + 1

      let product = num1[i] * num2[j] + (result[index2] || 0)
      result[index2] = product % 10
      result[index1] = Math.floor(product / 10) + (result[index1] || 0)
    }
  }
  return result.join('').replace(/^0+/, '')
}

console.log(multiply('123', '234')) //28782

代码中加了两个判断：是否是合法数字，如果有一个值为 0 则直接返回 0。注意最后要判断得到的结果是否开头有 0，如果有则要去掉，这里用的正则表达式。

深入发布订阅模式

Sun, 18 Oct 2020 12:00:00 GMT

前言

前端其实涉及到的设计模式不多，不过现在的主流框架都是用了发布订阅模式，所以这个设计模式也经常被提到，也是面试的时候的高频问题，这篇文章我们来深入讨论一下什么是发布订阅模式，为什么要使用发布订阅模式以及如何实现发布订阅模式。

观察者模式 Observer pattern

在讨论发布订阅模式之前，我们先来讨论一下观察者模式。这两者的思想是一致的，只是具体的实现不同，应用场景也不同，可以说发布订阅模式是观察者模式的一种更优化的实现。但是我觉的观察者模式更容易理解，我们也经常使用，所以作为前置。

观察者模式说起来很简单，我们希望对一个目标进行 observe，当这个目标发生变化的时候告诉我们。其实这听上去和回调函数很像，其实回调函数就是一种特殊的观察者模式。真正的观察者模式需要是一对多的，被观察者 Subject 会管理一个观察者列表，当这个 Subject 发生某个变化的时候会通知观察者列表中的所有观察者。大概关系如下图：

有没有感觉这个模式非常熟悉，这和我们经常使用的 DOM 事件模式完全相同。我们的 DOM 事件也就是一个观察者模式的实现。当我们为一个元素绑定事件的时候，我们就相当于进行了 Subscribe 订阅，成为了一个观察者。当对应的事件触发的时候，被观察的元素会通知我们，执行我们的回调函数（所谓的通知其实就是执行观察者中的对应方法，并不是真的发个通知）。我们也可以绑定多个 Observer，当事件触发的时候，所有的观察者都会被通知。DOM 提供了我们订阅 addEventListener，和取消订阅 removeEventListener 的 API。

所以观察者模式有两个部分；观察者和被观察对象。而主要的实现都是在被观察对象上，一个模拟的观察者模式的实现如下：

// 观察者
class Observer {
  constructor() {}
  update(val) {}
}
// 观察者列表
class ObserverList {
  constructor() {
    this.observerList = []
  }
  add(observer) {
    return this.observerList.push(observer)
  }
  remove(observer) {
    this.observerList = this.observerList.filter((ob) => ob !== observer)
  }
  count() {
    return this.observerList.length
  }
  get(index) {
    return this.observerList(index)
  }
}
// 目标
class Subject {
  constructor() {
    this.observers = new ObserverList()
  }
  addObserver(observer) {
    this.observers.add(observer)
  }
  removeObserver(observer) {
    this.observers.remove(observer)
  }
  notify(...args) {
    let obCount = this.observers.count()
    for (let i = 0; i < obCount; i++) {
      this.observers.get(i).update(...args)
    }
  }
}

我们可以看到所以的逻辑都是在被观察者 Subject 上，它提供了添加观察者，删除观察者和通知等方法，有一个管理观察者列表的机制，当事件触发的时候，会执行列表中所有观察者的对应方法。

观察者模式的逻辑是非常简单的，特别是我们可以和经常使用的 DOM 事件结合起来。它主要解决的问题就是我们希望在某种情况下执行我们的代码，但我们不确定这个情况什么时候发生，比如浏览器事件（我们不知道用户什么时候点击，但我们希望用户点击的时候执行某一段代码）。

最后在放一个用 Proxy 实现的简单的观察者模式。

let fnArr = new Set()
function observable(obj) {
  return new Proxy(obj, {
    set: function (target, prop, value, receiver) {
      Reflect.set(target, prop, value)
      for (let fn of fnArr) {
        console.log(fn)
        fn()
      }
    }
  })
}

function observe(fn) {
  fnArr.add(fn)
}

const person = observable({
  name: '张三',
  age: 20
})
function print() {
  console.log(`${person.name}, ${person.age}`)
}
observe(print)
person.name = '李四' // 李四, 20

发布订阅模式 Pub-sub pattern

有了观察者模式，为什么又要有发布订阅模式呢？观察者模式中，观察者和目标是依赖的，耦合性很强。

我们可以想象一个场景，我们有多个目标要进行监听，但是这些目标事件触发后执行的逻辑其实是相同的，如果是使用观察者模式我们不得不对每一个目标都进行绑定，并且每一个目标都要事先一套上面 Subject 的逻辑。这样处理在系统越来越复杂的情况下代码的逻辑会非常混乱，也非常难以管理，并且有非常多冗余的部分。

为了解决这个问题，就有了发布订阅模式。他们的本质都是一样的，都是对于未来会发生的事件进行一个监听，当事件发生了，通知监听的对象执行对应的方法。但是他们实现的逻辑不同。看下图：

在发布订阅模式中，添加了一个事件通道，发布者和订阅者不在直接进行交互。所有的注册，解绑，发布都是通过 Event Channel 来实现的。也就是说我们把观察者模式中的逻辑抽象出来，形成了一个单独的模块。

现在整个的逻辑大概是这样：我们不再是对某个对象进行监听，而是告诉 Event Channel，我想要注册一个名叫 type 的事件，当这个事件触发以后，请执行 fn 函数。事件中心将我的注册信息进行保存。当有一个模块想要执行订阅者的对应方法的时候，只要告诉 Event Channel，我想要触发 type 事件，并且传入参数 arg1, arg2 ...。Event Channel 就会找到对应事件对应的 fn 传入 arg1, arg2 ... 并执行。

我们可以看到 Event Channel 就像一个消息中介，调度中心，它让发布者和订阅者之间完全解耦，它们甚至不知道对方的存在。我们将所有的订阅发布行为进行集中的管理，并且能够定制我们的订阅发布行为，让不同模块之间的通信业变得非常便捷。我们看下面的模拟实现发布订阅代码：

class PubSub {
  constructor() {
    this.subscribers = {}
  }
  subscribe(type, fn) {
    let listeners = this.subscribers[type] || []
    listeners.push(fn)
  }
  unsubscribe(type, fn) {
    let listeners = this.subscribers[type]
    if (!listeners || !listeners.length) return
    this.subscribers[type] = listeners.filter((v) => v !== fn)
  }
  publish(type, ...args) {
    let listeners = this.subscribers[type]
    if (!listeners || !listeners.length) return
    listeners.forEach((fn) => fn(...args))
  }
}

let ob = new PubSub()
ob.subscribe('add', (val) => console.log(val))
ob.publish('add', 1)

比较观察者模式和发布订阅模式的代码我们可以发现，观察者模式由具体目标调度，每个被订阅的目标里面都需要有对观察者的处理，会造成代码的冗余。而发布订阅模式则统一由调度中心处理，消除了发布者和订阅者之间的依赖。

我们可以结合生活中的实例来帮助你理解，比如你周五想约朋友去吃饭，你不知道谁有空，按观察者模式的逻辑来说，你得给每个可能的朋友发条信息：如果触发有空事件请给我打电话（注册），当朋友触发 有空 事件的时候，将会对你进行通知（执行 打电话 方法）。如果是订阅发布模式的话逻辑就是，你向 朋友圈（这里相当于 Event Channel）注册了一个事件，名字叫 有空，方法是 打电话，当有朋友想要参与聚会的时候，会告诉 朋友圈 （Event Channel），你要发布 有空 事件，参数是 185xxxxxxxx，朋友圈用这个参数执行了 打电话 方法。

不知道上面这个例子有没有帮助你理解观察者模式和订阅发布模式的逻辑和区别。

实现

正因为观察订阅模式的这种机制，它成了很多框架和库用来实现模块之间通信的方式。比如 Vue 的 Event(bus)，React 的 Event 模块，他们都用来实现非父子组件的通信。实际上几乎所有的模块通信都是基于类似的模式,包括安卓开发中的Event Bus，Node.js 中的 Event 模块( Node 中几乎所有的模块都依赖于 Event,包括不限于 http、stream、buffer、fs 等)。

这一小节我们就仿照 NodeJS 的 Event API 实现一个简单的 Event 库。

我们的大致需求是：实现一个 Emitter 类，该类能够实现事件的订阅，解绑，发布。事件的存储使用 Map。对于同一个类型的事件，支持多次绑定（即传入多个方法），当事件发布的时候，这些方法都将执行。

class Emitter {
  constructor() {
    this._event = this._event || new Map()
    this.maxListeners = 10
  }

  addEventListener(type, fn) {
    const handler = this._event.get(type)

    if (!handler) {
      this._event.set(type, fn)
    } else {
      if (handler && typeof handler === 'function') {
        this._event.set(type, [handler, fn])
      } else {
        handler.push(fn)
      }
    }
  }

  removeEventListener(type, fn) {
    const handler = this._event.get(type)

    if (handler && typeof handler === 'function') {
      if (handler === fn) this._event.delete(type)
    } else {
      let newHandler = handler.filter((v) => v !== fn)
      if (newHandler.length === 1) {
        this._event.set(type, newHandler[0])
      } else {
        this._event.set(type, newHandler)
      }
    }
  }

  emit(type, ...args) {
    const handler = this._event.get(type)

    if (Array.isArray(handler)) {
      handler.forEach((fn) => {
        fn.apply(this, args)
      })
    } else {
      handler.apply(this, args)
    }
    return true
  }
}

let emitter = new Emitter()

emitter.addEventListener('change', (obj) => {
  console.log(`name is ${obj.name}.`)
})

emitter.addEventListener('change', (obj) => {
  console.log(`age is ${obj.age}.`)
})

emitter.addEventListener('change', (obj) => {
  console.log(`sex is ${obj.sex}.`)
})

function site(obj) {
  console.log(`site is ${obj.site}`)
}

emitter.addEventListener('change', site)

emitter.emit('change', {
  name: 'clloz',
  age: 28,
  sex: 'male',
  site: 'clloz.com'
})
//name is clloz.
//age is 28.
//sex is male.
//site is clloz.com

emitter.removeEventListener('change', site)

emitter.emit('change', {
  name: 'clloz',
  age: 28,
  sex: 'male',
  site: 'clloz.com'
})
//name is clloz.
//age is 28.
//sex is male.

如果你有兴趣也可以研究一下 browserify 的 Event 模块实现：event.js - browserify。

总结

本文对观察者模式和发布订阅模式进行了比较深入的分析，也进行了简单的模拟实现，希望对你的理解有所帮助。如果有错漏之处欢迎指正。

参考文章

JS事件详解

Wed, 14 Oct 2020 12:00:00 GMT

前言

JS 和 HTML 之间的交互是通过事件来实现的，在我们的页面加载完毕，所有的 html，css，js 文件都已经 load 的情况下，我们如何在文档或浏览器窗口发生变化时通过 js 来进行交互，这就是事件产生的原因。我们在 js 中预定一个事件的处理程序，然后浏览器的监听程序监听各种事件的发生，当事件发生的时候调用预定的事件处理程序来执行。这种观察员模式的模型让我们实现了 js 和 html，css 之间的松散耦合。

事件流

由于 DOM 结构是层层嵌套的，所以监听程序会遇到一个问题，就是当我们点击一个位置的时候，这个位置有多个 DOM 节点嵌套在一起，那么我们到底点击的谁呢？Javascript高级程序设计 给出了一个更形象的比喻，在纸上画一组同心圆，然后把手指指向圆心，此时你指向的不仅仅是一个圆，而是一串同心圆。同理当你点击一个 DOM 元素，你不仅点击了这个元素，也点击了所有父元素，包括页面本身。由于这个问题，才产生了事件流，也就是一个事件发生了，这个事件会在嵌套的 DOM 结构里面传播，而事件流就描述了这个传播的具体规则，嵌套的 DOM 元素是按照什么顺序接收事件的。

即使你没深入学习过事件，也应该听过事件捕获和事件冒泡，它们也只不过是浏览器大战中IE和网景对事件流的不同理解而产生的不同实现，IE选择了事件冒泡流，而网景选择了事件捕获流。

事件冒泡流

先来说一说IE的事件冒泡流，事件冒泡流的设计思路是事件最开始是由事件的目标事件（当前点击的位置所嵌套的DOM结构的嵌套最深的那个节点）接收，然后沿着 DOM 树逐级向上传播一直到根节点也就是 document 节点。一下面的 HTML 文档为例：

<!DOCTYPE html>
<html lang="en">
  <head>
    <title>Test</title>
  </head>
  <body>
    <div class="btn">Click me!</div>
  </body>
</html>

如果我们点击了 Click 这个按钮以后按事件冒泡流的规则，事件会按照如下顺序传播 1. <div> 2. <body> 3. <html> 4. document

也就是 click 事件首先发生在 div 上，也就是我们单击的元素，然后 click 事件沿着 DOM 树向上传播，在每一级的 DOM 节点上都会发生，直到传播到 DOM 树的根节点 document。

所有现代浏览器都支持事件冒泡，但在具体实现上还是有一些差别。IE5.5 及更早版本中的事件冒泡会跳过<html>元素(从 <body> 直接跳到 document)。IE9 、 Firefox 、 Chrome 和 Safari 则将事件一直冒泡到 window 对象。

目标事件，也就是我们后面提到的 DOM2 里面 event 对象的 target 属性，我看网上的很多解释都不清晰，其实直白的说就是事件触发的坐标所在位置 DOM 结构嵌套最深的那个节点，也即是在 DOM 树上最深的节点，这个节点也就是所谓的 target 。

事件捕获

网景对于事件流的实现和 IE 则是截然相反的，也就是目标节点最后接收事件， DOM 树上的上层节点则更早地接收事件。还以上面的 HTML 代码作为例子，在事件捕获流中，事件的传播顺序如下：

document
<html>
<body>
<div>

在事件捕获流中，document 对象首先接收到事件，然后沿着 DOM 树逐级向下传播，一直传播到目标节点 div 元素，如下图：

DOM事件流

事件捕获只能在事件传播到目标元素之前截获，而事件冒泡只能在事件已经传播到目标元素之后进行截获，所以 DOM二级事件 把两者结合了起来，DOM二级事件 规定了事件传播的三个阶段：

事件捕获阶段
处于目标事件阶段
事件冒泡阶段

还用上面的 HTML 例子来解释，在 DOM 事件流中，实际的目标( <div> 元素)在捕获阶段不会接收到事件。这意味着在捕获阶段，事件从 document 到 <html> 再到 <body> 后就停止了。下一个阶段是“处于目标”阶段，于是事件在 <div> 上发生，并在事件处理(后面将会讨论这个概念)中被看成冒泡阶段的一部分。然后，冒泡阶段发生，事件又传播回文档。传播的顺序如下图：

在DOM Level 3 Events draft中有一个更清晰的图表示三个阶段：

这里总结一下事件流的顺序 window -> document -> documentElement -> document.body -> ... -> target -> ... -> document.body -> documentElement -> document -> window。一个元素上绑定的多个事件的执行顺序首先是看事件处理程序是定义在哪个阶段，定义在同一个阶段的多个事件处理程序的执行顺序由代码中的顺序决定，先绑定的就先执行。比如给目标元素同时绑定捕获阶段和冒泡阶段两个事件，如果冒泡阶段的事件处理程序先绑定，那么先执行的就是冒泡阶段的事件监听程序先执行。

关于事件流写了两个简单的 Demo，点击查看 Demo1 和 Demo2，打开控制台查看事件流的触发机制。

事件处理程序

也可以叫做事件侦听器，事件就是用户或浏览器自身执行的某种动作。诸如 click、load 和 mouseover，都是事件的名字。而响应某个事件的函数就叫做事件处理程序(或事件侦听器)。事件处理程序的名字以 on 开头，因此 click 事件的事件处理程序就是 onclick，load事件的事件处理程序就是 onload。为事件指定处理程序的方式有好几种。

事件处理程序主要有以下几种：HTML 事件处理程序就是我们常见的用 HTML 元素 attribute 写在行内的事件，这种做法非常不推荐，效率低下难以维护。然后是 DOM 事件处理程序，DOM 处理程序有所谓的 DOM0，DOM2 和 DOM3 等，这里的数字指的就是 DOM 标准的版本，目前的主流浏览器基本都实现了 DOM3 标准，正在推行的的是 DOM4。至于为什么没有 DOM1 事件处理程序，因为 DOM1 中没有和事件相关的更新，所以在讨论事件处理程序的时候就没有 DOM1。

还有一点就是 HTML 的 attribute 和 DOM 的 property 的区别，我们发现 DOM0 级事件使用的也是 onclick 这样的属性，而 HTML 事件处理程序的属性名也是这个，但是不要混淆他们。可以简单的理解为多数情况 attribute 值仅用作初始 DOM 节点对象使用，而 property 更多用于页面交互，很多框架都是在与元素和指令的 property 和事件打交道。比如 input 标签有 value 属性，input 对应的 DOM 对象也有 value 属性，当在用户未输入数据，或设置 property 的值时，取的值是 attribute 的值。当用户输入值或者设置了 property 的值后，property 的值就不受 attribute 影响了。

当然也不是所有的 HTML attribute 都和 DOM property 同名，比如 HTML 的 class 属性和 DOM 的 className。

HTML事件处理程序

当一个HTML元素支持某种事件，我们可以通过该元素的属性来指定事件处理程序，比如click事件就可以用 onclick 属性来指定事件处理程序，属性值应该是可执行的 javascript 代码，比如点击按钮弹出警告框：

<input type="button" value="Click Me" onclick="alert('Clicked')" />

在html中定义的事件处理程序也可以调用别的地方定义的脚本，比如调用你在别的地方定义的函数，如下：

<script type="text/javascript">
  function showMessage() {
    alert('Hello world!')
  }
</script>
<input type="button" value="Click Me" onclick="showMessage()" />

调用的函数可以是在当前 html 文件中的 script 标签中，也可以是在页面引用的其他 js 文件中，事件处理程序中的代码在执行时，有权访问全局作用域中的任何代码。

HTML 事件处理程序的特点：

创建了一个封装着元素属性值的函数，通过函数中的局部变量 event 直接访问事件对象（后面会介绍），不需要定义这个参数，也不需要从参数列表中读取，可以直接使用。
```
<script type="text/javascript">
  function showMessage() {
    console.log(event.type)
    console.log(this.value)
  }
</script>
<input type="button" value="Click Me" onclick="showMessage()" /> /* 输出 click*/
```
this 的指向：如果是直接在onclick属性中执行的javascript代码，那么 this 指向当前的元素；如果是引用自其他标签或文件中的函数，那么 this 指向 window 对象。

<script type="text/javascript">
  function showMessage() {
    console.log(event.type)
    console.log(this)
  }
</script>
<!-- 指向当前元素 -->
<input type="button" value="Click Me" onclick="console.log(this)" />
<!-- 指向window对象 -->
<input type="button" value="Click Me" onclick="showMessage()" />
```html 这里说一下内联的 `onclick` 引用其他地方的函数的理解方式，对于 `
<div onclick="fun()"></div>
` 我们应该这么理解 ```javascript div.onclick = function (this, event) { fun(this, event); } function
fun() { //code.... }

内联的 onclick 触发的时候相当于执行的上面这段代码，我们写在 onclick 属性中的代码其实是在一个匿名函数中执行的 js 代码，这也是为什么写成 onclick="fun()" 而不是写成 onclick=fun 的形式，这里不要理解成对 fun 函数的引用，而是在 onclick 触发的时候，执行双引号中的代码，此时我们的 fun 函数只是在匿名函数中执行的一个在全局中定义的函数，如果匿名函数没有把 this 传递给 fun 函数，那么 fun 的 this 应该是指向 window 对象的。看下面这段代码：

<div onclick="obj.fun()">test</div>
<script>
  var obj = {
    a: 'test',
    fun: function () {
      console.log(this) //{a: "test", fun: ƒ}
      console.log(this === obj) //true
    }
  }
</script>

这样是不是比较容易理解呢。

需要注意的是 body 中的 onload="console.log(this);" 会指向 window 对象，但是 img 中的 onload="console.log(this); 则还是指向当前元素的。

在函数内部可以像访问局部变量一样访问 document 以及该元素本身的成员，需要注意的是引用的函数同样不可以（函数的作用域链取决于函数定义的位置，而不是执行的位置），函数的内部实现类似如下：

function(){
    with(document){
        with(this){ //元素属性值
        }
    }
}

如果当前元素是一个表单输入元素，则作用域中还会包含访问表单元素(父元素)的入口，这样扩展作用域的方式，无非就是想让事件处理程序无需引用表单元素就能访问其他表单字段。

<form method="post">
  <input type="text" name="username" value="" />
  <!-- 可以直接访问username的value -->
  <input type="button" value="Echo Username" onclick="alert(username.value)" />
</form>

如果属性值采取的引用函数的方式，当元素已经渲染好，而 js 还没有加载完成，可能会造成触发事件而事件处理程序并没有执行，这样会报错，防止报错可以使用 try-catch：

<input type="button" value="Click Me" onclick="try{showMessage();}catch(ex){}" />

用 HTML 指定的事件处理程序造成 html 和 javascript 耦合，我们也无法同时给多个元素绑定事件，也无法给同一个事件绑定多个函数等等，由于这种方式的缺点非常明显，所以几乎已经消失了。

再次强调，不要使用 HTML 内联事件处理程序，它是非常低效和难以维护的！

由于属性值是 javascript 代码，因此不能在语句中使用未经转义的 HTML 语法字符，比如和号&，双引号"，大于号>，小于号<等，并且在 HTML 中转义不能使用反斜杠\，而要使用 html 实体（entity），比如双引号是"，如果你要查询某个字符的实体，在w3.org查询。

DOM0级事件处理程序

页面上的每一个元素都有一个事件处理程序属性（包括 window 和document 对象），这些属性都是小写，比如代表 click 事件的onclick，将需要监听事件的元素的该属性的值设置为一个函数，就可以指定事件处理程序，当事件在元素上触发的时候会调用事件处理程序。

var btn = document.getElementById('myBtn')
btn.onclick = function () {
  alert('Clicked')
}

DOM0 级事件处理程序中的this指向绑定事件的元素，在事件处理程序中可以访问元素的所有属性和方法。这种方法绑定的事件处理程序会在事件流的冒泡阶段被执行。

想要删除绑定的 DOM0 级事件处理程序，只要将元素的onclick属性设置为null即可，在 HTML 标签中绑定的事件处理函数也可以用这个方法来删除绑定的事件处理程序，需要注意的是删除绑定的代码要在需要删除的标签之后。

DOM2级事件处理程序

DOM2 级事件处理程序是我们目前最多使用的绑定事件处理程序的方法，包含了两个主要的方法用来绑定和删除事件处理函数addEventListener()和removeEventListener()。所有 DOM 节点都包含这两个方法。这两个方法都接受三个参数，第一个参数是要处理的事件类型（和 DOM0 级事件中的对象属性不同，这里的事件类型不需要加on），第二个参数是事件处理程序对应的函数，第三个参数是一个布尔值，如果是true表示在捕获阶段调用事件处理程序，如果是false表示在冒泡阶段调用事件处理程序，默认为false。具体细节可以看MDN。第三个参数还可以是一个对象，有如下三个属性：

useCapture: Boolean，true 表示 listener 会在该类型的事件捕获阶段传播到该 EventTarget 时触发。
once: Boolean，表示 listener 在添加之后最多只调用一次。如果是 true， listener 会在其被调用之后自动移除。
passive: Boolean，设置为 true 时，表示 listener 永远不会调用 preventDefault()。如果 listener 仍然调用了这个函数，客户端将会忽略它并抛出一个控制台警告。

如果我们要在一个元素上添加click事件的事件处理程序，就可以使用如下代码：

var btn = document.querySelector('.btn')
btn.addEventListener(
  'click',
  function () {
    console.log(this)
  },
  false
)

其中的click就是要处理的事件类型，匿名函数就是我们指定的事件处理函数，最后的false就是指定事件触发是在冒泡阶段。当事件监听程序监听到符合要求的事件发生时，就会调用事件处理程序来执行。

DOM2 级事件处理程序的特点：

可以为同一个元素的同一类型的事件绑定多个事件处理程序，他们会按照添加顺序执行。如：

var btn = document.getElementById('myBtn')
btn.addEventListener(
  'click',
  function () {
    console.log(this.id)
  },
  false
)
btn.addEventListener(
  'click',
  function () {
    console.log('Hello world!')
  },
  false
)

这段代码为 btn 的 click 类型的事件指定了两个事件处理程序，当我们触发 btn 的 click 事件的时候，这两个事件处理程序会按顺序执行，也就是先输出this.id然后输出Hello world!。

由于可以指定事件触发的阶段以及 event 对象的存在我们可以用 DOM2 级事件进行事件委托，达到对性能的提升和同类型元素绑定事件的简化，后面会详细讨论。
因为可以为同一元素和同一类型的事件绑定多个事件处理程序，所以要删除这些事件只能通过 removeEventListener() 来删除，并且移除时传入的参数必须与绑定时传入的参数相同，如果在绑定的时候如果用的是匿名函数，那么这个事件处理程序将无法删除，因为两个不同的匿名函数指向的是不同的空间，如：

var btn = document.getElementById('myBtn')
btn.addEventListener(
  'click',
  function () {
    alert(this.id)
  },
  false
)
btn.removeEventListener(
  'click',
  function () {
    //无效
    alert(this.id)
  },
  false
)

如果要实现事件处理函数的删除需要将第二个参数换成函数的引用：

var btn = document.getElementById('myBtn')
var handler = function () {
  alert(this.id)
}
btn.addEventListener('click', handler, false)
//这里省略了其他代码
btn.removeEventListener('click', handler, false) //有效!

IE9 、Firefox 、Safari 、Chrome 和 Opera 支持 DOM2 级事件处理程序。如果不是特别的事件如mouseenter不支持事件冒泡，一般就默认在冒泡阶段触发即可，事件捕获可以当我们需要在事件传播到目标之前截获的时候使用。

IE事件处理程序

在 IE9 之前的版本使用的是 IE 独特的事件处理程序，它只支持冒泡，有两个方法 attachEvent() 和 detachEvent() 两个方法，接收两个参数：事件类型（和 DOM0 一样需要加上 on）和事件处理程序函数，由于现在很少需要兼容 IE9 之前的版本，就不过多讨论了，放上一个跨浏览器的事件处理程序：

/* 若支持DOM2级事件处理程序则用DOM2级，若支持IE的事件处理程序则用IE，否则用DOM0级事件处理程序 */
var EventUtil = {
  addHandler: function (element, type, handler) {
    if (element.addEventListener) {
      element.addEventListener(type, handler, false)
    } else if (element.attachEvent) {
      element.attachEvent('on' + type, handler)
    } else {
      element['on' + type] = handler
    }
  },
  removeHandler: function (element, type, handler) {
    if (element.removeEventListener) {
      element.removeEventListener(type, handler, false)
    } else if (element.detachEvent) {
      element.detachEvent('on' + type, handler)
    } else {
      element['on' + type] = null
    }
  }
}

事件对象

在上面的事件处理程序中多次提到了 event 对象，我们在上面的代码中输出过 event 对象的 type 属性，这个属性表示当前指定的事件处理成熟的事件类型。事实上，每当某个 DOM 元素触发了某个事件，都会产生一个 event 事件对象，这个对象中包含着所有与事件有关的信息。包括触发事件的元素、事件的类型以及其他与特定事件相关的信息。例如，鼠标操作导致的事件对象中，会包含鼠标位置的信息，而键盘操作导致的事件对象中，会包含与按下的键有关的信息。所有浏览器都支持 event 对象，但支持方式不同。

在 DOM0 级和 DOM2 级事件处理程序中，浏览器会将一个 event 对象传入我们定义的事件处理程序的函数中，即使我们没有在函数的参数列表中加入 event 形参，我们也可以在函数内部使用，应该是浏览器替我加上了参数 event ：

<button id="myBtn">btn</button>
<script type="text/javascript">
  var btn = document.getElementById('myBtn')
  btn.onclick = function () {
    console.log(event.type) //可以输出
  }
</script>

一般为了代码便于理解，我们在事件处理程序的回调函数中给出参数 event。

即使我们通过HTML内联的方式执行事件处理程序，在其中我们也可以使用一个指向 event 对象的变量 event ：

<input type="button" value="Click Me" onclick="alert(event.type)" />

event 对象包含与创建它的特定事件有关的属性和方法。触发的事件类型不一样，可用的属性和方法也不一样。不过，所有事件都会有下表列出的成员。

| 属性/方法 | 类型 | 读/写 | 说明 | | ------------------- | ---------- | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Event() | 构造函数 | | Event() 构造函数, 创建一个新的事件对象 Event。语法 event = new Event(typeArg, eventInit);，typeArg 是必选参数，为一个字符串，表示创建的事件名称。第二个参数是一个对象，用来定义事件是否冒泡和可以取消。 | | bubbles | Boolean | 只读 | 事件是否冒泡 | | cancelBubble | Boolean | 可写 | Event.stopPropagation() 的历史别名。在事件处理器函数返回之前，将此属性的值设置为 true，亦可阻止事件继续冒泡。 | | cancelable | Boolean | 只读 | 是否可以取消事件的默认行为，如果为 false 则事件发生时无法在事件监听回调中用 preventDefault() 停止事件 | | composed | Boolean | 只读 | 一个布尔值，表示事件是否可以穿过 Shadow DOM 和常规 DOM 之间的隔阂进行冒泡。 | | currentTarget | Element | 只读 | 事件处理程序当前处理元素 | | defaultPrevented | Boolean | 只读 | 为 true表示已经调用了 preventDefault() ( DOM3 级事件中新增) | | detail | Integer | 只读 | 与事件相关细节信息 | | eventPhase | Integer | 只读 | 事件处理程序阶段：1 捕获阶段，2 处于目标阶段，3 冒泡阶段 | | preventDefault() | Function | | 取消事件默认行为 | | stopPropagation() | Function | | 取消事件进一步捕获或冒泡 | | target | Element | 只读 | 事件的目标元素 | | timeStamp | | 只读 | 事件创建时的时间戳（精度为毫秒）。按照规范，这个时间戳是 Unix 纪元起经过的毫秒数，但实际上，在不同的浏览器中，对此时间戳的定义也有所不同。另外，规范正在将其修改为 DOMHighResTimeStamp | | isTrusted | Boolean | 只读 | 为 true 表示事件是浏览器生成的。为 false 表示事件是由开发人员通过 JavaScript 创建的(DOM3 级事件中新增) | | type | String | 只读 | 被触发的事件类型 | | composedPath | Function | | 返回事件的路径（将在该对象上调用监听器）。如果阴影根节点 (shadow root) 创建时 ShadowRoot.mode 值为 closed，那么路径不会包括该根节点下阴影树 (shadow tree) 的节点。 |

关于 currentTarget 和 target 只要记住一点，不管事件传播处于什么阶段，target 都是不变的，指向目标元素，所以我们在实现事件委托的时候会用到 target。而 currentTarget 则是随着事件传播处于不同的阶段而指向不同的元素。具体细节点击实现页面，打开控制台点击不同的元素查看细节。

在事件处理程序内部，对象 this 始终等于 currentTarget 的值，而 target 则只包含事件的实际目标。如果直接将事件处理程序指定给了目标元素，则 this、currentTarget 和 target 包含相同的值。来看下面的例子。

我们可以利用 event 对象的 type 属性来用一个函数处理多种事件：

var handler = function (event) {
  switch (event.type) {
    case 'click':
      alert('Clicked')
      break
    case 'mouseover':
      event.target.style.backgroundColor = 'red'
      break
    case 'mouseout':
      event.target.style.backgroundColor = ''
      break
  }
}

有时我们会需要阻止某些事件的默认行为，比如点击表单的 submit 跳转，以及点击 a标签 的跳转，如果我们不希望这些行为发生，那么我们可以利用 event对象 的 preventDefault() 方法，只有 cancelable 属性设置为 true 的事件，才可以使用 preventDefault() 来取消其默认行为。

event对象 还有一个重要的方法是 stopPropagation()，这个方法用来停止事件在 DOM 树上的传播，不管在哪个传播阶段，都会停止事件的传播。比如我们在按钮和 body 上都注册了一个事件，当用户点击按钮，我们不希望注册在 body 上的事件被触发，此时我们就需要用到这个方法：

var btn = document.getElementById('myBtn')
btn.onclick = function (event) {
  alert('Clicked')
  event.stopPropagation()
}
document.body.onclick = function (event) {
  alert('Body clicked')
}

事件对象的 eventPhase 属性，可以用来确定事件当前正位于事件流的哪个阶段。如果是在捕获阶段调用的事件处理程序，那么 eventPhase 等于 1;如果事件处理程序处于目标对象上，则 event- Phase 等于 2;如果是在冒泡阶段调用的事件处理程序，eventPhase 等于 3。这里要注意的是，尽管“处于目标”发生在冒泡阶段，但 eventPhase 仍然一直等于 2。来看下面的例子。

var btn = document.getElementById('myBtn')
btn.onclick = function (event) {
  alert(event.eventPhase) //2
}
document.body.addEventListener(
  'click',
  function (event) {
    alert(event.eventPhase) //1
  },
  true
)
document.body.onclick = function (event) {
  alert(event.eventPhase) //3
}

还有一个要注意的点是，很多同学学习事件传播顺序的知识会容易混淆到单个元素的事件处理程序的执行顺序上，对于单个元素，无论你是绑定在捕获阶段还是冒泡阶段，都是先绑定的事件处理程序先执行，事件传播只在嵌套中的不同 DOM 元素之间有效，比如如下代码，就是先执行冒泡在执行捕获。

<div id="el">element</div>
<script type="text/javascript">
  var el = document.getElementById('el')
  //冒泡
  el.addEventListener(
    'click',
    function () {
      console.log('el冒泡')
    },
    false
  )
  //捕获
  el.addEventListener(
    'click',
    function () {
      console.log('el捕获')
    },
    true
  )
</script>

event对象 在事件触发的时候生成，当事件处理程序执行结束后，event对象 即被销毁，也就是说只有在事件处理程序执行期间，event对象 才会存在。

事件类型

浏览器中发生的事件类型很多，详情查询事件参考 - MDN，GlobalEventHandlers - MDN，每种事件对应的元素，行为都不尽相同。

内存和性能

在 JS 中，添加到页面上的事件处理程序的数量会影响的页面的整体性能，因为每一个事件处理函数也都是对象，都保存在内存中，事件处理程序多了自然对内存的开销会增大。其次，在 JS 的渲染过程中，指定事件处理程序需要访问 DOM ，没绑定一个事件处理程序都需要访问一次DOM，如果事件处理程序过多，会影响页面渲染完成的时间。如果我们能够更好地处理事件，对提升页面的性能是有一定的帮助的。

事件委托

事件委托其实很好理解，利用事件流传播的特性，利用事件冒泡，我们可以对多个需要绑定事件的同类型元素的上级 DOM 节点绑定一个事件处理程序，用这个上层节点的事件处理程序来同一管理那些同一类型的事件。举个例子：

<ul id="myLinks">
  <li id="goSomewhere">Go somewhere</li>
  <li id="doSomething">Do something</li>
  <li id="sayHi">Say hi</li>
</ul>

如果我们要实现点击每个 li 都输出其中的文本，那么按照传统的做法，我们会为每个 li 绑定一个事件，如果同样类型的元素特别多，那么我们一个一个绑定事件显然是不现实的，而且这样页面的性能也不佳。如果我们事件委托，我们就可以把事件处理程序绑定到 ul 上，利用事件冒泡的特性来统一管理点击 li 的事件。

var list = document.querySelector('myLinks')
ul.addEventListener('click', function (e) {
  if (e.target.tagName.toLowerCase() === 'li') {
    console.log(e.target.innerText)
  }
})

当我们点击 li 的时候，由于事件冒泡传播，所以当事件传播到 ul 的时候，会被我们绑定在 ul 上的事件处理程序捕获，然后在函数内部我们利用 event.target 会指向目标元素的特点来判断用户点击的是否是 li，然后在执行对应的逻辑需求。

上面只是最简单的事件委托情况，有时候我们的 DOM 结构嵌套更多，我们不仅要处理绑定元素内的元素的委托，还有可能要在触发内部元素的事件之后修改外部的 DOM 节点，这时候我们就需要将 currentTarget 和 target 结合起来用，比如下面这种场景: 当我们点击上面的按钮的时候，下面的 panel 要进行切换，一共有四个 panel 点击第几个按钮，显示第一个 panel，用 display: none 来设置。并且这样的模块有两个。

DOM结构如下：

<div class="mod_tab">
  <div class="header">
    <div class="tab active">1</div>
    <div class="tab">2</div>
    <div class="tab">3</div>
    <div class="tab">4</div>
  </div>
  <div class="content">
    <div class="panel active">panel1</div>
    <div class="panel">panel2</div>
    <div class="panel">panel3</div>
    <div class="panel">panel4</div>
  </div>
</div>
<div class="mod_tab">
  <div class="header">
    <div class="tab active">1</div>
    <div class="tab">2</div>
    <div class="tab">3</div>
    <div class="tab">4</div>
  </div>
  <div class="content">
    <div class="panel active">panel1</div>
    <div class="panel">panel2</div>
    <div class="panel">panel3</div>
    <div class="panel">panel4</div>
  </div>
</div>

我们可以把事件绑定到 header 上，当点击按钮的时候用 event.target 来操作按钮的样式，同时利用 event.currentTarget 找到 header 然后找到 header 的兄弟元素 content 来操作 panel 的显示。具体代码查看页面

使用事件委托还有一个优点就是当我们动态向我们绑定了事件处理程序的上册元素中添加新的元素时，事件处理程序对这个新的元素也会生效，而传统的绑定事件方法则不行。

最适合采用事件委托技术的事件包括 click、mousedown、mouseup、keydown、keyup 和 keypress。虽然 mouseover 和 mouseout 事件也冒泡，但要适当处理它们并不容易，而且经常需要计算元素的位置。(因为当鼠标从一个元素移到其子节点时，或者当鼠标移出该元素时，都会触发 mouseout 事件。)

移除事件处理程序

移除事件处理程序更像一个程序员来维护的垃圾回收方式。每当将事件处理程序指定给元素时，运行中的浏览器代码与支持页面交互的 JavaScript 代码之间就会建立一个连接。这种连接越多，页面执行起来就越慢。采用事件委托的方式能有效的减少连接的数量，但是一些残留在内存中的未被回收的空事件处理程序也是影响页面性能的一个原因。

如果我们绑定了事件处理程序的元素被 removeChild(), replaceChild()或者innerHTML 方法删除或替换的时候，原来添加到元素中的事件处理程序很可能没有被当作垃圾回收，这时候用 removeEventListener() 或者 element.onclick = null 来手动移除事件处理程序是个不错的选择。

在事件处理程序中删除按钮也能阻止事件冒泡。目标元素在文档中是事件冒泡的前提。

自定义事件

自定义事件与浏览器定义的事件并没有什么不同，一样能够传播，能够指定事件处理程序。有了自定义事件以后，我们可以在任意时刻触发特定的事件。对于复杂页面不同功能模块之间的解耦有很大的帮助。同时自定义事件能够实现对全局的广播，这在复杂的应用中有很大的作用。

创建自定义事件

Events 可以使用 Event 构造函数创建如下：

var event = new Event('build');

// Listen for the event.
elem.addEventListener('build', function (e) { ... }, false);

// Dispatch the event.
elem.dispatchEvent(event);

注意的是如果要模拟内置事件需要使用内置事件自己的对应接口，比如鼠标事件用 new MouseEvent()，焦点相关事件用 new FocusEvent()，和键盘事件相关的 new KeyboardEvent()。如果是用 new Event() 的话，很可能会出问题，比如你想模拟复选框的点击事件，如果用 new Event('click')，虽然事件流都触发了，但是最后复选框的勾没打上，用 MouseEvent 就没有问题。但是 MouseEvent 无法配置 bubbles 和 cancelable 字段。内置事件的详情查看 Web API 接口参考 - MDN

最早定义事件使用 event = document.createEvent(MouseEvents)，event.initEvent() 和 event.initMouseEvent() 等方法，如今这些方法董聪标准中移除，不推荐使用。现在要模拟内置事件，就用内置事件的构造函数（不再支持 bubbles 和 cancelable 参数，内置事件的冒泡和取消默认行为都要在绑定事件时设定）创建内置事件，想要自定义事件则使用 Event() 或者 customEvent() 构造函数。

自定义事件通常称为合成事件，而不是浏览器本身触发的事件。如果我们用 new Event()，创建了和内置事件同名的事件，不会影响浏览器的默认行为。

派发事件

使用 EventTarget.dispatchEvent 方法进行事件的派发，语法是 cancelled = !target.dispatchEvent(event)，event 是要被派发的 事件对象，注意这里必须是事件对象，而不是事件类型的字符串。比如你想派发一个内置 click 事件，需要 element.dispatchEvent(new MouseEvent('click'))，而不是 e'le'ment.dispatchEvent('click')。

该方法的返回值是一个布尔值，当该事件是可取消的(cancelable 为 true)并且至少一个该事件的事件处理方法调用了Event.preventDefault()，则返回值为 false；否则返回 true。

如果该被派发的事件的事件类型(event's type)在方法调用之前没有被经过初始化被指定，就会抛出一个 UNSPECIFIED_EVENT_TYPE_ERR 异常，或者如果事件类型是 null 或一个空字符串。 event handler 就会抛出未捕获的异常；这些 event handlers 运行在一个嵌套的调用栈中：他们会阻塞调用直到他们处理完毕，但是异常不会冒泡。

最后一点需要注意的是，事件派发必须在事件绑定完成之后，否则不会有任何效果。

关于 cancelable 和 preventDefault() 添加一点理解，我觉得 cancelable 对自定义事件来说意义不是很大，因为自定义事件本来就没有任何默认行为，cancelable 唯一的作用就是确定自定义事件中的 event.preventDefault() 是否执行了。而这种状态的传递是完全可以依靠其他的方式来做，不是必须的。有默认行为的内置事件已经不支持设置 cancelable 和 bubbles。下面这个例子是现代 JavaScript 教程中的一个例子，可以在 dispatchEvent 的位置根据返回值进行逻辑判断，不过我依然觉得这个功能不是很有用，除非以后能让我们添加自定义函数的默认行为，这才会比较有用。

<pre id="rabbit">
  |\   /|
   \|_|/
   /. .\
  =\_Y_/=
   {>o<}
</pre>
<button onclick="hide()">Hide()</button>

<script>
  // hide() 将在 2 秒后被自动调用
  function hide() {
    let event = new CustomEvent('hide', {
      cancelable: true // 没有这个标志，preventDefault 将不起作用
    })
    if (!rabbit.dispatchEvent(event)) {
      alert('The action was prevented by a handler')
    } else {
      rabbit.hidden = true
    }
  }

  rabbit.addEventListener('hide', function (event) {
    if (confirm('Call preventDefault?')) {
      event.preventDefault()
    }
  })
</script>

添加自定义数据

要向事件对象添加更多数据，可以使用 CustomEvent，该接口继承自 Event 所以 Event 的方法和属性它都继承了。他自己本身只有一个静态属性，就是初始化时传入的自定义数据 detail。它的第二个参数是一个对象接受三个参数：bubbles，cancelable 和 detail。其中 detail 就是我们初始化的时候传给事件的数据，当派发的时间出发的时候，我们可以在回调函数中取得该值。

CustomEvent 接口可以为 event 对象添加更多的数据。例如，event 可以创建如下：

var event = new CustomEvent('build', { detail: elem.dataset.time })

访问自定义数据，在事件处理程序中的回调函数中使用：

function eventHandler(e) {
  log('The time is: ' + e.detail)
}

元素可以侦听尚未创建的事件：

<form>
  <textarea></textarea>
</form>

<script>
  const form = document.querySelector('form')
  const textarea = document.querySelector('textarea')

  form.addEventListener('awesome', (e) => console.log(e.detail.text()))

  textarea.addEventListener('input', function () {
    // Create and dispatch/trigger an event on the fly
    // Note: Optionally, we've also leveraged the "function expression" (instead of the "arrow function expression") so "this" will represent the element
    this.dispatchEvent(
      new CustomEvent('awesome', { bubbles: true, detail: { text: () => textarea.value } })
    )
  })
</script>

javascript高级程序设计中的模拟事件章节中的方法都已经废弃，想要了解自定义事件的查看MDN

通常事件是在队列中处理的。也就是说：如果浏览器正在处理 onclick，这时发生了一个新的事件，例如鼠标移动了，那么它会被排入队列，相应的 mousemove 处理程序将在 onclick 事件处理完成后被调用。

值得注意的例外情况就是，一个事件是在另一个事件中发起的。例如使用 dispatchEvent。这类事件将会被立即处理，即在新的事件处理程序被调用之后，恢复到当前的事件处理程序。

参考文章

《JavaScript 高级程序设计 3rd Edition》
MDN

深入 JavaScript 类型转换

Tue, 13 Oct 2020 12:00:00 GMT

前言

JavaScript 中的类型转换是一个非常让人头大的内容，其实我们平时的编码一般会尽量避免让自己陷入不确定的类型转换中。但是很多时候面试会考查这方面的知识，并且搞清楚类型转换的机制能够让我们在遇到一些奇葩问题的时候知道发生了什么。我们不一定要记住所有的类型转换的可能性，只要记住一些常用的，以及如何进行查询即可。

装箱拆箱

在讨论具体的类型转换场景之前，我们先来说一下装箱拆箱操作。在这之前你应该复习一下 JavaScript 中关于数据类型的知识，你可以看我的这一篇文章：JS数据类型和判断方法。

装箱 wrapper

在 JavaScript 中目前共有八种数据类型 Undefined, Null, Number, String, Boolean, BigInt, Symbol, Object。除了 Object 其他都是基本数据类型（primitive values，也称原始值，原始类型）。所谓基本数据类型就是它们是一种即非对象也没有属性和方法的数据，基本类型直接代表了最底层的语言实现。

所有基本类型的值都是不可改变的。但需要注意的是，基本类型本身和一个赋值为基本类型的变量的区别。变量会被赋予一个新值，而原值不能像数组、对象以及函数那样被改变。即基本类型值可以被替换，但不能被改变。比如，JavaScript 中对字符串的操作一定返回了一个新字符串，原始字符串并没有被改变。

既然如此，为什么我们还能在 Number 或者 String 上使用方法呢？这就引出了 JavaScript 中的基本包装类型（primitive wrapper types，也成为原始包装类型），因为我们有在基本类型上频繁操作的需求（比如 String 的截取，Number 的格式转换等），所以 JavaScript 也为基本类型内置了一系列的 API。但是只有对象才能使用方法，所以 JavaScript 就用基本包装类型来让基本类型能够拥有属性和方法。除了 null 和 undefined 之外，所有基本类型都有其对应的包装对象：

String 为字符串基本类型。
Number 为数值基本类型。
BigInt 为大整数基本类型。
Boolean 为布尔基本类型。
Symbol 为字面量基本类型。

其中最重要的就是 String，Number 和 Boolean 三种原始包装类型，也是我们本文重点讨论的内容。

这些类型与其他引用类型相似，但同时也具有与各自的基本类型相应的特殊行为。实际上，每当读取一个基本类型值的时候，后台就会创建一个对应的基本包装类型的对象，从而让我们能够调用一些方法来操作这些数据。看下面的例子：

let str1 = 'clloz'
let str2 = str1.substring(2)

上面的代码中我们创建了一个基本类型的字符串 str1，然后我们调用了 str1 的 substring 方法，从逻辑上来讲基本类型不应该有方法的。实际上 JavaScript 在背后为我们创建了一个基本包装类型，大致过程如下：

let temp = new String('clloz')
let str2 = temp.substring(2)
temp = null

引用类型与基本包装类型的主要区别就是对象的生存期。使用 new 操作符创建的引用类型的实例，在执行流离开当前作用域之前都一直保存在内存中。而自动创建的基本包装类型的对象，则只存在于一行代码的执行瞬间，然后立即被销毁。这意味着我们不能在运行时为基本类型值添加属性和方法。

let str1 = 'clloz'
str1.color = 'red'
console.log(str1.color) // undefined

一般情况下，我们不需要手动进行装箱操作，因为装箱后的基本类型就变成了一个对象，typeof 将返回 object，在转换为 Boolean 的时候也会转换成 true，比如 Boolean(new Boolean(false)) 将返回 true。我们只需要根据自己的需求来创建基本类型即可，将是否需要装箱的判断交给引擎，一般来说我们能在代码中优化的内容，引擎一定会帮我们进行优化。

最后说一说进行装箱的几种方法，这些方法对除了 null 和 undefined 的基本类型都有效（null 和 undefined 没有原生构造函数，因为它们并不需要 API）：

用 new 操作符调用对应类型的构造函数。
使用 Object 函数，带不带 new 都可以。Object() 构造函数将会根据参数的不同做以下操作：
- 如果给定值是 null 或 undefined，将会创建并返回一个空对象
- 如果传进去的是一个基本类型的值，则会构造其包装类型的对象
- 如果传进去的是引用类型的值，仍然会返回这个值，经他们复制的变量保有和源对象相同的引用地址
- 当以非构造函数形式被调用时，Object 的行为等同于 new Object()。
利用 call。

let a = 2
console.log(typeof a) //number
let t = function () {
  return this
}.call(a)
console.log(typeof t) //object

拆箱 toPrimitive

装箱的操作是为了让我们能够使用一些为基本类型内置的 API。但有时我们也需要对对象进行拆箱操作，比如当我们进行四则运算，进行比较等逻辑运算，等等。

在 JavaScript 标准中，规定了 ToPrimitive 函数，它是对象类型到基本类型的转换（即，拆箱转换）。拆箱转换会尝试调用 valueOf 和 toString 来获得拆箱后的基本类型。如果 valueOf 和 toString 都不存在，或者没有返回基本类型，则会产生类型错误 TypeError。String 的拆箱转换会优先调用 toString。在 ES6 之后，还允许对象通过显式指定 @@toPrimitive Symbol 来覆盖原有的行为。

这里为了让大家彻底明白拆箱的机制，我们直接把 ECMAScript2021 标准中的定义拿过来解读一下：

我主要讲一下 2 中的步骤：

a：获取 input 的 @@toPrimitive 方法，input 是一个对象。
b：如果 @@toPrimitive 不是 undefined，然后
- i：如果 @@toPrimitive 方法中没有指定第二个参数，那么 hint 设为 default。
- ii：如果第二个参数是 string，那么 hint 设为 string。
- iii：如果第二个参数是 number，那么 hint 设为 number。
- iv：以 input 和 hint 为参数调用 @@toPrimitive 方法。
- v：如果执行结果不是一个对象，那么返回结果。
- vi：如果执行结果是一个对象，抛出 TypeError。
c：如果没有定义 @@toPrimitive 方法，并且没有指定 preferredType，那么 preferredType 设为 number。
d：返回 OrdinaryToPrimitive(input, preferredType)

所以当我们没有指定 @@toPrimitive 方法的时候，就是执行 OrdinaryToPrimitive(input, preferredType)，该函数定义如下：

它接受两个参数 O 和 hint，也就是我们上面 d 步骤中的 input 和 preferredType。主要步骤如下：

hint 必须是 string 或者 number 的一种。
如果 hint 是 string，就按顺序调用对象的 toString 和 valueOf 方法，如果调用后结果不是对象则返回。
如果 hint 是 number，就按顺序调用对象的 valueOf 和 toString 方法，如果调用后结果不是对象则返回。

其实逻辑还是比较清晰，并没有很复杂，最后在说一说 toPrimitive 中的 b 情况。@@toPrimitive 方法就是让我们自定义拆箱的规则，而不是根据标准的规则进行，我们可以根据自己的需求定制拆箱的规则。@@ 开头的名字是标准中的 Well-Known Symbols，他们是内置的 Symbol，作为属性的 key。在 ES2016 引入 Symbol 后我们已经可以访问这些 Symbol，比如 @@match，@@matchAll 等等，我们在编码中可以直接使用 String.prototype.match 和 String.prototype.matchAll 来调用，他们在引擎内部即调用的 Symbol 对应的方法。@@ 是在标准文档中的名字，我们在 JavaScript 编码中使用的名字是将 @@ 替换为 Symbol.，所以我们给对象添加 @@toPrimitive 属性就是添加一个 Symbol.toPrimitive 属性。当引擎调用 @@toPrimitive 的时候就会找到我们定义的方法。

// 一个没有提供 Symbol.toPrimitive 属性的对象，参与运算时的输出结果
var obj1 = {}
console.log(+obj1) // NaN
console.log(`${obj1}`) // "[object Object]"
console.log(obj1 + '') // "[object Object]"

// 接下面声明一个对象，手动赋予了 Symbol.toPrimitive 属性，再来查看输出结果
var obj2 = {
  [Symbol.toPrimitive](hint) {
    if (hint == 'number') {
      return 10
    }
    if (hint == 'string') {
      return 'hello'
    }
    return true
  }
}
console.log(+obj2) // 10      -- hint 参数值是 "number"
console.log(`${obj2}`) // "hello" -- hint 参数值是 "string"
console.log(obj2 + '') // "true"  -- hint 参数值是 "default"

内置 Symbol 参考 Symbol - MDN

类型转换

现在我们已经知道装箱和拆箱的规则，也就是掌握了类型转换的工具，剩下的只要搞清楚哪个场景用哪个工具进行转换即可。

显式强制类型转换

在讨论隐式强制类型转换之前，我们先讨论一下显式强制类型转换。

所谓 显式强制类型转换 指的就是我们直接调用 Number()， String() 和 Boolean() 构造函数（不带 new）对一个值进行类型转换。我们还是来解读标准文档。

注意一点，标准文档中的蓝色的方法前面的 ! 不是取反的意思，你可以无视掉，就当做执行后面的方法就可以。

Number

上面的截图就是对 Number 构造函数的定义，内容很简单：

如果不是用 new 调用的，则返回 ToNumeric(value) 的值，value 是我们传入的值，如果没有传入 value，那么就返回 +0。
如果是用 new 调用，则生成基本包装类型对象。

ToNumeric 的定义如下：

表格十分清晰，我就不解读了。表格中没有说的是 String，String 转 Number 在标准中定义了非常长的内容，我个人理解就是不符合 JavaScript 格式的 string 返回 NaN，其他返回对应的数字。所谓的符合格式就包括 0o 或 0 开头的八进制，0x 开头的十六进制，0b 开头的二进制，科学计数法等。

String

还是从标准解读：

如果不是 new 调用 String 构造函数，返回 ToString(value)。
如果是以 new 调用 String 构造函数，返回基本包装类型对象。

ToStrong 定义如下：

这当中 Number::String 在标准中定义比较复杂，应该是进行了严格的数学定义，我们按我们正常的理解就可以了。-0，-0 都是 0，NaN 返回 "NaN"。

Boolean

如果不是 new 调用 Boolean 构造函数，返回 ToBoolean(value)。
如果是以 new 调用 Boolean 构造函数，返回基本包装类型对象。

隐式强制类型转换

隐式强制类型转换可能是更让人头疼的一部分，其实只要搞清楚标准，隐式的转换也是用的我们上面看到的那些方法进行转换的，我们也不必记清楚每一个规则，只要知道到哪里去查，还有编码中避免一些会出问题的转换。我这里就找出一些我们比较常见的隐式转换的场景对标准进行解读。

算数运算符

在标准中所有的算数运算符最后都是由下面这个方法执行的 lval 即操作符左边的值，opText 即操作符，rval 即操作符右边的值：

如果操作符是 +
- 计算 ToPrimitive(lval) 赋值给 lprim
- 计算 ToPrimitive(rval) 赋值给 rprim
- 如果 lprim 或 rprim 中有一个类型是 String
  - 计算 ToString(lprim) 赋值给 lstr
  - 计算 ToString(rprim) 赋值给 rstr
  - 拼接 lstr 和 rstr 并返回
- 将 lprim 赋值给 lval
- 将 rprim 赋值给 rval
计算 ToNumeric(lval)，赋值给 lnum
计算 ToNumeric(rval)，赋值给 rnum
如果 Type(lnum) 和 Type(rnum) 不同，抛出一个 TypeError
进行算数运算

我们可以看到这段定义中的方法都是我们在上面显示转换中介绍过的方法。在算数操作符中 ToPrimitive() 是并没有传入 hint 的，所以就用默认 number，所以在算术运算的类型转换中，总是先调用 valueOf，后调用 toString()。

一元操作符

一元操作符的定义都非常简单，这里就不贴图了，直接给一个总结，如果你想看相关定义点击ECMAScript 2021 - Unary Operators

++ -> ToNumeric
-- -> ToNumeric
+ -> ToNumeric
- -> ToNumeric
~ -> ToNumeric
! -> ToBoolean

这里再给大家举个例子 'a' + + 'a' （注意两个加号不能相连）得到的结果是 aNaN，因为第二个 + 作为一元操作符，调用 ToNumber() 最后的结果是 NaN。然后执行 'a' + NaN，就是回到算术运算符的定义，有一个是 String 两个都转成 String 然后返回拼接的字符串，所以最后的结果是 aNaN。你也可以找一些例子进行验证。

关系运算符

所有的关系运算符（<, >, <=, >=）的结果都是根据 Abstract Relational Comparison 的返回值计算，所以我们先着重分析这个方法，看下图。由于在标准中统一用小于号，所以用 leftFirst 表示是大于操作符还是小于操作符，true 则为小于关系符，false 则为大于关系符。

我们可以看到第一部就是进行拆箱操作，hint 为 number，也就是先调用 valueOf，在调用 toString。

当两个操作数 operand 都是字符串的时候，会调用一个方法 IsStringPrefix(a, b) 来计算结果。这个方法的意思就是：比如判断 a<b 的结果，就是判断 a 是不是 b 的一个前缀，就是 a 加上另一个字符串能构成 b，如果能，则返回 true ；如果 b 是 a 的前缀，则返回 false，所以 'cl' < 'clloz' 会返回 true。如果不存在前缀关系，则进行 code unit 比较，在 JavaScript 中是 UTF-16 编码，从最低位开始进行码点比较相同则进入下一位，如果能找到一位是 a 的码点小于 b 则返回 true 否则返回 false。一般的字符串我们只要根据扩展 ASCII 进行比较即可。

console.log('cllob' < 'clloc') //true
console.log('cllob' < 'clloa') //false
console.log('clloba' < 'cllob') / false

bigInt 我们就跳过，因为运用不是很多。我们直接进入下面的 ToNumeric，将两个操作数都进行 ToNumeric，如果得到的结果类型相同，则调用对应类型的 T::lessThan. ToNumeric 的结果要么是 Number 要么是 BigInt，要么抛错，所以我们只要看 Number::lessThan(x, y) 的定义即可：

如果 x 是 NaN，返回 undefined。
如果 y 是 NaN，返回 undefined。
如果 x 和 y 是相同的数值，返回 false。
如果 x 和 y 一个是 +0 一个是 -0 返回 false。
如果 x 和 y 任意一个为 $\pm \infty$，返回 false。
其他情况进行数值比较（非零并且不是无穷），x < y 返回 true，否则返回 false。

注意，得到的 Abstract Relational Comparison 的返回值不是最终的结果。对于 <, > 来说，如果 Abstract Relational Comparison 返回值是 undefined，则则返回 false，否则直接返回 Abstract Relational Comparison 的返回值。对于 <=, >=，如果 Abstract Relational Comparison 的返回值是 true 或 undefined，则返回 false，否则返回 true。

这里可能有同学疑惑 <= 和 >= 的逻辑是不是错了，Abstract Relational Comparison 的返回值是 true 应该返回 true，这里标准里面是将 <=, >= 的 leftFirst 相对于 <, > 去了一个相反，这样能保持 lessThan 中的逻辑最简单，即 <, > 为 false 的时候 <=, >= 为 true；<, > 为 true 的时候 <=, >= 为 false。否则因为有第三条相等规则在，逻辑会比较复杂。具体的定义看 Relation-Operators -ECMAScript

下面来几个例子：

console.log(null < -0) //false null被转为 +0，和 -0 进行lessThan 返回false，所以最终结果为 false

console.log(NaN < 10) //false 只要有 NaN，lessThan的结果就是 undefined，对于 < 和 > 来说 undefined最后返回 false

console.log(NaN <= 10) //false 对于 <= 和 >= 来说，undefined就是 false

相等操作符

相等操作符有四个 ==, !=, ===, !==，定义在 Equality-Operators - ECMAScript，其中最关键的就是两个方法：Abstract Equality Comparison 和 Strict Equality Comparison，前者是双等号的方法，后者是全等号的方法。定义间下图：

我们可以看到两个方法的定义长度完全不同 :joy: 。双等号可以算作是 JavaScript 中的一个设计失误，非常不建议使用。这里我就说一说全等好的定义。

如果两个操作数的类型不同，返回 false。
如果两个操作数的类型都是 Number，调用 Number::equal(x, y) 方法，返回方法的返回值（BigInt 不讨论）。该方法定义在 Number::equal - ECMAScript
- 两个操作数有一个是 NaN，返回 false。
- 两个操作数是同一个数值，返回 true。
- 两个操作数分别是 +0 和 -0，返回 true。
- 上面的条件都不满足，返回 false。
如果类型不是 Number 或 BigInt，则返回 SameValueNonNumeric(x, y) 的返回值。
- 断言：两者不是 Number 和 BigInt
- 断言：两者类型相同
- 如果 x 类型是 Undefined，返回 true。
- 如果 x 类型是 Null，返回 true。
- 如果 x 类型是 String，则必须 x 和 y 的所有码点序列完全一致才返回 true，否则返回 false。
- 如果 x 类型是 Boolean，则必须 x 和 y 同为 true 或 false 才返回 true，否则返回 false。
- 如果 x 类型是 Symbol，则必须 x 和 y 是同一个 Symbol 才返回 true，否则返回 false。
- 如果 x 和 y 是同一个对象，返回 true，否则返回 false。

相等操作符到这里就讲完了，双等号我没有仔细看，因为我从来不用，也不建议大家使用。如果你有兴趣可以仔细阅读一下图片中的标准定义。

valueOf 和 toString

上面从标准的角度讲了类型转换，toPrimitive 最后会尝试调用 valueOf 或者 toString。

valueOf 就是返回对象的原始值，这个方法是在 Object.prototype 上。JavaScript 调用 valueOf 方法将对象转换为原始值。你很少需要自己调用 valueOf 方法；当遇到要预期的原始值的对象时，JavaScript 会自动调用它。

默认情况下，valueOf 方法由 Object 后面的每个对象继承。每个内置的核心对象都会覆盖此方法以返回适当的值。如果对象没有原始值，则 valueOf 将返回对象本身。JavaScript 的许多内置对象都重写了该函数，以实现更适合自身的功能需要。因此，不同类型对象的 valueOf() 方法的返回值和返回值类型均可能不同。不同类型对象的 valueOf() 方法的返回值如下：

Array：返回数组对象本身。
Boolean：返回布尔值。
Date：存储的时间从 1970 年 1 月 1 日 午夜开始计的毫秒数 UTC。
Function：函数本身。
Number：数字值。
Object：对象本身。这是默认情况。
String：字符串值。
Math 和 Error 对象没有 valueOf 方法。

你可以在自己的代码中使用 valueOf 将内置对象转换为原始值。创建自定义对象时，可以覆盖 Object.prototype.valueOf() 来调用自定义方法，而不是默认 Object 方法。

每个对象都有一个 toString() 方法，当该对象被表示为一个文本值时，或者一个对象以预期的字符串方式引用时自动调用。默认情况下，toString() 方法被每个 Object 对象继承。如果此方法在自定义对象中未被覆盖，toString() 返回 [object type]，其中 type 是对象的类型。

所以 valueOf 就是返回这个对象本来的“面目”，比如一个被包装过的 Number；而 toString 则是把对象转化成一个字符串。不同的对象有不同的处理方式，内置对象几乎都实现了自己的对应方法覆盖 Object.prototype 上的方法。这两个方法主要就是为了应对不同的类型在进行某些操作是需要进行类型转换的情况。

总结

这篇文章应该将双等号以外的绝大多数类型转换的情况都说清楚了，而且是根据标准来讲的，还是比较清晰的。其实整个思路理下来也不是非常的复杂，所以有时候就是 Just Do It! :punch: 。希望这篇文章给你带来帮助，如果有错误的地方，欢迎指正。

函数柯里化

Mon, 12 Oct 2020 12:00:00 GMT

前言

本文讲一讲面试经常出现但是实际编码中很少使用到 :laughing: 的函数柯里化的实现。

什么是函数柯里化

柯里化是一个函数式编程的概念，维基百科的定义时在数学和计算机科学中，柯里化是一种将使用多个参数的一个函数转换成一系列使用一个参数的函数的技术。大致的效果是这样，比如一个函数需要三个参数：

function fu(a, b, c) {
  console.log(a, b, c)
}

一般我们调用这样的函数是一次性传入三个参数 fn(1, 2, 3)，但是经过柯里化之后，我们可以分次传入参数。

function curry(fn) {
  //content ....
  return function () {
    //content ...
  }
}

let newFn = curry(fn)

newFn(1)(2)(3)

那么函数柯里化有什么用呢？一个比较明显的作用就是返回一个已经设定好参数的函数，当我们的函数参数有多种可能情况的时候，比如 ajax 我们可能需要传入 type, url, data 等数据，那我们可以用 curry 进行包装，得到预设好 type 的 get 和 post 函数，这样我们使用的时候更加方便。但其实这个功能用 bing 也能实现。

所以我觉得 bind 和 curry 是有一些相同的逻辑的。比如我在模拟实现call，apply 和 bind 一文中写的用 bind 可以将 Array.prototype.slice.apply(arguments) 简化成 slice(arguments) 的调用方式。curry 也有相同的作用。以我的理解就是函数柯里化是对函数的一种抽象和包装，让我们能够更好地定制函数，更简洁地调用函数。

虽然可能在实际编码中我们不太会用到这个，但是之所以经常有面试问到这个问题我觉得是考查你对于函数的理解。函数既可以作为一个参数，也可以作为一个返回值。也可以赋值给变量，所谓的一等公民。只要是函数式编程就可以实现柯里化，他也是函数式编程语言自带的一个特性。

实现

实现函数柯里化的主要逻辑： 1. 实现一个 curry 函数 function curry() {}，该函数接受一个函数beCurry作为参数，返回一个函数 fn_judge。这个返回的函数 fn_judge 才是我们后面分次接受参数执行的函数，也是我们的主要逻辑。 2. 给 fn_judge 传入参数，执行 fn_judge，按照柯里化的定义，每次只传入一个参数，实际可以根据自己的需求。 3. fn_judge 的主要逻辑就是用一个变量 args 保存传入的参数，判断传入的参数个数是否足够执行 beCurry，如果足够执行了。直接执行 beCurry；如果不够，则返回一个匿名函数 fn_anonymous。 4. 后面传入参数就是执行 fu_anonymous，fn_anonymous 的逻辑很简单，将传入 fn_anonymous 的参数拼接到 args 上，递归调用 fn_judge，然后回到第二步再依次执行。

其实说简单一点，就是我们在函数外面进行了一层逻辑包装：当前是否有足够参数执行函数？没有则将参数保存起来，返回一个函数继续接受参数，下次执行要将新传入的参数和保存的参数合并；如果有，则立即执行函数。最后其实我们要解决的就是如何保存和合并参数的问题，解决这个问题的方法很多，也大同小异。我的代码如下：

function curry(fn) {
  let length = fn.length

  return function judge() {
    let args = Array.prototype.slice.call(arguments)

    if (args.length < length) {
      return function () {
        args = Array.prototype.concat.apply(args, arguments)
        return judge.apply(null, args)
      }
    } else {
      return fn.apply(null, args)
    }
  }
}

var fn = curry(function (a, b, c) {
  console.log([a, b, c])
})

fn('a', 'b', 'c') // ["a", "b", "c"]
fn('a', 'b')('c') // ["a", "b", "c"]
fn('a')('b')('c') // ["a", "b", "c"]
fn('a')('b', 'c') // ["a", "b", "c"]

当然如果你有需要可以设置 judge 只可以传入一个参数，一般来说不需要。

最后还有一个问题就是 this 的问题，比如如下这样的形式我们按上面的方式进行柯里化会丢失 this。

let obj = {
  id: 'clloz',
  age: '28',
  func: function (a, b, c) {
    console.log(this.id, this.age)
    console.log([a, b, c])
  }
}
obj.func(1, 2, 3)
//clloz 28
//[1, 2, 3]

var fn = curry(obj.func, obj)
fn(1)(2)(3)
//undefined undefined
//[1, 2, 3]

我没想到特别好的解决办法，唯一就是在进行柯里化的时候传入需要的 this 在后面 apply 的时候传入这个 this。

function curry(fn, thisArg) {
  let length = fn.length

  return function judge() {
    let args = Array.prototype.slice.call(arguments)

    if (args.length < length) {
      return function () {
        args = Array.prototype.concat.apply(args, arguments)
        return judge.apply(thisArg, args)
      }
    } else {
      return fn.apply(thisArg, args)
    }
  }
}

let obj = {
  name: 'clloz',
  age: '28',
  func: function (a, b, c) {
    console.log(this.name, this.age)
    console.log([a, b, c])
  }
}
var fn = curry(obj.func, obj)
fn(1)(2)(3)
//clloz 28
//[ 1, 2, 3 ]

其他实现

这里给大家贴上一些别人的实现，主要的逻辑是不变的，看能不能帮助理解。

冴羽的实现

冴羽大神的博客非常建议大家看，很多非常深入的知识，博客地址：冴羽的博客。他的 JavaScript专题之函数柯里化这篇博客里也贴出了几种实现。

逻辑比较复杂的实现

function sub_curry(fn) {
  var args = [].slice.call(arguments, 1)
  return function () {
    return fn.apply(this, args.concat([].slice.call(arguments)))
  }
}

function curry(fn, length) {
  length = length || fn.length

  var slice = Array.prototype.slice

  return function () {
    if (arguments.length < length) {
      var combined = [fn].concat(slice.call(arguments))
      return curry(sub_curry.apply(this, combined), length - arguments.length)
    } else {
      return fn.apply(this, arguments)
    }
  }
}

和我上面的实现逻辑比较接近的实现

function curry(fn, args) {
  var length = fn.length

  args = args || []

  return function () {
    var _args = args.slice(0),
      arg,
      i

    for (i = 0; i < arguments.length; i++) {
      arg = arguments[i]

      _args.push(arg)
    }
    if (_args.length < length) {
      return curry.call(this, fn, _args)
    } else {
      return fn.apply(this, _args)
    }
  }
}

可以改变参数顺序的实现

function curry(fn, args, holes) {
  length = fn.length

  args = args || []

  holes = holes || []

  return function () {
    var _args = args.slice(0),
      _holes = holes.slice(0),
      argsLen = args.length,
      holesLen = holes.length,
      arg,
      i,
      index = 0

    for (i = 0; i < arguments.length; i++) {
      arg = arguments[i]
      // 处理类似 fn(1, _, _, 4)(_, 3) 这种情况，index 需要指向 holes 正确的下标
      if (arg === _ && holesLen) {
        index++
        if (index > holesLen) {
          _args.push(arg)
          _holes.push(argsLen - 1 + index - holesLen)
        }
      }
      // 处理类似 fn(1)(_) 这种情况
      else if (arg === _) {
        _args.push(arg)
        _holes.push(argsLen + i)
      }
      // 处理类似 fn(_, 2)(1) 这种情况
      else if (holesLen) {
        // fn(_, 2)(_, 3)
        if (index >= holesLen) {
          _args.push(arg)
        }
        // fn(_, 2)(1) 用参数 1 替换占位符
        else {
          _args.splice(_holes[index], 1, arg)
          _holes.splice(index, 1)
        }
      } else {
        _args.push(arg)
      }
    }
    if (_holes.length || _args.length < length) {
      return curry.call(this, fn, _args, _holes)
    } else {
      return fn.apply(this, _args)
    }
  }
}

利用箭头函数一行实现

这个实现来自 segmentfault 的大笑平。

var curry = (fn) =>
  (judge = (...args) => (args.length === fn.length ? fn(...args) : (arg) => judge(...args, arg)))

//分行
var curry = (fn) =>
  (judge = (...args) => (args.length === fn.length ? fn(...args) : (arg) => judge(...args, arg)))

看着很美，但是可读性很差，我把它转化成了比较好理解的方式：

function curry(fn) {
  return function judge(...args) {
    if (args.length === fn.length) {
      return fn(...args)
    } else {
      return function (arg) {
        return judge(...args, arg)
      }
    }
  }
}

参考文章

实现 B 站首页头部效果

Sun, 11 Oct 2020 12:00:00 GMT

前言

今天偶然发现 B 站首页的头部有一个移动鼠标，背景移动并且透明度变化，也带有一点视差滚动的效果。同时小人的眼睛隔一段时间眨一下。我觉得挺有趣就自己实现了一下。

实现效果：点击查看 Demo

实现思路

分析一下这个效果大概就是两个部分。第一个部分是人物的眨眼，这个我用的嵌套的定时器实现。第二个部分就是鼠标移动改变图片的位置和透明度，这个用鼠标事件解决。

眨眼效果

眨眼效果的其实就是几张图片的连续播放。但是需要注意的是，眨眼的动作是非常快的，整个动作要三个状态，睁眼，半睁眼，闭眼，我们需要四张图片循环即可。

由于眨眼的帧之间的间隔和两次眨眼之间的间隔是不同的，我们需要嵌套定时器。外部的就是控制多久眨眼一次，内部的就是眨眼的几个帧的切换。对于定时器的嵌套中的一些细节可以看我的另一篇文章：定时器的一些思考。最后的代码大致如下：

let img = this.layers[anime.index].querySelector('img')

setInterval(() => {
  let index = 0

  let blink = setInterval(() => {
    img.src = `./images/${anime.path}/${index % anime.length}.png`
    index++
    if (index === anime.length + 1) clearInterval(blink)
  }, 100)
}, 5000)

这里有一个我没有解决的问题，我的图片切换是用改变 img 的 src 来实现的。这样会出现一个问题，每次改变 src 浏览器都会发送新的请求。而且由于我们的这种行为在浏览器看来很怪异，可能会被 cancel 掉（关于浏览器请求的 cancel 可以参考这篇文章浏览器你为什么要干掉我的请求？。这就导致了我们本地运行可能没问题，但是到线上访问动画就时灵时不灵了。我看 B 站的实现似乎是将 img 这个元素替换了，源码混淆过，看着着实吃力，放弃了。这里应该是一个知识盲区，我尝试了替换元素，但是并没有效果 :dizzy_face: 。这里暂时只能留个坑，等以后知道怎么解决了再来填。

在 segmentfault 上提问后，Fractal 给出的回答是预先生成好 img 元素，放到一个数组中，然后定时器内替换即可。我是用 cloneNode 和 replaceChild 两个方法进行创建和切换的。这样就基本实现了原先要的效果了。以后遇到这种加载切换问题应该也可以用同样的逻辑解决。

鼠标事件

第二个效果就是移动鼠标图片会跟着移动，然后透明度变化，最后的效果就是感觉随着鼠标的移动，我们的视角也发生变化的感觉。这部分的实现就是用三个鼠标事件，mouseover, mousemove, mouseout。然后改变元素的 style 对象中的属性即可，并没有什么复杂的逻辑。需要注意的是，mouseout 之后我们要将元素的状态还原，同时解绑 mousemove 和 mouseout 事件。

总结

完整的代码在 Github。运行方法为 npm install 之后运行 npx webpack-dev-server 然后打开 index.html 即可。

深入 JavaScript 数组

Fri, 09 Oct 2020 12:00:00 GMT

前言

本文整理一些我觉得有用或者没用的（说不定哪天就有用了 :stuck_out_tongue: ） JavaScript 数组技巧。本文前半部分是对 Array 的 API 进行比较深入的解读，后半部分是对一些具体场景的解决方案。本文较长，请耐心阅读。

创建数组

JavaScript 的数组创建大致三种方式：字面量，new Array(el1, el2, el3...)，new Array(length)。new 可以省略。

new Array() 有两种初始化可能，即 new Array(el1, el2, el3...)，new Array(length)，出现第二种情况当且仅当只有一个参数，并且该参数是 $1 - (2^{32} - 1)$ 之间的整数，其他情况都会把传入的参数当做生成的数组的元素。

实际上， JavaScript 并没有常规的数组，所有的数组其实就是个对象，只不过会自动管理一些"数字"属性和 length 属性罢了。说的更直接一点, JavaScript 中的数组根本没有索引，因为索引应该是数字，而 JavaScript 中数组的索引其实是字符串。arr[1]其实就是 arr["1"]，给arr["1000"] = 1，arr.length 也会自动变为 1001。这些表现的根本原因就是，JavaScript 中的对象就是字符串到任意值的键值对。注意键只能是字符串。不过目前 ES6 中已经有了类似于 Java 等语言的 Map 类型,键可以是任意类型的值。

稀疏数组和密集数组

在 Java 和C语言中，数组是一片连续的存储空间，有着固定的长度。即数组元素之间是紧密相连的，不存在空隙，这就是密集数组。在 JavaScript 中是支持稀疏数组的，比如我们用 new Array(length) 创建的就是一个稀疏数组。

我们熟知的 Array 的 API 都会对这些空位有自己的处理：

flat()，flatMap() 会移除空位。
Object.keys()，Object.entires() 会跳过数组的空位
forEach(), filter(), reduce(), every() 和some()都会跳过空位。
map() 会跳过空位，但会保留这个值，即保留这个空位。
join()和 toString() 会将空位视为 undefined，而 undefined 和 null 会被处理成空字符串。
Array.from 将数组的空位转为 undefined
… 将空位转换为 undefined
copyWithin 将空位一起拷贝
fill() 将空位视为正常的数组位置
for…of 循环会遍历空位
entries()、keys()、includes()、values()、find() 和 findIndex() 将空位处理成 undefined。

如果你遍历数组希望跳过数组中的未赋值空位，可以使用 in 操作符，

let a = []
a[1] = 'clloz'
console.log(a) //[ <1 empty item>, 'clloz' ]
console.log(0 in a) //false
console.log(1 in a) //true

创建密集数组的方法：

//利用 apply 将数组作为多个参数传入
Array.apply(null, Array(3)) //[undefined, undefined, undefined]

//生成一个元素值等于下标的数组
Array.apply(null, Array(3)).map(Function.prototype.call.bind(Number)) // [0, 1, 2]
//上面这行代码等同于下面的代码
;[undefined, undefined, undefined].map((value, index) => Number.call(value, index)) //index

Array.from({ length: 3 }) //Array.from() 可以作用于拥有一个 length 属性和若干索引属性的任意对象

Array.apply(null, { length: 3 }) //这种用法突出了JavaScript中的数组其实就是个对象，只要有 `length` 属性，并且都是数字索引属性即使数组

new Array(...Array(3)) //扩展运算符和 apply 类似的效果

Array.apply 实际上是利用了 apply 将数组作为多个参数传递的特性来生成密集数组，Array.call(null, Array(3)) 实际上等于 Array(arr[0], arr[1], arr[2])（设 Array(3) 生成的数组是 arr）。

如果想让数组变为稀疏数组，可以用 delete 操作符删除数组的项，比如 delete arr[1] 则下标为 1 的数组项会变为 empty。

Array API 深入

我在 JavaScript常用内置对象API 一文整理了一些 JavaScript 内置对象的 API，主要是当做工具表，在使用一些不熟悉的 API 的时候有快速查询的地方（不常使用的知识很快就忘了 :sleeping: ，不过学习也就是不断遗忘和重复的过程）。本文主要是说 Array 的技巧，必然要对 API 深入一些，这一小节我们就对 Array 相关的内容进行梳理。

因为数组的 API 很多，有些很类似，特别是有没有返回值，以及是否会改变原数组，很容易混淆，在这一小节的最前面进行一个整理。

不改变原数组

Array.from()
Array.isArray()
Array.prototype.concat()
Array.prototype.every()
Array.prototype.filter()
Array.prototype.find()
Array.prototype.findIndex()
Array.prototype.flat()
Array.prototype.flatMap()
Array.prototype.forEach() forEach本身不改变原数组，但是 callback 可能会改变
Array.prototype.includes()
Array.prototype.map() map，但是 callback 可能会改变
Array.prototype.reduce()
Array.prototype.reduceRight()
Array.prototype.slice()

改变原数组

Array.prototype.copyWithin()
Array.prototype.fill()
Array.prototype.pop()
Array.prototype.push()
Array.prototype.shift()
Array.prototype.sort()
Array.prototype.splice()
Array.prototype.unshift()

返回数组

Array.from()
Array.prototype.concat()
Array.prototype.copyWithin()
Array.prototype.fill()
Array.prototype.filter()
Array.prototype.flat()
Array.prototype.flatMap()
Array.prototype.map()
Array.prototype.slice()
Array.prototype.sort()
Array.prototype.splice()

不返回数组

Array.isArray() 返回 Boolean
Array.prototype.every() 返回 Boolean
Array.prototype.find() 返回第一个满足测试函数的元素值或 undefined
Array.prototype.findIndex() 返回第一个满足测试函数的元素索引或 -1
Array.prototype.forEach() 返回 undefined
Array.prototype.includes() 返回 Boolean
Array.prototype.pop() 返回元素的值
Array.prototype.pop() 返回数组的新长度
Array.prototype.reduce() 返回遍历完成后累积的值
Array.prototype.reduceRight()返回遍历完成后累积的值
Array.prototype.shift() 返回删除的元素
Array.prototype.unshift() 返回新数组的长度

Array.length

JavaScript 规定了数组的 length 是一个 32bits 无符号整数，所以数组的最大长度是是 $2^{32} - 1$，所以 Array.length 的范围应该是在 0 - 4294967295 之间。

var namelistA = new Array(4294967296) // 2的32次方 = 4294967296
var namelistC = new Array(-100) // 负号

console.log(namelistA.length) // RangeError: 无效数组长度
console.log(namelistC.length) // RangeError: 无效数组长度

var namelistB = []
namelistB.length = Math.pow(2, 32) - 1 //set array length less than 2 to the 32nd power
console.log(namelistB.length) // 4294967295

改变 length 的大小会改变数组。当我们设置 length 小于数组长度的时候。超过的部分会被截断。当我们设置 length 大于数组长度的时候，实际的元素数目会增加，新增的元素的值为 undefined（实际上和 Array(length) 一样，新增的位置此时并没有包含任何实际的元素，不能理所当然地认为它包含 arrayLength 个值为 undefined 的元素，但是如果输出）。

let arr = [1, 2, 3]

arr.length = 5

console.log(arr, arr[3], arr[4]) //[ 1, 2, 3, <2 empty items> ] undefined undefined

let b = arr.map((e) => e)
console.log(b) //[ 1, 2, 3, <2 empty items> ]

arr.forEach((e) => console.log(e)) //forEach 会跳过空位
//1
//2
//3

Array.length 的属性特性为

writable：true 属性值可写。
enumerable：false 属性不可以通过迭代器 for 或 for...in 进行迭代。
configurable：false 不可删除或更改属性特性。

Array.from

Array.from() 方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。稀疏数组的空位会被转为 undefined。Array.from.length === 1。当我们有需要将对象转为数组的时候（比如需要使用数组方法而不想使用 apply 和 call），Array.from 是一个不错的选择。

Array.from() 的第一个参数可以类数组对象（拥有一个 length 属性和若干索引属性的任意对象，包括字符串）可迭代对象（可以获取对象中的元素,如 Map 和 Set 等）包括字符串。我的理解是可以用迭代器 for ... of 进行迭代的对象都可以。

Array.from() 可以接受第二，第三个参数，可以用这两个参数在新生成的数组上执行一次 map，Array.from(obj, mapFn, thisArg) 就相当于 Array.from(obj).map(mapFn, thisArg), 除非创建的不是可用的中间数组。

Array.from('clloz') //["c", "l", "l", "o", "z"]

//从Set生成数组
const set = new Set(['foo', 'bar', 'baz', 'foo'])
Array.from(set) // [ "foo", "bar", "baz" ]

//从Map生成数组
const map = new Map([
  [1, 2],
  [2, 4],
  [4, 8]
])
Array.from(map) // [[1, 2], [2, 4], [4, 8]]

Array.from(map.keys()) //[1, 2, 4]
Array.from(map.values()) //[2, 4, 8]

//从类数组对象生成数组
function f() {
  return Array.from(arguments)
}
f(1, 2, 3) //[ 1, 2, 3 ]

//使用map生成元素值为下标的数组
Array.from({ length: 5 }, (v, i) => i) // [0, 1, 2, 3, 4]

如果不考虑 Array.from 的 map，Array.from 做的事情类似如下函数

Array.from = function (arrayLike) {
  let k = 0
  len = arrayLike.length
  let result = new Array(len)
  while (k < len) {
    result[k] = arrayLike[k]
    k++
  }
  return result
}
let c = Array.from('clloz')
console.log(c) // [ 'c', 'l', 'l', 'o', 'z' ]

我这个只是大致演示一下 Array.from 做的事情，完整的 polyfill 参考 Array.from - MDN

Array.isArray()

Array.isArray() 有几个容易忽略的点: 1. Array.isArray(Array.prototype) 返回 true。Array.prototype 本身也是一个数组，length 为 0。 2. Array.isArray() 能检测 iframes 中的 Array，instanceof 则不能。 3. Array.isArray() 的 polyfill。

if (!Array.isArray) {
  Array.isArray = function (arg) {
    return Object.prototype.toString.call(arg) === '[object Array]'
  }
}

Array.of()

Array.of() 就是没有 Array(length) 形式的 Array。也就是说他只支持 Array.of(el1, el2, ...) 这种形式。它是 ES6 中的新方法。

//polyfill
if (!Array.of) {
  Array.of = function () {
    return Array.prototype.slice.call(arguments)
  }
}

Array.prototype.concat()

Array.prototype.concat() 需要注意的一点就是它是浅拷贝，当我们的数组中有对象或者嵌套数组的时候，是无法进行深拷贝的。细节看下面的代码：

let a = [[1], 2]
let b = [[3], 4, { name: 'clloz' }]

let c = a.concat(b)
console.log(c) //[ [ 1 ], 2, [ 3 ], 4, { name: 'clloz' } ]
b[2].name = 'clloz1992'
console.log(c)
a[0].push(100) //[ [ 1 ], 2, [ 3 ], 4, { name: 'clloz1992' } ]
console.log(c) //[ [ 1, 100 ], 2, [ 3 ], 4, { name: 'clloz1992' } ]

concat 除了接受数组作为参数，也可以接受其他值，如果值是引用类型则将引用添加到新的数组中，如果是值类型则将值添加到新数组中（String，Number 或者 Boolean，非包装类型）。

我自己实现的一个简单的 concat 的 polyfill：

Array.prototype._concat = function () {
  if (Object.prototype.toString.call(this) !== '[object Array]') throw Error('this is not a Array!')
  let result = Array.prototype.slice.call(this)
  let args = Array.prototype.slice.call(arguments)

  for (let i = 0; i < args.length; i++) {
    if (Array.isArray(args[i])) {
      for (let j = 0; j < args[i].length; j++) {
        result.push(args[i][j])
      }
    }
  }
  return result
}
let a = [1, 2, 3, 4]
let b = [5, 6, 7]
let c = [8, 9, 10]
let d = a._concat(b, c)
console.log(d) //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Array.prototype.every()

Array.prototype.every() 是 ES5 添加的数组方法，下面列出 every 的几个注意点：

every 和数学中的"所有"类似，当所有的元素都符合条件才会返回 true。正因如此，若传入一个空数组，无论如何都会返回 true。
没有传入 this 值，callback 中的 this 在非严格模式下是全局对象，严格模式下为 undefined。
只要任何一次 callback 的执行返回 false，将直接返回 false（后面的元素讲不会再执行回调函数）。否则会执行到最后一个元素，返回 true。
不改变原数组。
every 遍历的元素范围在第一次调用 callback 之前就已确定了。在调用 every 之后添加到数组中的元素不会被 callback 访问到。如果数组中存在的元素被更改，则他们传入 callback 的值是 every 访问到他们那一刻的值。那些被删除的元素或从来未被赋值的元素将不会被访问到（所以对于稀疏数组中的空位 every 是不会处理的）。

polyfill 实现参考 Array.prototype.every() - MDN

Array.prototype.fill()

Array.prototype.fill() 是 ES6 添加的数组方法，接受三个参数 value，start 和 end，start 和 end 的默认值分别是 0，this.length，如果传入的值是个负数, 则开始索引会被自动计算成为 length+start/end，即从后往前数第 start/end 个，-1 就是倒数第一个。几个注意点:

会填充稀疏数组的空位 Array(3).fill(4) 返回 [4,4,4]。
若填充的值是对象，则填充的是对象的引用。let a = Array(3).fill({}); console.log(a[0] === a[1]) 将返回 true。
原数组会改变，返回改变后的数组。

Array.prototype.filter()

Array.prototype.filter() 是 ES5 添加的数组方法。filter 为数组中的每个元素调用一次 callback 函数，并利用所有使得 callback 返回 true 或等价于 true 的值的元素创建一个新数组。注意点如下：

filter 的一个参数 callback 接受三个参数，元素值，元素索引，数组本身；第二个参数是 callback 执行时的 this，若没有传入则在非严格模式下为全局对象，严格模式下为 undefined。
callback 只会在已经赋值的索引上被调用，对于那些已经被删除或者从未被赋值的索引不会被调用。稀疏数组中的空位不会被处理。
filter 遍历的元素范围在第一次调用 callback 之前就已经确定了。在调用 filter 之后被添加到数组中的元素不会被 filter 遍历到（比如在遍历过程中）。如果已经存在的元素被改变了，则他们传入 callback 的值是 filter 遍历到它们那一刻的值。被删除或从来未被赋值的元素不会被遍历到。

Array.prototype.find()

Array.prototype.find() 是 ES6 添加的数组方法，参数和注意点和 filter 类似，不同的是不会跳过稀疏数组的空位，找到立即返回元素值（只找第一个），否则返回 undefined。

Array.prototype.findIndex()

和 find 几乎相同，不过返回值是元素索引，若没有找到则返回 -1。

Array.prototype.flat()

ES2019 新增的数组扁平化 API，支持设定深度，不改变原数组，返回扁平化后的新数组。该方法会移除稀疏数组中的空位。

Array.prototype.flatMap()

这个方法相当于先对数组执行 map，然后对 map 之后返回的数组执行 flat(1)。

var arr1 = [1, 2, 3, 4]
JSON.stringify(arr1.map((x) => [[x * 2]])) // "[[[2]],[[4]],[[6]],[[8]]]"
JSON.stringify(arr1.map((x) => [[x * 2]]).flat(1)) //"[[2],[4],[6],[8]]"
JSON.stringify(arr1.map((x) => [[x * 2]]).flat(1)) ===
  JSON.stringify(arr1.flatMap((x) => [[x * 2]])) //true

Array.prototype.forEach()

forEach() 方法按升序为数组中含有效值的每一项执行一次 callback 函数，稀疏数组上的空位被跳过。forEach 接受两个参数，第一个是 callback 回调函数，接受三个参数：当前元素值，当前元素索引，数组对象本身（后两个可选）；第二个是回调函数执行时的 this。该方法注意点总结：

稀疏数组的空位会被跳过。
this 默认在严格模式下是 undefined，非严格模式下是全局对象。
forEach() 遍历的范围在第一次调用 callback 前就会确定。调用 forEach 后添加到数组中的项不会被 callback 访问到。如果已经存在的值被改变，则传递给 callback 的值是 forEach() 遍历到他们那一刻的值。已删除的项不会被遍历到。如果已访问的元素在迭代时被删除了（例如使用 shift()），之后的元素将被跳过。
forEach() 为每个数组元素执行一次 callback 函数，返回值始终是 undefined，所以不可被链式调用，一般会放在链式调用的最后。
forEach() 本身不会改变原数组，但是在回调函数中由于我们可以传入原数组和当前元素索引，所以回调函数中可以修改原数组。
除了抛出异常以外，没有办法中止或跳出 forEach() 循环。如果你需要中止或跳出循环，forEach() 方法不是应当使用的工具。

//回调函数改变原数组
let arr = [1, 2, 3]
arr.forEach((v, i, thisArr) => {
  thisArr[i] *= 2
})
console.log(arr) //[ 2, 4, 6 ]

//迭代过程中修改数组，有元素会被跳过，其他遍历方法类似
var words = ['one', 'two', 'three', 'four']
words.forEach(function (word) {
  console.log(word)
  if (word === 'two') {
    words.shift()
  }
})
// one
// two
// four

Array.prototype.includes()

Array.prototype.includes() 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false。该方法接受两个参数，一个是要查找的值，另一个可选参数是从哪个索引开始查找。

Array.prototype.includes() 的注意点：

比较字符和字符串区分大小写。
稀疏数组的空位被当做 undefined 处理（当你想找的是 undefined 的时候会返回 true）
如果第二个参数大于等于数组长度，会直接返回 false，并且不会进行查找。
如果第二个参数 fromIndex 为负值，计算出的索引 array.length + fromIndex 将作为开始搜索的位置。如果计算出的索引仍然小于 0，则整个数组都会被搜索。
不仅可以用于数组，也可以用于类数组对象，需利用 call 和 apply 。

Array.prototype.indexOf()

indexOf() 方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回 -1。接受两个参数，一个是要查找的值，另一个可选参数是从哪个索引开始查找。该方法和 Array.prototype.includes() 类似，只不过一个返回的是布尔值，一个返回的是索引。匹配是否和参数相等采用的是 === 严格相等。

Array.prototype.join()

join() 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。接受一个可选参数作为连接数组元素时的分隔符。返回所有数组元素连接的字符串如果 arr.length === 0，则返回空字符串。该方法的注意点如下：

如果一个元素为 undefined 或 null，它会被转换为空字符串。
如果元素是 Object 或 Function，则会调用对应的 toString() 方法转为字符串。
Number(), String(), Boolean 包装的对象也都会被当做基本类型处理。
利用 call 和 apply 可以用在其他可迭代对象上，比如 arguments，字符串。

let a = { length: 10, name: 'clloz' }
let str = Array.prototype.join.call(a, ',')
console.log(str) //,,,,,,,,,

function m() {}
let arr = [
  1,
  2,
  3,
  4,
  { name: 'clloz' },
  [2, [3, 4, 5]],
  m,
  Number(10),
  true,
  String('clloz'),
  Boolean(1)
]
console.log(arr.join(','))
//1,2,3,4,[object Object],2,3,4,5,function m() {},10,true,clloz,true

Array.prototype.keys()

ES6 添加的数组方法.keys() 方法返回一个包含数组中每个索引键的 Array Iterator 对象。一个新的 Array 迭代器对象。

var arr = ['a', , 'c']
var sparseKeys = Object.keys(arr)
var denseKeys = [...arr.keys()]
console.log(sparseKeys) // ['0', '2']
console.log(denseKeys) // [0, 1, 2]

Array.prototype.lastIndexOf()

理解为反向的 Array.prototype.indexOf() 即可。

Array.prototype.map()

Array.prototype.map() 是 ES5 提供的数组方法。map() 方法创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。

和 forEach() 相同，接受两个参数，第一个是 callback 回调函数，接受三个参数：当前元素值，当前元素索引，数组对象本身（后两个可选）；第二个是回调函数执行时的 this。注意点如下：

稀疏数组的空位会被跳过并被保留在返回的数组中（根据规范中定义的算法，如果被 map 调用的数组是离散的，新数组将也是离散的保持相同的索引为空）。
只有在你需要返回数组或需要回调函数返回值的时候再使用 map，否则应该使用 forEach 或 for ... of。
和所有遍历方法一样，在回调中修改数组可能会让一些元素无法执行回调。
利用 call 和 apply 可以用在其他可迭代对象上，比如 arguments，字符串。
注意回调函数的参数个数和顺序，一个经典的问题就是 ["1", "2", "3"].map(parseInt); 返回 [1, NaN, NaN]
回调函数没有返回值，生成的元素是 undefined。

Array.prototype.pop()

ES3 就存在的数组方法。pop() 方法从数组中删除最后一个元素，并返回该元素的值(当数组为空时返回 undefined)。此方法更改数组的长度。可应用在类似数组的对象上。pop 方法根据 length 属性来确定最后一个元素的位置。如果不包含 length 属性或 length 属性不能被转成一个数值，会将 length 置为 0，并返回 undefined。

//数组即对象
let a = { length: 10, name: 'clloz' }
Array.prototype.pop.call(a)
console.log(a) //{ length: 9 }

//length 为 0，下标 0 处本来就没有元素，不会有任何变化
var obj = {
  2: 3,
  3: 4,
  length: 0,
  pop: Array.prototype.pop
}

obj.pop()
console.log(obj) //{ '2': 3, '3': 4, length: 0, pop: [Function: pop] }

//length 为 3，下标为 2 的元素是 `3`，该元素奖杯删除，`length` 减一
var obj = {
  2: 3,
  3: 4,
  length: 0,
  pop: Array.prototype.pop
}

obj.pop()
console.log(obj) //{ '2': 3, '3': 4, length: 0, pop: [Function: pop] }

//没有 length 或 length不能转为数字，会添加 length属性，属性值为 0
var obj = {
  2: 3,
  3: 4,
  pop: Array.prototype.pop
}

obj.pop()
console.log(obj) //{ '2': 3, '3': 4, pop: [Function: pop], length: 0 }

Array.prototype.push()

ES3 就存在的数组方法。push() 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

可以接受多个参数，作为添加到数组末尾的元素，返回值为新的 length 属性。和 pop 一样利用 call 和 apply 可以应用到非数组对象上。

push 方法根据 length 属性来决定从哪里开始插入给定的值。如果 length 不能被转成一个数值，则插入的元素索引为 0，包括 length 不存在时。当 length 不存在时，将会创建它。这一点非常重要，看下面的代码：

var obj = {
  2: 3,
  3: 4,
  length: 2,
  splice: Array.prototype.splice,
  push: Array.prototype.push
}

obj.push(1)
obj.push(2)
console.log(obj)

//{
//  '2': 1,
//  '3': 2,
//  length: 4,
//  splice: [Function: splice],
//  push: [Function: push]
//}

因为对象中的 length 为 2，所以从下标 2 开始插入，并改变 length 的值，所以最后 1 2 分别插入了下标 2 和 3 的报位置，取代了原来的值 3 和 4。而如果没有 length 则会创建 length，初始值为 0，并从 0 开始插入，最后结果如下：

var obj = {
  2: 3,
  3: 4,
  splice: Array.prototype.splice,
  push: Array.prototype.push
}

obj.push(1)
obj.push(2)
console.log(obj)

//{
//  '0': 1,
//  '1': 2,
//  '2': 3,
//  '3': 4,
//  splice: [Function: splice],
//  push: [Function: push],
//  length: 2
//}

唯一的原生类数组（array-like）对象是 String，它们并不适用该方法，因为字符串是不可改变的。

let a = { length: 10, name: 'clloz' }
Array.prototype.push.call(a, 1, 2, 3, 4)
console.log(a)
console.log(a[0])

Array.prototype.reduce()

Array.prototype.reduce() 是 ES5 提供的数组方法。reduce() 方法对数组中的每个元素执行一个由您提供的 reducer 函数(升序执行)，将其结果汇总为单个返回值。

该方法接受两个参数，回调函数 reducer 和初始值 initialValue。reducer 接受四个参数，accumulator 为上一次回调函数执行累积的值或者 initialValue，currentValue 当前正在处理的元素，index 当前处理元素的索引，array 调用 reducer 的数组，后两个参数可选。initialValue 作为第一次调用 callback 函数时的第一个参数的值。如果没有提供初始值，则将使用数组中的第一个元素。在没有初始值的空数组上调用 reduce 将报错。返回值为累积处理的结果。

回调函数第一次执行时，accumulator 和 currentValue 的取值有两种情况：如果调用 reduce() 时提供了 initialValue，accumulator 取值为 initialValue，currentValue 取数组中的第一个值；如果没有提供 initialValue，那么 accumulator 取数组中的第一个值，currentValue 取数组中的第二个值。如果没有提供 initialValue，reduce 会从索引1的地方开始执行 callback 方法，跳过第一个索引。如果提供 initialValue，从索引 0 开始。

如果数组为空且没有提供 initialValue，会抛出 TypeError 。如果数组仅有一个元素（无论位置如何）并且没有提供 initialValue，或者有提供 initialValue 但是数组为空，那么此唯一值将被返回并且 callback 不会被执行。

//reduce 实现 map
if (!Array.prototype.mapUsingReduce) {
  Array.prototype.mapUsingReduce = function (callback, thisArg) {
    return this.reduce(function (mappedArray, currentValue, index, array) {
      mappedArray[index] = callback.call(thisArg, currentValue, index, array)
      return mappedArray
    }, [])
  }
}

;[1, 2, , 3].mapUsingReduce((currentValue, index, array) => currentValue + index + array.length) // [5, 7, , 10]

//多函数管道 将多个函数当做数组进行 reduce实现特定功能
// Building-blocks to use for composition
const double = (x) => x + x
const triple = (x) => 3 * x
const quadruple = (x) => 4 * x

// Function composition enabling pipe functionality
const pipe =
  (...functions) =>
  (input) =>
    functions.reduce((acc, fn) => fn(acc), input)

// Composed functions for multiplication of specific values
const multiply6 = pipe(double, triple)
const multiply9 = pipe(triple, triple)
const multiply16 = pipe(quadruple, quadruple)
const multiply24 = pipe(double, triple, quadruple)

// Usage
multiply6(6) // 36
multiply9(9) // 81
multiply16(16) // 256
multiply24(10) // 240

Array.prototype.reduceRight()

Array.prototype.reduceRight() 是 ES5 提供的数组方法。从右向左进行遍历的 reduce()。

Array.prototype.reverse()

ES1 就存在的数组方法。reverse() 方法将数组中元素的位置颠倒，并返回该数组。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。该方法会改变原数组。利用 call 和 apply 可以用在其他可迭代对象上，比如 arguments。唯一的原生类数组（array-like）对象是 String，它们并不适用该方法，因为字符串是不可改变的。

Array.prototype.shift()

ES3 增加的数组方法。shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。该方法移除索引为 0 的元素(即第一个元素)，并返回被移除的元素，其他元素的索引值随之减 1。如果 length 属性的值为 0 (长度为 0)，则返回 undefined。该方法能够通过 call 或 apply 方法作用于类似数组的对象上，若对象没有 length 属性，调用该方法不会有其他操作，但是会添加 length 属性，属性值 0。

//没有length会给对象添加值为 0 的 length 属性，不执行其他操作
var obj = {
  2: 3,
  3: 4,
  shift: Array.prototype.pop
}

obj.shift()
console.log(obj) //{ '2': 3, '3': 4, shift: [Function: pop], length: 0 }

//length 为 0 不进行任何操作，返回undefined
var obj = {
  2: 3,
  3: 4,
  length: 0,
  shift: Array.prototype.pop
}

obj.shift()
console.log(obj) //{ '2': 3, '3': 4, length: 0, shift: [Function: pop] }

其实就是一个反向的 Array.prototype.pop()。

Array.prototype.slice()

slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。

该方法接受两个可选参数 begin 和 end，表示提取元素的索引，[begin, end)，包括 begin 不包括 end。

若没有传入 begin 则从 0 开始提取；没有传入 end，提取到原数组末尾。若 begin 或 end 为负，则计算 length + begin，若计算值在数组的索引范围内则从计算值开始提取，若依然为负则从 0 开始。如果 begin 大于原数组的长度，则会返回空数组。如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。

需要注意 slice 是浅拷贝，如果某个元素是对象引用，在返回的新数组中依然是相同的引用。对于字符串、数字及布尔值来说（不是 String、Number 或者 Boolean 对象），slice 会拷贝这些值到新的数组里。在别的数组里修改这些字符串或数字或是布尔值，将不会影响另一个数组。

可以使用 apply 或 call 将一个类数组（Array-like）对象/集合转换成一个新数组。

Array.prototype.some()

some() 方法测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个 Boolean 类型的值。

该方法可以类比 Array.prototype.every()，every() 是找到一个 callback 返回值可转换为为 false 的就立即返回，否则遍历所有元素，最后返回 true。some() 是找到一个 callback 返回值可转换为为 true 的就立即返回，否则遍历所有元素，最后返回 false。其他机制基本相同。

Array.prototype.sort()

ES1 就提供的数组方法。sort() 方法用原地算法对数组的元素进行排序，并返回数组。由于它取决于具体实现，因此无法保证排序的时间和空间复杂性。

该方法接受一个可选的 compareFunction 函数，如果没有指明该函数，那么元素会按照转换为的字符串的诸个字符的 Unicode 位点进行排序。

//默认按Unicode进行排序，我们记住 ACSII 的顺序即可
let arr = [3, 15, 8, 29, 102, 22]
console.log(arr.sort())
//[ 102, 15, 22, 29, 3, 8 ]

如果指明了 compareFunction ，那么数组会按照调用该函数的返回值排序。即 a 和 b 是两个将要被比较的元素：

如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；
如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。备注： ECMAScript 标准并不保证这一行为，而且也不是所有浏览器都会遵守（例如 Mozilla 在 2003 年之前的版本）；
如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。
compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果，否则排序的结果将是不确定的。

Array.prototype.splice()

Array.prototype.splice() 是 ES3 提供的数组方法。 splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。

该方法的前两个参数 start 和 deleteCount 表示从哪个索引开始删除多少个元素，删除的元素包含 start 位置的元素。如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于 start 之后的所有元素的数量)，那么 start 之后数组的所有元素都会被删除。如果 deleteCount 是 0 或者负数，则不移除元素，这种情况下，至少应添加一个新元素，否则没有意义。

从第三个参数开始就是要天剑的新元素，添加的位置就是从 start 开始。如果添加进数组的元素个数不等于被删除的元素个数，数组的长度会发生相应的改变。

返回值是由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。

Array.prototype.unshift()

类比 Array.prototype.push()。

//没有length属性的对象调用会添加值为 0 的length属性
var obj = {
  0: 3,
  1: 4,
  unshift: Array.prototype.unshift
}

obj.unshift()
console.log(obj) //{ '0': 3, '1': 4, unshift: [Function: unshift], length: 0 }

//从 length 处插入
var obj = {
  0: 3,
  1: 4,
  length: 0,
  unshift: Array.prototype.unshift
}

obj.unshift(1, 2)
console.log(obj) //{ '0': 1, '1': 2, length: 2, unshift: [Function: unshift] }

Array.prototype.toString()

toString() 返回一个字符串，表示指定的数组及其元素。

Array 对象覆盖了 Object 的 toString 方法。对于数组对象，toString 方法连接数组并返回一个字符串，其中包含用逗号分隔的每个数组元素。

当一个数组被作为文本值或者进行字符串连接操作时，将会自动调用其 toString 方法。

API 的几点共通点

很多方法存在对应，比如 some 和 every，pop 和 shift，push 和 unshift 等，他们的机制基本相同。
几乎所有 callback 的机制都相同，即在第一次 callback 执行之前元素遍历范围就已经确定，在 callback 执行过程中如果对原数组进行改动可能引起部分元素不会被遍历到。
大多数 API 都可以使用 call 和 apply 拓展到任何带有 length 属性的对象（javascript 的数组本质就是这样一个对象）。部分方法不支持字符串调用，因为字符串不可被更改。
大多数 callback 需要传入索引作为参数的方法，机制都相同。当索引为负的时候，会计算 length + index，若计算值是一个在数组范围内的值，则以这个值执行；若计算值依然是负值，则忽略该参数。
push, pop, shift, unshift 这几个添加删除元素的方法都是以 length 为基准进行操作，对于没有 length 的对象会添加一个值为 0 的 length 属性。以 length 为基准的意思举个例子就是，我们执行 push(1,2)，如果我们的对象 length 为 2，那么即使对象中索引 2 和 3 已经有元素值，那么也会用 1 和 2 进行覆盖。

查找数组

Array.prototype.find()
Array.prototype.findIndex()
Array.prototype.includes()
Array.prototype.indexOf()
Array.prototype.lastIndexOf()

遍历数组

Array.prototype.every()
Array.prototype.filter()
Array.prototype.forEach()
Array.prototype.map()
Array.prototype.reduce()
Array.prototype.reduceRgiht()
Array.prototype.some()

Array Iterator

Array.prototype.entries()
Array.prototype.keys()
Array.prototype.values

复制数组

Array.prototype.slice.call()
Array.from()，和 Array.prototype.slice.call() 的区别就是 Array.from() 是 ES6 才有的方法。他们的性能存在差异，我只用了一个简单的数组进行了测试：结果就是当数组长度比较小的时候，Array.from() 速度更快一点，当数组长度越长，Array.prototype.slice.call() 速度更快，我只是用的一个 flat 的数组，没有测试嵌套数组和对象， Set Map 等情况。

let a = Array.from({ length: 1000000 }, (v, i) => i)
console.time('slice')
for (let i = 0; i < 1000; i++) {
  Array.prototype.slice.call(a)
}
console.timeEnd('slice') //slice: 5995.096ms
console.time('from')
for (let i = 0; i < 1000; i++) {
  Array.from(a)
}
console.timeEnd('from') //from: 6668.785ms

创建元素值等于下标的数组

这个源于知乎上的一道题目，解法有如下几种：

Object.keys(Array.apply(null, {length: 100}))

Array.from(Array(100).keys())

Array.from({length: 100}, (v, i) => i);

[...Array(100).keys()]

Array.apply(null, Array(100)).map(Function.prototype.call.bind(Number))

//自定义迭代器
Number.prototype[Symbol.iterator] = function() {
    return {
        v: 0,
        e: this,
        next() {
            return {
                value: this.v++,
                done: this.v > this.e
            }
        }
    }
}

[...100]

需要特别注意，在 JavaScript 中参数的个数是有上限的，JavaScriptCore 引擎中有被硬编码的参数个数上限：65536。但是实际能接受多少参数取决于当前的系统和浏览器，并不确定。比如我用上面的用 apply 生成元素值为元素下标的数组，在 safari 中的上限是 65536，在 chrome 中是 125382。任何用到超大栈空间的行为都有可能出现这个现象，超出限制则会报错 Uncaught RangeError: Maximum call stack size exceeded。

去重

利用 Array.from 和 Set。

function combine() {
  let arr = [].concat.apply([], arguments) //没有去重复的新数组
  return Array.from(new Set(arr))
}

var m = [1, 2, 2],
  n = [2, 3, 3]
console.log(combine(m, n)) // [1, 2, 3]

reduce

let myArray = ['a', 'b', 'a', 'b', 'c', 'e', 'e', 'c', 'd', 'd', 'd', 'd']
let myOrderedArray = myArray.reduce(function (accumulator, currentValue) {
  if (accumulator.indexOf(currentValue) === -1) {
    accumulator.push(currentValue)
  }
  return accumulator
}, [])
console.log(myOrderedArray)

let arr = [1, 2, 1, 2, 3, 5, 4, 5, 3, 4, 4, 4, 4]
let result = arr.sort().reduce((init, current) => {
  if (init.length === 0 || init[init.length - 1] !== current) {
    init.push(current)
  }
  return init
}, [])
console.log(result) //[1,2,3,4,5]

两层循环比较

function unique(arr) {
  for (var i = 0; i < arr.length; i++) {
    for (var j = i + 1; j < arr.length; j++) {
      if (arr[i] == arr[j]) {
        //第一个等同于第二个，splice方法删除第二个
        arr.splice(j, 1)
        j--
      }
    }
  }
  return arr
}

filter + indexOf

function unique(arr) {
  return arr.filter(function (item, index, arr) {
    //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
    return arr.indexOf(item, 0) === index
  })
}

forEach + includes

function unique(arr) {
  let result = []
  arr.forEach((v) => {
    if (!result.includes(v)) result.push(v)
  })
  return result
}

去重还有很多种实现，不过本质都是一样的，遍历数组比较去除重复（根据利用的 API 不同可能要创建一个中间数组）。或者利用像 Set 或者 Object 的键不可重复的特性。

扁平化

Array.prototype.flat()

reduce 与 concat

var flattened = [
  [0, 1],
  [2, 3],
  [4, 5]
].reduce(function (a, b) {
  return a.concat(b)
}, [])
// flattened is [0, 1, 2, 3, 4, 5]

var flattened = [
  [0, 1],
  [2, 3],
  [4, 5]
].reduce((acc, cur) => acc.concat(cur), [])

reduce + concat + isArray + recursivity

// 使用 reduce、concat 和递归展开无限多层嵌套的数组
var arr1 = [1, 2, 3, [1, 2, 3, 4, [2, 3, 4]]]

function flatDeep(arr, d = 1) {
  return d > 0
    ? arr.reduce((acc, val) => acc.concat(Array.isArray(val) ? flatDeep(val, d - 1) : val), [])
    : arr.slice()
}

flatDeep(arr1, Infinity)
// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]

forEach+isArray+push+recursivity

// forEach 遍历数组会自动跳过空元素
const eachFlat = (arr = [], depth = 1) => {
  const result = [] // 缓存递归结果
  // 开始递归
  ;(function flat(arr, depth) {
    // forEach 会自动去除数组空位
    arr.forEach((item) => {
      // 控制递归深度
      if (Array.isArray(item) && depth > 0) {
        // 递归数组
        flat(item, depth - 1)
      } else {
        // 缓存元素
        result.push(item)
      }
    })
  })(arr, depth)
  // 返回递归结果
  return result
}

// for of 循环不能去除数组空位，需要手动去除
const forFlat = (arr = [], depth = 1) => {
  const result = []
  ;(function flat(arr, depth) {
    for (let item of arr) {
      if (Array.isArray(item) && depth > 0) {
        flat(item, depth - 1)
      } else {
        // 去除空元素，添加非undefined元素
        item !== void 0 && result.push(item)
      }
    }
  })(arr, depth)
  return result
}

使用堆栈stack

// 无递归数组扁平化，使用堆栈
// 注意：深度的控制比较低效，因为需要检查每一个值的深度
// 也可能在 shift / unshift 上进行 w/o 反转，但是末端的数组 OPs 更快
var arr1 = [1, 2, 3, [1, 2, 3, 4, [2, 3, 4]]]
function flatten(input) {
  const stack = [...input]
  const res = []
  while (stack.length) {
    // 使用 pop 从 stack 中取出并移除值
    const next = stack.pop()
    if (Array.isArray(next)) {
      // 使用 push 送回内层数组中的元素，不会改动原始输入
      stack.push(...next)
    } else {
      res.push(next)
    }
  }
  // 反转恢复原数组的顺序
  return res.reverse()
}
flatten(arr1) // [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
// 递归版本的反嵌套
function flatten(array) {
  var flattend = []
  ;(function flat(array) {
    array.forEach(function (el) {
      if (Array.isArray(el)) flat(el)
      else flattend.push(el)
    })
  })(array)
  return flattend
}

Generator

function* flatten(array) {
  for (const item of array) {
    if (Array.isArray(item)) {
      yield* flatten(item)
    } else {
      yield item
    }
  }
}

var arr = [1, 2, [3, 4, [5, 6]]]
const flattened = [...flatten(arr)]
// [1, 2, 3, 4, 5, 6]

计算元素出现的次数

reduce

var names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice']

var countedNames = names.reduce(function (allNames, name) {
  if (name in allNames) {
    allNames[name]++
  } else {
    allNames[name] = 1
  }
  return allNames
}, {})
// countedNames is:
// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }

清除

设置数组的 length 为 0。

按属性分类对象

var people = [
  { name: 'Alice', age: 21 },
  { name: 'Max', age: 20 },
  { name: 'Jane', age: 20 }
]

function groupBy(objectArray, property) {
  return objectArray.reduce(function (acc, obj) {
    var key = obj[property]
    if (!acc[key]) {
      acc[key] = []
    }
    acc[key].push(obj)
    return acc
  }, {})
}

var groupedPeople = groupBy(people, 'age')
// groupedPeople is:
// {
//   20: [
//     { name: 'Max', age: 20 },
//     { name: 'Jane', age: 20 }
//   ],
//   21: [{ name: 'Alice', age: 21 }]
// }

求两数组交集

let arr1 = [0, 1, 2, 3, 4, 5, 4, 5]
let arr2 = [4, 5, 6, 7, 8, 9, 0]
let result = Array.from(new Set(arr1.filter((v) => arr2.includes(v))))
console.log(result) //[ 0, 4, 5 ]

参考文章

模拟实现call，apply 和 bind

Wed, 07 Oct 2020 12:00:00 GMT

前言

call，apply 和 bind 是 Function.prototype 上的三个方法，他们能让我们指定函数执行的上下文和参数。关于他们的区别，可以参考我的另一篇文章 apply和call, bing方法的应用。为了加深对他们的理解，就动手实现一下模拟的 call，apply 和 bind。

模拟 call

call 和 apply 的主要区别就是参数的形式，本质并没有不同，我们实现了其中一个另一个也就解决了，这里我们详细说一下 call 实现的过程。

我们先来看看 ES5 标准中对 call 的定义：当以 thisArg 和可选的 arg1, arg2 等等作为参数在一个 func 对象上调用 call 方法，采用如下步骤：

如果 IsCallable(func) 是 false, 则抛出一个 TypeError 异常。
令 argList 为一个空列表。
如果调用这个方法的参数多于一个，则从 arg1 开始以从左到右的顺序将每个参数插入为 argList 的最后一个元素。
提供 thisArg 作为 this 值并以 argList 作为参数列表，调用 func 的 [[Call]]内部方法，返回结果。
call 方法的 length 属性是 1。

在外面传入的 thisArg 值会修改并成为 this 值。thisArg 是 undefined 或 null 时它会被替换成全局对象，所有其他值会被应用 ToObject 并将结果作为 this 值，这是第三版引入的更改。

所以我们要做的事情很简单，就是将 call 的第一个参数作为函数执行的 this，call 的后面其他参数作为函数执行的参数执行函数即可。

改变函数的 this 就需要改变函数的调用方式，直接调用的话 this 指向的是全局对象。我们很容易想到的就是将函数作为一个方法添加到 thisArg 上。但是这样 thisArg 上就多了一个属性，改变了 thisArg，所以我们要在函数调用完之后用 delete 删除这个属性。这样处理虽然还是能在函数中的 this 中看到我们添加的属性（因为我们删除是在函数调用之后），和原版的 call 不一样，不过目前我能想到的只有这么解决。我们可以用 Symbol 来让这个新添加的方法不可访问，不过 Symbol 是 ES6 的新特性，而 call 和 apply 都是在 es3 就支持的方法，所以这里我们也可以用 Math.random() 生成一串随机数作为键名，或者用 new Date().getTime() 生成时间戳也可以，这样做的另一个原因就是防止和 thisArg 中原有的属性名冲突 :joy:。下面的代码可以看出两者的区别。

//this is a testing javascript file

Function.prototype._call = function (thisArg) {
  thisArg.func = this
  thisArg.func()
  delete thisArg.func
}

let obj1 = {}
let obj2 = {}

function iscalled() {
  console.log(Object.getOwnPropertyNames(this))
}

iscalled._call(obj1) //['func']
iscalled.call(obj2) //[]
console.log(Object.getOwnPropertyNames(obj1)) //[]

将 thisArg 后面的参数作为函数调用的参数我们可以用一个数组将所有的参数 push 进去。但是执行的时候如何调用这个数组作为参数呢。我们比较容易想到用 es6 的扩展运算符 ... 这样调用 thisArg.func(...argList)，这样确实能解决问题，但和上面的 Symbol 一样，扩展运算符是一个 ES6 的特性，我们想要模拟实现一个 es3 的方法。所以这里我们可以用拼接字符串然后用 eval 调用的方式来执行代码。最后的实现如下：

Function.prototype._call = function (thisArg) {
    //判断this是否是函数
    if (typeof this !== 'function') {
        throw new TypeError(this + ' is not a function');
    }

    //thisArg 为 undefined 或者 null 则转为全局对象
    if (thisArg === void(0) || thisArg === null) {
        thisArg = window;
    } else {
        //thisArg 不是对象为其包装
        thisArg = new Object(thisArg)
    }
    console.log(thisArg)

    let argList = [];
    const FUNC = Symbol('func');
    thisArg[FUNC] = this;

    for (let i = 1; i < arguments.length; i++) {
        //es6
        //argList.push(arguments[i])

        //es3
        argList.push('arguments[' + i + ']');
    }
    //es6
    //let result = thisArg[FUNC](...argList);

    //es3
    let result = eval('thisArg[FUNC](' + argList + ')'); //这里会调用 `Array.prototype.toString()` 进行argList的类型转换
    delete thisArg[FUNC];
    return result;
}

// 测试
var value = 1;

var obj = {
    value: 2
}

function beCalled(name, age) {
    console.log(this.value);
    return {
        value: this.value,
        name: name,
        age: age
    }
}

beCalled._call(null); // 1 thisArg: window
beCalled._call(undefined); 1 thisArg: window
beCalled._call(1) // undefined thisArg: Number(1)

console.log(beCalled._call(obj, 'clloz', '28')); //2 {value: 2, name: "clloz", age: "28"}

对 thisArg 进行了一些判断，如果是 undefined null 就转为全局对象（判断 undefined 最好是使用 void(0)，因为在非全局作用域 window 和 undefined 都是能被修改的），如果不是对象则用 Object() 进行包装。

模拟 apply

有了 call 经验，实现 apply 就比较简单了，我们只是取参数的方式变化一下即可。我们需要判断一下 apply 的第二个参数是否是一个可用的数组。具体代码如下：

Function.prototype._apply = function (thisArg, args) {
  //判断this是否是函数
  if (typeof this !== 'function') {
    throw new TypeError(this + ' is not a function')
  }

  //thisArg 为 undefined 或者 null 则转为全局对象
  if (thisArg === void 0 || thisArg === null) {
    thisArg = window
  } else {
    //thisArg 不是对象为其包装
    thisArg = new Object(thisArg)
  }

  const FUNC = Symbol('func')
  thisArg[FUNC] = this
  let argList = []
  let result

  if (!argList) {
    result = thisArg[FUNC]()
  } else {
    for (let i = 0; i < args.length; i++) {
      argList.push('args[' + i + ']')
    }
    result = eval('thisArg[FUNC](' + argList + ')')
  }

  delete thisArg[FUNC]
  return result
}

// 测试一下
var value = 1

var obj = {
  value: 2
}

function beCalled(name, age) {
  console.log(this.value)
  return {
    value: this.value,
    name: name,
    age: age
  }
}

beCalled._apply(null) // 2
beCalled._apply(undefined)
beCalled._apply(1)

console.log(beCalled._apply(obj, ['clloz', '28']))

模拟 bind

bind 是返回一个指定了 this 的函数，同时这个函数支持 new 调用，使用 new 调用则指定的 this 不生效。

在模拟 bind 之前，我们先看一下 Function.prototype.bind 上的一个例子，这个例子我在 apply和call, bing方法的应用里面也谈过，不过今天看了下自己还不是很透彻就再讲一遍，感觉还是有助于对于本文知识点，包括是函数的理解的。

//给 Array.prototype.slice 一个别名，方便调用
var slice = Array.prototype.slice

slice.apply(arguments)

//也可以这样用bind实现
var unboundSlice = Array.prototype.slice
var slice = Function.prototype.apply.bind(unboundSlice)

slice(arguments)

上面的两段代码实现的都是实现 Array.prototype.slice 的快捷调用，让我们不用每次都输入一长串字符，直接一个 slice 就可以了。不过第一种实现，我们需要显示的使用 slice.apply，第二种实现则直接使用 slice 即可。这是如何实现的呢？

首先我们要明白，apply 本身就是一个函数，它是在 Function.prototype 上定义的一个函数，所有函数都能调用它。当我们用 func.apply() 调用 apply 的时候，本质就是以 func 作为 this 调用 apply。那么第二种实现就是用 Array.prototype.slice 作为 this 创建 apply 的一个绑定函数。当我们调用这个绑定函数的时候就相当于调用 Array.prototype.slice.apply()。

Function.prototype.call.bind(func) 或者 Function.prototype.apply.bind(func) 就可以直接理解为返回的绑定函数是 func.call 或者 func.apply。

当我们需要频繁调用一个指定 this 的函数，我们可以用 bind 来实现快捷调用。举个例子子，我们相对类数组对象（比如 arguments）执行数组方法（比如 slice），我们一般是 Array.prototype.slice.apply(arguments)，当我们需要频繁使用这个方法的时候，我们可能会这样 let slice = Array.prototype.slice; slice.apply(arguments);。如果我们使用 bind，我们可以直接 slice(arguments) 这样调用，更方便，具体实现看下面的代码。

实现 bind 主要有三个点，返回一个函数，可以预设参数以及生成的绑定函数可以使用 new 操作符。

返回函数和预设参数我们可以用 apply 来实现，大致的效果如下。

Function.prototype._bind = function (thisArg) {
  let self = this
  let args = Array.prototype.slice.call(arguments, 1)
  let fBound = function () {
    let bindArgs = Array.prototype.slice.call(arguments)
    return self.apply(thisArg, args.concat(bindArgs))
  }
  return fBound
}

function sum(c, d) {
  return this.a + this.b + c + d
}

let obj = { a: 1, b: 2 }

let t = sum._bind(obj, 3)

console.log(t(4)) //10

下面就是要实现 new 调用。如果你对 new 操作符不熟悉，可以先看一下 JavaScript 中的 new 操作符和实现。当使用 new 调用绑定函数，this 将指向绑定函数的原型，我们要的效果是原型指向的是原函数的 prototype，那么最直接的想法就是将绑定函数的 prototype 指向原函数的 prototype 即可。但是这样做有一个问题就是当我们后面改变绑定函数的 prototype，原函数的 prototype 也会被修改，他们指向的是同一个对象。基于这样的原因我们需要在中间加一层。最终的实现如下：

Function.prototype._bind = function (thisArg) {
  if (typeof this !== 'function') {
    throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable')
  }
  let self = this
  let args = Array.prototype.slice.call(arguments, 1)

  let fNOP = function () {}
  let fBound = function () {
    let bindArgs = Array.prototype.slice.call(arguments)
    return self.apply(this instanceof fNOP ? this : thisArg, args.concat(bindArgs))
  }

  fNOP.prototype = this.prototype
  fBound.prototype = new fNOP()

  return fBound
}

function sum(c, d) {
  console.log(this.a, this.b) //undefined undefined
  this.a = c
  this.b = d
}

let obj = { a: 1, b: 2 }

let t = sum._bind(obj, 3)

let m = new t(4, 5)

console.log(m) //{3, 4}

我们可以看到最后结果使用的参数是 bind 的时添加的一个参数和 new 添加的第一个参数，new 的多余参数被忽略。这也是 bind 的另一个功能，可以预设参数。而我们也发现 bind 绑定的 obj 没有生效，这部分我们是用 instanceof 判断调用绑定函数时的 this 来判断的，如果是 new 调用，那么这个 this 是 fNOP 的实例（如果是直接调用，那么这个 this 会是全局对象，浏览器环境就是 window 对象）。

关于原生的 bind 和我们这个 bind 还有一个区别就是原生的 bind 生成的绑定函数的 prototype 是 undefined，并且同时 newObj instanceof 绑定函数 返回时 true，这是违反我们对 instanceof 的理解的，我在标准中也没有找到合理的解释。我们这里实现的绑定函数的 prototype 就是 new fNOP()，在我们的代码里，t.prototype.__proto__ === sum.prototype 将返回 true。关于这一点，在我的另一片文章 apply和call, bing方法的应用的 bind 章节有更详细的说明

参考文章

水平垂直居中方案

Mon, 05 Oct 2020 12:00:00 GMT

前言

本文总结一些水平和垂直居中的方案。

水平居中

行内元素

行内元素的水平居中设置父元素的 text-aling: center 即可。元素的 display 可以是 inline，inline-block，inline-table 和 inline-flex。

<style>
  .wrap {
    text-align: center;
    margin-bottom: 30px;
  }
  .wrap > div {
    height: 200px;
    width: 200px;
    background-color: lightblue;
  }
</style>

<div class="wrap">this is a text.</div>
<div class="wrap">
  <div class="ib" style="display: inline-block"></div>
</div>
<div class="wrap">
  <div class="it" style="display: inline-table"></div>
</div>
<div class="wrap">
  <div class="if" style="display: inline-flex"></div>
</div>

块元素

使用 margin: 0 auto。margin: 0 auto 之所以能够进行居中，是在 CSS2.2中进行了规定的。当元素的宽度不为 auto 并且 margin-left 和 margin-right 都为 auto 的时候，元素将在水平方向上居中。

<style>
  .center {
    height: 200px;
    width: 200px;
    margin: 0 auto;
    background-color: lightblue;
  }
</style>

<div class="center"></div>

多个元素

实现多个元素的水平居中比较常用的方法就是 display: inline-block 配合 text-align: center 来实现。

水平垂直居中

这里介绍的几种垂直居中的方法都可以应用到水平方向上，所以就放到一起来说

绝对定位 + 负 margin

在知道元素宽高的情况下可以利用这一方法。

<style>
  .center {
    position: absolute;
    top: 50%;
    left: 50%;
    width: 200px;
    height: 200px;
    margin: -100px 0 0 -100px;
    background-color: lightblue;
  }
</style>

<div class="center"></div>

绝对定位 + calc

必须确定居中元素的宽高。

<style>
  .center {
    position: absolute;
    top: calc(50% - 100px);
    left: calc(50% - 100px);
    height: 200px;
    width: 200px;
    background-color: lightblue;
  }
</style>
<div class="center"></div>

绝对定位 + margin

元素必须设置宽高，否则元素的宽高都会是 100%，不过宽高可以设置百分比而不一定非要像素。

<style>
  .center {
    position: absolute;
    top: 0;
    right: 0;
    bottom: 0;
    left: 0;
    width: 200px;
    height: 200px;
    margin: auto;
    background-color: lightblue;
  }
</style>

<div class="center"></div>

绝对定位 + transform

这个方法和 绝对定位 + 负margin 类似，但是我们可以不用固定宽高，因为 transform 支持百分比。

<style>
    .center {
        position: absolute;
        top: 50%;
        left: 50%;
        width: 200px;
        height: 200px;
        transform: translate(-50%, -50%);
        background-color: lightblue;
    }
</style>
<div class="center"></div>

table-cell

将父元素的 display 设为 table-cell，然后利用 text-align 和 vertical-align 来实现元素的居中。不过要居中的元素需要是行内级元素。如果想相对于视口居中，可以在外面再套一层 display: table;。

<style>
  .container {
    display: table;
    width: 100%;
    height: 500px;
  }
  .wrap {
    display: table-cell;
    height: 500px;
    width: 500px;
    border: 1px solid black;
    text-align: center;
    vertical-align: middle;
  }
  .center {
    display: inline-block;
    width: 200px;
    height: 200px;
    background-color: lightblue;
  }
</style>
<div class="container">
  <div class="wrap">
    <div class="center"></div>
  </div>
</div>

flex布局

<style>
  .container {
    display: flex;
    justify-content: center;
    align-items: center;
    height: 200px;
    border: 1px solid;
  }

  .center {
    height: 100px;
    width: 100px;
    background-color: lightblue;
  }
</style>
<div class="container">
  <div class="center"></div>
</div>

::after 伪元素和 vertical-align

可以利用撑满父元素的 ::after 伪元素和 vertical-align 实现行内元素的居中（不用伪元素，用 line-height 同样也可以实现，根据需求选择）

<style>
  .wrap {
    width: 100%;
    height: 600px;
    /* line-height: 600px; */
    text-align: center;
    border: 1px solid;
    font-size: 0;
  }
  .wrap::after {
    content: '';
    display: inline-block;
    height: 100%;
    width: 1px;
    background-color: red;
    vertical-align: middle;
  }
  .center {
    display: inline-block;
    height: 200px;
    width: 200px;
    vertical-align: middle;
    background-color: lightblue;
  }
</style>
<div class="wrap">
  <div class="center"></div>
</div>

参考文章

JavaScript 中的按位操作符

Sun, 04 Oct 2020 12:00:00 GMT

前言

JavaScript 提供了多种按位操作符，由于不是很了解，我使用频率很低。不过经常看到别人的代码中利用按位操作符简化代码，在一些场景下能够更有效率。本文记录学习按位操作符的笔记。

按位操作符

JavaScript 中的按位操作符见下表：

| 运算符 | 用法 | 描述 | | -------------------- | --------- | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- | | 按位与（ AND） | a & b | 对于每一个比特位，只有两个操作数相应的比特位都是 1 时，结果才为 1，否则为 0。 | | 按位或（OR） | a | b | 对于每一个比特位，当两个操作数相应的比特位至少有一个 1 时，结果为 1，否则为 0。 | | 按位异或（XOR） | a ^ | 对于每一个比特位，当两个操作数相应的比特位有且只有一个 1 时，结果为 1，否则为 0。 | | 按位非（NOT） | ~ a | 反转操作数的比特位，即 0 变成 1，1 变成 0。 | | 左移（Left shift） | a << b | 将 a 的二进制形式向左移 b (< 32) 比特位，右边用 0 填充。 | | 有符号右移 | a >> b | 将 a 的二进制表示向右移 b (< 32) 位，丢弃被移出的位。 | | 无符号右移 | a >>> b | 将 a 的二进制表示向右移 b (< 32) 位，丢弃被移出的位，并使用 0 在左侧填充。 |

所有的按位操作符的操作数都会被转成补码形式的有符号 32 位二进制整数。关于补码的知识，可以参考我的另一片文章原码，反码和补码。如果操作数是一个非数字，我们需要注意 JavaScript 会将它转化为什么：

Number(null) //0
Number(undefined) //NaN
Number([]) //0
Number([1, 2, 3]) //NaN
Number(true) //1
Number(false) //0
Number('123') //123
Number('abc') //NaN
Number('') //0
Number(Symbol(123)) //Uncaught TypeError: Cannot convert a Symbol value to a number

按位逻辑操作符

按位逻辑操作符（按位与 &，按位或 |，按位异或 ^，按位非 ~）的规则：操作数被转换成 32 位二进制整数，超过 32 位的数字会被丢弃。第一个操作数的每个比特位与第二个操作数的相应比特位匹配（匹配规则见下方无序列表）：第一位对应第一位，第二位对应第二位，以此类推。位运算符应用到每对比特位，结果是新的比特值。

位匹配规则： - 按位与 &：对每对比特位执行与（AND）操作。只有 a 和 b 都是 1 时，a AND b 才是 1。将任一数值 x 与 0 执行按位与操作，其结果都为 0。将任一数值 x 与 -1 执行按位与操作，其结果都为 x。 - 按位或 |：对每一对比特位执行或（OR）操作。如果 a 或 b 为 1，则 a OR b 结果为 1。将任一数值 x 与 0 进行按位或操作，其结果都是 x。将任一数值 x 与 -1 进行按位或操作，其结果都为 -1。 - 按位异或 ^: 对每一对比特位执行异或（XOR）操作。当 a 和 b 不相同时，a XOR b 的结果为 1。将任一数值 x 与 0 进行异或操作，其结果为 x。将任一数值 x 与 -1 进行异或操作，其结果为 ~x。 - 对每一个比特位执行非（NOT）操作。NOT a 结果为 a 的反码。对任一数值 x 进行按位非操作的结果为 -(x + 1)。比如 ~str.indexOf(searchFor) 可以判断字符 searchFor 是否在 str 中出现，当 indexOf 返回 -1 时，~str.indexOf(searchFor) 的结果为 0。

这里需要注意，所有的按位操作符都是用 32 位有符号二进制补码进行计算的，所以上面的位匹配规则中用 -1 来说明，在补码中 -1 就是全为 1。~x 表示 x 取反。NaN 作为操作数的表现和 0 相同，比如 ({}) & -1 的结果为 0。

按位移动操作符

按位移动操作符（按位左移 <<，有符号按位右移 >>，无符号按位右移 >>>）有两个操作数：第一个是要被移动的数字，而第二个是要移动的长度。移动的方向根据操作符的不同而不同。

按位移动会先将操作数转换为大端字节序顺序(big-endian order)的 32 位整数,并返回与左操作数相同类型的结果。右操作数应小于 32 位，否则只有最低 5 个字节会被使用。

Big-Endian:高位字节排放在内存的低地址端，低位字节排放在内存的高地址端，又称为"高位编址"，是最直观的字节序。

按位左移 <<：该操作符会将第一个操作数向左移动指定的位数。向左被移出的位被丢弃，右侧用 0 补充。9 << 2 结果为 36，即 1001 变为 100100。
有符号按位右移 >>：该操作符会将第一个操作数向右移动指定的位数。向右被移出的位被丢弃，拷贝最左侧的位以填充左侧。由于新的最左侧的位总是和以前相同，符号位没有被改变。所以被称作“符号传播”。9>>2 结果为 2，即 1001 变为 0010；-9>>2 结果为 -3，即 11111111111111111111111111110111 变为 11111111111111111111111111111101。
无符号按位右移 >>>：该操作符会将第一个操作数向右移动指定的位数。向右被移出的位被丢弃，左侧用 0 填充。因为符号位变成了 0，所以结果总是非负的。对于非负数，有符号右移和无符号右移总是返回相同的结果。（即便右移 0 个比特，结果也是非负的，可以理解为将补码直接当做正数，比如 --1 的补码是 32 个 1，那么 -1 >>>0 的结果就是 4294967295）

应用

上面介绍了 JavaScript 中的位运算概念，本节介绍一些比较常见的应用场景。

掩码 bitmask

所谓掩码其实就是一串二进制数，我们通过 与/或 的操作来读取标志位。主要利用的特性就是任何数与 0 进行与操作都是 0，任何数与 1 进行或操作都是 1。

比如我们常见的子网掩码就是一种应用，为了区分我们 IP 地址中的网络号与主机号，用子网掩码来做与操作即可。我们的 IP 的地址是 4 字节，子网掩码也是 4 字节，当我们的子网掩码是 255.255.255.0 的时候，其实就是 11111111.11111111.11111111.00000000，当我们的 IP 地址和子网掩码进行与操作之后，只会留下前面 24 位，这 24 位也就是我们的主机号。也就是说，子网掩码就是将网络号对应的位全部设为 1，而主机号的位设为 0，可以很方便的知道我们的网络号和主机号。

在 JavaScript 中也有应用，比如 MouseEvent.buttons 就是用的掩码的形式来分辨当前按下了哪些鼠标上的键，用六位二进制数作为标志位，

0 : 没有按键或者是没有初始化
1 : 鼠标左键
2 : 鼠标右键
4 : 鼠标滚轮或者是中键
8 : 第四按键 (通常是“浏览器后退”按键)
16 : 第五按键 (通常是“浏览器前进”)

我们可以利用掩码来进行一些状态的保存和判断，用法主要是

用或运算设置标志位，掩码中为 1 的位可以设置对应的位，比如 0011 就可以将最后两位都设置为 1。
用与运算清除标志位，利用掩码中的 0 将目标位置进行重置。比如 0000 可以将目标的四位全部置为 0。
用与运算获得目标位置的状态，比如 0010 与目标进行与运算可以获得目标第三位的状态。
用异或运算切换标志位状态，掩码中的 1 能够让目标位置的状态切换。

我们可以用左移运算符进行掩码的自动化创建，无符号右移将掩码转化为布尔值：

//布尔值转掩码
function createMask() {
  var nMask = 0,
    nFlag = 0,
    nLen = arguments.length > 32 ? 32 : arguments.length
  for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++);
  return nMask
}
var mask1 = createMask(true, true, false, true) // 11, 0b1011
var mask2 = createMask(false, false, true) // 4, 0b0100
var mask3 = createMask(true) // 1, 0b0001

//掩码转布尔值
function arrayFromMask(nMask) {
  // nMask 必须介于 -2147483648 和 2147483647 之间，去除符号位还有31位
  if (nMask > 0x7fffffff || nMask < -0x80000000) {
    throw new TypeError('arrayFromMask - out of range')
  }
  for (
    var nShifted = nMask, aFromMask = [];
    nShifted;
    aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1
  );
  return aFromMask
}

var array1 = arrayFromMask(11) //[true, true, false, true]
var array2 = arrayFromMask(4) //[false, false, true]
var array3 = arrayFromMask(1) //[true]

乘除

我们的右移相当于除2，左移相当于乘2。

let a = -10
a >> 1 // -5
a << 1 // -20

交换两个数的值

利用异或的特点，我们可以不创建第三个变量进行两个变量值的交换，

let a = 100, b = -100;
a ^ = b; //a = a ^ b
b ^ = a; //b = b ^ b ^ a -> a
a ^ = b; // a = a ^ a ^ b -> b

这主要利用的是异或的结合律和交换律，即 a ^ b 和 b ^ a 是相等的；以及异或自身的结果为 0，任何值和 0 进行异或结果都为自身。

判断奇偶

二进制数只有最后一位是 0 就是偶数，最后一位是 1 就是奇数，我们可以利用这一点进行判断，

if (0 === (a & 1)) {
  console.log('an even number')
} else {
  console.log('an odd number')
}

变更符号

对于二进制补码，有 X + ~X + 1 = 0，变形可得 -X = ~X + 1，所以一个数的相反数就是按位取反再加一。

let a = 10
console.log(~a + 1) //-10

利用这一特性我们也可以求绝对值，只要先判断值的正负即可。利用 a >> 31 即可判断正负，正数右移 31 位后结果为 0，负数右移 31 位后结果为 -1，如果是负数则求其相反数。求绝对值还有一个更简化一点的办法：

let a = -10
let i = a >> 31
console.log((a ^ i) - i) //10

主要就是利用任何数与 -1 进行异或运算就是取反。

高低位交换

比如一个 16位 无符号整数，我们可以利用位运算进行高八位第八位的交换。a << 8 | a >> 8

求最小的2的整数次幂约数

给定一个数，想求其最小的整数次幂约数可以用 a & -a。求最小的 2 的整数次幂约数其实就是找其二进制表示中从右往左数第一个 1。利用 -a = ~a + 1 可以找到这个 1 的位置。

计算二进制数中 `1` 的个数

let count = 0;
let a = 100;
while(a){
  a = a & (a - 1);
  count++;
}
console.log(count) //3
console.log(100. toString(2)) //1100100

小数转整数

由于按位操作符的计算都会先将操作数转为 32 位有符号二进制数，我们可以利用这个来将小数转为整数。比如我们需要随机数的时候 Math.random() * 16 | 0 就能够直接得到整数。

参考文章

实现一个 JS 动画模块

Sun, 27 Sep 2020 12:00:00 GMT

前言

前端的动画可以用 CSS 来实现，但是如果我们希望管理多个元素的动画进行，支持暂停和继续。那么我们可以用 JS 来实现。

功能分析

用 CSS 实现动画是用 keyframe 定义关键帧，然后用 animation 属性对关键帧的过渡进行配置，其中比较常用的几个属性是 animation-na'me, animation-delay, animation-duration, animation-timing-function（详细内容参考使用 CSS 动画 - MDN）。

使用 JavaScript 来实现动画就是根据时间计算出对应时间点的元素样式。用 JavaScript 的好处是我们能够将动画的逻辑抽象出来，能够同时管理各种需要进行动画元素，并且我们能够对元素的动画进行更精确的控制，精确到帧。

从分析中我们可以得出，我们用 JavaScript 实现动画的核心就是对时间的把控，我们要明确每一帧元素应该处于什么样的状态。浏览器中一帧是 16ms （一秒钟 60 帧），我们要实现对每一帧的控制可以使用的几个方法是 setInterval，setTimeout 和 requestAnimationFrame。本文我们用 requestAnimationFrame 来实现。requestAnimationFrame 的 API 参考 window.requestAnimationRequest

动画类

首先要设计一个动画类，这个动画类主要是对元素和动画属性的对象进行初始化，同时根据时间计算当前元素的样式。代码如下：

class Animation {
  constructor(obj, prop, startVal, endVal, duration, delay, timeFunc, template) {
    this.obj = obj
    this.prop = prop
    this.startVal = startVal
    this.endVal = endVal
    this.duration = duration
    this.delay = delay
    this.timeFunc = timeFunc
    this.template = template
  }
  trans(time) {
    console.log(time)
    let range = this.endVal - this.startVal
    let progress = this.timeFunc(time / this.duration)
    this.obj[this.prop] = this.template(this.startVal + range * progress)
  }
}

参数中的 obj 是表示要应用动画的元素，prop 是要进行动画的属性，timeFunc 是和 css 中的 animation-timing-function 类似，template 是为了应对不同的 CSS 属性的不同格式，比如 transform 属性。

timeline类

我们要对动画实现 start，pause，resume 等功能，需要一个 timeline 对时间进行管理。我们的 Animation 是根据时间计算样式的，这个时间是一个相对时间。比如 pause 功能，我们可以在用户点击 pause 按钮后记录时间，然后在用户点击 resume 按钮后计算出暂停的时间，在返回给 Animation.trans() 方法的时间中减去这个暂停的时间就能够让元素继续暂停之前的状态进行动画。

对于不同的元素的动画我们用 Set 进行管理，当有新的需要动画的元素加入时我们将 new 的 Animation 对象存入 Set，当动画完成在从 Set 中删除。

整个的逻辑还是比较简单的，直接看代码吧.

const TICK = Symbol('tick')
const TICK_HANDLER = Symbol('tick handler')
const ANIMATIONS = Symbol('animations')
const MOVETIME = Symbol('movetime')
const PAUSE_START = Symbol('pause start')
const PAUSE_TIME = Symbol('pause time')

export class Timeline {
  constructor() {
    this.state = 'inited'
    this[ANIMATIONS] = new Set()
    this[MOVETIME] = new Map()
  }
  start() {
    if (this.state !== 'inited') return
    this.state = 'started'
    let startTime = Date.now()
    this[PAUSE_TIME] = 0
    console.log(startTime)
    this[TICK] = () => {
      let now = Date.now()
      for (let animation of this[ANIMATIONS]) {
        let t
        if (this[MOVETIME].get(animation) < startTime) {
          t = now - startTime - this[PAUSE_TIME] - animation.delay
        } else {
          t = now - this[MOVETIME].get(animation) - this[PAUSE_TIME] - animation.delay
        }
        if (t > animation.duration) {
          this[ANIMATIONS].delete(animation)
          t = animation.duration
        }
        if (t > 0) animation.trans(t)
      }
      this[TICK_HANDLER] = requestAnimationFrame(this[TICK])
    }
    this[TICK]()
  }
  pause() {
    if (this.state !== 'started') return
    this.state = 'paused'
    this[PAUSE_START] = Date.now()
    cancelAnimationFrame(this[TICK_HANDLER])
  }
  resume() {
    if (this.state !== 'paused') return
    this.state = 'started'
    this[PAUSE_TIME] += Date.now() - this[PAUSE_START]
    this[TICK]()
  }
  reset() {
    this.pause()
    this.state = 'inited'
    // let startTime = Date.now();
    this[ANIMATIONS] = new Set()
    this[MOVETIME] = new Map()
    this[TICK_HANDLER] = null
    this[PAUSE_START] = 0
  }
  add(animation, startTime) {
    if (arguments.length < 2) {
      startTime = Date.now()
    }
    this[ANIMATIONS].add(animation)
    this[MOVETIME].set(animation, startTime)
  }
}

一些模块中私有的属性，我用 Symbol 来生成，这样在模块文件外这些属性是不会被访问到的（目前 ES6 的静态属性支持还不好）。对于 delay 的处理其实和 pause 的逻辑也一样，我们记录 start 开始的时间，只有等到时间超过 delay 才会调用。注意我们的时间计算是从 start 开始一直到结束的，所以每次的 pause 的时间都需要累加到 pause time 中。

时间的前进我们利用 requestAnimationFrame 的回调函数来递归调用我们封装的函数实现。

最后我们可以为动画加上贝塞尔曲线的支持。

export function cubicBezier(p1x, p1y, p2x, p2y) {
  const ZERO_LIMIT = 1e-6
  const ax = 3 * p1x - 3 * p2x + 1
  const bx = 3 * p2x - 6 * p1x
  const cx = 3 * p1x

  const ay = 3 * p1y - 3 * p2y + 1
  const by = 3 * p2y - 6 * p1y
  const cy = 3 * p1y
  function sampleCurveDerivativeX(t) {
    return (3 * ax * t + 2 * bx) * t + cx
  }
  function sampleCurveX(t) {
    return ((ax * t + bx) * t + cx) * t
  }
  function sampleCurveY(t) {
    return ((ay * t + by) * t + cy) * t
  }
  function solveCurveX(x) {
    var t2 = x
    var derivative
    var x2
    for (let i = 0; i < 8; i++) {
      x2 = sampleCurveX(t2) - x
      if (Math.abs(x2) < ZERO_LIMIT) {
        return t2
      }
      derivative = sampleCurveDerivativeX(t2)
      if (Math.abs(derivative) < ZERO_LIMIT) {
        break
      }
      t2 -= x2 / derivative
    }
    var t1 = 1
    var t0 = 0
    t2 = x
    while (t1 > t0) {
      x2 = sampleCurveX(t2) - x
      if (Math.abs(x2) < ZERO_LIMIT) {
        return t2
      }
      if (x2 > 0) {
        t1 = t2
      } else {
        t0 = t2
      }
      t2 = (t1 + t0) / 2
    }
    return t2
  }
  function solve(x) {
    return sampleCurveY(solveCurveX(x))
  }
  return solve
}

export let ease = cubicBezier(0.25, 0.1, 0.25, 1)
export let easeIn = cubicBezier(0.42, 0, 1, 1)
export let easeOut = cubicBezier(0, 0, 0.58, 1)
export let easeInOut = cubicBezier(0.42, 0, 0.58, 1)

效果查看：效果Demo

代码地址：Github

一台设备添加多个 Github 账号

Fri, 25 Sep 2020 12:00:00 GMT

前言

想要深入学习 Git 肯定要模拟多人操作同一个仓库，最好的方法就是自己创建两个账号进行模拟。Github 的账号注册很简单，但是一般我们在一台设备上只配置一个 ssh 公私钥，多个账号的 ssh 该如何配置呢。在谷歌上找的文章没有一个讲的特别清楚的，不过经过我的尝试，已经把配置和使用过程搞清楚了，本文和大家分享一下。

准备

准备工作就是两个 Github 账号和两对 ssh 公私钥。Github 的账号注册就不说了，ssh 的公私钥的创建可以参考ssh的简介和使用。这里特别提一下，ssh 默认创建的公私钥文件名分别是 id_rsa 和 id_rsa.pub，为了清楚的区分我们是为 Github 创建的公私钥我们可以加上 -f location 参数来指定生成的文件的路径和名字，比如 -f ~/.ssh/github1 就会生成 github1 和 github1.pub 这一对公私钥。

然后将两个公钥分别放到自己注册的两个 Gihub 账号的 Settings -> SSH and GPG keys 中。

注册账号的时候如果 verify 页面报错 Unable to verify your captcha response，很可能是连不上 https://octocaptcha.com/，需要代理。

设置过程

现在我们已经生成两对公私钥，并且公钥也配置到对应的账户中去了，下面就是对机器的配置。

我们通过 ssh 访问 Github 的项目。比如 git clone，Github 会给我们一个项目链接形如 git@github.com:username/repository_name.git，这个 git@github.com 就是我们连接 Github 的关键。当我们的设备中只有一对默认公私钥 id_rsa 的时候，ssh 请求默认就会认为私钥是 id_rsa，从而进行匹配。

但是当我们的 .ssh 文件夹中有两对甚至更多的公私钥的时候，并且我们进行了自定义的命名，此时我们就要对公私钥进行配置，告诉 ssh 如何寻找对应的私钥。

配置文件位于 ~/.ssh/config，如何配置看下面的例子。更多 ssh config 的配置字段参考 SSH Config 那些你所知道和不知道的事

#Github clloz@outlook.com
host github.com
    hostname github.com
    User Clloz
    IdentityFile /Users/clloz/.ssh/Clloz_Github

#Github clloz1992@gmail.com
host clloz1992
    hostname github.com
    User Clloz1992
    IdentityFile /Users/clloz/.ssh/Clloz1992_Github

这几个字段意思如下:

Host: 我们上面说过 Github 的链接是 git@github.com，这个 host 就是我们自定义的，下面的 hostname 别名。
hostname：Github 域名，其实 IP 也可以，我们和 git 进行 ssh 通信的时候，请求从这个地址来。
user：我们在 Github 上注册的用户名（好像邮箱也可以）。
IdentityFile：对应的私钥的路径。

这里特别提一下 Host 这个字段，理论上这个字段可以自定义，但是我建议你常用的那个 GIthub 账号这个字段就使用 github.com。首先我们说一下配置生效的原理，所有的 Github 的仓库的地址默认都是 git@github.com 开头，无论是来自哪个用户，也就是说 hostname 都是 github.com。现在我们在 config 文件中，为 github.com 指定了两个别名 allias1 和 alias2，现在我们设置 remote 或者 git clone 的时候不再是使用 git@github.com，而是换成 git@alias1 和 git@alias2。这样配置以后，每次用 ssh 通信的时候我们用别名做 host，而每个别名对应的私钥都在 identityfile 字段中配置了，自然能够成功的按账号进行区分。简单的说，就是原本我们的公私钥是按照 hostname 来匹配的，但是由于 github 的所有仓库 hostname 都一样，无法对用户进行区分，我们就用别名来设置 host 进行区分，别名的作用就类似于用户名，

而由于 Github 上复制地址的时候默认就是 git@github.com，如果你将 host 自定义成其他的，每次 git clone 都要手动改一下 host，非常麻烦。如果不改的话将无法对仓库进行任何操作，因为此时 github.com 这个 host 在我们本地的 ssh 中是找不到对应的私钥的。而且如果你的本地本来就有很多原来 clone 的项目，他们的 host 都是 github.com，此时你也不能对他们进行任何操作，git pull 都不可以，你必须将 remote 修改为你配置后的 host 才能正常操作，如果本地仓库非常多的话，这将非常麻烦。关于报错可以参考下面的我将 host 改为一个自定义的值之后，对原来的 github.com 的仓库进行 git pull 报错如下：

git@github.com: Permission denied (publickey).
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

都设置完成后我们可以用 ssh -T host_alias 来进行测试，如果 host 和返回的用户名匹配成功则说明我们的设置生效了。

ssh -T git@clloz1992
#Hi Clloz1992! You've successfully authenticated, but GitHub does not provide shell access.

ssh -T git@github.com 
#Hi Clloz! You've successfully authenticated, but GitHub does not provide shell access.

经过上面的配置以后，我们已经能够正常的进行两个 github 账号的仓库管理了。需要注意的是分清楚当前仓库是属于哪个用户的。比如 account1 对应的 host 是 allias1，accout2 对应的 host 是 alias2，那么你 clone 或者设置 remote 的时候地址就要将 github.com 改为对应的 alias。如果你在 accout2 下面创建了一个仓库，然后 clone 的时候用的是 git clone git@alias1:username/repository_name.git。那么你会发现，当你进行 push 的时候会报如下的错误：

ERROR: Permission to Clloz/git_learning.git denied to Clloz1992.
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

因为这是 alias1 的仓库，我们自然没有权限对其进行操作。不过我们可以登录 alias1 的 Github 账户，在对应的 repository 的 Settings -> Manage Access 中将 allias2 对应的用户添加到 Collaborator 中，我们就能对这个仓库进行操作了。

还有一点需要注意的，在 git config --global 中的 user.name 和 user.email 我们可以设置为常用账户的，在 alias2 的本地仓库中我们可以用 git config --local 进行单独的设置。我们在 Github 中看到的 commit 就是根据 config 来确定是哪个 github 用户提交的。比如我在 alias2 的仓库中设置 config 的 user.name 和 user.email 为 alias1 对应的用户信息然后进行 commit push，那么在 github 上看到的提交就是由 alias1 对用的用户完成的，contributor 中也多了 alias1 对应的用户，虽然我们并没有把他加入到 Collaborator 中。

所以如果我们只是要模拟多人提交，我们也不必在本地配置两个 github 账户的 ssh，我们可以用同一个账号 clone 将 repository 克隆到两个不同的文件夹，然后两个文件夹的 .git/config 中的 user.name 和 user.email 配置成我们对应的 github 账号的就可以。因为 github 分辨 commit 的来源是根据 config 中的 user 信息的。

所以我们总结一下：ssh 的公私钥只是根据 host 确定了当前的设备是否有权限访问某个 Github 下的仓库；而 config 中的 user 信息确定了当前在操作仓库的是谁。

ssh-agent

最后再说一下 ssh-agent。关于 ssh-agent 的详细内容还是看ssh的简介和使用，我这里主要要说的是，如果你为私钥设置了 passphrase，想要使用 ssh-agent，那么你必须把两个账号的私钥都交给 ssh-agent 来代理，否则会出错。

参考文章

CSS实现视差滚动 Parallax Scrolling

Thu, 24 Sep 2020 12:00:00 GMT

前言

在博客首页的头部背景图本来是用 JavaScript 实现的视差滚动，但是觉得性能不是很好。于是尝试用 CSS 来实现视差滚动的效果。

原理

用 CSS 实现视差滚动的原理就是利用 3d 空间的 z 轴距离产生的近大远小，让元素之间的滚动距离产生差距。perspective 的属性值确定观察的 z 轴坐标，比如我们设 perspective: 1px，最后所有的透视效果都是以和 z = 1px 的位置观察的效果是相同的。z 轴的原点就是我们的屏幕，所有的最后显示效果，都是投影在屏幕上的效果。如果以人眼作为比喻的话，perspective 就是我们的眼睛位置，而屏幕就是视网膜的位置。

如果我们以 z = -1px 为观察点，在z z = 0 和 z= -1px 的位置放两个相同长度的元素，那么实际的成像效果就后面的元素只有前面的元素的长度的一半。如果我们想要让位于 z = -1px 位置的元素看上去和 z = 0 的元素一样大，那么我们就需要将它的边长放大到两倍，可以用 scale(2) 实现。放大后，从我们的 perspective 位置看上去就和 z = 0 的元素是一样的，但是如果我们对屏幕进行滚动，可以理解为我们将我们的观察点沿着 y 轴上下移动，这个位移对于 z = 0 和 z = -1px 的元素是相同的，但是由于 z = -1px 的元素的边长是 z = 0 位置元素的两倍，所以视觉上，我们觉得 z = -1px 的元素的位移好像更短，这就是视差效果。

详细的研究和推理过程可以参考 Tour of a Performant and Responsive CSS Only Site

实现

有了原理之后，实现就简单了。我们将要进行视差移动的元素放到 -1px 的位置，同时放大两倍，将 perspective 设置到 1px 即可。

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>parallax</title>
    <style>
      html,
      body {
        height: 100%;
        margin: 0;
      }
      .container {
        position: relative;
        height: 100%;
        overflow: auto;
        perspective: 1px;
        perspective-origin: 0 0;
      }
      .bg {
        /* position: absolute; */
        width: 100%;
        height: 600px;
        background-image: url('bg.jpg');
        background-size: cover;
        transform-origin: 0 0;
        transform: translateZ(-1px) scale(2);
      }
      .content {
        height: 3000px;
        background: pink;
        margin: -60px 15px 0;
        position: relative;
      }
    </style>
  </head>
  <body>
    <div class="container">
      <div class="bg"></div>
      <div class="content"></div>
    </div>
  </body>
</html>

Demo 效果可以查看：视差滚动效果demo

总结

这种 CSS 实现的视差滚动效果在手机上没法达到效果，手机上可以实现透视的效果，但是滚动的效果出不来。最终我也没有应用到博客上。几种视差滚动的实现方式，包括 js，background-attachment 和透视，都没有一个十分满意的方法，因为性能都不是非常好，而且改动也非常多，最后我干脆就把把这个效果拿掉了，

图片轮播

Tue, 22 Sep 2020 12:00:00 GMT

前言

用两种方式实现图片轮播，自动轮播和拖动轮播。

代码结构

由于 img 是一个可选标签，可以被拖动，我们这里选择用 background-image 来实现。基本的 DOM 结构和 CSS 如下：

<style>
  .carousel {
    width: 500px;
    height: 280px;
    margin: 30px auto;
    font-size: 0;
    white-space: nowrap;
    overflow: hidden;
  }
  .carousel > div {
    display: inline-block;
    width: 500px;
    height: 280px;
    background-size: contain;
    transition: ease 0.5s;
  }
  .carousel > div:nth-child(1) {
    background-image: url('https://img.clloz.com/blog/writing/cat1.jpg');
  }
  .carousel > div:nth-child(2) {
    background-image: url('https://img.clloz.com/blog/writing/cat2.jpg');
  }
  .carousel > div:nth-child(3) {
    background-image: url('https://img.clloz.com/blog/writing/cat3.jpg');
  }
  .carousel > div:nth-child(4) {
    background-image: url('https://img.clloz.com/blog/writing/cat4.jpg');
  }
</style>

<div class="carousel cp1">
  <div></div>
  <div></div>
  <div></div>
  <div></div>
</div>
<div class="carousel cp2">
  <div></div>
  <div></div>
  <div></div>
  <div></div>
</div>

我们用 display: inline-block 和 overflow: hidden 让图片横向排列并且一次只显示一张。这里需要注意 inline-block 空格导致的间隙问题，我直接用 font-size: 0 来解决。

自动轮播

自动轮播的逻辑是比较简单的，我们其实只要关注两张图片，即当前图片和下一张图片。设每一张图片的编号为 index （从 0 开始），每一张图片要显示所对应的 translateX 的值就是 -(index * 100)%。所以我们只需要每次移动时将当前图片和下一章图片左移一个单位（即一张图片的宽度），同时将下一次要显示的图片放到当前图片的右边一个单位。如下图：

关键逻辑就是将下次要显示的图片移动到预备位置，并且这个过程要关掉动画效果。最后的代码如下：

// transform loop settimeout
let el2 = document.querySelector('.carousel.cp2')
let currentIndex = 0
setInterval(() => {
  let children = el2.children
  let nextIndex = (currentIndex + 1) % children.length
  let current = children[currentIndex]
  let next = children[nextIndex]

  next.style.transition = 'none'
  next.style.transform = `translateX(${100 - nextIndex * 100}%)`

  setTimeout(() => {
    next.style.transition = ''
    current.style.transform = `translateX(${-100 - currentIndex * 100}%)`
    next.style.transform = `translateX(${-nextIndex * 100}%)`
    currentIndex = nextIndex
  }, 16)
}, 3000)

动画效果的开关我们可以用 element.style.transition 来控制行内样式的值来达到效果。因为行内样式的优先级最高，当我们设置其值为 none 会覆盖 style 标签中的样式。当我们将 element.style.transition 的值设为 ''，style 标签中的对应样式又生效了

代码中间使用了一个小技巧。就是如果连续对同一个元素进行操作，浏览器会忽略前一个操作，这里我们用一个 setTimeout 避免浏览器的这种行为，16ms 为浏览器一帧的时间。

还有一点就是最后一张图片的下一张应该是第一张，这里我们可以使用简单的模运算来达到效果，模就是元素的个数。

拖动轮播

拖动轮播的逻辑要比自动复杂一些，因为拖动的情况下我们既可以向左又可以向右进行拖动。并且当拖动结束的时候，显示窗口中会有两张图片，我们要根据面积来判断哪张图片显示，并且要把另一张图片也移动到窗口外。

首先我们要处理拖动事件，这个逻辑和我在拖动旋转 3D 的骰子效果一文中的逻辑是相同，我们对包含元素，也就是代码中的 .carousel 绑定一个 mousedown 事件，在其回调函数中绑定 mousemove 和 mouseup 事件。注意后两个事件要绑定到 document 上，因为我们即使拖动到元素外也是一个完整的 mousemove 行为，并且绑定到 document 上即使我们拖出浏览器外也依然能保持触发 mousemove 事件。

mousedown 事件我们只要做一件事就是记录用户点击的初始位置坐标，用 clientX(因为轮播是横向的，我们只需要判断 x 方向的移动距离)

mousemove 我们要处理图片的移动，这里我们需要将动画效果关闭。以一张图片的的宽度为一个单位，我们只需要知道一共滚过了几个单位，就知道当前显示图片的 index，然后在计算当前 index 的前一张和后一张就能够得到连续的效果。mousemove 回调函数如下：

let move = (e) => {
  let x = e.clientX - startX

  //拖动的整数屏
  let current = index - (x - (x % 500)) / 500

  for (let offset of [-1, 0, 1]) {
    //计算可能出现的图片下标
    let pos = current + offset
    pos = (pos + children.length) % children.length //要处理大屏幕拖动小于 -children.length 的情况

    children[pos].style.transition = 'none'
    children[pos].style.transform = `translateX(${-pos * 500 + offset * 500 + (x % 500)}px)` //当前，前一个，后一个图片当前位置
  }
}

mouseup 是这里面逻辑稍微复杂的一个，当我们拖动停止的时候，视口里面会有两张图片（一般情况下）（x 为 e.clientX - startX，即从触发 mousedown 到 mouseup 水平方向一共移动了多少像素），我们要判断哪张图片所占面积比较大，让这张图片用动画移动到整个视口，而另一张图片用动画移出视口。这里我讲两种实现方式。

第一种是比较好理解，但是代码量比较大。我们可以用 (x - (x % 500)) / 500 得出一共滚动了多少个单位，index - (x - (x % 500)) / 500 这张图片在触发 mouseup 时必然在视口内，只是我们不确定它是要移出的还是要显示的，我们只需要分情况，用 if 判断一下 x % 500 的各种情况。

x % 500 的值就是页面滚动完整数个单位后多的部分，这部分如果超过一半的图片宽度，当前图片就要从视口移出；如果小于一半的图片宽度，当前图片就显示到视口中。同时我们还要判断视口中的另一张图片的移动方向，这里就不仅需要判断面积，同时需要判断是向左拖动还是向右拖动的。所以最后我们要 2 x 2 共四种情况。代码如下：

let up = (e) => {
  let x = e.clientX - startX

  //index不变，向下取整，需要分情况，可读性好
  index = (index - (x - (x % 500)) / 500) % children.length
  index = (index + children.length) % children.length
  let base = x % 500

  if (base > 0) {
    if (base > 250) {
      children[index].style.transition = ''
      children[index].style.transform = `translateX(${(-index + 1) * 500}px)`
      let pre = index === 0 ? children.length - 1 : index - 1
      children[pre].style.transition = ''
      children[pre].style.transform = `translateX(${-pre * 500}px)`
      index = pre
    } else {
      children[index].style.transition = ''
      children[index].style.transform = `translateX(${-index * 500}px)`
      let pre = index === 0 ? children.length - 1 : index - 1
      children[pre].style.transition = ''
      children[pre].style.transform = `translateX(${(-pre - 1) * 500}px)`
    }
  }
  if (base < 0) {
    if (base < -250) {
      children[index].style.transition = ''
      children[index].style.transform = `translateX(${(-index - 1) * 500}px)`
      let pre = index === 3 ? 0 : index + 1
      children[pre].style.transition = ''
      children[pre].style.transform = `translateX(${-pre * 500}px)`
      index = pre
    } else {
      children[index].style.transition = ''
      children[index].style.transform = `translateX(${-index * 500}px)`
      let pre = index === 3 ? 0 : index + 1
      children[pre].style.transition = ''
      children[pre].style.transform = `translateX(${(-pre + 1) * 500}px)`
    }
  }

  document.removeEventListener('mousemove', move)
  document.removeEventListener('mouseup', up)
}

上面的代码比较繁琐，其实我们可以将情况简化，我们可以利用 Math.round() 四舍五入求出 mouseup 触发以后要显示的图片（四舍五入后就不需要在特别判断哪个占的面积大了），现在我们要判断的就是另一张图片是前一张还是后一张即可。这个判断也是有规律的，我们利用 Math.abs() 和 Math.sign() 可以得出其值，Math.sign(base) 判断是向左还是向右拖动，Math.abs(base) 判断 base 是否超过一半，结合两者我们就能判断出是上一张还是下一张。代码如下：

let up = (e) => {
  let x = e.clientX - startX

  //index 四舍五入，代码简洁，不易理解，主要是利用四舍五入，统一了要从可视范围移出的元素的下标
  index = (index - Math.round(x / 500)) % children.length
  index = (index + children.length) % children.length //四舍五入，得到的就是mouseup触发后应该显示的图片下标
  let base = x % 500
  for (let offset of [0, (Math.abs(base) > 250 ? 1 : -1) * Math.sign(base)]) {
    let pos = (index + offset + children.length) % children.length //获得另一个要移动的图片的下标（要移除可视范围的图片）
    children[pos].style.transition = ''
    children[pos].style.transform = `translateX(${(offset - pos) * 500}px)` //一个下标为index图片要显示它的偏移量是 -index, 偏移量 -1 表示再向左移动一个图片单位，偏移量 1 表示向右移动一个图片单位，最后的总偏移量为 -index + offset
  }

  document.removeEventListener('mousemove', move)
  document.removeEventListener('mouseup', up)
}

这样代码也简单多了，不过要比上面那个难理解一点。理解的关键就是，同一个方向的移动，base 是否超过一半其 index 是不同的。

完整的代码查看：图片轮播效果

总结

轮播问题的主要逻辑就是我们不需要关注所有图片，不需要每次移动都要保持视口外的图片都在**“正确”**的位置，我们只需要关注几张与当前显示相关的图片即可。

终端设置代理

Tue, 15 Sep 2020 12:00:00 GMT

前言

配置了 V2ray 或者 Shadowsocks 以后，一般来说，只有浏览器（包括内嵌在各种软件中的浏览器，比如 WeGame、优酷、迅雷等软件中的内嵌浏览器）会走代理，其他的应用默认是不走代理的，需要我们手动配置。当需要在终端中使用 brew，git 或者 npm 等安装 package 或应用的时候，如果连接比较吃力的时候启动代理是一个解决方案。本文介绍以下如何在终端中配置代理。

全局代理模式

我们使用 V2ray 或者 Shadowsocks 会进行全局代理模式的选择，一般来说有三种 PAC，Global 和 Manual。

PAC：Proxy auto-config，根据配置文件来确定当前的连接是否需要代理，一般来说这个配置文件是 GFW List 加上我们自己配置的 user rules。关于 user rules 如何配置可以参考我的另一片文章：V2ray安装配置教程
Global: 全局模式，所有连接都走代理。
Manual：手动模式，不会设置系统级代理，需要使用代理的应用（比如浏览器）都需要手动配置代理。

一般来说我们使用前两个模式比较多，大多数情况下 PAC 模式都足够了，如果发现某个我们经常访问的网站不在 PAC 的规则之中，则手动添加到 user rules 里面即可。

虽然 PAC 和 Global 都设置了系统级代理，但是一般只有浏览器（包括内嵌在各种软件中的浏览器，比如 WeGame、优酷、迅雷等软件中的内嵌浏览器）才会使用这个系统级代理，其他应用一般还是需要手动配置。大部分应用不太需要使用这个需求，但是对于经常使用的终端配置一下代理能让我们使用 homebrew，git 和 npm 下载的时候效率高很多。

终端配置

终端中使用有两种方式，一种是临时配置，重启终端后就失效了；另一种是写入到配置文件中去，每次启动终端都可以使用。我们还需要知道 V2ray 和 Shadowsocks 的客户端给我们提供了三种代理配置类型，HTTP，socks5 和 PAC，对应的端口都不同。

临时配置

# 默认一般address是127.0.0.1，http默认port是1087，socks5默认port是1086，PAC默认port是1089
export http_proxy=http://proxyAddress:port
export https_proxy="http://localhost:port"
export all_proxy=socks5://127.0.0.1:1086

写入配置文件

在终端配置文件中（.zshrc 或者 .bash_profile）将配置写入。

alias proxy='export all_proxy=socks5://127.0.0.1:1086'
alias unproxy='unset all_proxy'

使用 proxy 命令开启代理，使用 unproxy 关闭代理。如何检测我们的代理是否开启了，可以使用命令 curl cip.cc，你可以看到你当前的 IP，位置和运营商。如果代理成功开启，那么你可以看到你的 IP 位置等信息都编程了你的代理服务器。

这里补充一下，用 curl cip.cc 进行测试，其实这个测试结果完全就是看你 curl 这个地址是否走了代理，如果在代理工具中配置了这个地址直连，那么得到的结果肯定还是真实的 IP 而不是代理服务器 IP，可以参考请问clashx怎么设置终端代理呢？这个 issue，用 curl -vv https://www.google.com 来进行测试。

最后还需要注意的一点是，如果你设置了 brew 或者 npm 的国内镜像，那么开启了代理以后，这些镜像的访问也会走代理，可能影响访问速度。

参考文章

Shadowsocks(R)设置：系统代理模式、PAC、代理规则

JavaScript 原型机制

Fri, 11 Sep 2020 12:00:00 GMT

前言

原型链的概念相信大家都知道，ES6 出来以后可能关注度没有以前那么高的。虽然在 ES2015/ES6 中引入了 class 关键字，但那只是语法糖，JavaScript 仍然是基于原型的，作为 JavaScript 中的主要继承方式，我们有必要深入理解它。理解了原型之后，你对对象的理解也会更深入。

原型机制

原型机制说起来很简单，就是一个对象可以访问它原型对象上的属性和方法，从而实现属性和方法的复用。而原型对象又有自己的原型对象，这样原型就构成了一个链式结构，也就是我们说的原型链。一个对象可以访问自己原型链上的所有方法和属性。

JavaScript 中的继承只有一种结构：对象。每个实例对象（ object ）都有一个私有属性（称之为 __proto__，引擎内部是 [[prototype]] ）指向它的构造函数的原型对象（prototype ）。该原型对象也有一个自己的原型对象( __proto__ ) ，层层向上直到一个对象的原型对象为 null。根据定义，null 没有原型，并作为这个原型链中的最后一个环节。

在 JavaScript 中，我们知道的数据类型有 Number, String, Undefined, Null, Boolean, BigInt, Symbol 七个基础类型，还有就是一个引用类型 Object。在内置对象比如 Function, Array, Date, RegExp 等中，Function 是一个特殊的内置对象。

我们将 JavaScript 中的对象分成两大类，一类是 Object ，一类就是 Function。我们来说一下他们之间的关系。

我们创建对象有很多种方法，Object.create()，new Object()，new function()，和对象字面量等。但其实他们的本质都是 new Object() （关于 new 和对象创建的内容参考另外两篇文章：JavaScript对象属性类型和赋值细节和 JavaScript中new操作符的解析和实现）。

Object.prototype.proto

我们用 new Object() 创建一个空对象，它在 Chrome 中打印出的结果如下。

我们可以看到所谓的 空对象，并不是完全空的，它内部有一个 __proto__ 属性。但其实这个属性并不是它自身的，这个属性是 Object.prototype.__proto__，一个访问器属性（一个 getter 函数和一个 setter 函数）, 暴露了通过它访问的对象的内部 [[Prototype]] (一个对象或 null)。

这里要注意，Object.prototype.__proto__ 和内部的 [[prototype]] 并不是同一个东西。我们的原型是靠内部的 [[prototype]] 链接的，Object.prototype.__proto__ 只是浏览器提供的一个访问器属性向我们暴露 [[prototype]]。

这个属性是由浏览器厂商提供的，并且目前绝大多数的浏览器都支持这个属性，所以 ECMAScript 2015 中也将其写入标准附录中，保持浏览器的兼容性。但是直接修改对象的 [[prototype]] 在任何引擎和浏览器中都是非常慢并且影响性能的操作，使用这种方式来改变和继承属性是对性能影响非常严重的，并且性能消耗的时间也不是简单的花费在 obj.__proto__ = ... 语句上, 它还会影响到所有继承来自该 [[Prototype]] 的对象。标准中还提供了两组关于读写原型对象的方法 Object.getPrototypeOf/Reflect.getPrototypeOf 和 Object.setPrototypeOf/Reflect.setPrototypeOf。不过写对象和上面说的一样，依然是一个影响性能的操作，如果你关心性能，不应该用这些方法。比较好的实践是用 Object.create() 来设置原型，用 Object.getPrototypeOf() 来读取原型对象。

我们同样可以用对象字面量来设置 __proto__，也可以自定义 __proto__ 来覆盖 Object.prototype.__proto__。参考文章：JavaScript对象属性类型和赋值细节。

不同类型的对象其 [[prototype]] 是不同的，对于使用数组字面量创建的对象，这个值是 Array.prototype。对于 functions，这个值是 Function.prototype。对于使用 new fun 创建的对象，其中 fun 是由 js 提供的内建构造器函数之一(Array, Boolean, Date, Number, Object, String 等等），这个值总是 fun.prototype。对于用 js 定义的其他 js 构造器函数创建的对象，这个值就是该构造器函数的 prototype 属性。关于内置对象之间的关系，我们后面会详细讨论。

Object 和 Function

Object 和 Function 是 JavaScript 中最重要的两个对象，他们同时也是构造函数 function Object(), function Function()。几乎所有对象都是 function Object() 的实例，而所有函数都是 function Function() 的实例，包括 Object 也是由 Function 构造的。

我们上面说过对象内部有一个 [[prototype]] 属性指向它的源性对象；而每一个函数都有一个 prototype 属性，指向由这个函数构造出的对象的 [[prototype]]。更准确的说，在函数被创建的时候，就有一个 prototype 属性指向一个对象，这个对象本身只有一个 constructor 属性指向这个函数。当用 new func() 创建对象的时候，新对象的 [[prototype]] 就指向构造函数的 prototype 对应的对象。不过需要注意的是 prototype 和 constructor 都是可以重写的。

对于我们的自定义对象，这是很好理解的。那么内置对象之间的关系，特别是 Object 和 Function 之间的关系是怎么样的呢。先明确两点：

一切函数都是由 function Function() 构造的，所以函数的 [[prototype]] 指向 Function.prototype。
所有由 function Object() 构造的非函数对象的 [[prototype]] 指向 Object.prototype。
函数的创建的同时，会创建一个 function.prototype 对象，该对象是一个由 function Object() 构造的对象。prototype 属性可以任意指定，指定的对象内可能没有 constructor 属性或者是错误的 constructor。
所有非函数对象都是由构造函数通过 new 运算符创建的（本质都是 new Object()，很多内置对象可以省略 new，比如 Function， Object，Array，省略和不省略效果是一样的)。这个构造函数要么是自定义的（由 function Function() 构造），要么是 function Object()。
自定义函数手动指定 prototype 为其它自定函数的实例，可以让我们实现链式继承，这条链最终有一个节点会是有 function Object() 构造的对象，它的 [[protottype]] 指向 Object.prototype。所以我们可以说，所有的非函数对象都是 function Object() 的实例。

其实记住这几点就可以应对绝大部分问题，如果你还对内置对象的关系有兴趣，可以继续往下看。

根据我们上面的两条规律我们可以知道 Object 的 [[prototype]] 指向 Function.prototype，那么 function Function() ，Function.prototype 和 Object.prototype 的 [[prototype]] 都分别是什么呢？

先说 Object.prototype，它是所有非函数对象的 [[prototype]] 指向，而它自己的 [[prototype]] 指向的就是 null，也就是一切对象的原型链的终点。它的 constructor 属性指向 function Object()

而 function Function() 的 [[prototype]] 和其它的函数一样，指向 Function.prototype，也就是说 function Function() 的 prototype 和 [[prototype]]指向的是同一个对象 Function.prototype。

Function.prototype 的 [[prototype]] 指向的是 Object.prototype。consctructor 指向的是 function Function()。其实 Function.prototype 本身就是函数，可以直接调用，接受任何参数并返回 undefined。

为什么要这样呢？我认为是确保每一个函数对象，非函数对象，他们的原型链上都有 Object.prototype，都能够访问 Object.prototype 上定义的一些公有方法。

constructor: ƒ Object()
hasOwnProperty: ƒ hasOwnProperty()
isPrototypeOf: ƒ isPrototypeOf()
propertyIsEnumerable: ƒ propertyIsEnumerable()
toLocaleString: ƒ toLocaleString()
toString: ƒ toString()
valueOf: ƒ valueOf()
__defineGetter__: ƒ __defineGetter__()
__defineSetter__: ƒ __defineSetter__()
__lookupGetter__: ƒ __lookupGetter__()
__lookupSetter__: ƒ __lookupSetter__()
get __proto__: ƒ __proto__()
set __proto__: ƒ __proto__()

想要更清晰的看清楚我上面说的关系，可以借助于这张来自网上的图，画的非常好。

其他内置对象

最后在说一说其他的内置对象，绝大多数内置对象都是函数对象（BigInt，Math，JSON 和 Reflect 不是函数对象），虽然有些不能用 new 操作符（比如 Symbol，有些对象用不用 new 表现一样，比如 Object， Function，Array 等）。所以内置对象的 [[prototype]] 指向 function.prototype。内置对象的 prototype 一般来说就是一个普通的对象（用 function Object() 构造的）。这个对象上挂载了很多该类型可以使用的方法，比如 Array.prototype 有如下属性：

concat: ƒ concat()
constructor: ƒ Array()
copyWithin: ƒ copyWithin()
entries: ƒ entries()
every: ƒ every()
fill: ƒ fill()
filter: ƒ filter()
find: ƒ find()
findIndex: ƒ findIndex()
flat: ƒ flat()
flatMap: ƒ flatMap()
forEach: ƒ forEach()
includes: ƒ includes()
indexOf: ƒ indexOf()
join: ƒ join()
keys: ƒ keys()
lastIndexOf: ƒ lastIndexOf()
length: 0
map: ƒ map()
pop: ƒ pop()
push: ƒ push()
reduce: ƒ reduce()
reduceRight: ƒ reduceRight()
reverse: ƒ reverse()
shift: ƒ shift()
slice: ƒ slice()
some: ƒ some()
sort: ƒ sort()
splice: ƒ splice()
toLocaleString: ƒ toLocaleString()
toString: ƒ toString()
unshift: ƒ unshift()
values: ƒ values()
Symbol(Symbol.iterator): ƒ values()
Symbol(Symbol.unscopables): {copyWithin: true, entries: true, fill: true, find: true, findIndex: true, …}
__proto__: Object

需要注意的一点是，几乎所有内置对象的属性都是不可枚举的，所以无论是 for ... in 还是 Object.keys() 都是无法枚举这些属性的。我们自己也可以在内置对象的 prototype 上添加属性或者方法，让所有该类型的对象都能使用。

基本包装类型 String，Number 和 Boolean 在一般情况下不要使用创建对象的方式来初始化对应的类型。使用这种方式创建的值都是对象（使用 typeof 返回 object），而且所有基本包装类型的对象都会被转换为布尔值 true。看下面的代码。

console.log(typeof String('')) //string
console.log(typeof new String('')) //object
console.log(!!'') //false
console.log(!!String('')) //false
console.log(!!new String('')) //true

console.log(typeof Number(0)) //number
console.log(typeof new Number(0)) //object
console.log(!!0) //false
console.log(!!Number(0)) //false
console.log(!!new Number(0)) //true

console.log(typeof Boolean('')) //string
console.log(typeof new Boolean('')) //object
console.log(!!Boolean('')) //false
console.log(!!new Boolean('')) //true

关于 constructor 和 prototype 有一个有趣的小题目，可以看一看：关于constructor和prototype的思考

参考文章

更换 Apache 到 Nginx

Thu, 10 Sep 2020 12:00:00 GMT

前言

将服务器上的 Apache 升级到 2.4.46 后，内充占用率飙涨，改了 MaxConnectionPerChild 配置到 50 也不见效。2G 的内存占用率已经超过 90，Apache 吃掉了差不多 1G 内存。systemctl restart httpd 以后，很快又把内存吃回去。虽然一直都遇到内存占用的问题，但之前没有这么严重，也就凑活着用了。每次想换 nginx 都觉得太折腾就作罢。现在这情况只能强行折腾了，服务器都卡的用不了了。下面分享一下更换 web 服务器的过程。

过程

其实过程也比较简单，停了 apache。

systemctl stop httpd
systemctl disable httpd

安装 nginx，直接用 yum 安装即可。启动并设置开机启动，同时确保 php-fpm 也启动了。

yum install nginx
systemctl start nginx
systemctl enable ninx

剩下的就是配置了，配置文件路径 /etc/nginx/nginx.conf。nginx 支持模块化的配置，你可以把不同功能的配置写到不同的文件里面，然后用 include 引入。单独的 conf 文件要放到 /etc/nginx/conf.d 文件夹里。如果你不想创建单独的文件，就把配置写在 nginx.conf文件夹里也可以，是一个 server {}。需要特别注意的是你的配置要写到 include /etc/nginx/conf.d/*.conf 这一句的前面。我一开始就是看错成后面，白白乱折腾了一阵子。

然后 nginx 的配置其实还是比较好理解的，但是不支持 .htaccess。关于配置我这里就不细说了，我也就东拼西凑搞了个差不多的，目前看来基本能用了，有些问题可能后期使用中才能慢慢发现，这里就给大家贴一下我现在的配置。

server {
    #http重定向到https
    listen    80;
    listen [::]:80;
    server_name www.clloz.com clloz.com;
    return 301  https://$server_name$request_uri;
}
server {
    listen                  443 ssl http2;
    listen                  [::]:443 ssl http2;
    server_name             www.clloz.com clloz.com;

    #网站根目录
    root            /var/www/html;

    #https
    ssl_certificate         ssl/3793755_www.clloz.com.pem;
    ssl_certificate_key     ssl/3793755_www.clloz.com.key;
    ssl_session_timeout 5m;
    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4; #使用此加密套件。
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2; #使用该协议进行配置。
    ssl_prefer_server_ciphers on;

    # 安全标头
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
    add_header X-Frame-Options DENY;
    add_header X-Content-Type-Options nosniff;
    add_header X-Xss-Protection 1;

    # 禁用目录列表
    autoindex off;

    # 限制请求次数
    #limit_req_zone $binary_remote_addr zone=WPRATELIMIT:10m rate=2r/s;
    #location ~ \wp-login.php$ {
    #    limit_req zone=WPRATELIMIT;
    #}

    #隐藏 nginx 版本.
    server_tokens off;

    #隐藏 PHP 版本
    fastcgi_hide_header X-Powered-By;
    proxy_hide_header X-Powered-By;

    # 禁止访问敏感文件
    location ~ /\.(svn|git)/* {
        deny all;
        access_log off;
        log_not_found off;
    }
    location ~ /\.ht {
        deny all;
        access_log off;
        log_not_found off;
    }
    location ~ /\.user.ini {
        deny all;
        access_log off;
        log_not_found off;
    }

    # 禁止直接访问php文件
#    location ~* /(?:uploads|files|wp-content|wp-includes|akismet)/.*.php$ {
#       deny all;
#       access_log off;
#       log_not_found off;
#    }

    #固定链接交给php-fpm处理
    location / {
        index index.php index.html index.htm;
        try_files $uri $uri/ /index.php?$args;
    }

    # 禁止访问指定类型文件
    location ~ \.(ini|conf)$ {
        deny all;
    }

    # 允许内部分  wp-includes 目录的 .php 文件
    location ~* ^/wp-includes/.*\.(php|phps)$ {
        internal;
    }

    #禁止访问 wp-config.php install.php 文件
    location = /wp-config.php {
        deny all;
    }
    location = /wp-admin/install.php {
        deny all;
    }


    # 禁止访问 /wp-content/ 目录的 php 格式文件 (包含子目录)
    location ~* ^/wp-content/.*.(php|phps)$ {
        deny all;
    }
    # 固定连接的php处理
    location ~* ^/s/.*.(php|phps)$ {
        #deny all;
    return 404;
    }
    location ~* ^/programming/.*.(php|phps)$ {
        #deny all;
    return 404;
    }
    location ~* ^/essay/.*.(php|phps)$ {
        #deny all;
    return 404;
    }
    location ~* ^/sweets/.*.(php|phps)$ {
        #deny all;
    return 404;
    }
    location ~* ^/links/.*.(php|phps)$ {
        #deny all;
    return 404;
    }
    location ~* ^/abouts/.*.(php|phps)$ {
        #deny all;
    return 404;
    }

    location ~* /(?:uploads|files|wp-content|wp-includes|akismet)/.*.php$ {
        deny all;
        access_log off;
        log_not_found off;
    }

    # 错误页面设置
    error_page 403 /403.html;
    location = /403.html {
        root /etc/nginx/error_pages;
        internal;
    }
    error_page 404 /404.html;
    location = /404.html {
        root /etc/nginx/error_pages;
        internal;
    }
    error_page 500 /500.html;
    location = /500.html {
        root /etc/nginx/error_pages;
        internal;
    }
    error_page 503 /503.html;
    location = /503.html {
        root /etc/nginx/error_pages;
        internal;
    }


    location ~ .php$ {
        fastcgi_pass   127.0.0.1:9000;
        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
        include        fastcgi_params;
    }
}

还有一个没有解决的问题就是，php 类型的 url 都交给 php-fpm 处理，当找不到 url 的时候，php-fpm 会直接返回一个 file not found。我们在 nginx 中设置的 404 页面也不会显示。我本来想看看 php-fpm 能不能设置默认 404 页面的，不过没找到方法。nginx 这边也没设么很好的处理方法，我最后的解决办法就是用 location 来过滤固定链接，只要检测到是固定链接，同时路径是以 php 结束的直接返回 404，固定链接一共也就几种(取决于你有几个一级分类目录)。这个方法有一个瑕疵就是根目录下的以 php 结尾的路径无法过滤，因为根目录下有些 php 是要访问的，我们没法一刀切。不过目前也没有找到其他的好办法，就先这样吧，问题也不大。

更新：根目录下路径下的 php 结尾的路径我用正则表达式 ^/(?!(wp-|xmlrpc))[^/]*php$ 进行了处理，把除了 wp- 开头的和 index.php，xmlrpc.php 以外的全部过滤了。除了 wp-content，wp-includes，wp-admin 路径下，其他的带 / 的路径访问 php 都直接返回 404，正则表达式为 ^/(?!wp-content|wp-includes|wp-admin|editormd).*/.*php$。

这里顺便说一下 location 配置指令格式为：location [ = | ~ | ~* | ^~ ] uri {...}。这里的 uri 分为标准 uri 和正则 uri，两者的唯一区别是 uri 中是否包含正则表达式。uri 前面的方括号中的内容是可选项，解释如下：

= ：用于标准 uri 前，要求请求字符串与 uri 严格匹配，一旦匹配成功则停止
~ ：用于正则 uri 前，并且区分大小写
~* ：用于正则 uri 前，但不区分大小写
^~ ：用于标准 uri 前，要求 Nginx 找到标识 uri 和请求字符串匹配度最高的 location 后，立即使用此 location 处理请求，而不再使用 location 块中的正则 uri 和请求字符串做匹配

由于我只是更换 web 服务器，所以还算比较简单，如果你是从头安装，那么你可以看我之前的文章，或者参考腾讯云的这篇教程：手动搭建 LNMP 环境（CentOS 7）

更新内存占用的主要原因是 php-fpm 进程过多，配置一下 /etc/php-fpm.d/www.conf。

pm = dynamic #指定进程管理方式，有3种可供选择：static、dynamic和ondemand。
pm.max_children = 16 #static模式下创建的子进程数或dynamic模式下同一时刻允许最大的php-fpm子进程数量。
pm.start_servers = 10 #动态方式下的起始php-fpm进程数量。
pm.min_spare_servers = 8 #动态方式下服务器空闲时最小php-fpm进程数量。
pm.max_spare_servers = 16 #动态方式下服务器空闲时最大php-fpm进程数量。
pm.max_requests = 2000 #php-fpm子进程能处理的最大请求数。
pm.process_idle_timeout = 10s
request_terminate_timeout = 120

我是将 max_spare_servers 设置为 10，这样最多同时存在 10 个 php-fpm。

Object.create(null) 和 {...}

Thu, 10 Sep 2020 12:00:00 GMT

前言

我们会在一些框架的源码中看到作者用 Object.create(null) 来初始化一个新的对象，和我们平常使用的对象字面量 {} 不同。本文讲解一下这两者的区别。

对象初始化

在 JavaScript 中初始化对象的方法有三种：Object.create()，new Object() 和字面量标记。我们分别来讲一讲三者的区别。

Object.create()

Object.create() 方法接受两个参数，一个是新对象的原型对象，一个是要添加到新对象的属性（可选，是一个对象，添加的属性默认不可枚举，属性的形式参考 Object.defineProperty()）。返回值一个新对象，带着指定的原型对象和属性。

Object.create() 内部的原理参考 MDN 的实现：

//请注意，尽管在 ES5 中 Object.create支持设置为[[Prototype]]为null，但因为那些ECMAScript5以前版本限制，此 polyfill 无法支持该特性。
if (typeof Object.create !== 'function') {
  Object.create = function (proto, propertiesObject) {
    if (typeof proto !== 'object' && typeof proto !== 'function') {
      throw new TypeError('Object prototype may only be an Object: ' + proto)
    } else if (proto === null) {
      throw new Error(
        "This browser's implementation of Object.create is a shim and doesn't support 'null' as the first argument."
      )
    }

    if (typeof propertiesObject !== 'undefined')
      throw new Error(
        "This browser's implementation of Object.create is a shim and doesn't support a second argument."
      )

    function F() {}
    F.prototype = proto

    return new F()
  }
}

Object.create() 可以帮我们实现继承，并且配置属性特性。也可以结合 Object.assign() 来实现多继承。

function MyClass() {
  SuperClass.call(this)
  OtherSuperClass.call(this)
}

// 继承一个类
MyClass.prototype = Object.create(SuperClass.prototype)
// 混合其它
Object.assign(MyClass.prototype, OtherSuperClass.prototype)
// 重新指定constructor
MyClass.prototype.constructor = MyClass

MyClass.prototype.myMethod = function () {
  // do a thing
}

new Object()

在 JavaScript 中，几乎所有的对象都是 Object 类型的实例，它们都会从 Object.prototype 继承属性和方法。Object 构造函数为给定值创建一个对象包装器。用 Object 构造函数创建新的对象，参数接收任何值，但是根据值的不同会产生不同的对象。

如果给定值是 null 或 undefined，将会创建并返回一个空对象（没有给定值也可以认为是 undefined）
如果传进去的是一个基本类型的值，则会构造其包装类型的对象
如果传进去的是引用类型的值，仍然会返回这个值，经他们复制的变量保有和源对象相同的引用地址
当以非构造函数形式被调用时，Object 的行为等同于 new Object()。

在实际编码中我们很少用到这种方式初始化对象。

对象字面量

一个对象初始化器，由花括号{} 包含的一个由零个或多个对象属性名和其关联值组成的一个逗号分隔的列表构成。这是我们最常使用的一种初始化对象的方式。之所以使用最频繁，是因为他是最方便的一种创建对象的方式。我们可以在创建对象的时候同时创建属性，并且在 ES6 之后，字面量方式创建对象添加了更多支持，包括扩展运算符，计算属性名等。

定义属性为 __proto__: 值或 "__proto__": 值时，不会创建名为 __proto__ 属性。如果给出的值是对象或者 null，那么对象的 [[Prototype]] 会被设置为给出的值。注意的是一定要使用冒号的方式定义，不使用冒号标记的属性定义，不会变更对象的原型；而是和其他具有不同名字的属性一样是普通属性定义。下面这些形式都不可以。

var __proto__ = 'variable'

var obj1 = { __proto__ }
console.log(Object.getPrototypeOf(obj1) === Object.prototype) //true
console.log(obj1.hasOwnProperty('__proto__')) //true
console.log(obj1.__proto__ === 'variable') //true

var obj2 = {
  __proto__() {
    return 'hello'
  }
}
console.log(obj2.__proto__() === 'hello') //true

var obj3 = { ['__prot' + 'o__']: 17 }
console.log(obj3.__proto__ === 17) //true

还有一点就是对象字面量虽然和 JSON 很像，但他们不是同一个东西，主要不同点有以下：

JSON 只允许 "property": value syntax 形式的属性定义。属性名必须用双引号括起来。且属性定义不允许使用简便写法。
JSON 中，属性的值仅允许字符串，数字，数组，true，false，null 或其他（JSON）对象。
JSON 中，不允许将值设置为函数。
Date 等对象，经 JSON.parse() 处理后，会变成字符串。
JSON.parse() 不会处理计算的属性名，会当做错误抛出。

Object.create(null) 和 {...}

最后来说一说 Object.create(null) 和 {...} 的区别。

其实很简单，{} 是一个继承自 Object.prototype 的空对象，它能够使用 Object.prototype 上定义的一些方法，比如 hasOwnProperty()，toString() 等。他的结果和 new Object()（可以传 null 或者 undefined 做参数）或者 Object.create(Object.prototype) 是一样的。

而 Object.create(null) 是以继承自 null 的对象，它是一个没有任何属性，包括 [[prototype]]，包括原型的非常**“干净”** 的对象，和 {__porot__: null} 是一样的（不建议用这种方式设置原型）。在 chrome 中打印这个对象然后展开会显示 No properties。

所以他们唯一的区别就是一个有 [[prototype]]，另一个没有。不过我个人认为这是没什么影响的，定义和原型上同名的方法会覆盖原型的方法，而且 Object.prototype 上的所有属性和方法都是不可枚举的，所以 for ... in 也是不会访问到多原型上的属性。两者之间应该也没有很大的性能差异。我也是在想不出有什么不得不用 Object.create(null) 的场景，除非你不希望自己的对象上有除了自己定义以外的能访问的属性🤔。

所以我觉得日常编码中使用哪个都可以，对象字面量肯定更方便。Object.create(null) 可以创建一个更干净的对象，但是由于 Object.prototpye 上的属性都不可枚举，其实也不会产生影响，可以放心使用。

参考文章

Symbol

Thu, 10 Sep 2020 12:00:00 GMT

前言

本文主要讲一讲 ES6 引入的原始数据类型 Symbol。

概念

Symbol 本身的概念并不复杂，就一个独一无二的值。在 ES6 之前，我们只能用字符串作为对象的属性名，这很容易造成属性名冲突。Symbol 就是为了解决这种问题而产生的。

注意 Symbol 函数不是一个构造函数，不能用 new 操作符。Symbol() 函数会返回 symbol 类型的值，该类型具有静态属性和静态方法。它的静态属性会暴露几个内建的成员对象；它的静态方法会暴露全局的 symbol 注册，且类似于内建对象类。

创建一个 Symbol 的语法是 Symbol([description])，参数是可选的，字符串类型，是对 symbol 的描述，可用于调试但不是访问 symbol 本身。每个从 Symbol() 返回的 symbol 值都是唯一的。一个 symbol 值能作为对象属性的标识符；这是该数据类型仅有的目的。

注意，Symbol 函数的参数只是表示对当前 Symbol 值的描述，因此相同参数的 Symbol 函数的返回值是不相等的。

如果 Symbol 函数的参数是一个对象，就会调用该对象的 toString 方法，将其转为字符串，然后才生成一个 Symbol 值。

const obj = {
  toString() {
    return 'abc'
  }
}
const sym = Symbol(obj)
sym // Symbol(abc)

虽然不能用 new 创建一个 Symbol 对象，但是可以通过 Object 方法获得一个包装对象。

var sym = Symbol('foo')
typeof sym // "symbol"
var symObj = Object(sym)
typeof symObj // "object"

Symbol 作为属性名，该属性不会出现在 for ... in、for ... of 循环中，也不会被被 Object.keys()、Object.getOwnPropertyNames()、JSON.toStringify() 返回。但是，它也不是私有属性，有一个 Object.getOwnPropertySymbols() 放法，可以获取指定对象的所有 Symbol 属性名。另一个新的 API， Reflect.ownKeys 方法可以返回所有类型的键名，包括常规键名和 Symbol 键名。由于以 Symbol 值作为名称的属性，不会被常规方法遍历得到。我们可以利用这个特性，为对象定义一些非私有的、但又希望只用于内部的方法。

对于用了 Symbol 作为键名的对象，我们可以用 Object.getOwnPropertySymbols() 方法查找对象的符号属性。该返回一个 symbol 类型的数组。注意，每个初始化的对象都是没有自己的symbol属性的，因此这个数组可能为空，除非你已经在对象上设置了 symbol 属性。

let obj = {
  [Symbol('clloz')]: 'clloz'
}
console.log(Object.getOwnPropertySymbols(obj)) //[ Symbol(clloz) ]

关于 Symbol 的类型转换可以参考我的另一片文章深入 JavaScript 类型转换，这里做一个简单的总结：

尝试将一个 symbol 值转换为一个 number 值时，会抛出一个 TypeError 错误 (e.g. +sym or sym | 0).
使用宽松相等时， Object(sym) == sym 返回 true。
Symbol 值不能与其他类型的值进行运算，会报错，这会阻止你从一个 symbol 值隐式地创建一个新的 string 类型的属性名。例如，Symbol("foo") + "bar" 将抛出一个TypeError can't convert symbol to string。
Symbol 值可以显式转为字符串，用 String() 强制转换或者使用 Symbol.prototype.toString()
Symbol 值也可以转为布尔值，但是不能转为数值。

方法

Symbol 的静态方法有两个 Symbol.for() 和 Symbol.keyFor()。

使用 Symbol() 函数创建的 Symbol，不会在你的整个代码库中创建一个可用的全局的 symbol 类型。要创建跨文件可用的 symbol，甚至跨域（每个都有它自己的全局作用域） , 使用 Symbol.for() 方法和 Symbol.keyFor() 方法从全局的 symbol 注册表设置和取得 symbol。

Symbol.for() 方法会根据给定的键 key，来从运行时的 symbol 注册表中找到对应的 symbol，如果找到了，则返回它，否则，新建一个与该键关联的 symbol，并放入全局 symbol 注册表中。注意，Symbol.for() 只能找到用 Symbol.for() 创建的 Symbol，不能找到用 Symbol() 创建的 Symbol。

Symbol.for() 和 Symbol() 的区别是，Symbol.for() 创建的 Symbol 会被登记在全局环境中共搜索。Symbol.fo() 不会每次都创建一个新的 Symbol，只会在搜索不到的时候创建。

Symbol.for('foo') // 创建一个 symbol 并放入 symbol 注册表中，键为 "foo"
Symbol.for('foo') // 从 symbol 注册表中读取键为"foo"的 symbol

Symbol.for('bar') === Symbol.for('bar') // true，证明了上面说的
Symbol('bar') === Symbol('bar') // false，Symbol() 函数每次都会返回新的一个 symbol

var sym = Symbol.for('mario')
sym.toString()
// "Symbol(mario)"，mario 既是该 symbol 在 symbol 注册表中的键名，又是该 symbol 自身的描述字符串

//为了防止冲突，最好为键名设置前缀
Symbol.for('mdn.foo')
Symbol.for('mdn.bar')

Symbol.keyFor(sym) 方法用来获取全局 symbol 注册表中与某个 symbol 关联的键。即参数是一个 Symbol，如果这个 Symbol 是用 Symbol.for() 在全局注册的，则返回这个 Symbol 的描述符，一个字符串。若没找到则返回 undefined。

let symbol1 = Symbol('clloz')
let symbol2 = Symbol.for('clloz')
console.log(Symbol.keyFor(symbol1)) //undefined
console.log(Symbol.keyFor(symbol2)) //clloz

Symbol() 有原型 Symbol.prototype，你可以使用构造函数的原型对象来给所有 Symbol 实例添加属性或者方法。Symbol.prototype 默认有一个数姓 Symbol.prototype.description，返回对应 Symbol 的描述符。

Symbol.prototype 有几个方法，Symbol.prototype.valueOf()，Symbol.Prototype.toString() 和 Symbol.prototype[Symbol.toPrimitive](hint)。

toString() 方法返回当前 symbol 对象的字符串表示。symbol 原始值不能转换为字符串，所以只能先转换成它的包装对象，再调用 toString() 方法。

Symbol('foo') + 'bar'
// TypeError: Can't convert symbol to string
Symbol('foo').toString() + 'bar'
// "Symbol(foo)bar"，就相当于下面的:
Object(Symbol('foo')).toString() + 'bar'
// "Symbol(foo)bar"

valueOf() 方法返回当前 symbol 对象所包含的 symbol 原始值。在 JavaScript 中，虽然大多数类型的对象在某些操作下都会自动的隐式调用自身的 valueOf() 方法或者 toString() 方法来将自己转换成一个原始值，但 symbol 对象不会这么干，symbol 对象无法隐式转换成对应的原始值。

Object(Symbol('foo')) + 'bar'
// TypeError: can't convert symbol object to primitive
// 无法隐式的调用 valueOf() 方法

Object(Symbol('foo')).valueOf() + 'bar'
// TypeError:  can't convert symbol to string
// 手动调用 valueOf() 方法，虽然转换成了原始值，但 symbol 原始值不能转换为字符串

Object(Symbol('foo')).toString() + 'bar'
// "Symbol(foo)bar"，需要手动调用 toString() 方法才行

关于 Symbol.prototype[Symbol.toPrimitive](hint) 参考深入 JavaScript 类型转换

属性

除了我们自己创建的 Symbol，JavaScript 还内建了一些在 ECMAScript 5 之前没有暴露给开发者的 symbol，它们代表了内部语言行为。在标准中他们以 @@ 开头替代 Symbol，被称为 Well-Known Symbols。

Symbol.iterator：一个返回一个对象默认迭代器的方法。被 for...of 使用。
Symbol.asyncIterator: 一个返回对象默认的异步迭代器的方法。被 for await of 使用。试验性API
Symbol.match: 一个用于对字符串进行匹配的方法，也用于确定一个对象是否可以作为正则表达式使用。被 String.prototype.match() 使用。
Symbol.replace: 一个替换匹配字符串的子串的方法. 被 String.prototype.replace() 使用。
Symbol.search: 一个返回一个字符串中与正则表达式相匹配的索引的方法。被 String.prototype.search() 使用。
Symbol.split: 一个在匹配正则表达式的索引处拆分一个字符串的方法.。被 String.prototype.split() 使用。
Symbol.hasInstance: 一个确定一个构造器对象识别的对象是否为它的实例的方法。被 instanceof 使用。
Symbol.isConcatSpreadable: 一个布尔值，表明一个对象是否应该 flattened 为它的数组元素。被 Array.prototype.concat() 使用。简单说就是表示该对象用于 Array.prototype.concat() 时，是否可以展开。
Symbol.unscopables: 拥有和继承属性名的一个对象的值被排除在与环境绑定的相关对象外。
Symbol.species: 一个用于创建派生对象的构造器函数。
Symbol.toPrimitive: 一个将对象转化为基本数据类型的方法。
Symbol.toStringTag: 用于对象的默认描述的字符串值。被 Object.prototype.toString() 使用。

我们可以看到我们原来使用的一些方法其实就是调用的这些 Symbol 对应的方法。现在 JavaScript 将这些 Symbol 暴露出来我们可以自己配置这些 Symbol。在 ES6 之前，当我们执行这些 Symbol 对应的操作的时候，调用的是引擎内部的默认方法，现在这些 Symbol 暴露出来以后，我们可以自己配置这些 Symbol 对应的一些行为。

Symbol.hasInstance

当我们执行 A instanceof B 的时候其实就是调用的 B 内部的 Symbol.hasInstance 方法。我们可以自己定义对象内部的这个方法，改变对象的行为。

class MyClass {
  [Symbol.hasInstance](foo) {
    return foo instanceof Array
  }
}
console.log([1, 2, 3] instanceof new MyClass()) // true

Symbol.isConcatSpreadable

对象的 Symbol.isConcatSpreadable 属性等于一个布尔值，表示该对象用于 Array.prototype.concat() 时，是否可以展开。

let arr1 = ['c', 'd']
console.log(['a', 'b'].concat(arr1, 'e')) // ['a', 'b', 'c', 'd', 'e']
console.log(arr1[Symbol.isConcatSpreadable]) // undefined

let arr2 = ['c', 'd']
arr2[Symbol.isConcatSpreadable] = false
console.log(['a', 'b'].concat(arr2, 'e'))
//['a', 'b', ['c', 'd', ([Symbol(Symbol.isConcatSpreadable)]: false)], 'e'];

上面代码说明，数组的默认行为是可以展开，Symbol.isConcatSpreadable 默认等于 undefined 。该属性等于 true 时，也有展开的效果。当我们把数组的 Symbol.isConcatSpreadable 设置为 false，在调用 cancat 发现没有展开。

let obj = { length: 2, 0: 'c', 1: 'd' }
console.log(['a', 'b'].concat(obj, 'e')) // [ 'a', 'b', { '0': 'c', '1': 'd', length: 2 }, 'e' ]

obj[Symbol.isConcatSpreadable] = true
console.log(['a', 'b'].concat(obj, 'e')) // ['a', 'b', 'c', 'd', 'e']

类似数组的对象正好相反，默认不展开。将它的 Symbol.isConcatSpreadable 属性设为 true ，就可以展开。

class A1 extends Array {
  constructor(args) {
    super(args)
    this[Symbol.isConcatSpreadable] = true
  }
}
class A2 extends Array {
  constructor(args) {
    super(args)
  }
  get [Symbol.isConcatSpreadable]() {
    return false
  }
}
let a1 = new A1()
a1[0] = 3
a1[1] = 4
let a2 = new A2()
a2[0] = 5
a2[1] = 6
console.log([1, 2].concat(a1).concat(a2)) // [ 1, 2, 3, 4, A2(2) [ 5, 6 ] ]

也可以在类中设置这个属性，可以在构造函数中设置，也可以直接作为原型的访问器属性。

Symbol.species

JavaScript 有个特性，当我们用一个 MyArray 继承 Array 的时候，用 MyArray 创建一个数组，然后用 map 生成一个新的数组。这个新数组的创建调用的是 MyArray 构造函数，而不是 Array 构造函数。这是非常有用的，因为新数组还可以用我们在 MyArray 上定义的方法。但是如果我们希望新数组是以 Array 为构造函数创建的话，就需要用到 Symbol.species 这个访问器属性，它能够修改派生对象的构造函数。注意，使用 new 操作符的时候依然是创建 MyArray 的实例。

class MyArray extends Array {
  // 覆盖 species 到父级的 Array 构造函数上
  static get [Symbol.species]() {
    return Array
  }
}

const a = new MyArray(1, 2, 3)
console.log(a instanceof MyArray) //true
console.log(a instanceof Array) //true

const mapped = a.map((x) => x * x)

console.log(mapped instanceof MyArray)
// expected output: false

console.log(mapped instanceof Array)
// expected output: true

上面代码中，子类 MyArray 继承了父类 Array 。用 new 操作符创建的实例 a 是 MyArray 的实例。但是用 map 创建的实例却不是 MyArray 的实例，而是 Array 的实例。这个例子也说明，定义 Symbol.species 属性要采用 get 读取器。默认的 Symbol.species 属性等同于下面的写法。

class MyArray extends Array {
  static get [Symbol.species]() {
    return this
  }
}

Symbol.match

对象的 Symbol.match 属性，指向一个函数。当执行 str.match(RegExp) 时，如果该属性存在，会调用它，返回该方法的返回值。这个方法用于确定一个对象是否可以作为正则表达式使用，String.prototype.match() 默认就是找参数的这个方法。

有了这个属性之后，即使不是正则对象，我们也可以让 String.prototype.match() 正常执行。

String.prototype.match(regexp)
// 等同于
regexp[Symbol.match](this)

class MyMatcher {
  [Symbol.match](string) {
    return 'hello world'.indexOf(string)
  }
}
'e'.match(new MyMatcher()) // 1

Symbol.replace

Symbol.replace 一个替换匹配字符串的子串的方法。当对象被 String.prototype.replace() 方法调用时，会调用对象上的 Symbol.replace 方法。

String.prototype.replace(searchValue, replaceValue)
// 等同于
searchValue[Symbol.replace](this, replaceValue) // this 就是调用 replace 的字符串

有了这个属性，即使不是正则对象，String.prototype.replace() 也能正常执行。

const x = {}
x[Symbol.replace] = (...s) => console.log(s)
'Hello'.replace(x, 'World') // ["Hello", "World"]

Symbol.search

Symbol.search 指向一个返回一个字符串中与正则表达式相匹配的索引的方法。被 String.prototype.search() 使用。当对象被 String.prototype.search() 方法调用时，会调用对象的这个方法。

String.prototype.search(regexp) // 等同于 regexp[Symbol.search](this)
class MySearch {
  constructor(value) {
    this.value = value
  }
  [Symbol.search](string) {
    return string.indexOf(this.value)
  }
}
'foobar'.search(new MySearch('foo')) // 0

Symbol.split

Symbol.split 指向一个在匹配正则表达式的索引处拆分一个字符串的方法.。被 String.prototype.split() 使用。当对象被 String.prototype.split() 方法调用时，会调用对象的这个方法。split 的第一个参数可以是字符串也可以是正则表达式。

String.prototype.split(separator, limit)
// 等同于
separator[Symbol.split](this, limit)

有了这个属性，我们可以定制 split 的行为：

class MySplitter {
  constructor(value) {
    this.value = value
  }
  [Symbol.split](string) {
    var index = string.indexOf(this.value)
    if (index === -1) {
      return string
    }
    return [string.substr(0, index), string.substr(index + this.value.length)]
  }
}
'foobar'.split(new MySplitter('foo'))
// ['', 'bar']
'foobar'.split(new MySplitter('bar')) // ['foo', '']
'foobar'.split(new MySplitter('baz')) // 'foobar'

Symbol.Iterator

这应该是最重要的一个内置 Symbol，我会在别的文章单独讨论，这里简单说一下。该属性指向一个返回一个对象默认迭代器的方法。被 for...of 和扩展运算符等需要进行迭代是使用。很多内置类型都有默认的 @@iterator 方法：

Array.prototype[@@iterator]()
TypedArray.prototype[@@iterator]()
String.prototype[@@iterator]()
Map.prototype[@@iterator]()
Set.prototype[@@iterator]()

自定义迭代器：

var myIterable = {}
myIterable[Symbol.iterator] = function* () {
  yield 1
  yield 2
  yield 3
}
;[...myIterable] // [1, 2, 3]

Symbol.toPrimitive

Symbol.toPrimitive 指向一个将对象转化为基本数据类型的方法，当一个对象转换为对应的原始值时，会调用此函数。这个方法我在深入 JavaScript 类型转换中已经详细介绍过了。

Symbol.toPrimitive 被调用时，一个对象可被转换为原始值。该函数被调用时，会被传递一个字符串参数 hint ，表示要转换到的原始值的预期类型。 hint 参数的取值是 number、string 和 default 中的任意一个。详细的解析参考上面的那篇文章，这里放一个例子：

// 一个没有提供 Symbol.toPrimitive 属性的对象，参与运算时的输出结果
var obj1 = {}
console.log(+obj1) // NaN
console.log(`{obj1}`) // "[object Object]"
console.log(obj1 + '') // "[object Object]"

// 接下面声明一个对象，手动赋予了 Symbol.toPrimitive 属性，再来查看输出结果
var obj2 = {
  [Symbol.toPrimitive](hint) {
    if (hint == 'number') {
      return 10
    }
    if (hint == 'string') {
      return 'hello'
    }
    return true
  }
}
console.log(+obj2) // 10      -- hint 参数值是 "number"
console.log(`{obj2}`) // "hello" -- hint 参数值是 "string"
console.log(obj2 + '') // "true"  -- hint 参数值是 "default"

Symbol.toStringTag

Symbol.toStringTag 是一个内置 symbol，它通常作为对象的属性键使用，对应的属性值应该为字符串类型，这个字符串用来表示该对象的自定义类型标签，通常只有内置的 Object.prototype.toString() 方法会去读取这个标签并把它包含在自己的返回值里。

许多内置的 JavaScript 对象类型即便没有 toStringTag 属性，也能被 toString() 方法识别并返回特定的类型标签，比如：

Object.prototype.toString.call('foo') // "[object String]"
Object.prototype.toString.call([1, 2]) // "[object Array]"
Object.prototype.toString.call(3) // "[object Number]"
Object.prototype.toString.call(true) // "[object Boolean]"
Object.prototype.toString.call(undefined) // "[object Undefined]"
Object.prototype.toString.call(null) // "[object Null]"
// ... and more

另外一些对象类型则不然，toString() 方法能识别它们是因为引擎为它们设置好了 toStringTag 标签：

Object.prototype.toString.call(new Map()) // "[object Map]"
Object.prototype.toString.call(function* () {}) // "[object GeneratorFunction]"
Object.prototype.toString.call(Promise.resolve()) // "[object Promise]"
// ... and more

但你自己创建的类不会有这份特殊待遇，toString() 找不到 toStringTag 属性时只好返回默认的 Object 标签：

class ValidatorClass {}

Object.prototype.toString.call(new ValidatorClass()) // "[object Object]"

加上 toStringTag 属性，你的类也会有自定义的类型标签了：

class ValidatorClass {
  get [Symbol.toStringTag]() {
    return 'Validator'
  }
}

Object.prototype.toString.call(new ValidatorClass()) // "[object Validator]"

Symbol.unscopables

Symbol.unscopables 指向一个对象。该对象指定了使用 with 关键字时，哪些属性会被 with 环境排除。

console.log(Array.prototype[Symbol.unscopables])
// [Object: null prototype] {
//     copyWithin: true,
//     entries: true,
//     fill: true,
//     find: true,
//     findIndex: true,
//     flat: true,
//     flatMap: true,
//     includes: true,
//     keys: true,
//     values: true
//   }
console.log(Object.keys(Array.prototype[Symbol.unscopables]))
// [
//     'copyWithin', 'entries',
//     'fill',       'find',
//     'findIndex',  'flat',
//     'flatMap',    'includes',
//     'keys',       'values'
//   ]

上面代码说明，数组有 7 个属性，会被 with 命令排除。

// 没有 unscopables 时
class MyClass {
  foo() {
    return 1
  }
}
var foo = function () {
  return 2
}
with (MyClass.prototype) {
  console.log(foo()) // 1
}

// 有 unscopables 时
class MyClass {
  foo() {
    return 1
  }
  get [Symbol.unscopables]() {
    return { foo: true }
  }
}
var foo = function () {
  return 2
}
with (MyClass.prototype) {
  console.log(foo()) // 2
}

JavaScript对象属性类型和赋值细节

Wed, 09 Sep 2020 12:00:00 GMT

前言

在研究 JavaScript 中深浅拷贝的方式的时候遇到一个违反我直觉的内容，就是 JavaScript 对象在和原型对象的情况下的赋值行为。本文介绍一下这部分的一些细节。

问题

在研究 Object.create 方法的时候，发现用 Object.create 创建的对象的时候，给访问到的原型中的属性赋值的时候会在新创建的对象中新建这个属性。看如下代码：

let Obj = {
  a: 1,
  b: 2
}

let obj = Object.create(Obj)

obj.a = 10

console.log(obj, Obj) //{ a: 10 } { a: 1, b: 2 }

我也曾使用这个方法来复制对象的属性。但是今天仔细看里面的细节，发现这是违反我直觉的。我自己的思路是，obj 对象没有 a 属性，所以访问到的是原型 Obj 上的 a 属性，那么我修改属性的时候应该修改的也是原型上的属性。但是实际情况是一个 a 属性在 obj 对象上创建，原型上的 a 属性还保持原来的状态。

其实仔细想一下，这种处理才是合理的。原型存在的目的是为了继承，继承的目的本质也是为了复用。而用来复用的方法或者属性随便就被修改了，会影响到很多其他对象。所以 JavaScript 的这种处理是合理的。

我们可以把原型中的属性认为是一个默认值，当我们的对象没有对应属性的时候，原型能够提供一个默认值给我们，而默认值是不应该随便被修改的。甚至当我们用 delete 删除对象的属性的时候，原型上的同名属性依然是可以访问的，这也正是原型的意义。而且仔细想一想，非常频繁被使用的赋值操作都可以修改原型上的属性的话，将会是非常危险的。

深入

上面我们对属性的赋值的行为举了一个例子，在参考了网络上的其他文章后，我发现这个简单的赋值行为其实还有更多可以研究的行为。

属性类型

在分析具体的情况之前我们先说一下 JavaScript 中对象的属性。JavaScript 中属性分为两种类型，一种是数据属性 data properties，一种是访问器属性 accessor properties。JavaScript 标准还定义了一些用来描述属性的特性 attributes。属性的精确描述方式称为属性描述符 properties descriptor，也是 Object.defineProperty() 方法的第三个参数，数据属性的描述符称为 data descriptor，访问器属性的描述符称为 accessor descriptor。

属性描述符其实就是对属性的精确定义，数据描述符是一个具有值的属性，该值可以是可写的，也可以是不可写的。访问器描述符是由 getter 函数和 setter 函数所描述的属性。一个描述符只能是这两者其中之一，不能同时是两者。这两种描述符都是对象。

数据描述符和访问器描述符都支持支持以下两个 attribute 描述属性：

configurable：特性表示对象的属性是否可以被删除，以及除 value 和 writable 特性外的其他特性是否可以被修改。。默认为 false。configurable 属性设置为 false，则该属性被认为是 不可配置的，并且没有属性可以被改变（除了单向改变 writable 为 false）。当属性不可配置时，不能在数据和访问器属性类型之间切换。
enumerable：当且仅当该属性的 enumerable 键值为 true 时，该属性才会出现在对象的枚举属性中。默认为 false。定义了对象的属性是否可以在 for...in 循环和 Object.keys() 中被枚举。

数据描述符还支持两个独占的 attribute 来描述属性：

value：该属性对应的值。可以是任何有效的 JavaScript 值（数值，对象，函数等）。默认为 undefined。
writable：当且仅当该属性的 writable 键值为 true 时，属性的值，也就是上面的 value，才能被赋值运算符改变。默认为 false。

访问器属性也有两个独占的 attribute （两个都是函数）来描述属性：

get：属性的 getter 函数，如果没有 getter，则为 undefined。当访问该属性时，会调用此函数。执行时不传入任何参数，但是会传入 this 对象（由于继承关系，这里的 this 并不一定是定义该属性的对象，比如是从原型脸上访问到的 get）。该函数的返回值会被用作属性的值。默认为 undefined。 set：属性的 setter 函数，如果没有 setter，则为 undefined。当属性值被修改时，会调用此函数。该方法接受一个参数（也就是被赋予的新值），会传入赋值时的 this 对象。默认为 undefined。

get 和 set 并一定要成对出现，只指定 getter 意味着属性是不能写，尝试写入属性会被忽略。在严格模式下，尝试写入只指定了 getter 函数的属性会抛出错误。类似地，只指定 setter 函数的属性也不能读，否则在非严格模式下会返回 undefined，而在严格模式下会抛出错误。

// this 指向
function myclass() {}

Object.defineProperty(myclass.prototype, 'x', {
  get() {
    return this.stored_x
  },
  set(x) {
    this.stored_x = x
  }
})

var a = new myclass()
var b = new myclass()
a.x = 1 //this 是 a
console.log(b.x) // undefined //this 是 b

拥有布尔值的特性 configurable、enumerable 和 writable 的默认值都是 false。属性值和函数的键 value、get 和 set 字段的默认值为 undefined。默认值在描述符省略某些字段时启用。对于直接用对象字面量或属性访问器（点运算符或者方括号运算符）赋值的方式（比如 obj.a = 10 ）创建的属性其数据描述符中的属性的默认值和 Object.defineProperty() 方法是不同的，参考如下代码：

let a = {
  m: 1,
  set t(arg) {}
}
console.log(Object.getOwnPropertyDescriptors(a))

//{
//  m: { value: 1, writable: true, enumerable: true, configurable: true },
//  t: {
//      get: undefined,
//      set: [Function: set t],
//      enumerable: true,
//      configurable: true
//  }
//}

一个 configurable 为 true 的属性是可以在数据属性和访问器属性之间切换，方法就是用 Object.defineProperty() 方法重新定义一个同名属性。

let a = {}
a.m = 10 //字面量定义，所有的布尔型 attribute 都为 true

Object.defineProperty(a, 'm', {
  get() {
    return 100
  }
})

console.log(a.m) //100

Object.defineProperty(a, 'm', {
  value: 20
})

console.log(a.m) //20

如果一个描述符不具有 value、writable、get 和 set 中的任意一个键，那么它将被认为是一个数据描述符。如果一个描述符同时拥有 value 或 writable 和 get 或 set 键，则会产生一个异常。

无论是数据属性还是访问器属性，都是可以从原型上继承的。如果原型上是一些不希望被修改的默认值，可以用 Object.freeze 冻结源性对象，防止后续代码添加或删除对象原型的属性。

如果原型上有了同名的访问器属性，那么你无法用属性访问器（点运算符或者方括号运算符）赋值的方式，比如 obj.a = 10，在子对象上创建同名属性（只能用 Object.defineProperty() 方法），在子对象上访问或者修改这个属性都会调用原型上的 get 或者 set 方法（如果只指定了一个，那么行为参考上面的 get 和 set 部分）。和访问器属性不一样，数据属性始终在对象自身上设置，而不会影响到原型上的属性。但如果一个不可写的属性被继承，它仍然可以防止修改对象的属性。这也是我们这篇文章讨论的重点。

//只设置set
let value = 10
let a = {
  set m(m) {
    value = m
  }
}
let b = Object.create(a)
console.log(a.m) //没有设置get 返回undefined 严格模式下报错
console.log(b.m) //b对象没有m属性，调用a的get方法。返回undefined，同上
Object.defineProperty(b, 'm', {
  value: 100,
  writable: true,
  configurable: true,
  enmerable: true
})
console.log(b) //{m: 100}
console.log(b.m, a.m) //100 undefined

//只设置get
let value = 10
let a = {
  get m() {
    return value
  }
}
let b = Object.create(a)
console.log(a.m) //10
a.m = 100 //没有设置set，赋值会被忽略，严格模式下报错
console.log(a.m) //10

console.log(b.m) //10, b上面没有m属性，返回a.m
b.m = 100 //属性访问器（点运算符或方括号运算符）无法创建同名属性
console.log(b.m) //10, 依然返回a.m
Object.defineProperty(b, 'm', {
  value: 100,
  writable: true,
  configurable: true,
  enmerable: true
})
console.log(b, b.m) //{m:100} 100
console.log(a.m) //10 a对象不受影响

我们平时可能使用数据属性比较多，但是其访问器属性也有很多应用场景。比如我们属性的 Vue 的双向数据绑定就是用 set 实现的。

赋值行为

原型链上没有同名属性

这是最简单的情况，会直接在子对象上创建一个新的属性。JavaScript 会现在子对象中检索该属性，如果没有找到则会沿着原型链寻找到原型链的终点 null，在原型链的任何位置找到会立即返回找到的值。

let a = {}
let b = Object.create(a)
b.m = 10
console.log(b) //{m: 10}

原型链上有同名可写属性

这种情况就是开头的问题中提到的情况，同样会在子对象上创建新的属性。

let a = {
  m: 2
}
let b = Object.create(a)
b.m = 10
console.log(a) //{m: 2} a对象不变
console.log(b) //{m: 10}

原型链上有同名不可写属性

这种情况下不会在子对象上创建新的属性，赋值也不会执行，在严格模式下会报错。至于为什么这样设计，贺师俊认为是保持 getter-only property（只定义了get 方法的访问器属性，上面详细介绍了）和 non-writable property 行为的一致。You Dont Know Js 则认为是为了保持和传统语言继承表现的一致。

//'use strict'
let a = {}
Object.defineProperty(a, 'm', {
  value: 10,
  configurable: true,
  enumerable: true,
  writable: false
})

console.log(a.m)
a.m = 100 //无效，严格模式下会报错 TypeError: Cannot assign to read only property 'm' of object

let b = Object.create(a)
console.log(b.m)
b.m = 200 //无效，严格模式下报错
console.log(b) //{} 不会创建新的属性

访问器属性

关于访问器属性，我在上一节详细介绍过了。如果不考虑用 Object.defineProperty 来定义属性描述符，我们是无法在子对象上创建新的同名属性的，我们对同名属性的操作都是在调用原型对象上对应属性的 get 和 set 方法，唯一不同的就是方法内的 this 指向会发生变化。

总结

其实对属性类型和赋值行为的讨论，最终还是会回到继承机制的问题上。属性的类型和继承的机制在标准的发展过程中也不是一成不变的，ES5 标准中属性描述里的特性都是没法直接在 JS 中访问和操作的，它只是在实现引擎是使用的。而现在 getter 和 setter 也能够让我们实现一些高级特性。而继承机制需要在很多方面取得一个平衡，比如复用，灵活性和数据的安全性等。

参考文章

JavaScript浅拷贝和深拷贝

Wed, 09 Sep 2020 12:00:00 GMT

前言

JavaScript 中最重要的就是对象，除了 Number, String, Null, Undefined, Boolean, Symbol, BigInt 等基本数据类型，剩下的就 Object 对象。JavaScript 也给我们提供了一系列内置对象，比如 Function，Array，Math，Date，RegExp 等等，他们都是用 function Object() 构造的。我们使用 JavaScript 大多是时候都是在操作对象。本文就讲一讲复制对象涉及到的浅拷贝和深拷贝。

内存堆栈

在讲对象的复制之前我们先来了解一下 JavaScript 中的数据类型在内存中是如何存放的。

每一个数据都需要分配一块内存空间，内存空间分为两种：栈 stack 和堆 heap：stack 为自动分配的内存空间，它由系统自动释放；而 heap 则是动态分配的内存，大小不定也不会自动释。基本类型值是存储在栈中的简单数据段，也就是说，他们的值直接存储在变量访问的位置。堆是存放数据的基于散列算法的数据结构，在 javascript 中，引用值是存放在堆中的。

let a = 10
let b = 20
let obj = {
  name: 'clloz'
}
let obj2 = obj

比如这段代码在内存中的结构应该为：

所以访问基本类型的变量时，是直接访问到栈内存中其真正的值；而访问引用类型的变量时，是通过栈内存中保存的引用地址去访问。

栈的优势就是存取速度比堆要快，仅次于直接位于 CPU 中的寄存器，但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，垃圾收集器会自动地收走这些不再使用的数据，但是缺点是由于在运行时动态分配内存，所以存取速度较慢。所以对于基本数据类型，他们占用内存比较小，如果放在堆中，查找会浪费很多时间，而把堆中的数据放入栈中也会影响栈的效率。比如对象和数组是可以无限拓展的，正好放在可以动态分配大小的堆中。

从上面的例子中我们可以看到，我们将一个对象赋值给一个变量的时候，系统会在栈中为我们分配一块空间，里面存入对象在堆中的地址。obj 和 obj1 指向的是堆中的同一块内存，不管我们用哪个标识符来操作对象中的数据，都会影响到另一个，因为他们本质就是同一个对象的不同名字。而如果是基本数据类型的复制，则直接在栈中将值写入，新变量的改变不会影响到原来的变量。

这就是值传递和地址传递的主要区别，也就是深拷贝和浅拷贝的产生的原因。当我们想要真正地复制一个对象，希望开辟一块新的内存空间，新对象的操作不会影响到原来的对象，就需要用深拷贝的方式。

概念

有了上面对数据类型和内存对战的概念，我们可以来说一说浅拷贝 shallow copy 和深拷贝 deep copy 的概念了。

浅拷贝：只对原始数据类型进行复制，引用类似则是复制其地址引用。也就是说对对象属性中的对象，不会进行递归复制，只会拷贝对象第一层的值类型。
深拷贝：进行递归复制，不仅复制值类型，还对引用类型进行完整的递归复制。

遍历对象的方法

不管是浅拷贝和深拷贝都会涉及到对象的遍历，JavaScript 提供了很多遍历对象的方法，我们先来看看它们有什么不同，方便我们在对应的场景选择合适的遍历方法。

for ... in：遍历对象自身可其原型链上的可枚举属性，不包括 Symbol 属性。
Object.keys()：返回一个数组，包括对象自身的(不含圆形脸上的)所有可枚举属性 (不含 Symbol 属性)。
Object.getOwnPropertyNames()：返回一个数组，包含对象自身的所有属性(不含 Symbol 属性，但是包括不可枚举属性)
Object.getOwnPropertySymbols()：返回一个数组，包含对象自身的所有 Symbol 属性。
Reflect.ownKeys()：返回一个数组，包含对象自身的所有属性，不管属性名是 Symbol 或字符串，也不管是否可枚举。
Object.values()：返回一个给定对象自身的所有可枚举属性值的数组。(不含 Symbol 属性)
Object.entries()：返回一个给定对象自身可枚举属性的键值对数组。(不含 Symbol 属性)

他们遍历属性的顺序都遵循以下几点：

首先遍历所有属性名为数值的属性，按照数字排序。
其次遍历所有属性名为字符串的属性，按照生成时间排序。
最后遍历所有属性名为 Symbol 值的属性，按照生成时间排序。

浅拷贝实现

Object.assingn()

Object.assign() 方法也是常用的浅拷贝方法，该方法只会拷贝源对象自身的并且可枚举的属性到目标对象，String 类型和 Symbol 类型的属性都会被拷贝。看下面的代码：

let a = {
  p1: 10,
  p2: 20,
  p3: {
    m: 100,
    n: 200
  }
}
let b = Object.assign({}, a)
console.log(b) //{ p1: 10, p2: 20, p3: { m: 100, n: 200 } }
b.p1 = 'teste'
console.log(a) //{ p1: 10, p2: 20, p3: { m: 100, n: 200 } } a中的p1没有改变
b.p3.m = 'test'
console.log(a) //{ p1: 10, p2: 20, p3: { m: 'test', n: 200 } } a.m是一个嵌套对象，浅拷贝

关于 Object.assign() 还有需要注意的点就是，该方法只能拷贝源对象的可枚举的自身属性，同时拷贝时无法拷贝属性的特性，而且访问器属性会被转换成数据属性（值为访问器属性的 getter 的返回值，如果访问器属性没有设置 getter，那么值为 undefined）。看下面的例子：

//'use strict'
let a_p = {
  fun: () => console.log('a.[[prototype]]')
}
let a = Object.create(a_p)
let out_var = 'out variable'

Object.defineProperty(a, Symbol('symbol'), {
  value: 'symbol',
  enumerable: true
})

Object.defineProperty(a, 'val', {
  //不可枚举属性
  value: 100,
  configurable: false,
  enumerable: false,
  writable: true
})

Object.defineProperty(a, 'enum', {
  //可枚举属性
  value: 'enumerable',
  configurable: false,
  enumerable: true,
  writable: false
})

Object.defineProperty(a, 'm', {
  //不可枚举的访问器属性
  enumerable: false,
  set(val) {
    this.val = val
  },
  get() {
    return this.val
  }
})

Object.defineProperty(a, 'n', {
  //可枚举的访问器属性
  enumerable: true,
  set(val) {
    a.val = val
  },
  get() {
    return a.val
  }
})

let b = Object.assign({}, a)
console.log(b) //{ enum: 'enumerable', n: 100, [Symbol(symbol)]: 'symbol' } 只有可枚举的数据属性和访问器属性是会被复制的。访问器属性被转换成数据属性，值是调用访问器属性getter的返回值
console.log(Object.getOwnPropertyDescriptor(b, 'enum')) //属性描述符全部变为 true
//{
//  value: 'enumerable',
//  writable: true,
//  enumerable: true,
//  configurable: true
//}
console.log(Object.getPrototypeOf(b) === Object.prototype) //true 没有复制原型

如果想要实现复制属性的特性，访问器属性以及链接原型，可用如下的方法：

let c = Object.create(Object.getPrototypeOf(a), Object.getOwnPropertyDescriptors(a))

原始数据类型作为 source 的时候，字符串会以数组形式，拷贝入目标对象，数字和布尔值则没有效果，这是因为只有字符串的包装对象，会产生可枚举属性。

var v1 = 'abc'
var v2 = true
var v3 = 10
var obj = Object.assign({}, v1, v2, v3)
console.log(obj) // { "0": "a", "1": "b", "2": "c" }

Object.create()

用 Object.create() 也可以实现对象的浅拷贝。主要是结合对象的属性类型和赋值特性，主要是配合 Object.getOwnPropertyDescriptors() 方法获取要拷贝的对象的属性。

const clone = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj))
// 或者
const shallowClone = (obj) =>
  Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj))

当然其实直接用 Object.create(source) 也可以实现 拷贝，我们可以通过访问原型访问到对应的属性，并且如果我们如果给属性赋值，不会影响到原型，具体可以参考另一篇文章：JavaScript对象属性类型和赋值细节。当然这不算传统意义上的拷贝，并且对访问器属性无效。

遍历

还有一个最普遍的浅拷贝方法就是遍历：

function shallowClone(source) {
  var target = {}
  for (var i in source) {
    if (source.hasOwnProperty(i)) {
      target[i] = source[i]
    }
  }
  return target
}

当然也可以用我们上面提到的其他遍历方法。

深拷贝实现

for...in 递归

这个方法是最好理解的，代码如下。注意 for...in 会遍历所有能访问到的属性，包括原型链上的。

let testObj = {
    num: 0,
    str: 'clloz',
    boolean: true,
    unf: undefined,
    nul: null,
    obj: {
        name: 'clloz',
        id: 1
    },
    arr: [0, 1, 2],
    func: function() {
        console.log('clloz')
    },
    date: new Date(0),
    reg: new RegExp('/clloz/ig'),
    err: new Error('clloz')
}

function isObject(obj) {
    return (typeof obj === 'function' || typeof obj === 'object') && obj !== null;
}

function deepClone(obj) {
    if (!isObject(obj)) {
        throw new Error(obj + 'is not a Object!');
    }

    let newObj = Array.isArray(obj); ? [] : {};

    for (let prop in obj) {
        if (obj.hasOwnProperty(prop)) {
            newObj[prop] = isObject(obj[prop]) ? deepClone(obj[prop]) : obj[prop];
        }
    }
    return newObj;
}

let a = deepClone(testObj)
console.log(a)
//{
//  num: 0,
//  str: '',
//  boolean: true,
//  unf: undefined,
//  nul: null,
//  obj: { name: '我是一个对象', id: 1 },
//  arr: [ 0, 1, 2 ],
//  func: {},
//  date: {},
//  reg: {},
//  err: {}
//}

console.log(a.obj === testObj.obj) //false
console.log(a.arr === testObj.arr) //false

最终成功拷贝了 obj 和 arr。func，date，reg 和 err 没有拷贝成功，因为他们不是普通的 Object 结构。

采用 for ... in 递归我们有几个需要注意的细节：

没有对传入参数进行校验，传入 null 时应该返回 null 而不是 {}
要对传入的参数进行判断是否是对象
要对传入参数是数组的情况进行兼容

第一点很好解决，第二点判断对象我们一般可以使用 Object.prototype.toString.call(x) === '[object Object]'，但是这压力需要兼容数组（在这题里面，数组也是一个合法参数），所以我们使用 (typeof obj === 'function' || typeof obj === 'object') && obj !== null。然后创建新对象的时候用 let newObj = isArray ? [] : {} 进行处理。

递归爆栈

如果我们要拷贝的对象层级非常深，有可能导致递归爆栈（一般来说不可能，这里只是讨论解决方案）

//创建一个指定深度和宽度的对象
function createData(deep, breadth) {
  var data = {}
  var temp = data

  for (var i = 0; i < deep; i++) {
    temp = temp['data'] = {}
    for (var j = 0; j < breadth; j++) {
      temp[j] = j
    }
  }

  return data
}
function clone(source) {
  var target = {}
  for (var i in source) {
    if (source.hasOwnProperty(i)) {
      if (typeof source[i] === 'object') {
        target[i] = clone(source[i]) // 注意这里
      } else {
        target[i] = source[i]
      }
    }
  }

  return target
}
clone(createData(1000)) // ok
clone(createData(10000)) // Maximum call stack size exceeded
clone(createData(10, 100000)) // ok 广度不会溢出

解决的方案就是用循环代替递归，把横向的嵌套对象想象成一个纵向的树，然后用栈和循环来处理。开始将跟元素放入栈中，每次从栈中取一个节点进行拷贝，如果拷贝过程中遇到对象则放入栈中，循环从栈中取元素，知道栈空，则拷贝完毕。

function clone(obj) {
  if (!isObject(obj)) return obj
  //创建一个新对象用来复制
  let root = {}

  //创建一个栈，栈中的第一个元素就是 root，不断从栈中取出元素，遍历元素的 data 中的属性复制到 parent 中
  let stack = [
    {
      parent: root, //这里栈中第一个元素设置 key 为 undefined，用来判断是否是跟节点
      key: undefined,
      data: obj
    }
  ]

  while (stack.length) {
    const node = stack.pop()
    const parent = node.parent
    const key = node.key
    const data = node.data

    let res = parent
    if (key !== undefined) res = parent[key] = {}

    for (let key in data) {
      if (Object.prototype.hasOwnProperty.call(data, key)) {
        if (isObject(data[key])) {
          stack.push({
            parent: res,
            key: key,
            data: data[key]
          })
        } else {
          res[key] = data[key]
        }
      }
    }
  }
}

function isObject(obj) {
  return (typeof obj === 'function' || typeof obj === 'object') && obj !== null
}

循环引用

我们在深拷贝的 JSON 序列化部分说到了循环引用会引起序列化报错的问题。但时期我们的 for...in 方法遇到循环引用一样会出问题。

比如上面的例子，我们为 testObj 添加一个属性 loop: testObj，在执行会发现栈溢出了 RangeError: Maximum call stack size exceeded。

如果你用了 lodash 的 baseClone 会发现它的执行不会报错，因为它用栈来保存克隆的对象，用来检测循环引用。

// Check for circular references and return its corresponding clone.
stack || (stack = new Stack())
const stacked = stack.get(value)
if (stacked) {
  return stacked
}

我这里写了一个简单的实现，用一个 WeakMap 来保存嵌套的对象，每进入一层对象就在 Set 中保存起来，每次要递归之前，检测该对象是否已在 Set 中，如果不在才进行递归。每次递归完一个对象时，将该对象从 set 中删除。

function cloneDeep3(source, hash = new WeakMap()) {
  if (!isObject(source)) return source
  if (hash.has(source)) return hash.get(source) //查询该对象是否在 WeakMap 中

  var target = Array.isArray(source) ? [] : {}
  hash.set(source, target) // 注意这里的键名是源对象中的对象，键值是新对象中的

  for (var key in source) {
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      if (isObject(source[key])) {
        target[key] = cloneDeep3(source[key], hash) // 新增代码，传入哈希表
      } else {
        target[key] = source[key]
      }
    }
  }
  return target
}

如果要兼容 ES6 之前的代码，不能使用 WeakMap，及使用数组来保存，需要增加一个遍历数组的逻辑，因为不想 WeakMap 有 has 方法。

function cloneDeep3(source, uniqueList) {
  if (!isObject(source)) return source
  if (!uniqueList) uniqueList = [] // 新增代码，初始化数组

  var target = Array.isArray(source) ? [] : {}

  // ============= 新增代码
  // 数据已经存在，返回保存的数据
  var uniqueData = find(uniqueList, source)
  if (uniqueData) {
    return uniqueData.target
  }

  // 数据不存在，保存源数据，以及对应的引用
  uniqueList.push({
    source: source,
    target: target
  })
  // =============

  for (var key in source) {
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      if (isObject(source[key])) {
        target[key] = cloneDeep3(source[key], uniqueList) // 新增代码，传入数组
      } else {
        target[key] = source[key]
      }
    }
  }
  return target
}

// 新增方法，用于查找
function find(arr, item) {
  for (var i = 0; i < arr.length; i++) {
    if (arr[i].source === item) {
      return arr[i]
    }
  }
  return null
}

// 用上面测试用例已测试通过

JSON 序列化和反序列化

用 JSON.stringify() 和 JSON.parse() 进行序列化反序列化。先将一个 JavaScript 对象转为一个 JSON 字符串，然后再将字符串转为对象。这种方法不能复制非枚举属性，也不能复制属性特性，也不能复制访问器属性。而且JSON.parse()和 JSON.stringify() 能正确处理的对象只有 Number、String、Array 和 Boolean 等能够被 json 表示的数据结构，因此函数，RegExp这种不能被 json 表示的类型将不能被正确处理。

还有一点存在循环引用的对象，例如 let a = {m:a} 这样的对象序列化会报错 TypeError: Converting circular structure to JSON。

这个方法根据自己的需求使用。

第三方库

jQuery.extend, baseClone -lodash，还有 lodash自定义深拷贝方法 cloneDeepWith。有兴趣可以去阅读以下源码。

Symbol

如果属性的 key 是一个 Symbol，那么 for...in 无法遍历到该属性。这里我们可以用 Reflect.ownKeys() 方法。也可以使用 Object.getOwnPropertySymbols() 方法。

function deepClone(obj) {
  if (!isObject(obj)) {
    throw new Error('obj 不是一个对象！')
  }

  let isArray = Array.isArray(obj)
  let newObj = isArray ? [...obj] : { ...obj }
  Reflect.ownKeys(newObj).forEach((key) => {
    newObj[key] = isObject(obj[key]) ? deepClone(obj[key]) : obj[key]
  })

  return newObj
}

不可枚举属性

关于不可枚举属性的深拷贝，我想到的是用 Object.getOwnPropertyNames 来遍历添加。如果遇到 value 是对象则递归。不过很多内置对象需要单独处理，比如 Function，RegExp，Date 等。这种需求几乎不存在，看一看就好。

let testObj = {
  num: 0,
  str: 'clloz',
  boolean: true,
  unf: undefined,
  nul: null,
  obj: {
    name: 'clloz',
    id: 1
  },
  arr: [0, 1, 2],
  func: function () {
    console.log('clloz')
  },
  date: new Date(0),
  reg: new RegExp('/clloz/ig'),
  err: new Error('clloz')
}
Object.defineProperty(testObj, 'test', {
  value: {
    name: 'clloz',
    age: 28
  },
  writable: true,
  enumerable: false,
  configurable: true
})

function isObject(obj) {
  return (
    typeof obj === 'object' &&
    obj !== null &&
    obj instanceof RegExp !== true &&
    obj instanceof Date !== true
  )
}

function deepClone(obj) {
  if (!isObject(obj)) {
    throw new Error('obj is not a Object!')
  }

  let isArray = Array.isArray(obj)

  let newObj = isArray ? [] : {}

  let keys = Object.getOwnPropertyNames(obj)

  for (let key of keys) {
    if (isObject(Object.getOwnPropertyDescriptor(obj, key).value)) {
      Object.defineProperty(newObj, key, {
        value: deepClone(obj[key]),
        configurable: Object.getOwnPropertyDescriptor(obj, key).configurable,
        enumerable: Object.getOwnPropertyDescriptor(obj, key).enumerable,
        writable: Object.getOwnPropertyDescriptor(obj, key).writable
      })
    } else {
      Object.defineProperty(newObj, key, Object.getOwnPropertyDescriptor(obj, key))
    }
  }
  return newObj
}

let a = deepClone(testObj)
console.log(Object.getOwnPropertyDescriptors(a))
console.log(a.obj === testObj.obj) //false
console.log(a.arr === testObj.arr) //false

这个实现在加上 Symbol的处理，循环引用的处理基本就可以应对大多数情况了。如果你还想增加对原型的支持，那么可以在创建对象的时候用 Object.create()。

总结

如果要实现一个能应对各种对象各种情况的深拷贝函数还是非常不容易的，本文处理的情况包括：

Symbol：用 Reflect.ownKeys() 或者 Object.getOwnPropertySymbols()
for-in：遍历原型链上的属性，如果不需要原型上的方法，可以添加判断。
递归爆栈
循环引用的处理
Object.getOwnPropertyNames: 实现非枚举属性的拷贝

在日常的编码中我们不太会遇到这么复杂的情况，大多数情况下我们要深拷贝的对象用 for...in 或者序列化就可以处理了。扩展这么多主要是为了加深对 JavaScript 对象的理解。

参考文章

CentOS7 Apache 开启 HTTP/2 支持

Mon, 07 Sep 2020 12:00:00 GMT

前言

Apache Httpd 从 2.4.17 开始支持 mod_http2，不过 CentOS 7 的 httpd 版本一直停留在 2.4.6。今天详细说明一下如何安装升级 Apache 的最新版本和开启 HTTP/2 的支持。

关于 HTTP/2

HTTP/2 简称为 h2（基于 TLS/1.2 或以上版本的加密连接）或 h2c（非加密连接），是 HTTP 协议的的第二个主要版本。是 HTTP协 议自 1999 年 HTTP 1.1 发布后的首个更新，主要基于 SPDY 协议。

HTTP/2 标准于 2015年5月 以 RFC 7540 正式发表。HTTP/2 的标准化工作由 Chrome、Opera、Firefox、Internet Explorer 11、Safari、Amazon Silk及 Edge 等浏览器提供支持。

多数主流浏览器已经在 2015 年底支持了该协议。此外，根据 W3Techs 的数据，截至 2019年6月，全球有 36.5% 的网站支持了 HTTP/2。

关于 HTTP/2 这里就不再详细介绍了，想要了解的可以参考 HTTP/2 - Wikipedia 和我的另一篇文章前端网络基础和HTTP。

HTTP/2 的优势可以看这篇知乎上的文章：怎样把网站升级到http/2

升级 Apache

首先是要升级 Apache 的版本，你可以用 yum info httpd 查看一下 CeontOS 7 软件库中的 Apache 版本，不出意外是 2.4.6。

CodeIT 提供了一个很好的自定义库。这个库提供了最新版本的服务器软件(Apache & Nginx)。在安装 CodeIT 库之前，你需要开启 EPEL 。EPEL 提供了 CodeIT 库需要的依赖。

sudo yum install -y epel-release

cd /etc/yum.repos.d && wget https://repo.codeit.guru/codeit.el`rpm -q --qf "%{VERSION}" $(rpm -q --whatprovides redhat-release)`.repo

此时我们再用 yum info httpd 查看 Apache 版本会发现已经到最新的版本了(我今天安装的是 2.4.46)。

安装依赖

需要安装的依赖主要是 openssl 和 nghttp2，其中 openssl 版本要大于 1.0.2，不过这两个依赖在 CentOS 7 软件库中都是有的，直接用 yum 安装即可。

yum install openssl nghttp2

配置 httpd.conf

这里参考 Apache 的官方文档即可，文档也有中文版。

根据文档中的说明，我们需要加载 mod_http2 模块，这个模块是依赖于上面安装的 nghttp2 的。然后就是添加一行配置即可。

# 加载 mod_http2
LoadModule http2_module modules/mod_http2.so

# 配置文件中添加指令，该指令允许h2协议，并让其成为服务器连接上的首选协议
Protocols h2 http/1.1

# 要启用所有 HTTP/2 变体时，使用如下指令
Protocols h2 h2c http/1.1

# 根据放置此指令的位置，它会影响所有连接或仅影响到某个虚拟主机的连接。比如下面的配置仅允许使用 HTTP/1 进行连接，但与提供 HTTP/2 的test.example.org的 SSL 连接除外。
Protocols http/1.1
<VirtualHost ...>
    ServerName test.example.org
    Protocols h2 http/1.1
</VirtualHost>

到这里就已经完成全部配置，systemctl restart httpd 即可。此时打开浏览器的开发者工具访问自己的网站会发现 HTTP/2 已经生效。除了通过开发者工具，这个 http2-test 网站也可以帮助你检测网站是否开启 HTTP/2 的支持。$

内存占用

如果 Apache 出现内存占用过高，那么修改 httpd-mpm.conf 中的 prefork 工作模式的参数，将 MaxConnectionPerChild 改为 50。文件位置用命令 find / -name httpd-mpm.conf 查找。更多内容参考文章 Apache内存溢出的分析与解决

参考文章

JavaScript逻辑运算符

Thu, 03 Sep 2020 12:00:00 GMT

前言

关于 JavaScript 中的逻辑运算符，我们经常使用却可能不知道它的一些机制和用法。

机制

首先我们需要知道几种逻辑运算符的优先级是不同的（关于完整的运算符优先级，看运算符优先级），逻辑非>逻辑与>逻辑或>条件运算符（三目运算符）。运算顺序条件运算符是从右向左，而逻辑与和逻辑或都是从左向右。

//表达式的优先级导致结果不同
;(false && true) || true // 结果为 true
false && (true || true) // 结果为 false

逻辑运算表达式返回的是字表达式的值，而不是一个 Boolean，只不过很多时候我们使用逻辑表达式的地方帮我们强制转换了，比如 if 语句等。

逻辑运算符通常用于布尔型（逻辑）值。这种情况下，它们返回一个布尔值。然而， && 和 || 运算符会返回一个指定操作数的值，因此，这些运算符也用于非布尔值。这时，它们也就会返回一个非布尔型值。

逻辑与 expression1 && expression2 的机制是，如果 expression1 能够转换为 true 那么返回 expression2 ，否则返回 expression1。

逻辑或 expression1 || expression2 的机制是，如果 expression1 能够转化为 true 那么返回 expression1，否则返回 expression2。

逻辑非 !expression ，若 expression 能够转化为 true 则返回 false，否则返回 true。

expression 可能是任何一种类型, 不一定是布尔值。

会被转化为 false 的表达式有：

null
NaN
0
空字符串（"" or '' or ``）
undefined

需要特别注意的是 undefined，有些表达式返回的是 undefined ，比如没有设置 return 的函数执行的返回值就是 undefined。

尽管 && 和 || 运算符能够使用非布尔值的操作数, 但它们依然可以被看作是布尔操作符，因为它们的返回值总是能够被转换为布尔值。如果要显式地将它们的返回值（或者表达式）转换为布尔值，请使用双重非运算符（即!!）或者 Boolean 构造函数。

双重非运算符 !! 可以将任意值强制转换为布尔值，在需要条件判断的地方经常使用。

短路计算

逻辑运算的机制还存在短路计算：

(some falsy expression1) && (expression2) 短路计算的结果为假。
(some truthy expression1) || (expression2) 短路计算的结果为真。

短路意味着上述表达式中的 expression2 部分不会被执行，因此 expression2 的任何副作用都不会生效（举个例子，如果 expression 是一次函数调用，这次调用就不会发生）。造成这种现象的原因是，整个表达式的值在第一个操作数被计算后已经确定了。

用法

利用 javascript 中逻辑运算符支持任意类型和短路计算的特性我们可以将逻辑运算符运用到一些特殊的地方。

逻辑与

逻辑与可以用来获得第一个假值，比如 expr1 && expr2 && expr3，当其中存在假值的时候会被返回。也可以类推至前面的表达式都为真的时候执行最后一个表达式来简化判断逻辑的代码，比如 x > 0 && a()，这可以代替 if 语句。

逻辑或

逻辑或可以用来设置默认值，比如你的函数需要用户输入一个参数，如果用户没有输入则给定一个默认值。this.a = param || {}。

npm常用命令

Wed, 02 Sep 2020 12:00:00 GMT

前言

整理 npm 常用的一些命令，方便查看。

通用命令

帮助命令

npm <command> -h  #快速查看某条命令的简单使用帮助，包括语法和别名。
npm -l            #显示所有可用命令和说明
npm help <term>   #查看命令的详细帮助

初始化

npm init    #在命令行所在的文件夹初始化一个项目（创建 package.json 文件）
npm init --yes    #跳过配置，强制yes

模块

通用命令

npm root    #查看本地安装的目录

npm root -g    #查看全局安装的目录

npm info package    #查看包信息

npm info "package@latest" peerDependencies #查看包依赖

npm ls    #查看本地安装包

npm ls -g    #查看全局安装包，包含依赖

npm ls -g --depth 0    #查看全局安装包，不包含依赖

npm outdated    #列出所有不是最新版的包，可以带参数

npm cache clean    #清除本地缓存

npm config ls -l    #查看npm配置

npm view package versions    #查看包的所有版本

npm publish     #发布包

npm access    #设置发布包的访问级别

npm search    #搜索registry

安装模块

我们经常在 package.json 看到包的版本号之前有 ~ ^ * x 等符号，这些符号是 semantic-versioning 语义化版本控制。版本号形如 major.minor.patch，分别表示 主版本号.次版本号.修补版本号。

没有任何修饰符的版本号表示必须匹配某个具体版本号。

< <= > >= 即字面上的意思。

~ 波浪线表示如果 minor 版本号指定了，那么 minor 版本号不变，而 patch 版本号任意，如果 minor 和 patch 版本号未指定，那么 minor 和 patch 版本号任意，如果 patch 版本号也制定了，则从指定的数字为范围的下限。下面是 npm 官方文档的一些例子。

~1.2.3 := >=1.2.3 <1.(2+1).0 := >=1.2.3 <1.3.0
~1.2 := >=1.2.0 <1.(2+1).0 := >=1.2.0 <1.3.0 (Same as 1.2.x)
~1 := >=1.0.0 <(1+1).0.0 := >=1.0.0 <2.0.0 (Same as 1.x)
~0.2.3 := >=0.2.3 <0.(2+1).0 := >=0.2.3 <0.3.0
~0.2 := >=0.2.0 <0.(2+1).0 := >=0.2.0 <0.3.0 (Same as 0.2.x)
~0 := >=0.0.0 <(0+1).0.0 := >=0.0.0 <1.0.0 (Same as 0.x)

^ 尖括号表示版本号中最左边的非 0 数字的右侧可以任意。

^1.2.3 := >=1.2.3 <2.0.0
^0.2.3 := >=0.2.3 <0.3.0
^0.0.3 := >=0.0.3 <0.0.4

x 表示该位置任意，* 和 "" 则表示任意版本。

关于版本号的语法参考官方文档。

可以用连字符表示版本号范围，比如 1.2.3 - 2.3.4 等价于 >=1.2.3 <=2.3.4，可以用空格来表示逻辑与，|| 表示逻辑或，如：<1.0.0 || >=2.3.1 <2.4.5 || >=2.5.2 <3.0.0，表示满足这 3 个范围的版本都可以。

~

npm install package    #局部安装模块，安装在命令行所在的文件夹；并将模块依赖写入到 package.json 文件的 dependencies 中（生产环境）
#简写
npm i package

npx install-peerdeps  package #安装包的同时安装所有依赖

npm install --save-prod package    #局部安装时将模块依赖写入到 package.json 文件的 dependencies 中（生产环境），这是默认值，除非指定其他值，所以一般不需要输入这个参数
#简写
npm install -P package

npm install --save-dev package    #局部安装时将模块依赖写入到 package.json 文件的 devDependencies 中（开发环境）
#简写
npm install -D package

npm install --save-optional package #局部安装时将模块依赖写入到 package.json 文件的 optionalDependencies 中.
#简写
npm install -O package

npm install --no-save package #局部安装时阻止模块依赖写入到 package.json 文件的 devDependencies 中.

npm install -g package    #全局安装模块

#从github仓库安装
npm install git://github.com/package/path.git
npm install git://github.com/package/path.git#0.1.0

npm install <packageName> --force    #强制重新安装

#安装指定版本
npm install sax@latest
npm install sax@0.1.1
npm install sax@">=0.1.0 <0.2.0"

#安装beta版
npm install <module-name>@beta (latest beta)
npm install <module-name>@1.3.1-beta.3

#只安装package.json中的dependencies字段的模块
npm install --production
NODE_ENV=production npm install

这里讲一讲 dependencies，devDependencies，optionalDependencies 的区别，在 npm 5.0.0 之前，局部安装的包是默认不写入 package.json 中的，那时候需要将模块依赖手动加入 package.json，后来有个命令就是 npm install --save package 或者 npm install -S package，会将模块依赖写入到 dependencies 中，不过在 5.0.0 之后模块依赖默认写入到 dependencies 中，我们已经不需要为 npm install 添加额外的参数了，现在的缺省参数是 npm install --save-prod package 或者 npm install -P package。所以就我们现在的使用来说，生产环境的的包安装直接 npm install 即可，开发环境的包 npm install -D 即可。

那么这几种依赖有什么区别呢？大致总结如下：

dependencies：应用依赖，或者叫做业务依赖，它用于指定应用依赖的外部包，这些依赖是应用发布后正常执行时所需要的，但不包含测试时或者开发时所使用的包，比如打包工具之类。
devDependencies：开发环境依赖，它的对象定义和 dependencies 一样，只不过它里面的包只用于开发环境，不用于生产环境，这些包通常是单元测试或者打包工具等，例如 gulp, grunt, webpack, moca, coffee 等。
optionalDependencies：可选依赖，如果有一些依赖包即使安装失败，项目仍然能够运行或者希望 npm 继续运行，就可以使用 optionalDependencies。另外 optionalDependencies 会覆盖 dependencies 中的同名依赖包，所以不要在两个地方都写。举个栗子，可选依赖包就像程序的插件一样，如果存在就执行存在的逻辑，不存在就执行另一个逻辑。
peerDependencies：可以理解为子依赖，有时我们安装的包会依赖于其他的包。关于这一点可以参考官方文档以及探讨npm依赖管理之peerDependencies

卸载模块

npm uninstall package    #卸载局部模块

npm uninstall -g package    #卸载全局模块

更新模块

npm update package    #更新局部模块

npm update -g package    #更新全局模块

npm update -g package@version   #更新全局模块 package-name 到 x.x.x 版本

npm 镜像

npm install express --registry https://registry.npm.taobao.org    #临时使用

npm config set registry https://registry.npm.taobao.org    #永久更换 可以用 npm config get registry或npm info

npm config set registry https://registry.npmjs.org    #设置为默认镜像

也可以安装 nrm 管理 npm 源，安装命令 npm install -g nrm，它内置了如下源：

npm ---- https://registry.npmjs.org/
cnpm --- http://r.cnpmjs.org/
taobao - https://registry.npm.taobao.org/
nj ----- https://registry.nodejitsu.com/
rednpm - http://registry.mirror.cqupt.edu.cn/
npmMirror https://skimdb.npmjs.com/registry/
edunpm - http://registry.enpmjs.org/

主要有如下几个命令：

ls：列出所有可用 registries
current：列出当前使用的 registry
use <registry>：切换源
add <registry> <url> [home]：添加一个自定义的源
del <registry>：删除一个自定义源
home <registry> [browser]：打开指定源的主页
test [registry]：查看指定源的连接情况（响应时间）
help：查看帮助

npm的包管理机制

关于 package.json 的详细剖析和实际工作中的包管理实践，参考抖音前端整理的npm的包管理机制

参考文章

npm模块管理器

软件版本周期 - Wikipedia

Wed, 02 Sep 2020 12:00:00 GMT

前言

本文转自维基百科。

开发期

`Pre-alpha`

有时候软件会在 Alpha 或 Beta 版本前先发布 Pre-alpha 版本。一般而言相对于 Alpha 或 Beta 版本，Pre-alpha 版本是一个功能不完整的版本。

Alpha

Alpha 版本仍然需要测试，其功能亦未完善，因为它是整个软件发布周期中的第一个阶段，所以它的名称是 Alpha，希腊字母中的第一个字母 α。

Alpha 版本通常会送到开发软件的组织或某群体中的软件测试者作内部测试。在市场上，越来越多公司会邀请外部客户或合作伙伴参与其测试。这令软件在此阶段有更大的可用性测试。

在测试的第一个阶段中，开发者通常会进行白盒测试。其他测试会在稍后时间由其他测试团体以黑盒或灰盒技术进行，不过有时会同时进行。

Beta

Beta 版本是软件最早对外公开的软件版本，由公众（通常为公司外的第三方开发者和业余玩家）参与测试。因为是 Alpha 的下一个阶段，所以为希腊字母的第二个字 Beta (β)。一般来说，Beta包含所有功能，但可能有一些已知问题和较轻微的程序错误（BUG），要进行调试（debug）。Beta版本的测试者通常是开发软件的组织的客户，他们会以免费或优惠价钱得到软件。Beta 版本亦作为测试产品的支持和市场反应等。

其他情况不同企业有不同的称法，例如微软曾以 Community Technology Preview（简称 CTP，中文称为“社区技术预览”）为发布软件的测试版本之一，微软将这个阶段的软件散布给有需要先行试用的用户或厂商，并收集这些人的使用经验，以便作为进一步修正软件的参考。

Release Candidate

Release Candidate（简称 RC）指可能成为最终产品的候选版本，如果未出现问题则可发布成为正式版本。在此阶段的产品通常包含所有功能、或接近完整，亦不会出现严重问题。

多数开源软件会推出两个 RC 版本，最后的RC2则成为正式版本。闭源软件较少公开使用，微软公司在 Windows 7 上应用此名称。苹果公司把在这阶段的产品称为 Golden Master Candidate（简称GM Candidate），而最后的 GM 即成为正式版本。

完成期

生产商发放（`Release to Manufacting`，`RTM`）

生产商发放（Release to Manufacturing，缩写 RTM）是软件产品准备交付时使用的术语，来自于以前还需要使用实体载具（光盘，硬盘等）来进行安装的时代。某些计算机程序以 RTM 作为软件版本代号，例如微软 Windows 7 发行零售版前的 RTM 版本主要是发放给组装机生产商用，使制造商能够提早进行集成工作或解决软件与硬件设备可能遇到的错误。RTM 版本并不一定意味着创作者解决了软件所有问题；仍有可能向公众发布前更新版本。以 Windows 7 为例：RTM 版与零售版的版本号是一样的。

一般可用 GA

一般可用（General availability, 缩写 GA）是所有必要的商业活动已经完成，该软件产品已经可以发售的阶段。然而，这取决于语言、地域和电子设备与媒体的可用性，有些地区之间可能会有上市时间的延迟。商业活动可能也包括安全性和合法测试，以及本地化和全球销售的可能性评估。RTM 与 GA 的间隔可能会是 1 周或几个月，因为在此过程中需要进行许多商业活动。在这个阶段，可以说软件已经“上线”了。

网络分发 RTW

网络分发（Release to Web，缩写 RTW），或称 Web 发布是一种利用互联网进行分发的软件交付方式。制造商在这种类型的发布中并不生产实体软件工具，而会借由 OTA 来进行发放。随着互联网使用人数的增长，RTW 变得越来越普遍。

稳定版 Stable

稳定版本来自预览版本释出使用与改善而修正完成，通常是初始版本进行几个小更新后的版本。为目前所使用的软件在符合需求规格的硬件与操作系统中运行不会造成严重的不兼容或是硬件冲突，其已受过某定量的测试无误后所释出者。

其他

原始设备制造商（`Original Equipment Manufacturer`，`OEM`）

给计算机厂商随着计算机贩卖的，也就是随机版。只能随机器出货，不能零售。只能全新安装，不能从旧有操作系统升级。包装不像零售版精美，通常只有一张 CD 和说明书(授权书)。

零售版 RTL

Retail正式上架零售版。

组织团体批量许可 VOL

Volume OR Volume License for Organizations 政府部门或大型商业机构批量购买的版本。

CSS 选择器 Selector

Sun, 30 Aug 2020 12:00:00 GMT

前言

去年曾经仔细地学习了一下css2.2的规范。其中，选择器，属性的赋值、层叠和继承，盒模型，视觉格式化模型 几章是最重要的，其实去看这个规范的原因很简单，自己在使用 css 的过程中，经常出现让自己很迷惑的问题，比如 inline-block 布局为什么两个块之间出现空隙，vertical-align 怎么有时有用有时没用，行内元素的高度怎么计算的等等，以往遇到这些问题只能依靠搜索引擎，但是依然不得要领，后面就到 w3c 去找规范看了看，其实内容也不是非常多，但是要理解透彻还是要结合不断的实践，不然感觉看懂了，理解了，很快又会忘了。

什么是 CSS 选择器

CSS选择器是我们在前端写样式的时候每天都要用到的，刚接触 CSS 的时候就会用到 类选择器，ID选择器，子选择器，后代选择器等等，说白了选择器的目的就是准确地定位到我们想要赋予样式的元素，我们只要掌握 CSS 的语法和模式匹配的规则，那么我们在使用选择器的时候就能够得心应手了。

模式匹配 Pattern matching

模式匹配的规则看下图，不管你的选择器是简单的类型选择器，还是丰富的上下文选择器，如果模式中的所有条件对于某个元素都为真，那么选择器就会匹配该元素。这里面有我们熟悉的类型选择器（标签），后代选择器，子选择器，兄弟选择器，属性选择器，伪类选择器。其实我们平时用的最多的类选择器和ID选择器，在 HTML 里面也属于属性选择器的范畴，比如途中的E#myid写成E[id="myid"]也是可以匹配的。

选择器语法

在我刚开始写 CSS 的时候，类型和属性，属性和属性之间，是否有空格，逗号，把我搞得很迷糊，踩了不少坑，晚上文章虽多却很少有写的透彻的。其实这也就是选择器语法的问题。复杂的选择器也是由简单选择器通过连接符来构成的，简单选择器包括：类型选择器（标签选择器），属性选择器（包括类选择器和ID选择器），伪类，伪元素，通配符选择器。而连接符一般就是空白符，> 和 + ，不过要注意的是我们一般使用 > 和+ 也会在它们和选择器之间留空白符比如 .a > .b 而不会写成 .a>.b，主要是为了可读性。除了上面说到的三个连接符，还有一个逗号需要提一下，在规范中被称之为分组（ grouping ），就是当几组选择器具有相同的声明的时候我们可以把他们当作一个分组来处理，比如：

h1 {
  font-family: sans-serif;
}

h2 {
  font-family: sans-serif;
}

h3 {
  font-family: sans-serif;
}

h1,
h2,
h3 {
  font-family: sans-serif;
}

他们是等价的。

所有 CSS 关键字都是 ASCII case-insensitive 的。

选择器类型

简单选择器 simple selector：单个元素的单个条件。包括 type selector, universal selector, attribute selector, class selector, ID selector, pseudo-class。
复合选择器 compound selector：一组没有被关系符分隔的简单选择器，表示单个元素的多个同时发生的条件。type selector 和 universal selector 必须放在最前面，并且只能允许有一个 universal selector 或 type selector。一个元素要匹配复合选择器就要匹配其中的所有简单选择器。
关系符 combinator：关系符是处于两个复合选择器之间的一个表示关系的条件。有后代关系符 descendant combinator （用空格表示），子代关系符 child combinator（用 > 表示），相邻兄弟关系符 next-sibling combinator （用 + 表示）和兄弟关系符 subsequent-sibling combinator（用 ~ 表示）。
复杂选择器 complex selector：即一个或多个复合选择器和关系符组成的选择器。

关于相邻兄弟选择器和兄弟选择器这里说明一下区别：

<!-- 对于math + p这样的相邻兄弟选择器，只有当p紧跟在math后面的时候才会匹配 -->
<div>
  <math></math>
  <p></p>
</div>

<!-- 对于h1 ~ pre这样的兄弟选择器，pre不需要紧跟在h1后面，只要共享父元素即可匹配 -->
<h1>Definition of the function a</h1>
<p>Function a(x) has to be applied to all figures in the table.</p>
<pre>function a(x) = 12x/13.5</pre>

通配符选择器，类型选择器

通配符选择器就是选择所有元素，一般是不建议使用的。类型选择器就是我们理解的标签选择器，他可以匹配文档树中所有该类型元素。

后代选择器

当我们想要选择某个元素的后代元素，比如匹配所有 h1 元素包裹的 em 元素，我们就会用 h1 em { color: red;} 这种表达方式，后代元素可以有多层，一个后代选择器由两个或者多个选择器由用空白符隔开的选择器组成，注意，此处的多个选择器不一定非要是简单选择器，比如我们可以这样 p .a.b.c { color: blue;}来选择被p包裹的同时具有 a，b，c 三个类的元素。还有一个场景就是当我们想选择某个元素的所有非子元素的后代的时候我们可以这样写 div * p {display: inline-block;}，需要注意，这里的 * 不是连接符，而是通配符选择器。

子选择器

子选择器匹配某个元素的子集元素，子选择器可以和后代选择器类比，子选择器是后代选择器的子集，因为它只检索一层，而后代选择器则要检索对应元素的全部子元素。子选择器用连接符 > 连接两个或多个选择器，同样这里的选择器不一定是简单选择器。不同类型的选择器是可以一起使用的，比如 div ul > li p {font-size: 1.2em} 匹配了作为 div 后代的无序列表 ul 的子级li 的后代 p 元素。

一般兄弟选择器

~ 组合器选择兄弟元素，也就是说，后一个节点在前一个节点后面的任意位置，并且共享同一个父节点。语法：A ~ B，例子：p ~ span 匹配同一父元素下，<p> 元素后的所有 <span> 元素。注意 B 必须是在 A 后面。

紧邻兄弟选择器

+ 组合器选择相邻元素，即后一个元素紧跟在前一个之后，并且共享同一个父节点。语法：A + B，例子：h2 + p 会匹配所有紧邻在 <h2> 元素后的 <p> 元素。注意先后顺序， B 必须在 A 后面。

属性选择器

属性选择器有几种表达方式

[attr] : 匹配拥有属性 attr 的元素，无论属性值是多少；
[attr=val]: 匹配拥有属性 attr 且属性值为 val 的元素；
[attr~=val] : 匹配拥有属性 attr 且 attr 属性值中包含 val 的元素（ DOM 元素的属性可以包含多个属性值，每一个属性值对应一个属性节点，我们常用的 class 属性就可以有多个值，用逗号分隔开，该条规则同样适用于 attr 属性值只有一项的元素）。
[attr|=val] :匹配一个有 attr 属性且值以 val 开头后面紧跟着 - ( U+002D )的元素。*[lang|="en"] {color: red;} 就会匹配下面代码的前三行。
[attr^="val"] : 匹配拥有属性 attr 且属性值是以 val 开头的元素。
[attr$="val"] : 匹配拥有属性 attr 且属性值是以 val 结尾的元素。
[attr*="val"]: 匹配拥有 attr 属性，且属性值包含 val 的元素。（只要 attr 属性中的任意一项包含val字符串就匹配该模式）

5，6，7 三项都是在 CSS2.1 规范之后发布的。

<p lang="en">Hello!</p>
<p lang="en-us">Greetings!</p>
<p lang="en-au">G'day!</p>
<p lang="fr">Bonjour!</p>
<p lang="cy-en">Jrooana!</p>

类选择器

类选择器其实也是属性选择器的一种，我们平时使用的 . 其实和刚刚属性选择器中的第三个表达方式 [attr~=val] 是同样的作用。当我们需要同时匹配多个属性的时候，我们可以将多个属性写到一起，不适用空白符 p.marine.pastoral { color: green }。

ID 选择器

注意，一个元素只能拥有一个 id，并且文档树中的元素不可以具有相同的 ID，如果同一个元素两次设置 ID，那么只有前面一个生效；如果两个元素设置了相同的 ID，他们的样式都会生效，但是如果你用 js 获取 ID 对应的元素只有第一个会被返回。

伪元素和伪类

伪元素和伪类在CSS2.2 中的第五章 Selector 中进行了介绍。但也有一个独立的Selectors Level 3标准，现在 CSS 很多模块都是单独的标准。

CSS 2.2 中，样式通常是根据元素在文档树中的位置添加的。这种简单模型在大多数情况下足够了，但在有些常见的排版场景下可能无法根据文档树的结构来添加样式。例如，HTML 4 中，没有元素对应的是一个段落的第一行。

为了允许根据文档树之外的信息来格式化，CSS 引入了伪元素和伪类的概念。伪元素建立了对超出文档语言指定的文档树的抽象。例如，文档语言不提供访问元素内容的第一个字母或者第一行的机制。CSS伪元素允许样式表设计者引用这个通过其它方式无法访问的信息。伪元素也给样式表设计者提供了一种给源文档中不存在的内容赋予样式的方法（例如，::before 和 ::after 伪元素提供了访问生成的内容的方法）

伪类根据元素的特征分类，而不是名字，属性或者内容。原则上，这些特征无法从文档树推断得出。伪类可以是动态的，用户与文档交互时，一个元素可能获得或者失去一个伪类。:first-child 是个特例，可以根据文档树推断出来，而且 :lang()在某些情况下也能根据文档树推断出来。伪元素和伪类都不会出现在源文档或者文档树中，伪类允许出现在选择器的任何位置，而一个伪元素只能跟在选择器的最后一个简单选择器后面。

有些伪类是互斥的，而其它的可以同时用在一个元素上。在规则冲突的情况下，常规层叠顺序决定结果。需要注意的是伪类和伪元素同样参与优先级的计算，伪类和普通类相同，伪元素和普通元素相同。

伪元素

伪元素有单独的标准：CSS Pseudo-Elements Module Level 4。目前兼容性达到可用的伪元素一共有四个 ::first-letter，::first-line，::before，::after。

::first-line表示的是 contents of the first formatted line of its originating element.。必须作用于包含块 block container 才能生效。一个元素的 first formatted line 一定是在它的流内块级后代内（这里的块级不是元素，而是块盒即可）。比如 display 为 table-cell 或者 inline-block 的后代流内元素的第一行就不会匹配到 ::first-line。

<!-- div::first-line{color: red;} 生效的是 etcetera -->
<div>
  <p style="display: inline-block">hello<br />goodbye</p>
  etcetera
</div>

上面的代码如果我们给 div 设置了一个宽度，让 etcetera 不在第一行出现，那么这个元素就没有能够匹配 ::first-line 的部分了。

还有一点需要注意的是，直接出现在块级元素中的文本按视觉格式化模型来说应该是生成的 anonymous inline box，内部也应该是行内格式上下文，不过依然能够匹配 ::first-line 的样式，这里是和标准有些出入的。

<!-- div::first-line{color: red;} 会对div内的文本生效 -->
<div>this is a test this is another test</div>

再来看下面两个例子的比较

<style>
  div {
    width: 300px;
  }

  div::first-line {
    color: red;
  }
  div span {
    color: green;
  }

  div p {
    color: green;
  }
</style>
<div>
  <span>This is a somewhat long HTML paragraph that will be broken into several lines.</span> The
  first line will be identified by a fictional tag sequence. The other lines will be treated as
  ordinary lines in the paragraph.
</div>

<div>
  <p>This is a somewhat long HTML paragraph that will be broken into several lines.</p>
  The first line will be identified by a fictional tag sequence. The other lines will be treated as
  ordinary lines in the paragraph.
</div>
```html 最后的效果如下图： ![first-line1](./images/first-line1.png "first-line1") 如果我们将第一个
`div span` 的 `color: green` 注释掉，得到的结果如下图： ![first-line1](./images/first-line2.png
"first-line2") 如果我们在第二个 `div` 的 `p` 元素之前插入一个空的 `div` ，则 `div::first-line`
失效。 综合以上的例子，我自己对 `first-line` 做一个总结：`first-line` 只对 `block container`
生效，生效位置就是 `the first formatted line of its originating element`。`first formatted line`
的规则： 1.
如果内部是行内格式上下文，则表示渲染后的第一行，若第一行文本有行内级元素额外设置了样式，则会覆盖
`::first-line`。 2. 如果内部是块级格式上下文，则表示渲染后的第一行中非 `tabel-cell` 和
`inline-block` 的部分。 3. 注意所谓的渲染后的第一行内可能没有文本，比如一个空的 `span` 或者 `p`
元素甚至就元素内部开头的 `br` ，但它们对应的就是 `first formatted line`。如 `
<p>
  <br />First...`，这里的第一行对应的就是 `p` 和 `br` 之间的内容，后面的 `First` 并不能匹配
  `::first-line`。 4. 如果第一行存在元素嵌套则递归调用者几条规则。 * * * 讲清楚了 `::first-line`
  以后 `::first-letter` 就简单了，`first-letter` 就是 `the first formatted line of originating
  element` 的第一个字母。但是需要注意的是，有些 `::first-line` 生效的情况 `::first-letter`
  也不存在。比如 `
</p>

<div>
  <p style="display: inline-block">hello<br />goodbye</p>
  etcetera
</div>
` 就没有 `::first-letter`。类似 `
<div>
  <br />
  this is a test
</div>
` 同样也没有 `::first-letter`。 * * * `::before` 和 `::after` ：只要他们的 `content` 不为
`none`，他们的表现就像 `originating element`
的紧邻的子元素一样。他们也可以像普通的文档元素一样设置样式，虽然他们并不在文档树中。
需要特别注意的是 `::before` 和 `::after` 一样会参与 `::first-line` 和 `::first-letter`
的计算。比如下面的例子中的第一个 `N` 就会设为红色。 ```html
<style>
  p.note::before {
    content: 'Note: ';
  }
  p::first-letter {
    color: red;
  }
</style>
<p class="note">test</p>

伪类 Pseudo-classes

伪类是简单选择器，它允许基于文档树之外的信息进行选择，或者使用其他简单的选择器可能难以表达或无法表达这些信息。它们也可以是动态的，即在用户与文档交互时元素可以获取或丢失伪类的意义上，而无需更改文档本身。伪类不会出现在文档源或文档树中，也不会对其进行修改。

伪类的语法为一个 :，后跟伪类的名称作为 CSS 标识符，如果是函数型伪类，则包含一对括号，其中包含它的参数（比如 :lang() 就是一个 functional pseudo-class，而 :valid 就是一个 regular pseudo-class）。我将目前标准中的所有伪类都整理出来，见下图。

注意伪类和伪元素不一样，他不是依附于某个文档元素的。伪元素的 :: 前必须由一个文档元素，但是不是所有伪类伪类不是这样。比如 :root，div :first-child 都是合法的伪类使用方法，前者表示根元素，后者表示 div 的第一个子元素。而当使用 div p:first-child 则表示 div 的第一个子元素要同时是一个 p 元素才能匹配，即p:first-child 组成了一个复合选择器，这里要把:first-child 当做一个普通的类。

不过直接使用伪类而不使用其他简单选择器复合的话（比如 div :first-child 等），在嵌套情况比较复杂的时候是比较难分析的，比如下面的例子。

<style>
  ul :last-child {
    color: red;
    font-weight: bold;
  }
  ul :nth-last-child(1) {
    color: blue;
  }
</style>
<ul>
  <li>
    Item 1
    <ul>
      <li>Item 3.1</li>
      <li>Item 3.2</li>
      <li>Item 3.3</li>
    </ul>
  </li>
  <li>
    Item 2
    <ul>
      <li>Item 3.1</li>
      <li>Item 3.2</li>
      <li>Item 3.3</li>
    </ul>
  </li>
  <li>Item 3</li>
</ul>

最外层的 ul 选择了 item3 没有问题，内层嵌套的 ul 内部所有子元素全部都被选中。原因就是内部的 ul 都是 li 的 last-child，所以样式就应用到了整个 ul 上。如果我们把选择器改成 ul > *:last-child 就没有问题。

所以还是建议大家使用伪类的时候用 p:first-child 这样的复合选择器，如果确实有找不同类型的子元素需求，则可以像上面的例子中一样用后代关系符和通配符选择器 ul > *:last-child。

结构伪类

:root：匹配文档的根元素。一般的 html 文件的根元素是 html 元素，而 SVG 或 XML 文件的根元素则可能是其他元素。
:empty：匹配除空格外没有孩子（包括元素，HTML entity，文本节点）的元素。
:nth-child(an + b): 根据位置匹配兄弟元素，n 为自然数，a 和 b 都必须为整数，并且元素的第一个子元素的下标为 1。标准中还有一种 of 语法，不过目前只有 safari 支持。一般使用都会添加父元素，否则会在全部文档生效。比如 div p:nth-child(2n + 1)，匹配 div 内处于奇数位的 p 元素，注意的是要同时满足奇数和 p 才能匹配。注意这里的计算都是以元素为单位，<br> 也是元素。2n 与 even 等价，2n+1 与 odd 等价。下面举了一个简单的例子，更多示例请查看:nth-child() - MDN
```

<style>
  div p:nth-child(2n + 1) {
    color: red;
  }
  div::before {
    content: 'test';
  }
</style>
<div>
  <p>1</p>
  <span>2</span>
  <span>3</span>
  <p>4</p>
  <p>5</p>
  <p>6</p>
  <p>7</p>
</div>
```
:nth-last-child(): 和 :nth-child() 类似，不同的是从末尾开始计数。
:first-child: 匹配一组兄弟元素中的第一个，比如 div > p:first-child 表示匹配 div 的 p 子元素中的第一个，要同时满足 p 和第一个。需要注意的是 div > p:first-child ， div p:first-child 和 div :first-child（有空格）的不同。
```

<style>
  div :first-child {
    color: red;
  }
</style>

<div>
  <div>1</div>
  <div>
    <div>2</div>
  </div>
</div>
```
:last-child: 匹配一组兄弟元素中的最后一个。
:only-child: 匹配一个没有兄弟元素的元素。比如 div > p:only-child 表示当 div 中只有一个 p 元素时匹配。和 :first-child:last-child 或 :nth-child(1):nth-last-child(1) 效果相同，不过前者的优先级更低。
:nth-of-type()：语法和 :nth-child() 类似，但是它的选择范围不再是所有兄弟元素，而是根据给定的类型筛选出相同类型的标签作为范围。比如 img:nth-of-type(2n + 1) 就表示匹配所有奇数位置的 img 兄弟元素。
:nth-last-of-type(): 和 :nth-of-type() 类型，不过是从末尾开始计数。比如 body > h2:nth-of-type(n+2):nth-last-of-type(n+2) 选中 body 中除了第一个和最后一个的 h2 元素，等价于 body > h2:not(:first-of-type):not(:last-of-type)。
:first-of-type: 等价于 :nth-of-type(1)。
:last-of-type: 等价于 :nth-last-of-type(1)。
:only-of type: 等价于 :first-of-type:last-of-type

逻辑伪类

:is(): 原来的名字是 :match()，一些旧的浏览器上用的是 :any()。该伪类函数将选择器列表作为参数，并选择该列表中任意一个选择器可以选择的元素。这对于以更紧凑的形式编写大型选择器非常有用。
:not(): 该伪类函数用来匹配不符合一组选择器的元素。由于它的作用是防止特定的元素被选中，它也被称为反选伪类（negation pseudo-class）。需要注意的是，内部参数不能有伪元素，也不能有 :not() 本身。
:where(): 该伪类和 :is() 的语法和功能完全按相同，不同的是 :is() 的优先级是由参数列表中优先级最高的选择器决定的，而 :where() 的优先级总是 0。目前只有 firefox 实现了这个伪类。
:has(): 对某个元素，参数对应的选择器至少匹配个子元素。比如 a:has(> img) 匹配含有子元素 img 的 a 元素。目前没有浏览器实现。

状态伪类

:hover: 适用于用户使用指示设备虚指一个元素（鼠标指针虚指在某个元素但没有激活）的情况。这个样式会被任何与链接相关的伪类重写，像 :link, :visited, 和 :active 等。为了确保生效，:hover规则需要放在 :link 和 :visited 规则之后，但是在 :active 规则之前，按照 LVHA 的循顺序声明 :link－:visited－:hover－:active。
:active: 匹配被用户激活的元素。它让页面能在浏览器监测到激活时给出反馈。当用鼠标交互时，它代表的是用户按下按键和松开按键之间的时间。一般被用在 <a> 和 <button> 元素中. 这个伪类的一些其他适用对象包括包含激活元素的元素，以及可以通过他们关联的 <label> 标签被激活的表格元素。
:focus: 示获得焦点的元素（如表单输入）。当用户点击或触摸元素或通过键盘的 tab 键选择它时会被触发。
:focus-within: 表示一个元素获得焦点，或，该元素的后代元素获得焦点。换句话说，元素自身或者它的某个后代匹配 :focus 伪类。该选择器非常实用。举个通俗的例子：表单中的某个 <input> 字段获得焦点时，整个表单的 <form> 元素都可被高亮。
:focus-visible: 实验功能，当元素匹配 :focus 伪类并且客户端( UA )的启发式引擎决定焦点应当可见(在这种情况下很多浏览器默认显示“焦点框”。)时，:focus-visible 伪类将生效。这个选择器可以有效地根据用户的输入方式(鼠标或键盘)展示不同形式的焦点。

链接伪类

:link: 选中元素当中的链接.
:any-link: 匹配一个有链接锚点的元素，而不管它是否被访问过，也就是说，它会匹配每一个有 href 属性的 <a>、<area> 或 <link> 元素。因此，它会匹配到所有的 :link 或 :visited。
:visited: 匹配用户已访问过的链接。出于隐私原因，可以使用此选择器修改的样式非常有限。
:target: 匹配一个唯一的页面元素(目标元素)，其 id 与当前 URL 片段匹配。比如当前页面 URL 为 http://www.example.com/index.html#section2，则 :target 将会匹配一个 id 为 section2 的元素。
:scope: 表示作为选择器要匹配的参考点元素。当前，在样式表中使用时, :scope 等效于 :root，因为目前尚无一种方法来显式建立作用域元素。当从 DOM API 使用，如（querySelector(), querySelectorAll(), matches(), 或 Element.closest()）, :scope 匹配你调用 API 的元素。

表单伪类

:enabled: 表示任何被启用的（enabled）元素。如果一个元素能够被激活（如选择、点击或接受文本输入），或者能够获取焦点，则该元素是启用的。元素也有一个禁用的状态（disabled state），在被禁用时，元素不能被激活或获取焦点。
:disabled: 表示任何被禁用的元素。如果一个元素不能被激活（如选择、点击或接受文本输入）或获取焦点，则该元素处于被禁用状态。元素还有一个启用状态（enabled state），在启用状态下，元素可以被激活或获取焦点。
:read-only: 表示元素不可被用户编辑的状态（如锁定的文本输入框）。
:read-write: 匹配可以被用户编辑的元素。
:placeholder-shown: 在 <input> 或 <textarea> 元素显示 placeholder text 时生效。
:default: 表示一组相关元素中的默认表单元素，可以理解为给默认选项一个特殊状态，告诉用户哪个选项是默认的。该选择器可以在 <button>, <input type="checkbox">, <input type="radio">, 以及 <option> 上使用。
:checked: 表示任何处于选中状态的radio, checkbox 或 select 元素中的option HTML元素。用户通过勾选/选中元素或取消勾选/取消选中，来改变该元素的 :checked 状态。
:indeterminate: 表示状态不确定的表单元素。indeterminate 属性可以用 JavaScript 进行设置，布尔型。这个属性可以影响的元素包括 indeterminate 属性为 true 的 checkbox；同 name 的所有 radio 都未被选中或没设置 name 的 radio；状态不确定的 <progress> 元素。
:blank: 匹配用户输入为空的输入框，如 <input> 和 <textarea>。目前尚未有浏览器支持。
:valid: 内容验证正确的 <input> 或其他 <form> 元素。这能简单地将校验字段展示为一种能让用户辨别出其输入数据的正确性的样式。
:invalid: 任意内容未通过验证的 <input> 或其他 <form> 元素。可以突出显示用户的错误输入。
:in-range/:out-range: 代表一个 <input> 元素，其当前值处于属性 min 和 max 限定的范围之内/之外。该伪类仅适用于那些拥有（或可以接受）取值范围设定的元素，包括 type 为 date，time，week，month，datetime-local，number 和 range。
:required: 任意设置了 required 属性的 <input> ，<select> , 或 <textarea> 元素。这个伪类对于高亮显示在提交表单之前必须具有有效数据的字段非常有用。
:optional: 表示任意没有 required 属性的 <input>，<select> 或 <textarea> 元素使用它。该伪类可让表单展示可选字段并且渲染其外观。

语言相关伪类

:dir(): 匹配特定文字书写方向的元素。试验性功能，只有 firefox 实现。
:lang(): 基于元素语言来匹配页面元素。可以用 quotes 属性来根据语言设置引号。

总结

CSS 的标准目前还是非常快的变化阶段，我们主要还是掌握一些核心用法，一些特别的用法可能会持续在标准中发生变化，如果

参考文章

几个有用的 Mac 命令

Sun, 30 Aug 2020 12:00:00 GMT

前言

在 Linux常用命令中介绍了一些在 Linux 中的常用命令。虽然 Mac OS X 和 Linux 都是基于 Unix 的，但是有些系统命令并不是通用的，本文就介绍一些只有 Mac 上可以使用的比较有用的命令。

pbcopy 和 pbpaste

原来我想复制一个文件中的内容，都是用 cat 命令打印出来然后复制，或者直接在软件中打开文件后再全选复制。在 Mac 中其实有命令可以直接实现这个功能，就是 pbcopy 和 pbpaste。这两个命令打通了终端和剪贴板。它们不仅可以复制文件，也可以结合其他命令进行使用。

#将主目录的文件列表复制到剪贴板
ls ~ | pbcopy

#将任意文件的内容复制到剪贴板
pbcopy < filename.txt

mdfind

mdfind 是 Mac 上更强大的文件搜索命令，可以理解为命令行版的 spotlight。

#按文件名关键字查找文件：
mdfind -name keyword

#查找文件内容中包含关键字的文件
mdfind "key string"

#-onlyin 参数指定搜索范围
mdfind -onlyin ~/Library txt

launchctl

Mac 上没有 systemctl 和 services 命令。管理服务的命令是 launchctl，我个人觉得不是很好用，如果你有使用 homebrew 也可以使用 homebrew 的 services 管理命令 brew services。

#加载一个服务到启动列表
sudo launchctl load -w /System/Library/LaunchDaemons/ssh.plist
#卸载一个服务
sudo launchctl unload  /System/Library/LaunchDaemons/ssh.plist
#查看服务
sudo launchctl list | grep <<Service Name>>
#停止
sudo launchctl stop <<Service Name>>
#开始
sudo launchctl start <<Service Name>>
#kill
sudo launchctl kill <<Service Name>>

say

say 命令使用 VoiceOver 给你朗读文本，比较特别的是你可以选择语言和发音（需要安装 System Preferences -> Accessibility -> Speech）。

参考文章

8个不可不知的Mac OS X专用命令行工具

Alfred入门

Fri, 28 Aug 2020 12:00:00 GMT

前言

Mac 系统本身提供了 spotlight 来供用户查询应用、文稿及其他文件等信息，但是我个人觉得不是很好用，一直都没怎么用过。Alfred 以前也听说过，但是没有详细了解，我一直也为很鸡肋。不过今天仔细研究了一下感觉确实是一个能提高 Mac 使用效率的工具。本文讲一下该软件的一些基础用法。

购买安装

软件有两个版本，single license 和 mega supporter，前者可以在两台设备上上使用当前版本（即小版本可以更新，大版本不能更新，你买的 4.x 版本就不能更新到 5.x），后者就是在以太设备上永久更新。现在绝大多数买断制的软件都是这种模式。价格分别是 29£ 和 49£，真的是有点贵，我是在淘宝上买的那种授权版。

也可以使用免费版，那样的话你只能进行基础的文件查找。

功能

Alfred 提供了非常丰富的功能，所有功能的调用方式都是以命令的形式，和终端的感觉类似，只不过它能在任何环境下直接启动，比较方便。

基础设置

基础设置中主要就是设置开机启动和调用快捷键。我的快捷键设置为双击 ⌘ 启动 Alfred。

在默认的查找结果中（即没有给出任何执行的情况下），可以选择哪些文件类型或文件夹需要被检索。这里我就添加了两个文件夹到 Search Scope 中，一个是 ~ 文件夹，一个是我的 SD 卡的对应的 Volume。如果你查找某个文件夹没有找到，那么可以检查一下是否对应的文件夹不在软件的检索范围。

如果没有检查到任何结果，默认情况下会显示三个查询选项：在谷歌，亚马逊，维基中查找。

查询出的选项除了可以用 ⌘ 加上数字进行选择。

文件查找

文件查找分为两个部分，一个是基础的 file search；另一个是 action，即对查找到的文件夹进行一些操作。

file search 的部分主要有四个指令 open，find，in 和 tags。open 和 find 都非常简单，in 是用来查询文本内容是否包含某一串字符；tags 则是查询文件夹标记的（估计大部分人很少使用，除了默认的几个颜色标记还可以在 Finder 的 Preferences 中添加），比如你有一个 tags 是 工作，那么你用 tags 工作 就能找到打了这个 tag 的文件夹。

文件查询也支持导航，你可以用左右方向键进入或退出文件夹，previous 执行可以打开上次打开的文件夹的父文件夹。

action 则是和文件相关的一系列操作，我们用 find 指令找到对应文件夹选项后，点击 ⌃ （可以自己录制快捷键）就可以打开操作面板，选择你想要的操作。操作包括在 finder 中查看，复制文件，复制路径等。

Web Search 和 Web Bookmarks

这两个功能就比较简单，Web Search 就是提供了一些常用网站的查询链接，直接可以输入关键词加查询内容直接在浏览器中打开查询页面，只是一个简化操作而已。软件自己提供了常用的一些网站，你也可以根据自己的需求添加，

Web Bookmarks 也很好理解，就是检索内容包括了浏览器的书签（只支持 safari 和 chrome），也就是你只要保存了一个书签，直接调出 Alfred 的查询框就可以进行模糊查询，这一功能还是非常方便的。

剪切板历史

这个功能也是比较好用的，它能够记录我们进行剪切复制操作的历史，包括了文本，图片和文件。只要输入关键词 clipboard 就能够进行查询（也可以录制快捷键）。

计算器和字典

这两个功能都不用说太多，比较简单也很好用。Mac 自带的字典不是很好用，也没有发音，建议使用下面插件部分介绍的有道词典。

snippets

这个功能可以称为模板，有时候我们需要在一些地方填写自己的地址邮件等比较长的文本，我们可以预先在软件中写好模板，然后只要在任意文本框内输入指令就会直接转化成我们模版中的内容。比如你的地址用关键词 \\address 为名字记录成模版，然后在任意文本框中输入 \\address 会自动替换为你的地址。

系统指令

Alfred 还提供了丰富的 Mac 系统功能对应的指令，比如锁屏，重启，关机，清空回收站，音量调节，强制关闭等等。

终端

Alfred 也支持直接执行终端命令，指令为 <，默认调用的终端是 terminal。如果你跟我一样使用的是 iTerm，那么你就参考更换默认终端为iTerm2 进行更换。不过根据我的实际使用情况，这个功能比较鸡肋，因为每次都还是在终端打开一个新的 tab，然后执行指令，不是很好用。

插件

目前没有一个专门管理插件的网站，如果你想寻找插件，可以到官网以及官方论坛。其他的只能借助搜索引擎查询或者按照自己的需求写一个。下面放一下我尝试的插件的链接。

其实插件功能就类似于 Mac 的 automator，不过它提供了更多更人性化的支持。关于自己写 workflow 我还在研究，，给几篇文章大家参考一下。

把自己日常的工作流形成 workflow，能够极大的提高我们在 Mac 上的使用效率，这也是 Alfred 最强大的功能，不过需要一点学习成本。

参考文章

CSS标准

Fri, 28 Aug 2020 12:00:00 GMT

前言

CSS 的知识本身就是比较庞杂，难以成体系，而且标准化也不像 ECMAScript 和 HTML 有一份完整的标准。一般我们查询 CSS 的内容都是到 MDN 上进行查询，如果想要查询 W3C 的标准，除了一份CSS2.2，其他的标准一大片，不知道看哪个才好。在W3C 的 ALL STANDARDS AND DRAFTS 中以 CSS 为 title 搜索一共有 94 份文档。本文来总结一下如何查看自己需要的标准。

MDN

对于我们日常的查询来说，MDN 是一个更合适的选择，如果遇到问题都去查标准效率太低了，MDN 的内容足够满足我们的大部分需求了。

使用 MDN 我们除了使用使用关键词查询之外，在 CSS参考页面给出了按字母索引的所有标准 CSS 属性、伪类、伪元素、数据类型、以及 @ 规则。还按类型排列的 CSS 选择器列表和 CSS 关键概念列表。还有一份简短的 DOM-CSS / CSSOM 参考。

MDN 的使用大家都不陌生，这里再给大家推荐两个软件，一个是 Dash for Mac，他提供了大多数语言和工具的 API，前端的包括 HTML，CSS，Javascript，NodeJS，React，Vue，Angular 等的 API，并且也能和 Alfred 进行整合，非常方便的 API 查询工具。

另一个是 CodeRunner，他右侧的工具栏直接可以进行 Google，StackOverflow 以及 MDN 的检索，非常方便。如果你是写一些小的 demo 非常建议使用这个软件。

标准

下面就是稍微有些杂乱的标准，如果我们想要系统地了解规范的细节，那么只能去看标准了。不过那么多的标准我们应该看哪些。这份CSS Working Group Editor Drafts可以作为参考，它给出了各个 CSS 细分区域有几份标准，哪一份是 Current Work 的。

在这些标准中最重要的就是 CSS2.2，它是所有 CSS 的基础，其他的标准都要在学习了 CSS2.2 之后，其中最重要的是：

5 Selectors 选择器
6 Assigning property values, Cascading, and Inheritance 属性值赋值，层叠和继承
8 Box model 盒模型
9 Visual formatting model 视觉格式化模型
10 Visual formatting model details 视觉格式化模型细节

CSS2.2之后的茫茫多的标准就是按具体内容细分成了独立的标准，比较重要的有如下这些：

Selectors Level 4
CSS Box Model Module Level 3
CSS Cascading and Inheritance Level 3
CSS Values and Units Module Level 3
CSS Pseudo-Elements Module Level 4
CSS Animations Level 1
CSS Transforms Module Level 1
Media Queries Level 4
CSS Flexible Box Layout Module Level 1
CSS Regions Module Level 1
CSS Multi-column Layout Module
CSS Inline Layout Module Level 3

我还是建议在有确实需要的时候再阅读标准，因为标准的阅读需要花费大量的时间，并且有些非常新的标准不一定就会一直持续下去，把最重要的 CSS2.2 掌握，其他的略读一下即可。

关于 CSS2.2 之后的标准还可以参考 MDN 的CSS3。CSS3 是层叠样式表（Cascading Style Sheets）语言的最新版本，旨在扩展 CSS2.1。它带来了许多期待已久的新特性，例如圆角、阴影、gradients(渐变) 、transitions(过渡) 与 animations(动画) 。以及新的布局方式，如 multi-columns 、 flexible box 与 grid layouts。

CSS Level 2 经历了 9 年的时间（从 2002 年 8 月到 2011 年 6 月）才达到 Recommendation（推荐）状态，主要原因是被一些次要特性拖了后腿。为了加快那些已经确认没有问题的特性的标准化速度，W3C 的 CSS Working Group(CSS 工作组) 作出了一项被称为 Beijing doctrine 的决定，将 CSS 划分为许多小组件，称之为模块（也就是我们现在看到的非常多的不同标准）。这些模块彼此独立，按照各自的进度来进行标准化。其中一些已经是 W3C Recommendation 状态，也有一些仍是 early Working Drafts（早期工作草案）。当新的需求被肯定后，新的模块也会同样地添加进来。

从形式上来说，CSS3 标准自身已经不存在了。每个模块都被独立的标准化，现在标准 CSS 包括了修订后的 CSS2.1 以及完整模块对它的扩充，模块的 level（级别）数并不一致。可以在每个时间点上为 CSS 标准定义一个 snapshots（快照），列出 CSS 2.1 和成熟的模块。W3C 会定期的发布这些 snapshots。

参考文章

CSS 实现文字颜色渐变

Tue, 25 Aug 2020 12:00:00 GMT

前言

我经常将自己的一些突发奇想的设计到自己的博客上尝试。博客首页右侧的热门文章的小工具上的文本颜色一直没找到满意的，于是想试试渐变色的文本会不会有不错的效果。

文本渐变色实现

background-clip

这种实现的主要思路就是对 background 进行裁剪。background-clip 提供了一个 text 属性，可以将背景裁剪成文本的前景色（即只有文本覆盖的部分有背景色），然后我们再将文本颜色设置为 transparent 即可以实现文本颜色的渐变。background-clip 的 text 属性目前仍然是实验功能，需要使用 -webkit-background-clip 才能生效。

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <title>text-color-gradient</title>
    <style>
      .text-color-gradient {
        display: inline-block;
        font-size: 10em;
        font-weight: 700;
        background: linear-gradient(0.25turn, #c21500, #ffc500);
        background-clip: text;
        -webkit-background-clip: text;
        color: transparent;
      }
    </style>
  </head>
  <body>
    <div style="text-align: center;">
      <div class="text-color-gradient">Clloz</div>
    </div>
  </body>
</html>

mask-image

第二种方法是使用 mask-image 配合伪元素做一个渐变遮罩层。如果我们的渐变是 color A 到 color B，我们可以将文本颜色设为 A，然后用伪元素（content 与元素文本相同）配合 mask-image 做一个渐变的遮罩层，渐变是从 transparent 到 color B，然后我们将伪元素覆盖到原来的文本上，就能得到想要的渐变。

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <title>text-color-gradient</title>
    <style>
      .text-color-gradient {
        display: inline-block;
        font-size: 10em;
        position: relative;
        color: #ffc500;
      }

      .text-color-gradient[data-text]::after {
        content: attr(data-text);
        color: #c21500;
        position: absolute;
        left: 0;
        z-index: 2;
        -webkit-mask-image: linear-gradient(0.25turn, #c21500, transparent);
      }
    </style>
  </head>
  <body>
    <div style="text-align: center;">
      <div class="text-color-gradient" data-text="Clloz">Clloz</div>
    </div>
  </body>
</html>

关于渐变色

关于渐变色推荐一个网站：uigradients，该网站有很多不错的渐变色搭配。另外还有一个软件aquarelo，可以查看渐变色，也支持导出。

总结

这就是我实现渐变的两种方法，总的来说还是第一种方法比较简单好用，并且可以设置两种以上颜色的渐变。mask-image 的 linear-gradient 取值似乎必须要一个 transparent ，并且只能有两个颜色。综合而言还是使用第一个方式比较好。

参考文章

CSS3下的渐变文字效果实现

HTML meta 标签

Tue, 25 Aug 2020 12:00:00 GMT

前言

本文讲一讲 HTML 的 <meta> 标签。

元数据

所谓元数据就是用来描述其他数据的数据 data that provides information about other data 或者说 data about data。

<meta> 元素表示那些不能由其它HTML元相关元素 (<base>, <link>, <script>, <style>, <title>) 之一表示的任何元数据信息。

meta 元素定义的元数据的类型包括以下几种：

如果设置了 name 属性，meta 元素提供的是文档级别（document-level）的元数据，应用于整个页面。
如果设置了 http-equiv 属性，meta 元素则是编译指令，提供的信息与类似命名的 HTTP 头部相同。
如果设置了 charset 属性，meta 元素是一个字符集声明，告诉文档使用哪种字符编码。
如果设置了 itemprop 属性，meta 元素提供用户定义的元数据。

Referer 首部字段和 Referrer-policy 首部字段

关于 HTTP 请求头中的 Referer 字段，是可选的，客户端在发送请求的时候可以选择是否加上这个字段。这个字段的正确拼写是 Referrer，也就是推荐人的意思，但是在写入标准的时候少了一个 r，后来就将错就错沿用到现在。

浏览器向服务器请求资源的时候，如果用户在地址栏输入网址，或者选中浏览器书签，就不发送 Referer 字段。发送 Referer 字段的情况主要有三种：

用户点击网页上的链接。
用户发送表单。
网页加载静态资源，比如加载图片、脚本、样式。

浏览器都会将当前网址作为 Referer 字段，放在 HTTP 请求的头信息发送。浏览器的 JavaScript 引擎提供 document.referrer 属性，可以查看当前页面的引荐来源。

Referer 字段实际上告诉了服务器，用户在访问当前资源之前的位置。这往往可以用来用户跟踪。

比如你在阿里云服务器的 OSS 里面存着一些自己服务器上要用的图片之类的静态资源，你不希望别人随意访问这些资源（cdn 流量要花你的钱），那么你就可以在后台设置允许访问的 referrer。你甚至可以禁止空 referrer 的访问，也就是直接在浏览器输入地址访问也不行。

而且 referrer 有可能暴露隐私，因此有些情况不能使用。比如功能 URL，即有的 URL 不要登录，可以访问，就能直接完成密码重置、邮件退订等功能。或者是内网 URL，不希望外部用户知道内网有这样的地址。Referer 字段很可能把这些 URL 暴露出去。

W3C 制定了一个referrer-policy标准来控制文档的 Referer 策略。referrer-policy 一共有 8 个值，和 name 为 referrer 的 <meta> 的 content 取值是相同的（各个取值和含义参考下面的属性章节的 name 部分）。改变浏览器默认 referrer-policy 的方法大概有三种referrer-policy 集成到 HTML 的方法有三种：

用一个 name 为 referrer 的 <meta> 元素为整个文档设置 referrer 策略。
```
<meta name="referrer" content="origin" />
```html
```
用 <a>、<area>、<img>、<iframe>、<script> 或者 <link> 元素上的 referrerpolicy 属性为其设置独立的请求策略。
```
<a href="http://example.com" referrerpolicy="origin"> ```html </a>
```
在 <a>、<area> 或者 <link> 元素上将 rel 属性设置为 noreferrer。
```
<a href="http://example.com" rel="noreferrer"></a>
```

CSS 可以从样式表获取引用的资源，这些资源也可以遵从 referrer 策略：外部 CSS 样式表使用默认策略 (no-referrer-when-downgrade)，除非 CSS 样式表的响应消息通过 Referrer-Policy 首部覆盖该策略。对于 <style> 元素或 style 属性，则遵从文档的 referrer 策略。

| Policy | Document | Navigation to | Referrer | | --------------------------------- | ------------------------------- | ------------------------------------ | ------------------------------- | | no-referrer | https://example.com/page.html | any domain or path | no referrer | | no-referrer-when-downgrade | https://example.com/page.html | https://example.com/otherpage.html | https://example.com/page.html | | no-referrer-when-downgrade | https://example.com/page.html | https://mozilla.org | https://example.com/page.html | | no-referrer-when-downgrade | https://example.com/page.html | http://example.org | no referrer | | origin | https://example.com/page.html | any domain or path | https://example.com/ | | origin-when-cross-origin | https://example.com/page.html | https://example.com/otherpage.html | https://example.com/page.html | | origin-when-cross-origin | https://example.com/page.html | https://mozilla.org | https://example.com/ | | origin-when-cross-origin | https://example.com/page.html | http://example.com/page.html | https://example.com/ | | same-origin | https://example.com/page.html | https://example.com/otherpage.html | https://example.com/page.html | | same-origin | https://example.com/page.html | https://mozilla.org | no referrer | | strict-origin | https://example.com/page.html | https://mozilla.org | https://example.com/ | | strict-origin | https://example.com/page.html | http://example.org | no referrer | | strict-origin | http://example.com/page.html | any domain or path | http://example.com/ | | strict-origin-when-cross-origin | https://example.com/page.html | https://example.com/otherpage.html | https://example.com/page.html | | strict-origin-when-cross-origin | https://example.com/page.html | https://mozilla.org | https://example.com/ | | strict-origin-when-cross-origin | https://example.com/page.html | http://example.org | no referrer | | unsafe-url | https://example.com/page.html | any domain or path | https://example.com/page.html |

对于 Referer 和 Referrer-Policy 这里做一下总结。Referer 就是我们在向服务器请求的时候，告诉服务器我们是来自哪里，服务器根据我们的这个位置决定是否要返回我们所请求的资源。而 Referrer-Policy 则是一个策略，确定我们在当前文档中的发生的请求要如何发送 Referer 首部字段。

属性

全局属性 name 在 <meta> 元素中具有特殊的语义; 在同一个 <meta> 标签中，name, http-equiv 或者 charset 三者中任何一个属性存在时，itemprop 属性不能被使用。

charset

这个属性声明了文档的字符编码。如果使用了这个属性，其值必须是与 ASCII 大小写无关（ASCII case-insensitive）的 utf-8。

content

此属性包含 http-equiv 或 name 属性的值，具体取决于所使用的值。

http-equiv

此属性定义了一个编译指示指令。这个属性叫做 http-equiv(alent)是因为所有允许的值都是特定 HTTP 头部的名称，如下：

content-security-policy：允许页面作者定义当前页的内容策略。内容策略主要指定允许的服务器源和脚本端点，这有助于防止跨站点脚本攻击。
content-type：如果使用这个属性，其值必须是 text/html; charset=utf-8。该属性只能用于 MIME type 为 text/html 的文档，不能用于 MIME 类型为 XML 的文档。
default-style：设置默认CSS样式表组的名称。
x-ua-compatible：如果使用了该属性，那么 content 属性必须包含 IE=edge，用户代理必须忽略此编译指示。
refresh：这个属性指定:
- 如果 content 只包含一个正整数,则是重新载入页面的时间间隔(秒);
- 如果 content 包含一个正整数并且跟着一个字符串 ;url= 和一个合法的 URL，则是重定向到指定链接的时间间隔(秒)

name

name 和 content 属性可以一起使用，以key - value 对的方式给文档提供元数据，其中 name 作为元数据的名称，content 作为元数据的值。

HTML 标准中定义的 name 取值如下：

author：文档作者。
description：一个简短精确的页面内容概要，firefox 和 Opera 用这个元数据作为书签页面的默认描述。
generator：生成页面的软件的标识符。
keyword：用逗号分隔开的页面相关的关键词。
referrer：控制文档发送的 HTTP request 的请求首部字段 Referer 的值。首部字段 Referer 会告知服务器请求的原始资源的 URI，通俗点说就是当前请求页面的来源页面的地址，即表示当前页面是通过此来源页面里的链接进入的。Referer 的正确的拼写应该是 Referrer 推荐人，但不知为何，大家一直沿用这个错误的拼写。referrer 对应的 content 取值有如下这些（即referrer-policy）：
- no-referrer：整个 Referer 首部会被移除。访问来源信息不随着请求一起发送。
- origin：Referer 字段一律只发送源信息（协议+域名+端口），不管是否跨域。https://example.com/page.html 会将 https://example.com/ 作为引用地址。
- no-referrer-when-downgrade(默认值): 如果从 HTTPS 网址链接到 HTTP 网址，不发送 Referer 字段，其他情况发送（包括 HTTP 网址链接到 HTTP 网址）。这是浏览器的默认行为。
- origin-when-cross-origin：对于同源的请求，会发送完整的 URL 作为引用地址，但是对于非同源请求仅发送文件的源。
- same-origin：对于同源（协议+域名+端口都相同）的请求会发送引用地址，但是对于非同源请求则不发送引用地址信息。
- strict-origin：在同等安全级别的情况下，发送文件的源作为引用地址(HTTPS->HTTPS)，但是在降级的情况下不会发送 (HTTPS->HTTP)。
- strict-origin-when-cross-origin：对于同源的请求，会发送完整的 URL 作为引用地址；在同等安全级别的情况下，发送文件的源作为引用地址(HTTPS->HTTPS)；在降级的情况下不发送此首部 (HTTPS->HTTP)。
- unsafe-url：无论是同源请求还是非同源请求（包含源信息、路径和查询字符串，不包含锚点、用户名和密码），都发送完整的 URL（移除参数信息之后）作为引用地址。这项设置会将受 TLS 安全协议保护的资源的源和路径信息泄露给非安全的源服务器。进行此项设置的时候要慎重考虑。

<!-- 实例 -->
<meta name="keywords" content="HTML, CSS, XML, XHTML, JavaScript" />
<meta name="description" content="Free Web tutorials on HTML and CSS" />
<meta name="author" content="Hege Refsnes" />
<meta http-equiv="refresh" content="30" />

非标准的 name 只要记住一个 viewport 即可，该 name 提示移动设备如何初始化视口大小，只对移动设备有效。该 name 对应多个 content，并且 content 还有取值，可以在一个 meta 标签中同时设置多个 content，用逗号隔开。

<meta name="viewport"> 的 content 取值：

| Value | Description & Subvalue | | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | width | 以 pixels（像素）为单位，定义 viewport（视口）的宽度。。值为一个正整数，或字符串 width-device | | initial-scale | 设置页面的初始缩放值（device-width 和 viewport size 的比例）。值为一个正数，取值范围为 0.0 ~ 10.0 | | minimum-scale | 定义最小缩放值，值为一个正数，取值范围为 0.0 ~ 10.0。取值必须小于等于 maximum-scale，不然会导致不确定的行为发生。浏览器设定可以忽略这条规则，iOS10+ 默认忽略这条规则 | | maximum-scale | 定义最大缩放值，值为一个正数，取值范围为 0.0 ~ 10.0。取值必须大于等于 minimum-scale，不然会导致不确定的行为发生。浏览器设定可以忽略这条规则，iOS10+ 默认忽略这条规则 | | height | 以 pixels（像素）为单位，定义 viewport（视口）的高度，取值为一个正整数或者字符串 device-height。很多浏览器不支持，很少使用 | | user-scalable | 是否允许用户进行缩放，值为 no 或 yes, no 代表不允许，yes 代表允许，默认值为 yes，浏览器设定可以忽略这条规则，iOS10+ 默认忽略这条规则 | | viewport-fit | 取值为 auto、contain 或 cover。取值为 auto 不会影响 layout viewport，整个页面都会显示。contain 值表示 viewport 已缩放以适合显示在显示屏上的最大矩形。 cover 表示视口已缩放至填充设备显示。强烈建议用 CSS 的env()来确保重要内容没有被截断在屏幕之外。 |

我们经常使用的 viewport 取值为 <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0">。

关于 viewport 的更多相关内容，请参考这篇文章移动前端开发之viewport的深入理解

参考文章

HTML标签语义化

Tue, 25 Aug 2020 12:00:00 GMT

前言

在 HTML5 中推出了很多语义化的标签，所谓语义化就是标签能够对内容有所表达，比如 p 标签就是段落 paragraph 的意思。其实如果只是实现页面的效果，只使用 div 和 span 就可以做到。但是语义化的好处就是对开发者比较友好，文档的结构清晰，各部分功能一目了然，便于开发和维护。同时语义化的文档也能够对 SEO 起到更好的效果。本文来介绍一下 HTML5 中的标签。

HTML5 标签

本文列出了所有标准化的 HTML5 元素，使用起始标签描述，按照功能分组。新网站应当只使用这里列出的元素。

符号这个元素在 HTML5 中加入代表该元素是在 HTML5 中新增的。另外注意，这里列出的其他元素可能在 HTML5 标准中得到了扩充或经过修改。

根元素

| Element | Description | | -------- | --------------------------------------------------------------------- | | <html> | 代表 HTML 或 XHTML 文档的根。其他所有元素必须是这个元素的子节点。 |

文档元数据

| Element | Description | | --------- | -------------------------------------------------------------------------------------------- | | <head> | 代表关于文档元数据的一个集合，包括脚本或样式表的链接或内容。 | | <title> | 定义文档的标题，将显示在浏览器的标题栏或标签页上。该元素只能包含文本，包含的标签不会被解释。 | | <base> | 定义页面上相对 URL 的基准 URL。 | | <link> | 用于链接外部资源到该文档。 | | <meta> | 定义其他 HTML 元素无法描述的元数据。 | | <style> | 用于内联 CSS。 |

脚本

| Element | Description | | ------------ | ----------------------------------------------------------------------- | | <script> | 定义一个内联脚本或链接到外部脚本。脚本语言是 JavaScript。 | | <noscript> | 定义当浏览器不支持脚本时显示的替代文字。 | | <template> | 这个元素在 HTML5 中加入，通过 JavaScript 在运行时实例化内容的容器。 |

章节

| Element | Description | | ------------------------------- | ----------------------------------------------------------------------------------------------------- | | <body> | 代表 HTML 文档的内容。在文档中只能有一个 <body> 元素。 | | <section> | 这个元素在 HTML5 中加入，定义文档中的一个章节。 | | <nav> | 这个元素在 HTML5 中加入，定义只包含导航链接的章节。 | | <article> | 这个元素在 HTML5 中加入，定义可以独立于内容其余部分的完整独立内容块。 | | <aside> | 这个元素在 HTML5 中加入，定义和页面内容关联度较低的内容——如果被删除，剩下的内容仍然很合理。 | | <h1>,<h2>,<h3>,<h4>,<h5>,<h6> | 标题元素实现了六层文档标题，<h1> 是最大的标题，<h6> 是最小的标题。标题元素简要地描述章节的主题。 | | <header> | 这个元素在 HTML5 中加入，定义页面或章节的头部。它经常包含 logo、页面标题和导航性的目录。 | | <footer> | 这个元素在 HTML5 中加入，定义页面或章节的尾部。它经常包含版权信息、法律信息链接和反馈建议用的地址。 | | <address> | 定义包含联系信息的一个章节。 | | <main> | 这个元素在 HTML5 中加入，定义文档中主要或重要的内容。 |

组织内容

| Element | Description | | -------------- | ----------------------------------------------------- | | <p> | 定义一个段落。 | | <hr> | 代表章节、文章或其他长内容中段落之间的分隔符。 | | <pre> | 代表其内容已经预先排版过，格式应当保留。 | | <blockquote> | 代表引用自其他来源的内容。 | | <ol> | 定义一个有序列表。 | | <ul> | 定义一个无序列表。 | | <li> | 定义列表中的一个列表项。 | | <dl> | 定义一个定义列表（一系列术语和其定义）。 | | <dt> | 代表一个由下一个 <dd> 定义的术语。 | | <dd> | 代表出现在它之前术语的定义。 | | <figure> | 这个元素在 HTML5 中加入，代表一个和文档有关的图例。 | | <figcaption> | 这个元素在 HTML5 中加入，代表一个图例的说明。 | | <div> | 代表一个通用的容器，没有特殊含义。 |

文字形式

| Element | Description | ------------- | <a> | <em> | <strong> | <small> | <s> | <cite> | <q> | <dfn> | <abbr> | <data> | <time> | <code> | <var> | <samp> | <kbd> | <sub>,<sup> | <i> | <b> | <u> | <mark> | <ruby> | <rt> | <rp> | <bdi> | <bdo> | <span> | <br> | <wbr> | | -------------------------------------------------------------------------------------------------------------------------------------------- | | 代表一个链接到其他资源的超链接。 | | 代表强调文字。 | | 代表特别重要文字。 | | 代表注释，如免责声明、版权声明等，对理解文档不重要。 | | 代表不准确或不相关的内容。 | | 代表作品标题。 | | 代表内联的引用。 | | 代表一个术语包含在其最近祖先内容中的定义。 | | 代表省略或缩写，其完整内容在 title 属性中。 | | 这个元素在 HTML5 中加入，关联一个内容的机器可读的等价形式（该元素只在 WHATWG 版本的 HTML 标准中，不在 W3C 版本的 HTML5 标准中）。 | | 这个元素在 HTML5 中加入，代表日期和时间值；机器可读的等价形式通过 datetime 属性指定。 | | 代表计算机代码。 | | 代表代码中的变量。 | | 代表程序或电脑的输出。 | | 代表用户输入，一般从键盘输出，但也可以代表其他输入，如语音输入。 | | 分别代表下标和上标。 | | 代表一段不同性质的文字，如技术术语、外文短语等。 | | 代表一段需要被关注的文字。 | | 代表一段需要下划线呈现的文本注释，如标记出拼写错误的文字等。 | | 这个元素在 HTML5 中加入，代表一段需要被高亮的引用文字。 | | 这个元素在 HTML5 中加入，代表被ruby 注释标记的文本，如中文汉字和它的拼音。 | | 这个元素在 HTML5 中加入，代表 ruby 注释，如中文拼音。 | | 这个元素在 HTML5 中加入，代表 ruby 注释两边的额外插入文本，用于在不支持 ruby 注释显示的浏览器中提供友好的注释显示。 | | 这个元素在 HTML5 中加入，代表需要脱离父元素文本方向的一段文本。它允许嵌入一段不同或未知文本方向格式的文本。 | | 指定子元素的文本方向，显式地覆盖默认的文本方向。 | | 代表一段没有特殊含义的文本，当其他语义元素都不适合文本时候可以使用该元素。 | | 代表换行。 | | 这个元素在 HTML5 中加入，代表建议换行 (Word Break Opportunity) ，当文本太长需要换行时将会在此处添加换行符。 |

编辑

| Element | Description | | ------- | ----------------------- | | <ins> | 定义增加到文档的内容。 | | <del> | 定义从文档移除的内容。 |

嵌入内容

| Element | Description | | ---------- | ------------------------------------------------------------------------------------------------ | | <img> | 代表一张图片。 | | <iframe> | 代表一个内联的框架。 | | <embed> | 这个元素在 HTML5 中加入，代表一个嵌入的外部资源，如应用程序或交互内容。不推荐使用 | | <object> | 代表一个外部资源，如图片、HTML 子文档、插件等。 | | <param> | 代表 <object> 元素所指定的插件的参数。 | | <video> | 这个元素在 HTML5 中加入，表一段视频及其视频文件和字幕，并提供了播放视频的用户界面。 | | <audio> | 这个元素在 HTML5 中加入，代表一段声音，或音频流。 | | <source> | 这个元素在 HTML5 中加入，为 <video> 或 <audio> 这类媒体元素指定媒体源。 | | <track> | 这个元素在 HTML5 中加入，为 <video> 或 <audio> 这类媒体元素指定文本轨道（字幕）。 | | <canvas> | 这个元素在 HTML5 中加入，代表位图区域，可以通过脚本在它上面实时呈现图形，如图表、游戏绘图等。 | | <map> | 与 <area> 元素共同定义图像映射区域。 | | <area> | 与 <map> 元素共同定义图像映射区域。 | | <svg> | 这个元素在 HTML5 中加入，定义一个嵌入式矢量图。 | | <math> | 这个元素在 HTML5 中加入，定义一段数学公式。大多数浏览器暂不支持 |

表格

| Element | Description | | ------------ | ------------------------------------- | --- | --- | | <table> | 定义多维数据。 | | <caption> | 代表表格的标题。 | | <colgroup> | 代表表格中一组单列或多列。 | | <col> | 代表表格中的列。 | | <tbody> | 代表表格中一块具体数据（表格主体）。 | | <thead> | 代表表格中一块列标签（表头）。 | | <tfoot> | 代表表格中一块列摘要（表尾）。 | | <tr> | 代表表格中的行。 | | <td> | 代表表格中的单元格 | | 。 | | <th> | 代表表格中的头部单元格。 |

表单

| Element | Description | | ------------ | ----------------------------------------------------------------------- | | <form> | 代表一个表单，由控件组成。 | | <fieldset> | 代表控件组。 | | <legend> | 代表 <fieldset> 控件组的标题。 | | <label> | 代表表单控件的标题。 | | <input> | 代表允许用户编辑数据的数据区（文本框、单选框、复选框等）。 | | <button> | 代表按钮。 | | <select> | 代表下拉框。 | | <datalist> | 这个元素在 HTML5 中加入，代表提供给其他控件的一组预定义选项。 | | <optgroup> | 代表一个选项分组。 | | <option> | 代表一个 <select> 元素或 <datalist> 元素中的一个选项 | | <textarea> | 代表多行文本框。 | | <keygen> | 这个元素在 HTML5 中加入，代表一个密钥对生成器控件。已在标准中废弃 | | <output> | 这个元素在 HTML5 中加入，代表计算值。 | | <progress> | 这个元素在 HTML5 中加入，代表进度条。 | | <meter> | 这个元素在 HTML5 中加入，代表滑动条。 |

交互元素

| Element | Description | | ------------ | ------------------------------------------------------------------------------ | | <details> | 这个元素在 HTML5 中加入，代表一个用户可以(点击)获取额外信息或控件的小部件。 | | <summary> | 这个元素在 HTML5 中加入，代表 <details> 元素的综述或标题。 | | <menuitem> | 这个元素在 HTML5 中加入，代表一个用户可以点击的菜单项。已在标准中废弃 | | <menu> | 这个元素在 HTML5 中加入，代表菜单。 |

新标签的应用

在 HTML5 中提供的新标签中有些特别的可以拿出来特别说一下。

templete 内容模板元素

HTML 内容模板（<template>）元素是一种用于保存客户端内容机制，该内容在加载页面时不会呈现，但随后可以(原文为 may be)在运行时使用 JavaScript 实例化。将模板视为一个可存储在文档中以便后续使用的内容片段。虽然解析器在加载页面时确实会处理 <template> 元素的内容，但这样做只是为了确保这些内容有效；但元素内容不会被渲染。

figure 和 figurecaption

HTML <figure> 元素代表一段独立的内容, 经常与说明（caption） <figcaption> 配合使用, 并且作为一个独立的引用单元。当它属于主内容流（main flow）时，它的位置独立于主体。这个标签经常是在主文中引用的图片，插图，表格，代码段等等，当这部分转移到附录中或者其他页面时不会影响到主体。

mark

<mark> 元素用来显示与用户当前活动相关的一部分文档内容。例如，它可能被用于显示匹配搜索结果中的单词。

ruby>、rt 和 rp

<ruby> 元素被用来展示东亚文字注音或字符注释。 <rt> 代表 ruby 注释，如中文拼音，日语罗马音等。 <rp> 元素用于不支持 <ruby> 元素的情况。 <rp> 的内容提供了应该展示的东西，通常是圆括号，以便表示 ruby 注解的存在。

ruby 这个单词来源于日语 ルビ，表示注音假名小铅字，即振り仮名。ruby 语言的名字也来源于此。

bdi 和 bdo

这两个元素在HTML全局属性dir中进行详细介绍。

wbr

<wbr> 是指 Word Break Opportunity，让浏览器在需要换行时从我们设定的位置进行换行。<wbr> 仅仅表示一个零宽的位置，不会对文本产生额外的影响。我们可以在我们期待浏览器换行的位置插入 <wbr> 标签，比如 url 的换行推荐在各个标点之前。比如如下的代码，当我们不断减小视口或元素的宽度，浏览器会从我们设置 <wbr> 的位置进行换行。

<p>
  http://this<wbr />.is<wbr />.a<wbr />.really<wbr />.long<wbr />.example<wbr />.com/With<wbr />/deeper<wbr />/level<wbr />/pages<wbr />/deeper<wbr />/level<wbr />/pages<wbr />/deeper<wbr />/level<wbr />/pages<wbr />/deeper<wbr />/level<wbr />/pages<wbr />/deeper<wbr />/level<wbr />/pages
</p>

embed

<embed> 元素将外部内容嵌入文档中的指定位置。此内容由外部应用程序或其他交互式内容源（如浏览器插件）提供。

大多数现代浏览器已经弃用并取消了对浏览器插件的支持，所以如果您希望您的网站可以在普通用户的浏览器上运行，那么依靠 <embed> 通常是不明智的。可以使用 <img>、<iframe>、<video>、<audio> 等标签代替。

picture、video、audio、track 和 source

这四个标签都是用来在文档中嵌入媒体文件的。

<picture> 元素通过包含零或多个 <source> 元素和一个 <img> 元素来为不同的显示/设备场景提供图像版本。浏览器会选择最匹配的子 <source> 元素，如果没有匹配的，就选择 <img> 元素的 src 属性中的 URL。然后，所选图像呈现在 <img> 元素占据的空间中。

<video> 元素用于在 HTML 或者 XHTML 文档中嵌入媒体播放器，用于支持文档内的视频播放。这些视频资源可以使用 src 属性或者 <source> 元素来进行描述：浏览器将会选择最合适的一个来使用。也可以将 <video> 标签用于音频内容，但是 <audio> 元素可能在用户体验上更合适。

<audio>元素用于在文档中嵌入音频内容。 <audio> 元素可以包含一个或多个音频资源，这些音频资源可以使用 src 属性或者 <source> 元素来进行描述：浏览器将会选择最合适的一个来使用。也可以使用 MediaStream 将这个元素用于流式媒体。

<track> 元素被当作媒体元素 <audio> 和 <video> 的子元素来使用。它允许指定时序文本字幕（或者基于时间的数据），例如自动处理字幕。字幕格式有 WebVTT 格式（.vtt 格式文件）— Web 视频文本字幕格式，以及指时序文本标记语言（TTML）格式。

<source> 元素为 <picture>, <audio> 或者 <video> 元素指定多个媒体资源。这是一个空元素。它通常用于以不同浏览器支持的多种格式提供相同的媒体内容。要决定加载哪个 URL，user agent 检查每个 <source> 的 srcset、media 和 type 属性，来选择最匹配页面当前布局、显示设备特征等的兼容资源。

<picture>
  <source media="(min-width: 650px)" srcset="demo1.jpg" />
  <source media="(min-width: 465px)" srcset="demo2.jpg" />
  <img src="img_girl.jpg" />
</picture>

<audio> 和 <video> 都有很多属性和用法，本文不作详细介绍。

canvas

<canvas>元素可被用来通过 JavaScript（Canvas API 或 WebGL API）绘制图形及图形动画。<canvas> 的内容也是非常丰富的，不在本文做详细介绍。

svg

SVG 是一种基于 XML 语法的图像格式，全称是可缩放矢量图（Scalable Vector Graphics）。其他图像格式都是基于像素处理的，SVG 则是属于对图像的形状描述，所以它本质上是文本文件，体积较小，且不管放大多少倍都不会失真。

如果 svg 不是根元素，svg 元素可以用于在当前文档（比如说，一个 HTML 文档）内嵌套一个独立的 svg 片段。这个独立片段拥有独立的视口和坐标系统。

svg 的内容可以参考阮一峰老师的文章SVG图像入门教程

math

Mathematical Markup Language (MathML) 是一个用于描述数学公式、符号的一种 XML 标记语言。MathML 的顶级元素是 <math>。所有有效的 MathML 实例必须被包括在 <math> 标记中。另外不可以在一个 <math> 元素中嵌套第二个 <math> 元素，但是 <math> 元素中可以有任意多的子元素。

MathML 的内容可以参考MDN，目前大多数浏览器都不支持 <math>，如果想使用数学公式有几个方案：

用 LaTex 编译数学公式，默认输出 PDF，可以转为 png 再到页面使用。
使用 MathJax 渲染。
使用 KaTeX 渲染。

datalist

<datalist> 元素包含了一组 <option> 元素，这些元素表示其它表单控件可选值。

output

<output> 标签表示计算或用户操作的结果。可以用标签的 form 属性指定关联的 form 的 id，从而达到在文档任何位置使用 <output> 的目的。

progress

<progress> 元素用来显示一项任务的完成进度.虽然规范中没有规定该元素具体如何显示,浏览器开发商可以自己决定,但通常情况下,该元素都显示为一个进度条形式。

meter

<meter>元素用来显示已知范围的标量值或者分数值。

details

<details> 元素可创建一个挂件，仅在被切换成展开状态时，它才会显示内含的信息。<summary> 元素可为该部件提供概要或者标签。

已废弃的标签

以下标签已经从 HTML5 中移除，应停止使用。

<acronym>
<applet>
<basefont>
<big>
<center>
<dir>
<font>
<frame>
<frameset>
<noframes>
<strike>
<tt>

语义化标签实例

上面我们已经介绍了所有的 HTML5 标签，HTML5 提供了非常丰富的语义化标签。我们如何用这些语义化的标签来重构我们的文档解构呢？我们就以 MDN 的HTML5 标签列表页面为例子来看看它是怎么实现的。MDN 的页面基本都是用语义化的标签编写 HTML 文档的。

首先我们按功能将页面分为几个主要结构，所有内容都是这些主要结构的子结构。

<body>
  <div>
    <header>页面头部，通常包含 logo、页面标题和导航性的目录。</header>
    <main>主内容：整个页面核心内容</main>
    <section>一个章节：显示一些与页面主要内容无关的部分</section>
    <footer>页面尾部，通常包含版权信息、法律信息链接和反馈建议用的地址。</footer>
  </div>
</body>

这样我们就已经确定了页面的结构，当我们要写入一个内容的时候也知道应该往哪个部分填充。

header

header 部分的内容有页面的标题，搜索框，用户头像和一个导航。MDN 采用的是 grid 网格结构，导航用的是 nav 标签，其他都是用 div 实现。

<header>
  页面头部，通常包含 logo、页面标题和导航性的目录。
  <div>MDN标题</div>
  <nav>
    导航
    <ul>
      列表
      <li></li>
      <li></li>
      <li></li>
    </ul>
  </nav>
  <div>搜索框</div>
  <div>用户头像</div>
</header>

main

核心内容部分是用户浏览页面最关注的部分，我们来 MDN 查阅资料主要就是看这部分内容，甚至可以说只看这部分内容。

<main>
  主内容：整个页面核心内容
  <header>主内容头部：包括标题导航等内容</header>
  <div>
    <aside>
      <section>
        侧边导航栏
        <header>侧边导航栏标题</header>
        <ul>
          列表展示当前页面的导航目录，点击跳转到对应章节，此处也可以用一个nav嵌套
        </ul>
      </section>
    </aside>
    <div class="content">
      核心内容
      <article>content</article>
      <div>
        一个独立于content的section：metadata 修改时间
        <section></section>
      </div>
    </div>
  </div>
</main>

section

一个用来填写邮箱，接收 MDN 邮件的章节，内部为一个 form。

footer

最后是页面的尾部，包含了 MDN 网站的一些重要链接导航和版权信息、法律信息链接等。

参考文章

HTML5 标签列表 - MDN

HTTP MIME 类型

Tue, 25 Aug 2020 12:00:00 GMT

前言

我们经常听到 MIME type，但是可能并不了解它是什么。我们如今的 web 内容非常丰富，有各种媒体资源在 web 上传播共享。那么浏览器如何分辨资源的类型而进行处理呢？就是通过 HTTP 响应报文实体首部中的 Content-Type 字段中的 MIME type 来确定的，比如常见的的 Content-Type: text/html，也就是描述报文实体主体内容的一些标准化名称。本文就来介绍以下 MIME type 相关的内容。

MIME type 简介

因特网上有数千种不同的数据类型，HTTP 仔细地给每种要通过 Web 传输的对象都打上了名为 MIME 类型(MIME type)的数据格式标签。最初设计 MIME(Multipurpose Internet Mail Extension，多用途因特网邮件扩展)是为了解决在不同的电子邮件系统之间搬移报文时存在的问题。MIME 在电子邮件系统中工作得非常好，因此 HTTP 也采纳了它，用它来描述并标记多媒体内容。

Web 服务器会为所有 HTTP 对象数据附加一个 MIME 类型(见下图，Content-Type 字段在 HTTP 报文的实体首部中)。当 Web 浏览器从服务器中取回一个对象时，会去查看相关的 MIME 类型，看看它是否知道应该如何处理这个对象。大多数浏览器都可以处理数百种常见的对象类型:显示图片文件、解析并格式化 HTML 文件、通过计算机声卡播放音频文件，或者运行外部插件软件来处理特殊格式的数据。

MIME 类型是一种文本标记，表示一种主要的对象类型和一个特定的子类型，中间由一条斜杠来分隔。常见的 MIME 类型有数百个，实验性或用途有限的 MIME 类型则更多。

HTML 格式的文本文档由 text/html 类型来标记。
普通的 ASCII 文本文档由 text/plain 类型来标记。
JPEG 格式的图片为 image/jpeg 类型。
GIF 格式的图片为 image/gif 类型。
Apple 的 QuickTime 电影为 video/quicktime 类型。
微软的 PowerPoint 演示文件为 application/vnd.ms-powerpoint 类型。

web 服务器如何确定 MIME 类型

当浏览器想服务器请求某个资源的时候，服务器要确定相应主体的 MIME 类型，并在响应报文首部的实体首部中。有很多配置服务器的方法可以将 MIME 类型与资源关联起来。

MIME 类型(mime.types) Web 服务器可以用文件的扩展名来说明 MIME 类型。Web 服务器会为每个资源扫描一个包含了所有扩展名的 MIME 类型的文件，以确定其 MIME 类型。这种基于扩展名的类型相关是最常见的，见下图。

魔法分类(Magic typing) Apache Web 服务器可以扫描每个资源的内容，并将其与一个已知模式表(被称为魔法文件)进行匹配，以决定每个文件的 MIME 类型。这样做可能比较慢，但很方便，尤其是文件没有标准扩展名的时候。

显式分类(Explicit typing) 可以对 Web 服务器进行配置，使其不考虑文件的扩展名或内容，强制特定文件或目录内容拥有某个 MIME 类型。

类型协商有些 Web 服务器经过配置，可以以多种文档格式来存储资源。在这种情况下，可以配置 Web 服务器，使其可以通过与用户的协商来决定使用哪种格式(及相关的 MIME 类型)“最好”。还可以通过配置 Web 服务器，将特定的文件与 MIME 类型相关联。

Apache Web 服务器 httpd 的配置文件 /etc/httpd/conf/httpd.conf 中就有两个配置是跟 MIME type 相关的：

AddType：用于返回 HTTP 响应给浏览器，将给定的文件扩展名映射到指定的内容类型（设置 Content-Type）。AddType image/gif .gif
AddHandler: 用于处理接收到的浏览器请求，将文件扩展名映射到指定的处理程序（用指定的程序处理某种类型的文件）。AddHandler cgi-script .cgi

浏览器通常使用 MIME 类型（而不是文件扩展名）来确定如何处理 URL，因此 Web 服务器在响应头中添加正确的 MIME 类型非常重要。如果配置不正确，浏览器可能会曲解文件内容，网站将无法正常工作，并且下载的文件也会被错误处理。

MIME type 语法

MIME 主要由下列 5 份文档定义。

RFC 2045，MIME: Format of Internet Message Bodies (MIME: 因特网报文主体的格式)：描述了 MIME 报文结构的概况，并介绍了 HTTP 借用的 Content-Type 首部。
RFC 2046，MIME: Media Types (MIME:媒体类型)：介绍了 MIME 类型及其结构。
RFC 2047，MIME: Message Header Extensions for Non-ASCII Text (MIME: 非 ASCII 文本的报文首部扩展)：定义了一些在首部包含非 ASCII 字符的方式。
RFC 2048，MIME: Registration Procedures (MIME:注册过程)：定义了如何向因特网号码分配机构(Internet Assigned Numbers Authority，IA- NA)注册 MIME 值。
RFC 2049，MIME: Conformance Criteria and Examples(MIME:一致性标准及实例)：详细介绍了一致性规则，并提供了一些实例。

IANA 是 MIME 媒体类型的官方注册机构，并维护了 list of all the official MIME types。

MIME 类型结构

每种 MIME 媒体类型都包含主类型、子类型和可选参数的列表。类型和子类型由一个斜杠分隔，如果有可选参数的话，则以分号开始，MIME 类型对大小写不敏感，但是传统写法都是小写。在 HTTP 中，MIME 媒体类型被广泛用于 Content-Type 和 Accept 首部。下面是几个例子:

Content-Type: video/quicktime
Content-Type: text/html; charset="iso-8859-6"
Content-Type: multipart/mixed; boundary=gc0p4Jq0M2Yt08j34c0p
Accept: image/gif

MIME type 可以分为离散类型、复合类型和多部分类型：

离散类型：MIME 类型可以直接用于描述对象类型，也可以用于描述其他对象类型的集合或类型包。如果直接用 MIME 类型来描述某个对象类型，它就是一种离散类型(discrete type)。其中包括文本文件、视频和应用程序特有的文件格式。
复合类型：如果 MIME 类型描述的是其他内容的集合或封装包，这种 MIME 类型就被称为复合类型(composite type)。复合类型描述的是封装包的格式。将封装包打开时，其中包含的每个对象都会有其各自的类型。
多部分类型：多部分媒体类型是复合类型。多部分对象包含多个组件类型。

MIME 类型由主类型、子类型和可选参数的列表组成。主类型可以是预定义类型、IETF（互联网工程任务组 Internet Engineering Task Forc）定义的扩展标记，或者(以x-开头的)实验性标记。常见的主类型见下表：

| 类型 | 描述 | 典型示例 | | ------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | | application | 应用程序特有的内容格式(离散类型) | application/octet-stream, application/pkcs12, application/vnd.mspowerpoint, application/xhtml+xml, application/xml, application/pdf | | audio | 音频格式(离散类型) | audio/midi, audio/mpeg, audio/webm, audio/ogg, audio/wav | | chemical | 化学数据集(离散 IETF 扩展类型) | | | image | 图片格式(离散类型) | image/gif, image/png, image/jpeg, image/bmp, image/webp, image/x-icon, image/vnd.microsoft.icon | | message | 报文格式(复合类型) | | | model | 三维模型格式(离散 IETF 扩展类型) | | | multipart | 多部分对象集合(复合类型) | multipart/form-data,multipart/byteranges | | text | 文本格式(离散类型) | text/plain, text/html, text/css, text/javascript | | video | 视频电影格式(离散类型) | video/webm, video/ogg |

子类型可以是主类型(比如，text/text)、IANA 注册的子类型，或者是(以 x- 开头的)实验性扩展标记。类型和子类型都是由 US-ASCII 字符的一个子集构成的。空格和某些保留分组以及标点符号称为 tspecials，它们是控制字符，不能用于类型和子类型名。

重要的 MIME type

常用 MIME type 可以查看MDN：常用MIME类型列表，完整的 MIME type 列表查看 IANA 的list of all the official MIME types。

application/octet-stream

这是应用程序文件的默认值。意思是未知的应用程序文件，浏览器一般不会自动执行或询问执行。浏览器会像对待设置了HTTP 头 Content-Disposition 值为 attachment 的文件一样来对待这类文件。

text/plain

文本文件默认值。即使它意味着未知的文本文件，但浏览器认为是可以直接展示的。

text/plain 并不是意味着某种文本数据。如果浏览器想要一个文本文件的明确类型，浏览器并不会考虑他们是否匹配。比如说，如果通过一个表明是下载 CSS 文件的 <link> 链接下载了一个 text/plain 文件。如果提供的信息是 text/plain，浏览器并不会认出这是有效的 CSS 文件。CSS 类型需要使用 text/css。

text/css

在网页中要被解析为 CSS 的任何 CSS 文件必须指定 MIME 为 text/css。通常，服务器不识别以 .css 为后缀的文件的 MIME 类型，而是将其以 MIME 为 text/plain 或 application/octet-stream 来发送给浏览器：在这种情况下，大多数浏览器不识别其为 CSS 文件，直接忽略掉。特别要注意为 CSS 文件提供正确的 MIME 类型。我们在使用 <link> 标签的时候也会设置 type 属性为 text/css。

text/html

所有的 HTML 内容都应该使用这种类型。XHTML 的其他 MIME 类型（如 application/xml+html）现在基本不再使用（HTML5 统一了这些格式）。如果你要使用严格的 XML 解析规则，你仍然要使用 application/xml 或者 application/xhtml+xml。

JavaScript types

据 MIME 嗅探标准，application/javascript，application/ecmascript是有效的 JavaScript MIME 类型。所有的 text JavaScript 类型已经被 RFC 4329 废弃。

图片类型

只有一小部分图片类型是被广泛支持的，Web 安全的，可随时在 Web 页面中使用的：

| MIME 类型 | 图片类型 | | ----------------- | ------------------------------------------ | | image/gif | GIF 图片 (无损耗压缩方面被 PNG 所替代) | | image/jpeg | JPEG 图片 | | image/png | PNG 图片 | | image/svg+xml | SVG 图片 (矢量图) |

另外的一些图片种类可以在 Web 文档中找到。比如很多浏览器支持 icon 类型的图标作为 favicons 或者类似的图标，并且浏览器在 MIME 类型中的 image/x-icon 支持 ICO 图像。尽管 image/vnd.microsoft.icon 在 IANA 注册, 它仍然不被广泛支持，image/x-icon 被作为替代品使用。

音频与视频

HTML 并没有明确定义被用于 <audio> 和 <video> 元素所支持的文件类型，所以在 web 上使用的只有相对较小的一组类型。Web 中最常见的音频视频格式见下表。

| MIME 类型 | 音频或视频类型 | | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ | | audio/wave,audio/wav,audio/x-wav,audio/x-pn-wav | 音频流媒体文件。一般支持 PCM 音频编码 (WAVE codec 1) ，其他解码器有限支持（如果有的话）。 | | audio/webm | WebM 音频文件格式。Vorbis 和 Opus 是其最常用的解码器。 | | video/webm | 采用 WebM 视频文件格式的音视频文件。VP8 和 VP9 是其最常用的视频解码器。Vorbis 和 Opus 是其最常用的音频解码器。 | | audio/ogg | 采用 OGG 多媒体文件格式的音频文件。 Vorbis 是这个多媒体文件格式最常用的音频解码器。 | | video/ogg | 采用 OGG 多媒体文件格式的音视频文件。常用的视频解码器是 Theora；音频解码器为 Vorbis 。 | | application/ogg | 采用 OGG 多媒体文件格式的音视频文件。常用的视频解码器是 Theora；音频解码器为 Vorbis 。 |

multipart/form-data

multipart/form-data 可用于 HTML 表单从浏览器发送信息给服务器。作为多部分文档格式，它由边界线（一个由 -- 开始的字符串）划分出的不同部分组成。每一部分有自己的实体，以及自己的 HTTP 请求头，Content-Disposition和 Content-Type 用于文件上传领域，最常用的 (Content-Length 因为边界线作为分隔符而被忽略）。

<form action="http://localhost:8000/" method="post" enctype="multipart/form-data">
  <input type="text" name="myTextField">
  <input type="checkbox" name="myCheckBox">Check</input>
  <input type="file" name="myFile">
  <button>Send the file</button>
</form>

上面的表单会发送如下请求：

POST / HTTP/1.1
Host: localhost:8000
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.9; rv:50.0) Gecko/20100101 Firefox/50.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Content-Type: multipart/form-data; boundary=---------------------------8721656041911415653955004498
Content-Length: 465

-----------------------------8721656041911415653955004498
Content-Disposition: form-data; name="myTextField"

Test
-----------------------------8721656041911415653955004498
Content-Disposition: form-data; name="myCheckBox"

on
-----------------------------8721656041911415653955004498
Content-Disposition: form-data; name="myFile"; filename="test.txt"
Content-Type: text/plain

Simple file.
-----------------------------8721656041911415653955004498--

multipart/byteranges

multipart/byteranges 用于把部分的响应报文发送回浏览器。当发送状态码 206 Partial Content 时，这个 MIME 类型用于指出这个文件由若干部分组成，每一个都有其请求范围。就像其他很多类型 Content-Type 使用分隔符来制定分界线。每一个不同的部分都有 Content-Type 这样的HTTP头来说明文件的实际类型，以及 Content-Range 来说明其范围。

HTTP/1.1 206 Partial Content
Accept-Ranges: bytes
Content-Type: multipart/byteranges; boundary=3d6b6a416f9b5
Content-Length: 385

--3d6b6a416f9b5
Content-Type: text/html
Content-Range: bytes 100-200/1270

eta http-equiv="Content-type" content="text/html; charset=utf-8" />
    <meta name="vieport" content
--3d6b6a416f9b5
Content-Type: text/html
Content-Range: bytes 300-400/1270

-color: #f0f0f2;
        margin: 0;
        padding: 0;
        font-family: "Open Sans", "Helvetica
--3d6b6a416f9b5--

浏览器和 MIME type

很多 web 服务器使用默认的 application/octet-stream 来发送未知类型。出于一些安全原因，对于这些资源浏览器不允许设置一些自定义默认操作，导致用户必须存储到本地以使用。常见的导致服务器配置错误的文件类型如下所示：

RAR 编码文件。在这种情况，理想状态是，设置真实的编码文件类型；但这通常不可能（可能是服务器所未知的类型或者这个文件包含许多其他的不同的文件类型）。这这种情况服务器将发送 application/x-rar-compressed 作为 MIME 类型，用户不会将其定义为有用的默认操作。
音频或视频文件。只有正确设置了MIME类型的文件才能被 <video> 或 <audio> 识别和播放。
专有文件类型。是专有文件时需要特别注意。使用 application/octet-stream 作为特殊处理是不被允许的：对于一般的 MIME 类型浏览器不允许定义默认行为（比如 在Word中打开 ）

在缺失 MIME 类型或客户端认为文件设置了错误的 MIME 类型时，浏览器可能会通过查看资源来进行 MIME 嗅探。每一个浏览器在不同的情况下会执行不同的操作。因为这个操作会有一些安全问题，有的 MIME 类型表示可执行内容而有些是不可执行内容。浏览器可以通过请求头Content-Type 来设置 X-Content-Type-Options 以阻止 MIME 嗅探。

参考文档

HTTP 权威指南
MIME类型 -MDN

HTML 发展

Mon, 24 Aug 2020 12:00:00 GMT

前言

HTML 的全称是 HyperText Markup Language 超文本标记语言，是一种用于创建网页的标准标记语言。所谓标记语言，就是一种将文本 text 以及文本相关的其他信息结合起来，展现出关于文档结构和数据处理细节的计算机编码，用标记进行标识。常见的标记语言有 SGML HTML、XML 和 XHTML 等。

HTML 历史

其实关于早期的 HTML 版本我们并没有太多的了解必要，我们主要关注的是，HTML4.01 和 HTML5 之间的差别，以及 SGML、XML 和 XHTML 与 HTML 之间的区别。这里先简要介绍以下 HTML 的发展历史，作为了解即可。

首先介绍以下 SGML，标准通用标记语言（Standard Generalized Markup Language）是现时常用的超文本格式的最高层次标准，是可以定义标记语言的元语言，甚至可以定义不必采用< >的常规方式。由于它的复杂，因而难以普及。HTML 和 XML 同样派生于它：XML 可以被认为是它的一个子集，而 HTML 是它的一个应用。XML 的产生就是为了简化它，以便用于更加通用的目的，比如语义 Web。它已经应用于大量的场合，比较著名的有 XHTML、RSS、XML-RPC 和 SOAP。

HTML 是蒂姆·伯纳斯-李在发明万维网的过程中根据 SGML 创造的，它描述 18 个元素，包括 HTML 初始的、相对简单的设计。除了超链接之外，其他标签都是以 SGML 为基础的。这些标签中有 11 个到 HTML4 都仍然存在。

不存在 HTML 1.0，只在 1993 年中期由 IETF互联网工程任务组提出了一个超文本标记语言（HTML）互联网草案。HTML 第一个正式的规范是由 IETF 的 HTML 工作小组创建的 HTML 2.0。

在 IETF 的主持下，HTML 标准的进一步发展因竞争利益而遭受停滞。自 1996 年起，HTML 规范一直由万维网联盟（W3C）维护，并由商业软件厂商出资。不过在 2000 年，HTML 也成为国际标准（ISO/ IEC15445：2000）。HTML 4.01 于 1999 年末发布，进一步的勘误版本于 2001 年发布。2004 年，网页超文本应用技术工作小组（WHATWG）开始开发 HTML5，并在 2008 年与 W3C 共同交付，2014年10月28日 完成标准化。

whatwg 是在 W3C 强推 XHTML2.0 后从 W3C 分裂出去的组织，如今两边已经是高度合作推动标准化。W3C 的 HTML5 是 whatwg 的一个 snapshot。whatwg 的标准是 living standard，也就是只有一个最新版本，不像 w3c 有各个阶段的版本。

HTML 语法

文本

在 HTML 中，规定了两种文本语法，一种是普通的文本节点，另一种是 CDATA 文本节点。注意，CDATA 片段不应该在 HTML 中被使用；它只在 XML 中有效。

注释

HTML 注释语法以  结尾，注释的内容非常自由，除了 --> 都没有问题。如果注释的内容一定要出现 -->，我们可以拆成多个注释节点。

DTD 文档类型定义

SGML 的 DTD 语法十分复杂，但是对 HTML 来说，其实 DTD 的选项是有限的，浏览器在解析 DTD 时，把它当做几种字符串之一，关于 DTD，我在本篇文章的后面会详细讲解。

ProcessingInstruction 语法（处理信息）

ProcessingInstruction 多数情况下，是给机器看的。HTML 中规定了可以有 ProcessingInstruction，但是并没有规定它的具体内容，所以可以把它视为一种保留的扩展机制。对浏览器而言，ProcessingInstruction 的作用类似于注释。ProcessingInstruction 包含两个部分，紧挨着第一个问号后，空格前的部分被称为“目标”，这个目标一般表示处理 ProcessingInstruction 的程序名。剩余部分是它的文本信息，没有任何格式上的约定，完全由文档编写者和处理程序的编写者约定。

DTD

DTD 的全称是 Document Type Defination，也就是文档类型定义。DTD 是一套用来定义文档类型的标记声明，主要的对象是 SGML 家族的标记语言：GML, SGML, XML, HTML。在 DTD 中可以定义文档中的元素、元素的属性、元素的排列方式、元素包含的内容等等。DTD 有四个组成如下：

元素（Elements）
属性（Attribute）
实体（Entities）
注释（Comments）

<!--元素声明语法-->
<!ELEMENT 元素名称　元素內容>
<!--属性声明语法-->
<!ATTLIST 元素名称、属性名称、属性值数据类型、属性默认值>
<!--实体声明语法-->
<!ENTITY 是名称　实体内容>
<!--注释语法-->
<!-- 注释内容 -->

在 HTML5 之后，由于这些 DTD 过于复杂的写法没啥实际用途，加之浏览器也不会使用 SGML 去解析他们，干脆放弃了 SGML 子集的的支持，规定了一个简单易记住的类似 DTD 的声明 <!DOCTYPE html>。XML 也逐渐用 XML Schema 来代替 DTD。但是因为我们的互联网上仍然存在大量的 HTML4.01 和 xhtml1.0 的网页，所以新的标准都是向前兼容的（比较激进的不向前兼容的 xhtml2.0 已经废弃）。常用的 DOCTYPE 声明有如下几种。

<!--HTML 5-->
<!DOCTYPE html>

<!--HTML 4.01 Strict 这个 DTD 包含所有 HTML 元素和属性，但不包括表象或过时的元素（如 font ）。框架集是不允许的。-->
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

<!--HTML 4.01 Transitional 这个 DTD 包含所有 HTML 元素和属性，包括表象或过时的元素（如 font ）。框架集是不允许的。-->
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<!--HTML 4.01 Frameset 这个 DTD 与 HTML 4.01 Transitional 相同，但是允许使用框架集内容。-->
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">

<!--XHTML 1.0 Strict 这个 DTD 包含所有 HTML 元素和属性，但不包括表象或过时的元素（如 font ）。框架集是不允许的。结构必须按标准格式的 XML 进行书写。-->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<!--XHTML 1.0 Transitional 这个 DTD 包含所有 HTML 元素和属性，包括表象或过时的元素（如 font ）。框架集是不允许的。结构必须按标准格式的 XML 进行书写。-->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<!--XHTML 1.0 Frameset 这个 DTD 与 XHTML 1.0 Transitional 相同，但是允许使用框架集内容。-->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">

<!--XHTML 1.1 这个 DTD 与 XHTML 1.0 Strict 相同，但是允许您添加模块（例如为东亚语言提供 ruby 支持）。-->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

doctype 声明开头的 !DOCTYPE 大小写不敏感。文档开头必须声明 doctype 否则浏览器无法判断文档类型，也无法正确解析。

XML

可扩展标记语言（Extensible Markup Language）是从标准通用标记语言（SGML）中简化修改出来的。之所以成为可扩展是因为它的标记 markup 是可以由开发者自由定义的，而不像 HTML 是由标准制定者来定义一个通用的标准。

XML 用于描绘封装数据，而 HTML 超文本标记语言用于展示数据，XHTML 就是用 XML 规则规范的 HTML。XML 语法更加严格。XML 与 HTML 的区别主要有如下一些点：

XML 大小写敏感，HTML 大小写不敏感。
XML 是严格的树状结构，不能省略掉结束标记。
在 XML 中，拥有单个标记而没有匹配的结束标记的元素必须用一个/ 字符作为结尾。这样分析器就知道不用查找结束标记了。
在 XML 中，属性值必须分装在引号中。在 HTML 中，引号是可用可不用的。
在 HTML 中，可以拥有不带值的属性名。在 XML 中，所有的属性都必须带有相应的值。
在 XML 文档中，空白部分不会被解析器自动删除；但是 HTML 是过滤掉空格的。
HTML 使用固有的标记；而 XML 没有固有的标记。
HTML 标签是预定义的；XML 标签是自定义的、可扩展的。
HTML 是用来显示数据的；XML 是用来描述数据、存放数据的，所以可以作为持久化的介质。HTML 将数据和显示结合在一起，在页面中把这数据显示出来；XML 则将数据和显示分开。 XML 被设计用来描述数据，其焦点是数据的内容。HTML 被设计用来显示数据，其焦点是数据的外观。
XML 不是 HTML 的替代品，XML 和 HTML 是两种不同用途的语言。 XML 不是要替换 HTML；XML 和 HTML 的目标不同 HTML 的设计目标是显示数据并集中于数据外观，而 XML 的设计目标是描述数据并集中于数据的内容。
没有任何行为的 XML。与 HTML 相似，XML 不进行任何操作。（共同点）
对于 XML 最好的形容可能是: XML 是一种跨平台的，与软、硬件无关的，处理与传输信息的工具。
XML 未来将会无所不在。XML 将成为最普遍的数据处理和数据传输的工具。

XHTML

可扩展超文本标记语言（eXtensible HyperText Markup Language），是一种标记语言，表现方式与超文本标记语言（HTML）类似，不过语法上更加严格。从继承关系上讲，HTML 是一种基于标准通用标记语言（SGML）的应用（HTML5 之前），是一种非常灵活的置标语言，而 XHTML 则基于可扩展标记语言（XML），XML 是 SGML 的一个子集。XHTML 1.0 在 2000年1月26日 成为 W3C 的推荐标准。

XHTML1.1 为 XHTML 最后的独立标准，2.0 止于草案阶段。XHTML5 则是属于 HTML5 标准的一部分，且名称已改为 以XML序列化的HTML5 XML-serialized HTML5，而非 可扩展的HTML eXtensible HyperText Markup Language。XHTML5 是对 HTML5 的 XML 序列化。XML 文档必须被设置为 XML 互联网文件类型，像 application/xhtml+xml 或者 application/xml。XHTML5 要求像 XML 一样严格的格式化的语法。在 XHTML5 中，HTML5 的<!DOCTYPE HTML> 可有可无的。

Content-Type: text/html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <title>HTML</title>
  </head>
  <body>
    <p>I am a HTML document</p>
  </body>
</html>

Content-Type: application/xhtml+xml <?xml version="1.0" encoding="UTF-8"?>
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
  <head>
    <title>XHTML</title>
  </head>
  <body>
    <p>I am a XHTML document</p>
  </body>
</html>

XHTML 曾经是作为 HTML 的继承者推出的,由于 HTML 的语法较为松散,因此就出现了由 DTD 定义规则,语法要求更加严格的 XHTML。XHTML 与 HTML 的主要区别是：

XHTML 与 HTML 的最大的变化在于所有标签必须闭合。
XHTML 中所有的标签必须小写。
XHTML 元素必须被正确地嵌套。
XHTML 文档必须拥有根元素。

HTML、XHTML、XML 和 SGML 的关系

SGML 定义电子文档和内容描述的标准。DTD 标准是 SGML 的一部分。
XML 是 SGML 的子集，优化版。
HTML 是遵循了 DTD 标准的 SGML 的文档，也可以说是 SGML 的一个实例。
XHTML 是遵循了 XML 标准的 HTML 文档。
HTML5 是最新的 HTML 标准。但不基于 SGML，所以不遵循 DTD 标准。

HTML5

HTML5 提供了一些新的元素和属性，反映典型的现代用法网站。其中有些是技术上类似 <div> 和 <span> 标签，但有一定含义，例如 <nav>（网站导航块）和 <footer>。这种标签将有利于搜索引擎的索引整理、小屏幕设备和视障人士使用。同时为其他浏览要素提供了新的功能，通过一个标准接口，如 <audio> 和 <video> 标记。一些过时的 HTML 4.01 标记将取消，其中包括纯粹用作显示效果的标记，如 <font> 和 <center>，因为它们已经被 CSS 取代。还有一些通过 DOM 的网络行为。

尽管和 SGML 在标记上的相似性，HTML5 的句法并不再基于它了，而是被设计成向后兼容对老版本的 HTML 的解析。它有一个新的开始列看起来就像 SGML 的文档类型声明，<!DOCTYPE HTML>，这会触发和标准兼容的渲染模式。

HTML5 与 HTML4.01 和 XHTML1.x 的差异

不再基于 SGML 所以也不再需要 DTD，文件类型声明仅有一型：<!DOCTYPE HTML>。
新的解析顺序：不再基于 SGML。
新的语义化标签：section, video, progress, nav, meter, time, aside, canvas, command, datalist, details, embed, figcaption, figure, footer, header, hgroup, keygen, mark, output, rp, rt, ruby, source, summary, wbr。
input 元素的新类型：date, email, url 等等。
新的属性：ping（用于 a 与 area）, charset（用于 meta）, async（用于 script）。
全局属性：id, tabindex, repeat。
新的全局属性：contenteditable, contextmenu, draggable, dropzone, hidden, spellcheck。
移除标签：acronym, applet, basefont, big, center, dir, font, frame, frameset, isindex, noframes, strike, tt。

除了原先的 DOM 接口，HTML5 增加了更多样化的 API。

Canvas
Timed Media Playback
Offline
Editable content
Drag and drop
History
MIME type and protocol handler registration
Microdata
Web Messaging
Web Storage – a key-value pair storage framework that provides behaviour similar to cookies but with larger storage capacity and improved API.

关于 HTML5 的新特性，参考 MDN 的HTML5

总结

本文介绍了一些和 HTML 相关的概念，这些概念其实并不清晰甚至有些混乱，主要就是 HTML 的标准化本身就走的比较磕磕绊绊，有些标准已经消失在历史中。不过现在我们只要专注于掌握 HTML5 标准即可。用来描述数据的 XML 也需要掌握。

参考文章

CSS 视觉格式化模型（一）：盒模型和盒类型

Wed, 19 Aug 2020 12:00:00 GMT

CSS 视觉格式化模型系列

前言

我们的浏览器说到底也就是一种信息的展示，无论是文字，图片还是其他媒体内容。内容的展示其实就是将内容按照一定的规则来对文档信息（HTML 文档和 CSS ）进行计算并渲染到屏幕上，这本质上上和现实中的印刷排版还是类似的，只不过载体不同。视觉格式化模型就是这套规则。我将分几篇文章来写一写我阅读标准的一些笔记。

视觉格式化模型 visual formatting model 对应CSS2.2的第九和第十章，我认为是 CSS2.2 中最核心的部分。

盒模型 box model

盒模型是我们了解视觉格式化模型的基础，我们的浏览器就是将文档中的元素转化为一个一个的盒子再来进行排版和渲染的，盒是浏览器排版和渲染的基本单位。盒模型描述了一个为文档树中的元素生成的并根据视觉格式化模型进行布局的矩形框。

我们先来了解一个盒子的基本结构（见下图）。一个盒子必然有一个 content area 和可选的 margin，padding 和 border。margin 表示外边距，padding 表示内边距，border 表示边框。content area 的宽高由盒内的内容以及视觉格式化模型的规则来决定。外边距总是透明的，内边距和边框的背景样式由元素的 background 决定。

当 margin 和 padding 的值是百分比时，注意的是这个百分比是根据该元素的包含块 containing block 的 width 来计算的。每一个元素生成的盒就是其后代元素的盒的包含块，这里说的该元素的包含块是指该元素所在的包含块，而不是该元素生成的包含块。如果包含块的宽度是由该元素决定的（即包含块没有设置宽度，由该元素撑开的情况），这种情况下产生的布局是 CSS2.2 中未定义的（即由具体实现的浏览器决定）。

以包含块的宽度为基准的原因就是为了在水平和垂直放下上有相同的留白，无论是外边距还是内边距都是为了分隔盒，让排版更加的清晰，容易阅读。而水平和垂直方向的边距用相同的基准也是符合直觉的。而为什么以宽度而不是高度为基准其实也很简单，我们的阅读习惯是从左向右的。

margin 和 padding 区别主要有三个个，第一是 margin 可以取值 auto 而 padding 不可以，第二是 margin 值可以为负但是 padding 不可以，第三是垂直方向上的 margin 对非替换的行内元素是不会产生任何效果。

可替换元素指的是独立于 CSS 的外部对象，它们的内容不受当前文档的样式的影响。CSS 可以影响可替换元素的位置，但不会影响到可替换元素自身的内容。某些可替换元素，例如 <iframe> 元素，可能具有自己的样式表，但它们不会继承父文档的样式。常见的可替换元素有 iframe，img，ebmed 和 video 等，有些元素只在特定情况下被当做可替换元素，比如 <option>，<audio>，<canvas>，<object>，<applet>。

margin 和 padding 都是简写属性，他们都有上下左右四个分量。简写属性接受多个值，用逗号分隔开。如果只给一个值，那么该值作用于四个分量；如果给两个值，那么第一个值作用于上下分量，而第二个值作用于左右分量；如果给三个值，那么第一个值作用于上分量，第二个值作用于左右分量，第三个值作用于下分量；如果给四个值，那么分别作用域上下左右分量。这种规则也适用于 border。

border 是简写属性，他有上下左右四个分量 border-top，border-right，border-bottome 和 border-left，不过和 margin/padding 不同，border 简写属性不能对四个方向设置不同的值。border 的四个分量依然是简写属性，他们还有 color，style 和 width 三个分量。而 border-color，border-style 和 border-width 也可以作为简写属性直接赋值，他们能够接受一到四个值，和 margin/padding 的规则一样，可以为四个方向应用不同的值。

border 相关的属性很多并且功能有所重叠，我们可以灵活运用，比如用 border 设置好四个方向的值在用 border-left 对 border 进行覆盖实现独立的效果等。

还有需要注意一点的是元素的 background 是覆盖到 border 的。

<div style="width: 100%; text-align:center;">
  <div
    style="display: inline-block; height: 300px; width: 300px; background: pink; border: 3px dashed rgba(0, 0, 0, 0.3)"
  ></div>
</div>

盒模型还有一点要注意的是 box-sizing 属性，该属性决定了如何计算元素的高度和宽度。默认设定下，宽度和高度只表示 content area ，也就是 content-box。而如果设置 box-sizing 为 border-box 的话，宽度和高度将包括 padding 和 border。

盒的类型

上面已经介绍了盒的基本结构，想要了解视觉格式化模型的具体内容我们还需要了解盒子的类型。

基本上我们的盒子可以分为两大类，一类是块级元素对应的盒子，一类是行内元素对应的盒子。但是在文档中将这两大类由进行了详细的说明，并引出了很多相似的概念，我们需要区分清楚。

包含块 containing block：一个元素生成的盒子是其后代盒子的包含块，通常情况下根元素所在的包含块就是初始包含块，他的大小取决于视口 viewport（浏览器环境下就是浏览器窗口）。包含块在标准中的具体定义看下面的介绍。
盒 box：一个抽象的概念，由 CSS 引擎根据文档中的内容所创建，主要用于文档元素的定位、布局和格式化等用途。盒子与元素并不是一一对应的，有时多个元素会合并生成一个盒子（列表元素），有时一个元素会生成多个盒子（如匿名盒子）。
块级元素block-level element：源文档中那些被格式化成视觉上的块的元素（例如，段落），元素的 display 为 block、list-item、table 时，该元素将成为块级元素。元素是否是块级元素仅是元素本身的属性，并不直接用于格式化上下文的创建或布局。
块级盒 block-level box：由块级元素生成，是参与块格式化上下文的盒。每个块级元素生成一个主块级盒（principal block-level box），用来包含后代盒及生成的内容，并且任何定位方案都与该盒有关。有些块级元素可能会生成除主盒外的额外的盒，比如 `list-item' 元素。这些额外的盒根据主盒来放置。
块容器盒 block container box：除了表格盒与替换元素外，一个块级盒也是块容器盒。一个块容器盒要么只包含块级盒，要么建立了行内格式化上下文并因此只包含行内盒。不是所有的块容器盒都是块级盒：非替换的行内块（比如 inline-block）与非替换的表格单元是块级容器盒，但不是块级盒。
块盒 block box：作为块级容器的块级盒也叫块盒。
块 block：块级盒（block-level box），块容器盒（block container box）和块盒（block box）这三个术语在没有歧义的时候就简称为“块（block）”。
行内级元素 inline-level element：行内级元素是源文档中那些不会形成新内容块的元素，内容分布于多行（例如，强调段落中的一部分文本，行内图片等等）。display 为 inline、inline-block、inline-table 的元素称为行内级元素。与块级元素一样，元素是否是行内级元素仅是元素本身的属性，并不直接用于格式化上下文的创建或布局。
行内级盒 inline-level box：行内级元素生成行内级盒，即参与行内格式化上下文的盒。行内级盒子包括行内盒和原子行内级盒两种，区别在于该盒是否参与行内格式化上下文的创建。
行内盒 inline box：特殊的行内级盒，其内容参与包含行内格式化上下文创建，display 值为 inline 的非替换元素会生成一个行内盒。比如 inline-block 虽然也是行内级盒，但是内部是块容器盒，对包含行内格式上下文来说它就像一个不透明的行内元素。与块盒类似，行内盒也分为具名行内盒和匿名行内盒（anonymous inline box）两种。
原子行内级盒 atomic inline-level box：不创建行内格式化上下文的行内级盒子，（例如，行内级替换元素，inline-block 元素和 inline-table 元素），它们作为单一的不透明盒（opaque box）参与包含行内格式化上下文。原子行内级盒子的内容不会拆分成多行显示。
行盒（也有翻译为行框的） line box：在行内格式化上下文中，盒是从包含块的顶部开始一个挨一个水平放置的。这些盒之间的水平外边距，边框和内边距都有效。盒可能会以不同的方式垂直对齐：以它们的底部或者顶部对齐，或者以它们里面的文本的基线对齐。包含来自同一行的盒的矩形区域叫做行盒。虽然标准中没有明确指出，但是行盒应该是块级的。行盒是我们无法看到也无法用语言接触到的一个概念上的盒。

一个盒子的类型不一定是唯一的，取决于你看盒子的角度，比如 inline-block 从父元素的盒角度来看，它是一个原子行内级盒，但是相对于内部的元素他也是一个块容器盒。

虽然概念看上去很多，但大部分都是不同的角度看同一个东西得出的不同概念，我们只需要对应起来理解。块级元素对应行内级元素，他们一般是由 display 来决定的；块级盒和行内级盒，他们由对应的块级元素或行内及元素生成，参与对应各格式上下文；块容器盒没有对应的行内级概念（行内格式上下文中的行框概念可以类比），他的角度是包含，即当前盒和它的后代之间的关系，它虽然不参与内部的子元素的布局和定位，但是他是内部子元素的布局定位的基准，可以简单理解为边界。

我们编写 HTML 和 CSS 都是以元素为单位，但是浏览器的工作过程却是把元素转换成一个一个的盒子，也就是手我们编写文档是以元素为单位，浏览器渲染文档是以盒为单位。

在标准中，块级元素块级盒和行内元素行内盒是并列的，但我认为块级元素块级盒才是排版的基本单元。所谓的行内元素行内盒都是在某个块内部的。一个块级盒内部要么全部是块级盒；要么建立了行内格式上下文，只有行内级盒。但其实行内格式上下文都是在行盒内 line boxex，而行框其实是块级的，也就是说从根元素 <html> 开始，块级盒里面只有块级盒，我们所见到的全是行内级元素的块容器盒，其实内部也是一个个垂直排列的行盒，只不过行盒我们无法看到。

CSS2.2 中没有明确说明行盒是块级的，我在 google 中也没有找到相关的说明。唯一看到的资料就是 winter 的文章，不过我认为这种逻辑是比较合理的，整个视觉格式化模型的结构在这种理解下变得非常有逻辑和清晰。

<!-- Some text 虽然没有被任何元素包裹，其实他显示包裹了一层匿名块盒，匿名块盒内部又包裹了一层匿名行盒 -->
<div>
  <div style="margin: 0 auto;border: 1px solid;width: 200px;font-size: 20px;">
    Some text
    <p style="border: 2px solid red">More text</p>
  </div>
</div>

Some text

More text

当一个行内盒包含流内块级元素（in-flow，没有因浮动或定位而脱离文档流的块级元素）时，行内盒（以及属于同一个行框的行内祖先）会被破坏，分布到该块级元素（以及任何连续的或只被可合并的空白符和/或流外元素隔开的块级兄弟：多个块级元素的情况）周围。行内盒会被切成两个部分（这两个部分各有一边是空的，也就是只有三条边），分布于块级元素的两边。拆分前的行框和拆分后的行框都被包进匿名块盒，这些匿名块盒会作为分隔块级盒的兄弟。当这样一个行内盒受到相对定位的影响时，任何由此产生的位移也会影响行内盒里面的块级盒。

<!-- 该例中p为行内元素，其中包含了两个匿名的文本块和一个块级元素，
最终的结果就是最外层的div产生一个块盒，里面的两个文本块产生两个匿名块盒，作为span块级盒的兄弟。
并且我们可以看到被块级元素分隔开的两个文本块的边框是断开的，这部分细节我们在下一篇格式上下文里面讲 -->
<div>
  <p style="display: inline; border: 1px solid red">
    This is anonymous text before the SPAN.
    <span style="display: block; border: 2px solid blue;">This is the content of SPAN.</span>
    This is anonymous text after the SPAN.
  </p>
</div>

This is anonymous text before the SPAN.This is the content of SPAN.This is anonymous text after the SPAN.

包含块 containing block

元素（生成的）盒的位置和大小有时是根据一个特定矩形计算的，叫做该元素的包含块（containing block）。元素包含块的定义如下：

根元素所在的包含块是一个被称为初始包含块的矩形。对于连续媒体，尺寸取自视口的尺寸，并且被固定在画布开始的位置；对于分页媒体就是页区（page area）。初始包含块的'direction'属性与根元素的相同
对于其它元素，如果该元素的 position 是 relative或者 static，包含块由其最近的块容器祖先盒的内容边界形成
如果元素具有 position: fixed，包含块由连续媒体的视口或者分页媒体的页区建立
如果元素具有 position: absolute，包含块由最近的 position 为 absolute，relative 或者 fixed 的祖先建立，按照如下方式：
- 如果该祖先是一个行内元素，包含块就是环绕着为该元素生成的第一个和最后一个行内盒的内边距框的边界框（bounding box）。在 CSS 2.2 中，如果该行内元素被跨行分割了，那么包含块是未定义的
- 否则，包含块由该祖先的内边距边界形成

display 属性

display 属性确定元素的类型和生成的盒的类型，以及内部的元素应用何种布局。display 属性会设置元素的内部和外部显示类型。外部类型确定了元素如何参与流 flow 的布局（关于 flow 的介绍在系列文章的第二篇），内部类型确定子元素的布局（这也就是我上面说的元素生成的盒不一定是唯一的，比如 inline-block。有些 display 属性的布局定义有一份完全单独的标准，比如 flex 属性就有自己单独的标准 CSS Flexible Box Layout Module Level 1。

display 的各种取值的含义如下：

block：这个取值会让元素生成一个主块盒。
inline-block：这个取值会让元素生成一个行内块级容器 inline-level block container。元素内部会被格式化为一个块盒；对于所在流，元素本身被格式化为一个原子行内级盒。
inline：这个取值会让元素生成一个或多个行内盒。
list-item：这个取值会让元素（比如 li 元素）生成一个主块盒和一个标记盒（列表项前的标记）。
none：这个取值下元素不会出现在格式化结构 formatting structure 中，对可视化媒体即不会生成盒也不会对布局有任何影响，对于最终的渲染结果，元素就好像不存在一样。元素的后代同样也不会生成盒，元素被完全移除格式化结构。后代元素的 display 属性不会影响上述行为。取值为 none 不会创建任何可见的盒；如果你想要元素在格式化结构中生成盒但是元素不可见，可以使用 CSS 的另一个属性 visibility。
table, inline-table, table-row-group, table-column, table-column-group, table-header-group, table-footer-group, table-row, table-cell, and table-caption：这些取值会让元素表现的像一个表格元素。

除了定位 positioning，浮动 float 和根元素，其他元素的 display 属性的计算值和指定值相同。关于例外的三者，我们会在下一篇文章进行讨论。

总结

本文主要是讲标准中的盒模型和盒的类型，盒是浏览器渲染文档的基本单元。我觉得这部分我们需要记住几点就行。

盒的结构。
文档被分成一个一个的块，根元素就是一个块盒。
一个块盒的子盒（直接子元素，嵌套的后代不在此列）要么全是块盒，要么全是行内级盒（其实行内级盒也是包含在一个看不见的行框中，而行框是块级的）。
块容器盒内的只要有一个块级元素，所有的行内元素都会被包裹上一层匿名块盒，为了保证第3 条中的内容。
块容器盒中未被任何元素包裹的文本将被一个匿名行内盒包裹（匿名行内盒外层就是匿名行块盒）

参考文章

ES6 迭代器 Iterator

Tue, 18 Aug 2020 12:00:00 GMT

前言

在 ES6 中我们可以用 for ... of 对很多对象进行遍历操作，包括数组，Map，Set，甚至是类数组对象和字符串都可以。之所以能够进行这样的操作是因为 ES6 引入了迭代器 Iterator 的机制，来为不同的数据结构提供一种统一的访问机制。本文就来讨论一下迭代器的机制。

概念

ES6 之前，我们遍历数组一般是使用 for 或者 map，forEach 等这样的 API。for 循环使用太麻烦，我们有时仅仅是需要数组中元素的值，但是我们需要提前知道数组的长度，并且声明一个索引变量，当出现嵌套的循环的时候，代码更复杂。而 map 和 forEach 等 API 则是 Array 对象特有的，使用起来也不够方便，比如无法中途跳出 forEach 循环， break 命令或 return 命令都不能奏效。。

所以 ES6 引入了迭代器和 for ... of 来统一和简化我们对对象的遍历。

要对对象进行遍历，首先要确定对象是否可遍历，以及如何进行遍历。ES6 就有两个协议：可迭代协议 和 迭代器协议。前者用来确定一个对象是可遍历的，后者告诉 for ... of 遍历对象的规则。

要确定一个对象是不是可迭代的，只要看看它有没有实现 Symbol.iterator 方法。Symbol.iterator 是一个内置 Symbol，它指向一个方法（即它是一个方法名），是专门供 for ... of 遍历使用的，当用 for ... of 对一个对象进行遍历的时候，就会首先寻找这个对象的 Symbol.iterator 方法。一个对象可遍历，就表示它自身或者其原型链上的某个对象实现了 Symbol.iterator 方法，这个方法是一个无参数的方法，其返回值为一个符合迭代器协议的对象。。这一些规则就是所谓的 可迭代协议。

Symbol.iterator 方法并不是没有要求的，这个方法必须要返回一个对象，这个对象必须实现了一个 next 方法。next() 方法必须返回一个对象，该对象应当有两个属性： done 和 value，如果返回了一个非对象值（比如 false 或 undefined），则会抛出一个 TypeError 异常（iterator.next() returned a non-object value）。这里的 done 是一个布尔值，表示迭代器是否还有下一个值。当迭代器还有下一个值，done 为 false，此时可省略；当迭代器已经遍历完毕，则此时 done 为 true。value 则表示迭代器的返回值，可以是任意 javascript 值，当 done 为 true 时刻省略。这就是 迭代器协议。

当一个对象满足上面两个协议的时候，就表示这个对象是可迭代对象，可以用 for ... of 对它进行遍历。当你将一个可迭代对象放入 for ... of 进行遍历的时候，会先调用这个对象的 Symbol.iterator 方法，然后用返回对象中的 next 方法不断对对象进行迭代，直到 done 为 true。

一个可迭代对象的实现如下：

let obj = {
  num: 0,
  [Symbol.iterator]() {
    let num = this.num //在 Symbol.iterator 中我们可以用 this 访问可迭代对象的属性，传递给 next，最后由 next 方法返回出去
    return {
      next() {
        if (num < 10) {
          return {
            value: num++,
            done: false
          }
        } else {
          return {
            value: undefined,
            done: true
          }
        }
      }
    }
  }
}

for (let c of obj) {
  console.log(c)
}
//输出：0 1 2 3 4 5 6 7 8 9

我们可以看到只要满足了可迭代协议和迭代协议，任何对象都能够用 for ... of 进行遍历，并且遍历行为是我们自定义的。其实 for ... of 的实现也很简单，就是一个 while 循环：

function forOf(obj, cb) {
  if (!obj[Symbol.iterator]) throw new TypeError(typeof obj + ' is not iterable')
  if (typeof obj[Symbol.iterator] !== 'function')
    throw new TypeError('Result of the Symbol.iterator method is not an object')
  if (typeof cb !== 'function') throw new TypeError('cb must be callable')

  let iterator = obj[Symbol.iterator]()
  let result = iterator.next()
  while (!result.done) {
    cb(result.value)
    result = iterator.next()
  }
}

forOf(obj, function (val) {
  console.log(val)
})

但是这样将 next 写在 Symbol.iterator 方法的返回对象中我们没法直接用 this 访问 obj 的属性所以我们可以改成如下形式：

let obj = {
  num: 0,
  [Symbol.iterator]() {
    return this
  },
  next() {
    if (this.num < 10) {
      return {
        value: this.num++,
        done: false
      }
    } else {
      return {
        value: undefined,
        done: true
      }
    }
  }
}

for (let c of obj) {
  console.log(c)
}

从这个修改我们可以看出来，可迭代对象也可以是一个迭代器，这在后面还会应用到，生成器对象 Generator 其实是这种实现。

其实不止 for ... of，还有很多其他操作也是调用的迭代器进行遍历，包括对数组和 Set 的解构赋值，扩展运算符，yield*，以及任何接受数组作为参数的场景。而且很多内置的对象默认就是可迭代的，目前所有的内置可迭代对象如下：String、Array、TypedArray、Map 和 Set，它们的原型对象都实现了 @@iterator 方法。

console.log(typeof 'clloz'[Symbol.iterator]) //function

let iterator = 'clloz'[Symbol.iterator]()

console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())

// { value: 'c', done: false }
// { value: 'l', done: false }
// { value: 'l', done: false }
// { value: 'o', done: false }
// { value: 'z', done: false }
// { value: undefined, done: true }

很多 API 可以接受一个可迭代对象作为参数：

new Map([iterable])
new WeakMap([iterable])
new Set([iterable])
new WeakSet([iterable])
Promise.all(iterable)
Promise.race(iterable)
Array.from(iterable)

内建迭代器

for ... of 调用的迭代器只能返回键值，但有时候我们希望能够返回键名，或者两者都需求。针对这种情况，ES6 为数组，Map 和 Set （其实 Object 也有这三个方法，不过不是返回迭代器）提供了三种不同的方法返回不同的迭代器：

entries() 返回一个遍历器对象，用来遍历 [键名, 键值] 组成的数组。对于数组，键名就是索引值。
keys() 返回一个遍历器对象，用来遍历所有的键名。
values() 返回一个遍历器对象，用来遍历所有的键值。

对于数组，for ... of 依次返回数组的元素值，keys() 返回每个元素的索引，values() 返回每个元素的值，entries() 返回每个元素所以和值组成的数组。

对于 Map，for ... of 按插入顺序返回每个键值对组成的数组，keys() 按插入顺序返回每个键名，values() 按插入顺序返回每个键值，entries() 和 for ... of 相同。

let m = new Map()
m.set(1, 'a')
m.set(2, 'b')
m.set(3, 'c')
m.set(4, 'd')

for (let c of m) {
  console.log(c)
}
// [ 1, 'a' ]
// [ 2, 'b' ]
// [ 3, 'c' ]
// [ 4, 'd' ]
for (let c of m.keys()) {
  console.log(c)
}
//1 2 3 4
for (let c of m.values()) {
  console.log(c)
}
//a b c d
for (let c of m.entries()) {
  console.log(c)
}
// [ 1, 'a' ]
// [ 2, 'b' ]
// [ 3, 'c' ]
// [ 4, 'd' ]

对于 Set，for ... of，keys() 和 values() 返回相同，说明 Set 结构的键名和键值是相同的， entries() 则和 Map 一样返回键名和键值组成的数组，只不过键名和键值相同。

let s = new Set()
s.add('a')
s.add('b')
s.add('c')

for (let c of s) {
  console.log(c)
}
// a b c
for (let c of s.keys()) {
  console.log(c)
}
// a b c
for (let c of s.values()) {
  console.log(c)
}
//a b c
for (let c of s.entries()) {
  console.log(c)
}
// [ 'a', 'a' ]
// [ 'b', 'b' ]
// [ 'c', 'c' ]

其实我们可以看出，对于 Set 来说，默认调用的是 values() 来获得迭代器，而 Map 默认是调用 entries() 来获得默认迭代器。

这里一定要注意数组，Map 和 Set 的 keys，values 和 entries 方法返回的是一个迭代器，而 Object 的对应方法返回的是一个数组。我们可以利用这些方法返回的迭代器来设置对象的 Symbol.iterator 方法让对象变为可迭代对象。

let obj = {
  nicknames: ['Jack', 'Jake', 'J-Dog'],
  [Symbol.iterator]() {
    console.log(Array.isArray(this.nicknames.entries()))
    return this.nicknames.entries()
  }
}

for (let c of obj) {
  console.log(c)
}

应用

迭代器的知识其实并不多也不复杂，上面的两个协议掌握即可，下面我来说一说一些应用。

实现链表

function List(value) {
  this.value = value
  this.next = null
}

List.prototype[Symbol.iterator] = function () {
  let current = this
  return {
    next() {
      if (current.next) {
        let value = current.value
        current = current.next
        return {
          value: value,
          done: false
        }
      } else {
        return {
          value: current.value,
          done: true
        }
      }
    }
  }
}
let a = new List('a')
let b = new List('b')
let c = new List('c')

a.next = b
b.next = c

for (let val of a) {
  console.log(val)
}

Linux常用命令

Tue, 18 Aug 2020 12:00:00 GMT

前言

整理 Linux 中的常用命令，方便查看使用。提供一个查询命令的网站linux-command。也可以用 man 命令查看对应命令的说明。

本文主要介绍 Linux 的常用命令，对 shell 的介绍和特殊符号的含义请查看另一篇文章Shell脚本语法和常用命令

命令

man 命令

man 命令是 Linux 下的帮助指令 (manual)，通过 man 指令可以查看 Linux 中的指令帮助、配置文件帮助和编程帮助等信息。 man(选项)(参数) 参数可以是数字或者关键字，数字是指定从哪本man手册中搜索帮助，关键字是指定要搜索帮助的关键字。数字有如下几种：

用户在 shell 环境可操作的命令或执行文件；
系统内核可调用的函数与工具等
一些常用的函数(function)与函数库(library)，大部分为C的函数库(libc)
设备文件说明，通常在/dev下的文件
配置文件或某些文件格式
游戏(games)
惯例与协议等，如Linux文件系统，网络协议，ASCII code等说明
系统管理员可用的管理命令
跟kernel有关的文件

# 选项
man -a #在所有的man帮助手册中搜索；
man -f # 等价于whatis指令，显示给定关键字的简短描述信息；
man -P # 指定内容时使用分页程序；
man -M # 指定man手册搜索的路径。

我们输入 man ls，它会在最左上角显示 LS（1），在这里，LS 表示手册名称，而 （1） 表示该手册位于第一节章，同样，我们输 man ifconfig 它会在最左上角显示 IFCONFIG（8）。也可以这样输入命令：man [章节号] 手册名称。

ls 命令

就是 list 的缩写，通过 ls 命令不仅可以查看 linux 文件夹包含的文件，而且可以查看文件权限(包括目录、文件夹、文件权限)查看目录信息等等。

# 选项
ls -a # 列出目录所有文件，包含以.开始的隐藏文件
ls -A # 列出除.及..的其它文件
ls -r # 反序排列
ls -t # 以文件修改时间排序
ls -S #以文件大小排序
ls -h #以易读大小显示
ls -l #除了文件名之外，还将文件的权限、所有者、文件大小等信息详细列出来

cd 命令

切换当前目录。

# 选项
cd / # 进入根目录
cd ~ # 进入 "home" 目录
cd - # 进入上一次工作路径
cd !$ # 把上个命令的参数作为cd参数使用。

pwd 命令

pwd 命令用于查看当前工作目录路径。

# 选项
pwd # 查看当前路径
pwd -P # 查看软连接的实际路径

mkdir 命令

mkdir 命令用于创建文件夹。参数为目录，指定要创建的目录列表，多个目录之间用空格隔开。

# 选项
mkdir -Z # 设置安全上下文，当使用SELinux时有效；
mkdir -m || mkdir --mode # 建立目录的同时设置目录的权限；
mkdir -p || mkdir --parents # 若所要建立目录的上层目录目前尚未建立，则会一并建立上层目录；
mkdir --version # 显示版本信息。

rm 命令

删除一个目录中的一个或多个文件或目录，如果没有使用 -r 选项，则 rm 不会删除目录。如果使用 rm 来删除文件，通常仍可以将该文件恢复原状。

# 选项
rm -d # 直接把欲删除的目录的硬连接数据删除成0，删除该目录；
rm -f # 强制删除文件或目录；
rm -i # 删除已有文件或目录之前先询问用户；
rm -r || rm -R # 递归处理，将指定目录下的所有文件与子目录一并处理；
rm --preserve-root #不对根目录进行递归操作；
rm -v # 显示指令的详细执行过程。

rmdir 命令

rmdir dirname用来删除空目录。当目录不再被使用时，或者磁盘空间已到达使用限定值，就需要删除失去使用价值的目录。利用 rmdir 命令可以从一个目录中删除一个或多个空的子目录。该命令从一个目录中删除一个或多个子目录，其中 dirname 表示目录名。如果 dirname 中没有指定路径，则删除当前目录下由 dirname 指定的目录；如 dirname 中包含路径，则删除指定位置的目录。删除目录时，必须具有对其父目录的写权限。

子目录被删除之前应该是空目录。就是说，该目录中的所有文件必须用 rm 命令全部删除，另外，当前工作目录必须在被删除目录之上，不能是被删除目录本身，也不能是被删除目录的子目录。

# 选项
rmdir -p || rmdir --parents # 删除指定目录后，若该目录的上层目录已变成空目录，则将其一并删除；
rmdir --ignore-fail-on-non-empty # 此选项使rmdir命令忽略由于删除非空目录时导致的错误信息；
rmdir -v || rmdir -verboes # 显示命令的详细执行过程；
rmdir --help # 显示命令的帮助信息；
rmdir --version # 显示命令的版本信息。

mv 命令

mv source target用来对文件或目录重新命名，或者将文件从一个目录移到另一个目录中。source 表示源文件或目录(源文件可以是多个文件，用空格分开，也可以使用通配符 mv * ../)，target 表示目标文件或目录。如果将一个文件移到一个已经存在的目标文件中，则目标文件的内容将被覆盖。

mv 命令可以用来将源文件移至一个目标文件中，或将一组文件移至一个目标目录中。源文件被移至目标文件有两种不同的结果：

如果目标文件是到某一目录文件的路径，源文件会被移到此目录下，且文件名不变。
如果目标文件不是目录文件，则源文件名(只能有一个)会变为此目标文件名，并覆盖己存在的同名文件。如果源文件和目标文件在同一个目录下，mv的作用就是改文件名。当目标文件是目录文件时，源文件或目录参数可以有多个，则所有的源文件都会被移至目标文件中。所有移到该目录下的文件都将保留以前的文件名。

注意事项：mv 与 cp 的结果不同，mv 好像文件“搬家”，文件个数并未增加。而 cp 对文件进行复制，文件个数增加了。

# 选项
mv --backup=<备份模式> # 若需覆盖文件，则覆盖前先行备份；
mv -b # 当文件存在时，覆盖前，为其创建一个备份；
mv -f # 若目标文件或目录与现有的文件或目录重复，则直接覆盖现有的文件或目录；
mv -i # 交互式操作，覆盖前先行询问用户，如果源文件与目标文件或目标目录中的文件同名，则询问用户是否覆盖目标文件。用户输入”y”，表示将覆盖目标文件；输入”n”，表示取消对源文件的移动。这样可以避免误将文件覆盖。
mv --strip-trailing-slashes # 删除源文件中的斜杠“/”；
mv -S<后缀> # 为备份文件指定后缀，而不使用默认的后缀；
mv --target-directory=<目录> # 指定源文件要移动到目标目录；
mv -u # 当源文件比目标文件新或者目标文件不存在时，才执行移动操作。

cp 命令

cp source target 用来将一个或多个源文件或者目录复制到指定的目的文件或目录。它可以将单个源文件复制成一个指定文件名的具体的文件或一个已经存在的目录下。cp 命令还支持同时复制多个文件，当一次复制多个文件时，目标文件参数必须是一个已经存在的目录，否则将出现错误。

# 选项
cp -a #此参数的效果和同时指定"-dpR"参数相同；
cp -d：当复制符号连接时，把目标文件或目录也建立为符号连接，并指向与源文件或目录连接的原始文件或目录；
cp -f # 强行复制文件或目录，不论目标文件或目录是否已存在；
cp -i # 覆盖既有文件之前先询问用户；
cp -l # 对源文件建立硬连接，而非复制文件；
cp -p # 保留源文件或目录的属性；
cp -R || cp r # 递归处理，将指定目录下的所有文件与子目录一并处理；
cp -s # 对源文件建立符号连接，而非复制文件；
cp -u # 使用这项参数后只会在源文件的更改时间较目标文件更新时或是名称相互对应的目标文件并不存在时，才复制文件；
cp -S # 在备份文件时，用指定的后缀“SUFFIX”代替文件的默认后缀；
cp -b # 覆盖已存在的文件目标前将目标文件备份；
cp -v # 详细显示命令执行的操作。

cat 命令

cat 连接多个文件并打印到标准输出。

显示文件内容，如果没有文件或文件为-则读取标准输入。
将多个文件的内容进行连接并打印到标准输出。
显示文件内容中的不可见字符(控制字符、换行符、制表符等)。

# 选项
cat -A # --show-all 等价于"-vET"组合选项。
cat -b, # --number-nonblank 只对非空行编号，从1开始编号，覆盖"-n"选项。
cat -e  # 等价于"-vE"组合选项。
cat -E # --show-ends 在每行的结尾显示'$'字符。
cat -n # --number 对所有行编号，从1开始编号。
cat -s # --squeeze-blank 压缩连续的空行到一行。
cat -t # 等价于"-vT"组合选项。
cat -T # --show-tabs 使用"^I"表示TAB（制表符）。
cat -u  #  POSIX兼容性选项，无意义。
cat -v # --show-nonprinting   使用"^"和"M-"符号显示控制字符，除了LFD（line feed，即换行符'\n'）和TAB（制表符）。
cat --help                   显示帮助信息并退出。
cat --version                显示版本信息并退出。

more 命令

是一个基于 vi 编辑器文本过滤器，它以全屏幕的方式按页显示文本文件的内容，支持 vi 中的关键字定位操作。more 名单中内置了若干快捷键，常用的有 H（获得帮助信息），Enter（向下翻滚一行），空格（向下滚动一屏），Q（退出命令）。语法 more(选项)(参数)。

该命令一次显示一屏文本，满屏后停下来，并且在屏幕的底部出现一个提示信息，给出至今己显示的该文件的百分比：--More--（XX%）可以用下列不同的方法对提示做出回答：

按 Space 键：显示文本的下一屏内容。
按 Enter 键：只显示文本的下一行内容。
按斜线符|：接着输入一个模式，可以在文本中寻找下一个相匹配的模式。
按 H 键：显示帮助屏，该屏上有相关的帮助信息。
按 B 键：显示上一屏内容。
Ctrl+F: ：向下滚动一屏
Ctrl+B：返回上一屏
=：输出当前行的行号
:f：输出文件名和当前行的行号
V：调用vi编辑器
!命令：调用 Shell，并执行命令
q：退出 more

# 选项
more -<数字> # 指定每屏显示的行数；
more -d # 显示“[press space to continue,'q' to quit.]”和“[Press 'h' for instructions]”；
more -c # 不进行滚屏操作。每次刷新这个屏幕；
more -s # 将多个空行压缩成一行显示；
more -u # 禁止下划线；
more <数字> # 从指定数字的行开始显示。

less 命令

less 命令的作用与 more 十分相似，都可以用来浏览文字档案的内容，不同的是 less 命令允许用户向前或向后浏览文件，而 more 命令只能向前浏览，而且 less 在查看之前不会加载整个文件。用 less 命令显示文件时，用 PageUp 键向上翻页，用 PageDown 键向下翻页。要退出 less 程序，应按 Q 键。操作和选项如下。

/ 字符串：向下搜索“字符串”的功能
? 字符串：向上搜索“字符串”的功能
n：重复前一个搜索（与 / 或 ? 有关）
N：反向重复前一个搜索（与 / 或 ? 有关）
-x <数字> 将“tab”键显示为规定的数字空格
b 向后翻一页
d 向后翻半页
h 显示帮助界面
Q 退出less 命令
u 向前滚动半页
y 向前滚动一行
空格键滚动一行
回车键滚动一页
[pagedown]：向下翻动一页
[pageup]：向上翻动一页

语法 less [选项] [参数]

# 选项
less -e # 文件内容显示完毕后，自动退出；
less -f # 强制显示文件；
less -g # 不加亮显示搜索到的所有关键词，仅显示当前显示的关键字，以提高显示速度；
less -l # 搜索时忽略大小写的差异；
less -N # 每一行行首显示行号；
less -s # 将连续多个空行压缩成一行显示；
less -S # 在单行显示较长的内容，而不换行显示；
less -x<数字> # 将TAB字符显示为指定个数的空格字符。

head 命令

head 用来显示档案的开头至标准输出中，默认 head 命令打印其相应文件的开头 10 行。处理多个文件时会在各个文件之前附加含有文件名的行。当没有文件或文件为 - 时，读取标准输入。

语法 head [选项] [参数]

# 选项
head -n<行数> # 显示的行数（行数为负数表示从最后向前数）

tail 命令

用于显示指定文件末尾内容，不指定文件时，作为输入信息进行处理。常用查看日志文件。

语法 tail [选项] [参数]

# 选项
tail -f # 循环读取（常用于查看递增的日志文件）
tail -n<行数> # 显示行数（从后向前）
tail -c<N> #——bytes=<N>：输出文件尾部的N（N为整数）个字节内容；

env 命令

env 命令用于显示系统中已存在的环境变量，以及在定义的环境中执行指令。该命令只使用 - 作为参数选项时，隐藏了选项 -i 的功能。若没有设置任何选项和参数时，则直接显示当前的环境变量。

如果使用env命令在新环境中执行指令时，会因为没有定义环境变量"PATH"而提示错误信息 such file or directory。此时，用户可以重新定义一个新的"PATH"或者使用绝对路径。

语法 env [选项] [参数]

# 选项
env -i # 开始一个新的空的环境；
env -u<变量名> # 从当前环境中删除指定的变量。

参数可以是定义在新的环境中变量，定义多个变量定义用空格隔开。格式为变量名=值；也可以指定要执行的指令和参数。

echo 命令

echo 命令用于在 shell 中打印 shell 变量的值，或者直接输出指定的字符串。linux 的 echo 命令，在 shell 编程中极为常用, 在终端下打印变量 value 的时候也是常常用到的，因此有必要了解下 echo 的用法 echo 命令的功能是在显示器上显示一段文字，一般起到一个提示的作用。

语法 echo [选项] [参数]

# 选项
echo -e：激活转义字符。

使用 -e 选项时，若字符串中出现以下字符，则特别加以处理，而不会将它当成一般文字输出：

\a 发出警告声；
\b 删除前一个字符；
\c 不产生进一步输出 (\c 后面的字符不会输出)；
\f 换行但光标仍旧停留在原来的位置；
\n 换行且光标移至行首；
\r 光标移至行首，但不换行；
\t 插入 tab；
\v 与 \f 相同；
\\ 插入 \ 字符；
\nnn 插入 nnn（八进制）所代表的 ASCII 字符；

echo 命令还可以设置输出的样式，格式如下：

echo -e "\033[字背景颜色；文字颜色m 字符串\033[0m" echo -e "\033[1;36;41m Something here \033[0m"

\033 代表键盘的 Ctl 键或 Esc 键（即 ASCII 码中的第 27 位 ESCAPE，八进制表示为 33）
1 代表字体行为(高亮，闪烁，下划线等)；
36 代表字体的颜色，
41 的位置代表背景色

注意：字背景颜色和文字颜色之间是英文的分号 ;，并且文字颜色后面有个 m ，字符串前后可以没有空格，如果有的话，输出也是同样有空格。在 Bash 中，Esc 字符可以用以下的语法来表示：\e，\033，\x1B。

字体颜色范围是 30 - 37, 0 表示重置。

echo -e "\033[30m 黑色字 \033[0m"
echo -e "\033[31m 红色字 \033[0m"
echo -e "\033[32m 绿色字 \033[0m"
echo -e "\033[33m 黄色字 \033[0m"
echo -e "\033[34m 蓝色字 \033[0m"
echo -e "\033[35m 紫色字 \033[0m"
echo -e "\033[36m 天蓝字 \033[0m"
echo -e "\033[37m 白色字 \033[0m"

背景颜色范围是 40 - 47

echo -e "\033[40;37m 黑底白字 \033[0m"
echo -e "\033[41;37m 红底白字 \033[0m"
echo -e "\033[42;37m 绿底白字 \033[0m"
echo -e "\033[43;37m 黄底白字 \033[0m"
echo -e "\033[44;37m 蓝底白字 \033[0m"
echo -e "\033[45;37m 紫底白字 \033[0m"
echo -e "\033[46;37m 天蓝底白字 \033[0m"
echo -e "\033[47;30m 白底黑字 \033[0m"

控制选项

033[0m # 关闭所有属性
\033[1m # 设置高亮度
\033[4m # 下划线
\033[5m # 闪烁
\033[7m # 反显
\033[8m # 消隐
\033[30m — \33[37m # 设置前景色
\033[40m — \33[47m # 设置背景色
\033[60A  # 光标上移60行
\033[60B  # 光标下移60行
\033[60C  # 光标右移60行
\033[60G  # 光标右移60行
\033[60D  # 光标左移60行
\033[y;xH # 设置光标位置
\033[2J   # 清屏
\033[K    # 清除从光标到行尾的内容
\033[s    # 保存光标位置
\033[u    # 恢复光标位置
\033[?25l # 隐藏光标
\033[?25h # 显示光标

结束非常规字符序列的 m 要紧跟前面的数字，不能有空格命令也可以写成echo -e "^[[44;37;5m ME \033[0m COOL"，其中的 ^[ 需要先按 ⌃ + V 键 ,然后再按 ESC 键生成。

在 RedHat 系统的 /etc/sysconfig/init 文件中有事先设置好的输出方式。

# color => new RH6.0 bootup
# verbose => old-style bootup
# anything else => new style bootup without ANSI colors or positioning
BOOTUP=color
# column to start "[  OK  ]" label in
RES_COL=60
# terminal sequence to move to that column. You could change this
# to something like "tput hpa ${RES_COL}" if your terminal supports it
MOVE_TO_COL="echo -en \\033[${RES_COL}G"
# terminal sequence to set color to a 'success' color (currently: green)
SETCOLOR_SUCCESS="echo -en \\033[0;32m"
# terminal sequence to set color to a 'failure' color (currently: red)
SETCOLOR_FAILURE="echo -en \\033[0;31m"
# terminal sequence to set color to a 'warning' color (currently: yellow)
SETCOLOR_WARNING="echo -en \\033[0;33m"
# terminal sequence to reset to the default color.
SETCOLOR_NORMAL="echo -en \\033[0;39m"

# 实例
echo -e "\e[1;31mThis is red text\e[0m" #红色字体

echo -e "\e[1;42mGreed Background\e[0m" # 绿色背景

echo -e "\033[37;31;5mMySQL Server Stop...\033[39;49;0m" #文字闪烁

文字和背景也可以设置更多颜色，参考网站Bash tips: Colors and formatting (ANSI/VT100 Control sequences)

which 命令

which 命令用于查找并显示给定命令的绝对路径，环境变量 PATH 中保存了查找命令时需要遍历的目录。which 指令会在环境变量 $PATH 设置的目录里查找符合条件的文件。也就是说，使用 which 命令，就可以看到某个系统命令是否存在，以及执行的到底是哪一个位置的命令。

# 选项
which -n<文件名长度> # 制定文件名长度，指定的长度必须大于或等于所有文件中最长的文件名；
which -p<文件名长度> # 与-n参数相同，但此处的<文件名长度>包含了文件的路径；
which -w # 指定输出时栏位的宽度；
which -V # 显示版本信息。

whereis 命令

whereis 命令只能用于程序名的搜索，而且只搜索二进制文件(参数 -b)、man 说明文件(参数-m)和源代码文件(参数-s)。如果省略参数，则返回所有信息。

和 find 相比，whereis 查找的速度非常快，这是因为 linux 系统会将系统内的所有文件都记录在一个数据库文件中，当使用 whereis 和下面即将介绍的 locate 时，会从数据库中查找数据，而不是像 find 命令那样，通过遍历硬盘来查找，效率自然会很高。但是该数据库文件并不是实时更新，默认情况下时一星期更新一次，因此，我们在用 whereis 和 locate 查找文件时，有时会找到已经被删除的数据，或者刚刚建立文件，却无法查找到，原因就是因为数据库文件没有被更新。

语法 whereis [选项] [参数]

# 选项
whereis -b # 只查找二进制文件(可执行文件)；
whereis -B<目录> # 只在设置的目录下查找二进制文件；
whereis -f # 不显示文件名前的路径名称；
whereis -m # 只查找说明文件；
whereis -M<目录> # 只在设置的目录下查找说明文件；
whereis -s # 只查找原始代码文件；
whereis -S<目录> # 只在设置的目录下查找原始代码文件；
whereis -u # 搜索默认路径下除可执行文件、源代码文件、帮助文件以外的其它文件。

参数：指令名：要查找的二进制程序、源文件和 man 手册页的指令名。

locate 命令

locate 通过搜寻系统内建文档数据库达到快速找到档案，数据库由 updatedb 程序来更新，updatedb 是由 cron daemon 周期性调用的。默认情况下 locate 命令在搜寻数据库时比由整个由硬盘资料来搜寻资料来得快，但较差劲的是 locate 所找到的档案若是最近才建立或刚更名的，可能会找不到，在内定值中，updatedb 每天会跑一次，可以由修改 crontab 来更新设定值 (etc/crontab)。locate 与 find 命令相似，可以使用如 *、?等进行正则匹配查找。

语法 locate [选项] [模式]

# 选项
-b, --basename  # 仅匹配路径名的基本名称
-c, --count     # 只输出找到的数量
-d, --database DBPATH # 使用DBPATH指定的数据库，而不是默认数据库 /var/lib/mlocate/mlocate.db
-e, --existing  # 仅打印当前现有文件的条目
-1 # 如果 是 1．则启动安全模式。在安全模式下，使用者不会看到权限无法看到 的档案。这会始速度减慢，因为 locate 必须至实际的档案系统中取得档案的  权限资料。
-0, --null            # 在输出上带有NUL的单独条目
-S, --statistics      # 不搜索条目，打印有关每个数据库的统计信息
-q                    # 安静模式，不会显示任何错误讯息。
-P, --nofollow, -H    # 检查文件存在时不要遵循尾随的符号链接
-l, --limit, -n LIMIT # 将输出(或计数)限制为LIMIT个条目
-n                    # 至多显示 n个输出。
-m, --mmap            # 被忽略，为了向后兼容
-r, --regexp REGEXP   # 使用基本正则表达式
    --regex           # 使用扩展正则表达式
-q, --quiet           # 安静模式，不会显示任何错误讯息
-s, --stdio           # 被忽略，为了向后兼容
-o                    # 指定资料库存的名称。
-h, --help            # 显示帮助
-i, --ignore-case     # 忽略大小写
-V, --version         # 显示版本信息

# 实例
locate -r '^/var.*reason$' # 查找 /var 目录下，以 reason 结尾的文件
locate pwd # 查找和 pwd 有关的文件
locate /etc/sh # 搜索 etc 目录下所有以 sh 开头的文件

find 命令

find 命令用来在指定目录下查找文件。任何位于参数之前的字符串都将被视为欲查找的目录名。如果使用该命令时，不设置任何参数，则 find 命令将在当前目录下查找子目录与文件，并且将查找到的子目录和文件全部进行显示。

语法 find pathname -options [-print -exec -depth -ok ...]

# 选项
-name #按照文件名查找文件
-perm #按文件权限查找文件
-user #按文件属主查找文件
-group  #按照文件所属的组来查找文件。
-type  #查找某一类型的文件，诸如：
# b - 块设备文件
# d - 目录
# c - 字符设备文件
# l - 符号链接文件
# p - 管道文件
# f - 普通文
-size n :[c] # 查找文件长度为n块文件，带有c时表文件字节大小
-amin n   # 查找系统中最后N分钟访问的文件
-atime n  # 查找系统中最后n*24小时访问的文件
-cmin n   # 查找系统中最后N分钟被改变文件状态的文件
-ctime n  # 查找系统中最后n*24小时被改变文件状态的文件
-mmin n   # 查找系统中最后N分钟被改变文件数据的文件
-mtime n  # 查找系统中最后n*24小时被改变文件数据的文件(用减号-来限定更改时间在距今n日以内的文件，而用加号+来限定更改时间在距今n日以前的文件。 )
-maxdepth n # 最大查找目录深度
-prune # 选项来指出需要忽略的目录。在使用-prune选项时要当心，因为如果你同时使用了-depth选项，那么-prune选项就会被find命令忽略
-newer # 如果希望查找更改时间比某个文件新但比另一个文件旧的所有文件，可以使用-newer选项
-print # find命令将匹配的文件输出到标准输出。
-exec # find命令对匹配的文件执行该参数所给出的shell命令。相应命令的形式为'command' {  } \;，注意{   }和\；之间的空格。
-ok # 和-exec的作用相同，只不过以一种更为安全的模式来执行该参数所给出的shell命令，在执行每一个命令之前，都会给出提示，让用户来确定是否执行。
-depth # 从指定目录下最深层的子目录开始查找；

# 实例
find -atime -2 # 查找48小时内修改过的文件
find ./ -name '*.log' # 在当前目录查找 以 .log 结尾的文件。 . 代表当前目录
find /opt -perm 777 #查找 /opt 目录下 权限为 777 的文件
find -size +1000c #查找大于 1K 的文件
find -size 1000c #查找等于 1000 字符的文件

find . -type f -mtime +10 -exec rm -f {} \; # 在当前目录中查找更改时间在10日以前的文件并删除它们(无提醒）
find . -name '*.log' mtime +5 -ok -exec rm {} \; # 当前目录中查找所有文件名以.log结尾、更改时间在5日以上的文件，并删除它们，只不过在删除之前先给出提示。 按y键删除文件，按n键不删除
find . -f -name 'passwd*' -exec grep "pkg" {} \; # 当前目录下查找文件名以 passwd 开头，内容包含 "pkg" 字符的文件
find . -name '*.log' -exec cp {} test3 \; # 用 exec 选项执行 cp 命令
find . -type f -print | xargs file # 查找当前目录下每个普通文件，然后使用 xargs 来判断文件类型
find . -type f -name "*.js" -exec grep -lF 'editor' {} \; # 查找当前目录下所有以 js 结尾的并且其中包含 'editor' 字符的普通文件
find -type f -name '*.js' | xargs grep -lF 'editor' # 查找当前目录下所有以 js 结尾的并且其中包含 'editor' 字符的普通文件
find . -name "*.log" | xargs -i mv {} test4 # 利用 xargs 执行 mv 命令
find . -name \*(转义） -type f -print | xargs grep -n 'hostnames' # 用 grep 命令在当前目录下的所有普通文件中搜索 hostnames 这个词，并标出所在行
find . -name '[a-z]*[4-9].log' -print # 查找当前目录中以一个小写字母开头，最后是 4 到 9 加上 .log 结束的文件
find test -path 'test/test4' -prune -o -print #

find 命令的参数非常多，用法爷非常多，这里只是列出了很小一部分，如果想详细了解可以用 man 命令查看。

chmod 命令

用于改变 linux 系统文件或目录的访问权限。用它控制文件或目录的访问权限。该命令有两种用法。一种是包含字母和操作符表达式的文字设定法；另一种是包含数字的数字设定法。

每一文件或目录的访问权限都有三组，每组用三位表示，分别为文件属主的读、写和执行权限；与属主同组的用户的读、写和执行权限；系统中其他用户的读、写和执行权限。可使用 ls -l 查找。关于 ls -l 的各个字段表示什么意思可以看我的另一篇文章WordPress文件权限问题

# 选项
-c 当发生改变时，报告处理信息
-R 处理指定目录以及其子目录下所有文件

权限范围

u ：user 目录或者文件的当前的用户
g ：group 目录或者文件的当前的群组
o ：other 除了目录或者文件的当前用户或群组之外的用户或者群组
a ：all 所有的用户及群组

权限代号：

r ：读权限，用数字 4 表示
w ：写权限，用数字 2 表示
x ：执行权限，用数字 1 表示
- ：删除权限，用数字 0 表示
s ：特殊权限

# 实例
chmod a+x t.log # 增加文件 t.log 所有用户可执行权限
chmod u=r t.log -c # 撤销原来所有的权限，然后使拥有者具有可读权限,并输出处理信息
chmod 751 t.log -c（或者：chmod u=rwx,g=rx,o=x t.log -c) # 给 file 的属主分配读、写、执行(7)的权限，给file的所在组分配读、执行(5)的权限，给其他用户分配执行(1)的权限
chmod u+r,g+r,o+r -R text/ -c # 将 test 目录及其子目录所有文件添加可读权限

tar 命令

用来压缩和解压文件。tar 本身不具有压缩功能，只具有打包功能，有关压缩及解压是调用其它的功能来完成（比如 gzip 和 bz2）。打包是指将一大堆文件或目录变成一个总的文件；压缩则是将一个大的文件通过一些压缩算法变成一个小文件。Linux 中很多压缩程序只能针对一个文件进行压缩，这样当你想要压缩一大堆文件时，你得先将这一大堆文件先打成一个包（tar 命令），然后再用压缩程序进行压缩（gzip bzip2）。

语法

# 选项
-c #建立新的压缩文件
-f #指定压缩文件
-r #添加文件到已经压缩文件包中
-u #添加改了和现有的文件到压缩包中
-x #从压缩包中抽取文件
-t #显示压缩文件中的内容
-z #支持gzip压缩
-j #支持bzip2压缩
-Z #支持compress解压文件
-v #显示操作过程

#实例
tar -cvf log.tar 1.log,2.log 或tar -cvf log.* # 将文件全部打包成 tar 包
tar -zcvf /tmp/etc.tar.gz /etc # 将 /etc 下的所有文件及目录打包到指定目录，并使用 gz 压缩
tar -ztvf /tmp/etc.tar.gz # 查看刚打包的文件内容（一定加z，因为是使用 gzip 压缩的）
tar --exclude /home/dmtsai -zcvf myfile.tar.gz /home/* /etc # 要压缩打包 /home, /etc ，但不要 /home/dmtsai

chown 命令

chown 将指定文件的拥有者改为指定的用户或组，用户可以是用户名或者用户 ID；组可以是组名或者组 ID；文件是以空格分开的要改变权限的文件列表，支持通配符。

# 选项
-c #显示更改的部分的信息
-R #处理指定目录及子目录

# 实例
chown -c mail:mail log2012.log # 改变拥有者和群组 并显示改变信息
chown -c :mail t.log # 改变文件群组
chown -cR mail: test/ # 改变文件夹及子文件目录属主及属组为 mail

df 命令

df 命令显示磁盘空间使用情况。获取硬盘被占用了多少空间，目前还剩下多少空间等信息，如果没有文件名被指定，则所有当前被挂载的文件系统的可用空间将被显示。默认情况下，磁盘空间将以 1KB 为单位进行显示，除非环境变量 POSIXLY_CORRECT 被指定，那样将以 512 字节为单位进行显示。

# 选项
-a #全部文件系统列表
-h #以方便阅读的方式显示信息
-i #显示inode信息
-k #区块为1024字节
-l #只显示本地磁盘
-T #列出文件系统类型

# 实例
df -l # 显示磁盘使用情况
df -haT # 以易读方式列出所有文件系统及其类型

du 命令

du 命令也是查看使用空间的，但是与 df 命令不同的是 du 命令是对文件和目录磁盘使用的空间的查看。

# 选项
-a #显示目录中所有文件大小
-k #以KB为单位显示文件大小
-m #以MB为单位显示文件大小
-g #以GB为单位显示文件大小
-h #以易读方式显示文件大小
-s #仅显示总计
-c #或--total  除了显示个别目录或文件的大小外，同时也显示所有目录或文件的总和

# 实例
du -h scf/ # 以易读方式显示文件夹内及子文件夹大小
du -ah scf/ # 以易读方式显示文件夹内所有文件大小
du -hc test/ scf/ # 显示几个文件或目录各自占用磁盘空间的大小，还统计它们的总和
du -hc --max-depth=1 scf/ # 输出当前目录下各个子目录所使用的空间

ln 命令

ln 命令的功能是为文件在另外一个位置建立一个同步的链接，当在不同目录需要该问题时，就不需要为每一个目录创建同样的文件，通过 ln 创建的链接（link）减少磁盘占用量。链接分为硬链接和软链接，关于两者的区别请看我的另一篇文章WordPress文件权限问题

# 选项
-b# 删除，覆盖以前建立的链接
-s #软链接（符号链接）
-v #显示详细处理过程

# 实例
ln -sv source.log link.log # 给文件创建软链接，并显示操作信息
ln -v source.log link1.log # 给文件创建硬链接，并显示操作信息
ln -sv /opt/soft/test/test3 /opt/soft/test/test5 # 给目录创建软链接

date 命令

Date 命令显示或设定系统的日期与时间。

# 选项
-d<字符串> 　#显示字符串所指的日期与时间。字符串前后必须加上双引号。
-s<字符串> 　#根据字符串来设置日期与时间。字符串前后必须加上双引号。
-u 　#显示GMT。
%H #小时(00-23)
%I #小时(00-12)
%M #分钟(以00-59来表示)
%s #总秒数。起算时间为1970-01-01 00:00:00 UTC。
%S #秒(以本地的惯用法来表示)
%a #星期的缩写。
%A #星期的完整名称。
%d #日期(以01-31来表示)。
%D #日期(含年月日)。
%m #月份(以01-12来表示)。
%y #年份(以00-99来表示)。
%Y #年份(以四位数来表示)。

# 实例
date +%Y%m%d --date="+1 day"  #显示下一天的日期
date -d "nov 22"  #今年的 11 月 22 日是星期三
date -d '2 weeks' #2周后的日期
date -d 'next monday' #下周一的日期
date -d next-day +%Y%m%d #明天的日期 或者：date -d tomorrow +%Y%m%d
date -d last-day +%Y%m%d #昨天的日期 或者：date -d yesterday +%Y%m%d
date -d last-month +%Y%m #上个月是几月
date -d next-month +%Y%m #下个月是几月

cal 命令

cal 命令可以用户显示公历（阳历）日历如只有一个参数，则表示年份(1-9999)，如有两个参数，则表示月份和年份。

#选项
-3 #显示前一月，当前月，后一月三个月的日历
-m #显示星期一为第一列
-j #显示在当前年第几天
-y #[year]显示当前年[year]份的日历

#实例
cal 9 2012 #显示指定年月日期
cal -y 2013 #显示2013年每个月日历
cal -3m #将星期一做为第一列,显示前中后三月

grep 命令

强大的文本搜索命令，grep(Global Regular Expression Print) 全局正则表达式搜索。

grep 的工作方式是这样的，它在一个或多个文件中搜索字符串模板。如果模板包括空格，则必须被引用，模板后的所有字符串被看作文件名。搜索的结果被送到标准输出，不影响原文件内容。

关于正则表达式的应用参考我的另一篇文章正则表达式入门以及JavaScript中的应用，需要注意一点的是在 grep 中分组 () 圆括号需要转义。

#选项
-a --text  # 不要忽略二进制数据。
-A <显示行数>   --after-context=<显示行数>   # 除了显示符合范本样式的那一行之外，并显示该行之后的内容。
-b --byte-offset                           # 在显示符合范本样式的那一行之外，并显示该行之前的内容。
-B<显示行数>   --before-context=<显示行数>   # 除了显示符合样式的那一行之外，并显示该行之前的内容。
-c --count    # 计算符合范本样式的列数。
-C<显示行数> --context=<显示行数>或-<显示行数> # 除了显示符合范本样式的那一列之外，并显示该列之前后的内容。
-d<进行动作> --directories=<动作>  # 当指定要查找的是目录而非文件时，必须使用这项参数，否则grep命令将回报信息并停止动作。
-e<范本样式> --regexp=<范本样式>   # 指定字符串作为查找文件内容的范本样式。
-E --extended-regexp             # 将范本样式为延伸的普通表示法来使用，意味着使用能使用扩展正则表达式。
-f<范本文件> --file=<规则文件>     # 指定范本文件，其内容有一个或多个范本样式，让grep查找符合范本条件的文件内容，格式为每一列的范本样式。
-F --fixed-regexp   # 将范本样式视为固定字符串的列表。
-G --basic-regexp   # 将范本样式视为普通的表示法来使用。
-h --no-filename    # 在显示符合范本样式的那一列之前，不标示该列所属的文件名称。
-H --with-filename  # 在显示符合范本样式的那一列之前，标示该列的文件名称。
-i --ignore-case    # 忽略字符大小写的差别。
-l --file-with-matches   # 列出文件内容符合指定的范本样式的文件名称。
-L --files-without-match # 列出文件内容不符合指定的范本样式的文件名称。
-n --line-number         # 在显示符合范本样式的那一列之前，标示出该列的编号。
-P --perl-regexp         # PATTERN 是一个 Perl 正则表达式
-q --quiet或--silent     # 不显示任何信息。
-R/-r  --recursive       # 此参数的效果和指定“-d recurse”参数相同。
-s --no-messages  # 不显示错误信息。
-v --revert-match # 反转查找。
-V --version      # 显示版本信息。
-w --word-regexp  # 只显示全字符合的列。
-x --line-regexp  # 只显示全列符合的列。
-y # 此参数效果跟“-i”相同。
-o # 只输出文件中匹配到的部分。
-m <num> --max-count=<num> # 找到num行结果后停止查找，用来限制匹配行数

#实例
ps -ef | grep svn #查找指定进程
ps -ef | grep svn -c #查找指定进程个数
cat test1.txt | grep -f key.log #从文件中读取关键词
grep -lR '^grep' /tmp #从文件夹中递归查找以grep开头的行，并只列出文件
grep '^[^x]' test.txt #查找非x开头的行内容
grep -E 'ed|at' test.txt #显示包含 ed 或者 at 字符的内容行

wc 命令

wc(word count) 命令功能为统计指定的文件中字节数、字数、行数，并将统计结果输出。

#选项
-c #统计字节数
-l #统计行数
-m #统计字符数
-w #统计词数，一个字被定义为由空白、跳格或换行字符分隔的字符串

#实例
wc text.txt #查找文件的 行数 单词数 字节数 文件名，结果：7 8 70 test.txt
cat test.txt | wc -l #统计输出结果的行数

ps 命令

ps(process status)，用来查看当前运行的进程状态，一次性查看，如果需要动态连续结果使用 top

linux上进程有 5 种状态:

运行(正在运行或在运行队列中等待)
中断(休眠中, 受阻, 在等待某个条件的形成或接受到信号)
不可中断(收到信号不唤醒和不可运行, 进程必须等待直到有中断发生)
僵死(进程已终止, 但进程描述符存在, 直到父进程调用 wait4() 系统调用后释放)
停止(进程收到 SIGSTOP, SIGSTP, SIGTIN, SIGTOU 信号后停止运行运行)

ps 工具标识进程的 5 种状态码:

D 不可中断 uninterruptible sleep (usually IO)
R 运行 runnable (on run queue)
S 中断 sleeping
T 停止 traced or stopped
Z 僵死 a defunct (”zombie”) process

# 选项
-A #显示所有进程
a #显示所有进程
-a #显示同一终端下所有进程
c #显示进程真实名称
e #显示环境变量
f #显示进程间的关系
r #显示当前终端运行的进程
-aux #显示所有包含其它使用的进程

# 实例
ps -ef #显示当前所有进程环境变量及进程间关系
ps -A #显示当前所有进程
ps -aux | grep apache #与grep联用查找某进程
ps aux | grep '(cron|syslog)' #找出与 cron 与 syslog 这两个服务有关的 PID 号码

top 命令

top 命令显示当前系统正在执行的进程的相关信息，包括进程 ID、内存占用率、CPU 占用率等。

#选项
-c 显示完整的进程命令
-s 保密模式
-p <进程号> 指定进程显示
-n <次数>循环显示次数

结果的前五行是当前系统情况整体的统计信息区。举例如下的信息：

top - 14:06:23 up 70 days, 16:44,  2 users,  load average: 1.25, 1.32, 1.35
Tasks: 206 total,   1 running, 205 sleeping,   0 stopped,   0 zombie
Cpu(s):  5.9%us,  3.4%sy,  0.0%ni, 90.4%id,  0.0%wa,  0.0%hi,  0.2%si,  0.0%st
Mem:  32949016k total, 14411180k used, 18537836k free,   169884k buffers
Swap: 32764556k total,        0k used, 32764556k free,  3612636k cached
PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND

28894 root      22   0 1501m 405m  10m S 52.2  1.3   2534:16 java

第一行，任务队列信息，同 uptime 命令的执行结果，具体参数说明情况如下：
- 14:06:23 — 当前系统时间
- up 70 days, 16:44 — 系统已经运行了 70 天 16 小时 44 分钟
- 2 users — 当前有 2 个用户登录系统
- load average: 1.15, 1.42, 1.44 — load average 后面的三个数分别是 1 分钟、5 分钟、15 分钟的负载情况。load average数据是每隔5秒钟检查一次活跃的进程数，然后按特定算法计算出的数值。如果这个数除以逻辑CPU的数量，结果高于5的时候就表明系统在超负荷运转了。
第二行，Tasks — 任务（进程），具体信息说明举例：系统现在共有 206 个进程，其中处于运行中的有1个，205个在休眠（sleep），stoped 状态的有 0 个，zombie 状态（僵尸）的有 0 个。
第三行，cpu状态信息，具体属性说明如下：
- 5.9%us — 用户空间占用 CPU 的百分比。
- 3.4% sy — 内核空间占用 CPU 的百分比。
- 0.0% ni — 改变过优先级的进程占用 CPU 的百分比
- 90.4% id— 空闲 CPU 百分比
- 0.0% wa — IO 等待占用 CPU 的百分比
- 0.0% hi — 硬中断（Hardware IRQ）占用 CPU 的百分比
- 0.2% si — 软中断（Software Interrupts）占用 CPU 的百分比
第四行，内存状态，具体信息如下：
- 32949016k total — 物理内存总量（32GB）
- 14411180k used — 使用中的内存总量（14GB）
- 18537836k free — 空闲内存总量（18GB）
- 169884k buffers — 缓存的内存量（169M）
第五行，swap交换分区信息，具体信息说明如下：
- 32764556k total — 交换区总量（32GB）
- 0k used — 使用的交换区总量（0K）
- 32764556k free — 空闲交换区总量（32GB）
- 3612636k cached — 缓冲的交换区总量（3.6GB）
第六行空行。
第七行以下：各进程（任务）的状态监控，项目列信息说明如下：
- PID — 进程 id
- USER — 进程所有者
- PR — 进程优先级
- NI — nice 值。负值表示高优先级，正值表示低优先级
- VIRT — 进程使用的虚拟内存总量，单位 kb。VIRT=SWAP+RES
- RES — 进程使用的、未被换出的物理内存大小，单位 kb。RES=CODE+DATA
- SHR — 共享内存大小，单位 kb
- S — 进程状态。
- %CPU — 上次更新到现在的CPU时间占用百分比
- %MEM — 进程使用的物理内存百分比
- TIME+ — 进程使用的 CPU 时间总计，单位 1/100 秒
- COMMAND — 进程名称（命令名/命令行）

top 命令的交互指令

h：显示 top 交互命令帮助信息
c：切换显示命令名称和完整命令行
m：以内存使用率排序
P 根据 CPU 使用百分比大小进行排序
T：根据时间/累计时间进行排序
W：将当前设置写入~/.toprc 文件中
o：或者 O 改变显示项目的顺序
q：退出

Mac 下排序需要先输入 o 然后输入列名，比如 mem，cpu 等。

kill 命令

kill 命令发送指定的信号到相应进程。不指定型号将发送 SIGTERM（15） 终止指定进程。如果仍无法终止该程序可用 -KILL 参数，其发送的信号为SIGKILL(9) ，将强制结束进程，使用 ps 命令或者 jobs 命令可以查看进程号。root 用户将影响用户的进程，非 root 用户只能影响自己的进程。

# 选项
-l  #信号，若果不加信号的编号参数，则使用“-l”参数会列出全部的信号名称
-a  #当处理当前进程时，不限制命令名和进程号的对应关系
-p  #指定kill 命令只打印相关进程的进程号，而不发送任何信号
-s  #指定发送信号
-u  #指定用户

#实例
kill -9 $(ps -ef | grep pro1) #先使用ps查找进程pro1，然后用kill杀掉

free 命令

free 命令显示系统内存使用情况，包括物理内存、交互区内存(swap)和内核缓冲区内存。

# 选项
-b #以Byte显示内存使用情况
-k #以kb为单位显示内存使用情况
-m #以mb为单位显示内存使用情况
-g #以gb为单位显示内存使用情况
-s<间隔秒数> #持续显示内存
-t #显示内存使用总合

#实例：
free #显示内存使用情况
free -k #显示内存使用情况
free -m #显示内存使用情况
free -t #以总和的形式显示内存的使用信息
free -s 10 #周期性查询内存使用情况

参考文章

CSS自定义属性

Tue, 11 Aug 2020 12:00:00 GMT

前言

CSS 自定义属性也被称为 CSS 变量。一直以来，在 CSS 中使用变量和函数都是很多人的期待，没有变量和函数的 CSS 不够灵活。目前的 CSS 依然是依靠层叠和继承来实现元素之间的样式关联，但实际上一些在结构上“不相关”的元素之间的样式并不是完全不相关的，比如我们整个页面的风格，色调等。目前的 CSS 更像是一个标记语言，一份对 DOM 文档的配置表，是静态的。引入变量和函数是 CSS 的一个发展方向，今天这篇文章就介绍一下目前已经被绝大多数浏览器支持的 CSS 自定义属性。

兼容性

我们可以在Can I use上查看到目前的 CSS variable 的兼容性，除了 IE、 QQ 和 baidu，其他的主流浏览器都已经支持该特性。该特性目前处于CR状态。

使用方法

带有前缀 -- 的属性名，比如 --example、--name，表示的是带有值的自定义属性，其可以通过 var 函数在全文档范围内复用的。

自定义属性名是大小写敏感的，--my-color 和 --My-color 会被认为是两个不同的自定义属性。

自定义属性的值可以是任何合法的 CSS 属性值。自定义属性也可以像别的 CSS 属性指定选择器。但是一般情况下我们是定义全局变量，选择器为 :root，:root 这个 CSS 伪类匹配文档树的根元素。对于 HTML 来说，:root 表示 <html>元素，除了优先级更高之外，与 html 选择器相同。。（我们也可以在非常复杂的选择器中比如 #wrap .container li.active 中定义变量，但一般不会有这种需求）

自定义属性的使用也非常简单，像函数调用一样 var()。var() 函数可以代替元素中任何属性中的值的任何部分。var() 函数不能作为属性名、选择器或者其他除了属性值之外的值。（这样做通常会产生无效的语法或者一个没有关联到变量的值。）语法 var( <custom-property-name> , <declaration-value>? )，方法的第一个参数是要替换的自定义属性的名称。函数的可选第二个参数用作回退值。如果第一个参数引用的自定义属性无效，则该函数将使用第二个值。

/* 只要合法的CSS属性值就可以作为变量值 */
--somekeyword: left;
--somecolor: #0000ff;
--somecomplexvalue: 3px 6px rgb(20, 32, 54);

/* 只能在选择器内使用 */
selector {
  --theme-color: gray;
}

/* 设置全局变量 */
:root {
  --theme-color: gray;
}

/* 使用变量 */
.button {
  background-color: var(--theme-color);
}

.title {
  color: var(--theme-color);
}

.image-grid > .image {
  border-color: var(--theme-color);
}

自定义属性并不是你在其他编程语言中遇到的实际的变量。这些值仅当需要的时候才会计算，而并不会按其他规则进行保存。比如，你不能为元素设置一个属性，然后让它从兄弟或旁支子孙规则上获取值。属性仅用于匹配当前选择器及其子孙，这和通常的 CSS 是一样的。

自定义属性的回退值允许使用逗号。例如， var(--foo, red, blue) 将 red, blue 同时指定为回退值；即是说任何在第一个逗号之后到函数结尾前的值都会被考虑为回退值。

实际上回退值可以包含任何字符，但是部分有特殊含义的字符除外，例如换行符、不匹配的右括号（如 )、] 或 }）、感叹号以及顶层分号（不被任何非 var() 的括号包裹的分号，例如var(--bg-color, --bs;color)是不合法的，而 var(--bg-color, --value(bs;color)) 是合法的）。

var() 的第二个参数也可以用 var() 嵌套。但是不建议这样使用，性能会有影响。

.two {
  color: var(--my-var, red); /* Red if --my-var is not defined */
}

.three {
  background-color: var(
    --my-var,
    var(--my-background, pink)
  ); /* pink if --my-var and --my-background are not defined */
}

.three {
  background-color: var(--my-var, --my-background, pink); /* Invalid: "--my-background, pink" */
}

当浏览器遇到无效的 var() 时（比如变量未设定并且没给出缺省值，或者当前元素不支持该属性），会使用继承值或初始值代替。

/*若为一个p元素设置如下的CSS*/
:root {
  --text-color: 16px;
}
p {
  color: blue;
}
p {
  color: var(--text-color);
}

浏览器会将 --text-color 的值替换给了 var(--text-color)，但是 16px 并不是 color 的合法属性值。代换之后，该属性不会产生任何作用。当遇到一个无效的 var() 时，浏览器会先看父元素有没有设置对应的属性，有则继承；如果没有则使用该属性的默认值。

自定义属性还可以和 calc() 结合实现更强大的功能。

:root {
  --base-size: 4px;
}
.title {
  text-size: calc(5 * var(--base-size));
}
.body {
  text-size: calc(3 * var(--base-size));
}
:root {
  --base-size: 4px;
  --title-multiplier: 5;
  --body-multiplier: 3;
}
.title {
  text-size: calc(var(--title-multiplier) * var(--base-size));
}
.body {
  text-size: calc(var(--body-multiplier) * var(--base-size));
}

在 JavaScript 中获取或者修改 CSS 变量和操作普通 CSS 属性是一样的，并且有了自定义属性后我们也可以更抽象地用 JavaScript 控制 CSS 了，一定程度上实现 JavaScript 和 CSS 的解耦，将一些需要用 JavaScript 操作的 CSS 属性用变量代替，我们只要操作这个变量即可，而不用管在哪些元素中使用了这个变量。

// 获取一个 Dom 节点上的 CSS 变量
element.style.getPropertyValue('--my-var')

// 获取任意 Dom 节点上的 CSS 变量
getComputedStyle(element).getPropertyValue('--my-var')

// 修改一个 Dom 节点上的 CSS 变量
element.style.setProperty('--my-var', jsVar + 4)

作用

我在前言中已经提到过自定义属性的作用，虽然我们在 CSS 中利用级联和继承来实现属性的复用，但是一些在 DOM 结构上并不相关的元素可能也有要复用的属性。复杂的网站都会有大量的 CSS 代码，通常也会有许多重复的值，比如同一个颜色值可能在很多地方被使用，如果这个值发生了变化，需要全局搜索并且一个一个替换。自定义属性很好的解决了这个问题。另一个好处是语义化的标识。比如，--main-text-color 会比 #00ff00 更易理解，尤其是这个颜色值在其他上下文中也被使用到。

/*不用自定义属性的实现*/
.image-grid {
  display: flex;
  flex-wrap: wrap;
  padding: 8px;
}

.image-grid > .image {
  margin: 8px;
  width: calc(100% - 16px);
}

@media (min-size: 600px) {
  /* 3 images per line */
  .image-grid > .image {
    width: calc(100% / 3 - 16px);
  }
}

@media (min-size: 1024px) {
  /* 6 images per line */
  .image-grid > .image {
    width: calc(100% / 6 - 16px);
  }
}

/*用自定义属性的实现*/
:root {
  --grid-spacing: 16px;
  --grid-columns: 1;
}

.image-grid {
  display: flex;
  flex-wrap: wrap;
  padding: calc(var(--grid-spacing) / 2);
}

.image-grid > .image {
  margin: calc(var(--grid-spacing) / 2);
  width: calc(100% / var(--grid-columns) - var(--grid-spacing));
}

@media (min-size: 600px) {
  :root {
    --grid-columns: 3;
  }
}

@media (min-size: 1024px) {
  :root {
    --grid-columns: 6;
  }
}

参考文章

enca查看修改文件charset

Sun, 09 Aug 2020 12:00:00 GMT

前言

Mac 的默认文本编辑器 TextEdit 不能查看和修改编码格式的，有时候打开一些 GB2312 的中文文本会有乱码。虽然 vscode 可以修改，但是比较麻烦。这里介绍一个可以查看、修改 charset 的工具 enca。

安装和使用

完整的使用教程查看官方文档，本文只介绍一些基础的使用方法。

Mac 上的安装非常简单：brew install enca。

使用方法：

//帮助
enca --help
//查看语言列表
enca --list language
//查看编码
enca -L zh_CN filename
//修改编码，覆盖源文件
enca -L zh_CN -x UTF-8 filename
//修改编码，写入新文件
enca -L zh_CN -x UTF-8 source_filename target_filename

简单的nodejs爬虫

Sun, 09 Aug 2020 12:00:00 GMT

前言

我们一般在https://www.w3.org/TR/中查找前端相关的标准文档，但是各种各样的文档非常多，想要找到我们想要的文档有时候比较麻烦。今天就写一个简单的 NodeJS 的小爬虫来把所有的 CSS 相关文档爬取然后以列表的形式输出到一个页面上。

准备工作

新建一个项目，然后 npm init 初始化。然后安装依赖：

superagent：一个轻量的渐进式的 ajax API，我们用来请求目标页面。
cheerio：相当于 jQuery，我们用来处理 DOM 元素。
express：用来搭建一个简单的 HTTP 服务器，也可以直接用 node 自带的 http 模块。
open：在浏览器中打开目标页面，完成数据处理后展示用。

主要代码

整个处理逻辑非常简单，用 superagent 请求目标页面，分析页面的 DOM 解构，取出需要的部分，然后对数据进行包装，返回给页面。

请求页面

这里就是直接调用 superagent 来获取页面的 DOM 文档，返回的 res 是一个对象，我们需要使用的是其中的 text 属性的值，也就是 DOM 文档对应的字符串。

superagent.get('https://www.w3.org/TR/').end((err, res) => {
  if (err) {
    console.log(`抓取失败：${err}`)
  } else {
    CSS_std = getCSSStd(res)
    console.log('complete!')
    open('http://localhost:3000/')
  }
})

解析文档

当我们已经获取了 DOM 文档以后我们要做的就是分析 DOM 解构，然后取出我们需要的内容。w3.org 的页面解构也很简单，我们在浏览器的开发者工具的帮助下很快能定位到我们需要的 DOM 解构。

<li
  data-title="media queries level 5"
  data-tag="css"
  data-status="wd"
  data-version="upcoming ed"
  style="display: inline-block; opacity: 1;"
>
  <div class="profile">WD</div>
  <h2 class="WorkingDraft">
    <a
      href="https://www.w3.org/TR/2020/WD-mediaqueries-5-20200731/"
      title="Latest draft of Media Queries Level 5 formally approved by the group"
      >Media Queries Level 5</a
    >
  </h2>
  <p class="deliverer">Cascading Style Sheets (CSS) Working Group</p>
  <p class="pubdetails">
    2020-07-31 -
    <a title="Media Queries Level 5 publication history" href="/standards/history/mediaqueries-5"
      >History</a
    >-
    <a
      href="https://drafts.csswg.org/mediaqueries-5/"
      title="Latest editor's draft of Media Queries Level 5"
      >Editor's Draft</a
    >
  </p>
  <ul class="editorlist">
    <li>Dean Jackson</li>
    <li>Florian Rivoal</li>
    <li>Tab Atkins Jr.</li>
  </ul>
  <ul class="taglist">
    <li class="css">CSS</li>
  </ul>
</li>

所有的标准还有草稿都是以列表的形式展示，在每一个列表元素中，我们需要的内容一个是标准或者草稿的名字，一个是 url，将他们解析出来放到一个对象中。

function getCSSStd(res) {
  let stdArr = []
  let $ = cheerio.load(res.text)

  $('#container [data-tag="css"]').each((idx, el) => {
    let std = {
      name: $(el).children('h2').children('a').attr('title'),
      url: $(el).children('h2').children('a').attr('href')
    }
    stdArr.push(std)
  })
  return stdArr
}

我们用 cheerio.load 方法将 DOM 字符串转化成一个类似 jQuery 对象的形式，然后就利用对象的方法将我们需要的属性取出依次存入一个数组中，几乎和 jQuery 没有什么区别，非常简单。

返回页面

现在我们已经获得了所有 CSS 相关的标准或草稿的名称和 url，剩下的就是将这些内容拼成一个 HTML 文档，通过 express 搭建的 http 服务器返回到浏览器上。

function buildTemplate(arr) {
  let str = ''
  for (let i = 0; i < arr.length; i++) {
    str += `<li><a href="${arr[i].url}" target="_blank" rel="noopener noreferrer">${arr[i].name}</a></li>`
  }
  return `<html name=clloz>
    <head>
    </head>
    <body>
        <ul>
           ${str}
        </ul>
    </body>
    </html>`
}

循环遍历数组，将名称和 url 拼接成要返回的 HTML 文档字符串。

let server = app.listen(3000, function () {
  let host = server.address().address
  let port = server.address().port
  console.log('Your App is running at http://%s:%s', host, port)
})

app.get('/', (req, res) => {
  res.setHeader('Content-Type', 'text/html')
  res.end(buildTemplate(CSS_std))
})

用 express 搭建 HTTP 服务器，监听 3000 端口，返回我们拼接完成的 HTML 文档。当解析完成之后，open('http://localhost:3000/'); 会帮我们打开默认浏览器，我们就能看到所有 CSS 相关的标准链接。

完整代码查看Github

参考文章

选择器匹配元素

Sun, 09 Aug 2020 12:00:00 GMT

前言

用原生的 JavaScript 实现给定一个选择器（复合选择器和子选择器，不考虑逗号），和一个元素，判断该元素是否与该选择器匹配。

实现

对于一个选择器比如 div #myid .class1.class2，我们应该是从后向前匹配。我们用 String.prototype.split() 方法将嵌套的选择器放入一个数组，然后从后向前依次进行匹配。最内层的选择器如果匹配失败则直接返回 false，其他父层级选择器则要依次向上遍历匹配。

复合选择器的匹配

解决了基本的逻辑，我们需要处理的就是如何将一个复合选择器和元素进行匹配。比如 div#myid.class1.class2 这样的复合选择器。我的思路是用正则表达式将复合选择器分解为简单选择器，然后和元素的属性进行对比。

function specificity(selector) {
  let reg = /(?<tagname>(\w+)?)(?<id>(#\w+)?)(?<classname>(.[\w.]+)?)/
  let result = selector.match(reg)
  return result.groups
}
console.log(specificity('div#myid.class1.class2'))
//[Object: null prototype] {
//  tagname: 'div',
//  id: '#myid',
//  classname: '.class1.class2'
//}

我们利用正则表达式中的分组提取出 tagname，id 和 class。关于正则表达式可以看我的另一篇文章正则表达式的入门和JavaScript中的应用。

将复合选择器转化为简单选择器后，我们要做的就是取得元素的简单选择器然后进行比较。元素的几个对应属性很简单，tagName 可以用 element.tagName 直接获得；id 和 class 可以通过 element.getAttribute() 方法获得（形式略有不同，需要处理）

function compare(result, element) {
  if (result.tagname !== '' && element.tagName.toLowerCase() !== result.tagname) {
    return false
  }
  if (result.id !== '' && element.getAttribute('id') !== result.id.slice(1)) {
    return false
  }
  if (result.classname !== '') {
    let classnames = result.classname.split('.').filter((val) => !!val)
    let el_classnames = element.getAttribute('class').split(' ')
    let isContain = classnames.every((x) => el_classnames.includes(x))
    if (!isContain) return false
  }
  return true
}

最后我们要做的就是循环选择器数组，与当前元素匹配。元素用 while 向上回溯，直到 element.parentElement 为 null。

function match(selector, element) {
  let selectors = selector.split(' ')
  for (let i = selectors.length - 1; i >= 0; i--) {
    let result = specificity(selectors[i])

    if (i === selectors.length - 1) {
      if (!compare(result, element)) return false
    } else {
      let isMatch = false
      element = element.parentElement
      console.log(element)

      while (element !== null && isMatch === false) {
        console.log(result, element)
        if (compare(result, element)) isMatch = true
        element = element.parentElement
      }
      console.log(isMatch)
      if (!isMatch) return false
    }
  }
  return true
}

完整代码可以查看选择器元素匹配，打开开发者工具查看，

匹配机制

我们上面说过，元素和选择器的匹配是从后往前（从右往左），这里来简单解释一下为什么。当我们要知道当前的元素是否和某个选择器匹配的时候，比如选择器 #id .class1 .class2。如果我们从左往右匹配，当我们遇到 #id 的元素的时候，我们需要检查所有的子元素来寻找 .class1，这在复杂的文档解构中是非常低效率的。而如果我们从后往前匹配，当我们遇到一个 .class2 的元素，我们只需要看他的父元素（有些选择器也要看兄弟元素）是否you 匹配 .class1 ，依次向上追溯就可以了。并且如果 .class2 没有匹配成功我们就可以直接确定这个元素不符合。

浏览器中的 CSS 是如何计算的可以参考这篇文章从Chrome源码看浏览器如何计算CSS

JavaScript Function 的知识点整理

Wed, 05 Aug 2020 12:00:00 GMT

前言

本文对 JavaScript 中的 Function 的一些比较容易忽略的知识点和新特性做一个整理。

new Function()

Function 构造函数创建一个新的 Function 对象。直接调用此构造函数可用动态创建函数，但会遇到和 eval 类似的的安全问题和(相对较小的)性能问题。然而，与 eval 不同的是，Function 创建的函数只能在全局作用域中运行。它的用法如下：

const sum = new Function('a', 'b', 'return a + b') //注意，无论是参数标识符还是函数体，都是字符串，new 可以省略

console.log(sum(2, 6))
// expected output: 8

当然一般我们不太会使用这种方式来构建函数，不过还是需要了解一下，很多框架都有使用 new Function 或者 eval 来实现一些功能。关于 eval 和 new Function()，我在 YDNJS学习笔记-上卷-第一部分有做详细的阐述。

Function 构造函数和 eval 最重要的区别是由 Function 构造器创建的函数不会创建当前环境的闭包，它们总是被创建于全局环境，因此在运行时它们只能访问全局变量和自己的局部变量，不能访问 Function 构造器创建时所在的作用域的变量。这一点与使用 eval 执行创建函数的代码不同。在平时的编码中不建议使用，它无法享受引擎的基于词法的静态分析带来的优化，并且有影响性能的可能性。

function foo(str, a) {
  Function(str)() //3
  console.log(a, b)
}
var b = 2
foo('var b = 3;console.log(b)', 1) // 1, 2

function foo(str, a) {
  eval(str) // 此处执行的代码声明了一个新的变量，改变了当前环境的词法作用域
  console.log(a, b)
}
var b = 2
foo('var b = 3;', 1) // 1, 3

Function.name

Function.name 在 ES6 被写入标准。它的主要功能就是返回函数名，在 ES6 之前该属性就存在，不过在 ES6 才加入标准。在非标准的 ES2015 之前的实现中，该属性的 configurable 属性也是 false ，现在为 true，也就意味着这是一个可配置属性。

针对不同方式声明的函数，这个属性会返回同的值。

// 函数声明
function doSomething() {}
doSomething.name // "doSomething"

//Function 构造函数
new Function().name // "anonymous"

//变量和方法可以从句法位置推断匿名函数的名称（ECMAScript 2015中新增），在 ES6 之前匿名函数返回值为空字符串
var f = function () {}
var object = {
  someMethod: function () {}
}
console.log(f.name) // "f"
console.log(object.someMethod.name) // "someMethod"

//简写的对象方法
var o = {
  foo() {}
}
o.foo.name // "foo";

//绑定函数
function foo() {}
foo.bind({}).name // "bound foo"

//getter 和 setter
var o = {
  get foo() {},
  set foo(x) {}
}

var descriptor = Object.getOwnPropertyDescriptor(o, 'foo')
descriptor.get.name // "get foo"
descriptor.set.name // "set foo";

我们可以在函数表达式中为后面的函数命名，但是这个名称是无法直接使用的，它只是改变了 Function.name 的值。

let someMethod = function object_someMethod() {}

console.log(someMethod.name) // "object_someMethod"

console.log(object_someMethod) //ReferenceError: object_someMethod is not defined

Function.name 是只读的，不可修改，要更改它只能通过 Object.defineProperty()。

var object = {
  // anonymous
  someMethod: function () {}
}

object.someMethod.name = 'otherMethod'
console.log(object.someMethod.name) // someMethod

注意，解释器只有在函数没有设置 name 属性的时候才会设置内置的 Function.name，并且 ES2015 规定静态方法也被认为是类的属性。

我们能取到一个函数的函数名 Function.name，前提是我们没有手动为这个函数设置 name 属性。由于类本质就是一个构造函数，所以我们也可以取到类的 name，我们可以通过实例获取构造函数的 name，方法就是 instance.constructor.name。但是如果我没在类里面定义了一个名叫 name 的静态方法，那么我们访问 Function.name 得到的就是这个方法。

如果函数名是 Symbol，那么 Function.name 将返回 Symbol 的描述符。

var sym1 = Symbol('foo')
var sym2 = Symbol()
var o = {
  [sym1]: function () {},
  [sym2]: function () {}
}

o[sym1].name // "[foo]"
o[sym2].name // ""

还有一点需要注意的是，代码压缩的过程中，我们的函数名很可能被改写，所以如果你使用了 Function.name 要确保函数名没有被构建工具修改。

Function.length

length 属性指明函数的形参个数。形参的数量不包括剩余参数个数，仅包括第一个具有默认值之前的参数个数。与之对比的是， arguments.length 是函数被调用时实际传参的个数。

function a(m, n = 'a', b) {
  console.log(a.length) //1
  console.log(arguments.length) //3
  console.log(m, n, b) //1 a 2
}

a(1, undefined, 2)

小知识：Function 构造器本身也是个 Function。他的 length 属性值为 1 。该属性 Writable: false, Enumerable: false, Configurable: true。Function.prototype 对象也是一个函数，它的 length 属性值为 0。

call，apply 和 bind

这部分内容参考模拟实现call，apply 和 bind

箭头函数

箭头函数表达式的语法比函数表达式更简洁，并且没有自己的 this，arguments，prototype，super 或 new.target。箭头函数表达式更适用于那些本来需要匿名函数的地方，并且它不能用作构造函数，也不能用作生成器函数。引入箭头函数有两个方面的作用：更简短的函数并且不绑定 this。

箭头函数不会创建自己的 this,它只会从自己的作用域链的上一层继承 this。下面列出一些箭头函数注意点，更多关于箭头函数的内容可以参考 JavaScript 中的 this 指向

对象的方法：对象的方法如果使用箭头函数则箭头函数中的 this 指向的是对象所在环境的 this。如果是在全局环境中创建的对象，this 指向全局对象 window。如果实在 node 模块中则指向 module.exports 对象。
原型上的方法逻辑也和上面一样，不过要注意一点，在 class 中定义方法如果使用箭头函数的话，这个函数会被 babel 转换到构造函数中。结合上面一点，不要在对象的方法或类方法中使用箭头函数。
箭头函数的 this 并不是不会变的，只是它确定指向它所在环境的 this，这个环境可能会变化。
箭头函数不能作为构造函数。
箭头函数没有自己的 this，arguments，super 或 new.target。
箭头函数不能作为生成器函数。
由于箭头函数没有自己的 this 指针，通过 bind()，call() 或 apply() 方法调用一个函数时，只能传递参数（不能绑定 this），他们的第一个参数会被忽略。
箭头函数没有 prototype 属性。
箭头函数在参数和箭头之间不能换行。
箭头函数中的箭头不是运算符，但箭头函数具有与常规函数不同的特殊运算符优先级解析规则。
严格模式下函数中的 this 不能指向全局对象，如果箭头函数的 this 指向全局对象，会返回 undefined。

函数参数的逗号

ES2017 允许函数的最后一个参数有尾逗号（trailing comma）。这样主要是为了以后添加参数或者修改参数的顺序提供方便，和数组对象的逗号行为保持一致。

Funtion.prototype.toString()

ES2019 对函数实例的 toString() 方法做出了修改。toString() 方法返回函数代码本身，以前会省略注释和空格。修改后的 toString() 方法，明确要求返回一模一样的原始代码。

function /* foo comment */ foo() {}

foo.toString()
// "function /* foo comment */ foo () {}"

catch 可省略参数

JavaScript 语言的 try...catch 结构，以前明确要求 catch 命令后面必须跟参数，接受 try 代码块抛出的错误对象。很多时候，catch 代码块可能用不到这个参数。但是，为了保证语法正确，还是必须写。ES2019 做出了改变，允许 catch 语句省略参数。

正则表达式入门以及JavaScript中的应用

Wed, 05 Aug 2020 12:00:00 GMT

前言

字符串的操作是我们在写程序中经常遇到的问题，有时我们会遍历字符串以及用已有的 String 的 API 来达到我们的目的。但处理字符串最强大的还是正则表达式。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串，我们可以用正则表达式找出字符串中的目标子串，来进行操作。几乎所有的和字符串相关的操作都离不开正则表达式，比如大部分编辑器现在都能够用正则表达式来检索文本，大部分编程语言都有内置了强大的正则引擎，我们所用的很多字符串的内置 API，其背后也是正则表达式。本文主要讲一讲正则表达式的入门和使用。正则表达式全称是 regular expression，一般简称 regex 或者 regexp。

正则引擎的工作原理需要理解 DFA 和 NFA 需要一定的离散数学和编译原理基础，如果你想要实现一个正则表达式引擎，可以深入了解，本文不做介绍。对于集合、关系以及 DFA 和 NFA 可以看《计算理论基础》。

语法

最简单的正则表达式就是直接匹配对应的字符，比如 abc 就可以直接匹配。为了实现更为复杂的模式，正则表达式提供了很多元字符来表达丰富的意义。查看元字符可以看MSDN-正则表达式语言 - 快速参考

需要注意的是不同语言的正则表达式实现并不完全相同，特别是一些高级特性的支持，比如平衡组等，使用之前查阅一下相关文档。

我用 xmind 制作了一个比较全的正则表达式常用的语法结构图，下面是导出的 PNG，你也可以下载regular-expression.xmind

正则表达式的常用语法基本都在其中了，如果你下载了 xmind，大部分规则都有一个 note 写了一个示例。关于语法方面有一个表里面没有提到的问题就是转义问题，需要转义的符号一般情况下是 * . ? + $ ^ [ ] ( ) { } | \ / (如果启用了 x 模式，忽略正则表达式模式中的非转义空白，那么 # 也需要转义)。而在字符组 [] 中情况又不太一样，在字符组中需要转义的有 [ ] \，还有处于字符组第一位表示取反的 ^ 以及类似 [0-9a-z] 中间的 - 是需要转义的，其他不需要。字符组中的 . 就表示 . 不表示除换行符以外的任意字符，\b 也不表示单词边界，而表示退格符。(这里为个人测试，不同的实现也可能不同，如有错误欢迎指正)

图中的字符转义部分和 \cX 模式(X 取值从 A 到 Z 用来表示 ASCII 的 1-26 个控制符或 Ctrl+X。在 Java 中必须大写，其他语言中大小写都可以)可以查看Non-Printable Characters，他们都是对 ASCII 码控制符(0-31位位控制符，可以查看ASCII)的一些匹配。

还有一点需要说的是 Unicode的匹配，主要就是几种用法。

\0 nn 首位为 0 的八进制表示，可以表示扩展 ASCII 码
\x nn 两位十六进制数表示扩展 ASCII 码。
\u nnnn 四位十六进制数表示 Unicode 基础平面 BMP 的码点。
\p{name} 用Unicode字符属性来匹配。

各个语言、平台或者库都有不同的实现，比如 JavaScript 中的 \u{} 来表示 Unicode 码点。

正则表达式的运算符优先级

| 运算符 | 描述 | | ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | \ | 转义符 | | (), (?:), (?=), [] | 圆括号和方括号 | | *, +, ?, {n}, {n,}, {n,m} | 限定符 | | ^, $, \任何元字符、任何字符 | 定位点和序列（即：位置和顺序） | | \| | 替换，或 操作字符具有高于替换运算符的优先级，使得 m\|food 匹配 m 或 food 。若要匹配 mood 或 food ，请使用括号创建子表达式，从而产生 (m\|f)ood 。 |

我自己觉得正则表达式的规则并不难理解，但是如何搭配使用这些规则则是需要大量的练习的，如果能够自己实现一个正则表达式引擎那就掌握得更透彻了。

这里给大家推荐一些学习资料。一个是我用来检验正则表达式的工具expression-setapp，然后是 《精通正则表达式》 这本书，最后是一个正则表达式可视化的在线工具regexper。关于网络上的正则表达式教程，比如比较出名的正则表达式30分钟入门教程或者正则表达式-菜鸟教程用来入门都是可以的。Github 上有一个learn-regex的教程也是不错的。

JavaScript 中的正则表达式

JavaScript 中正则表达式语法和上面的表中没有太大不同，语法部分就不介绍了，可以查看正则表达式 - MDN。

这里主要说一下 JavaScript 中和正则表达式相关的两个对象 RegExp 和 String。这两个对象的属性和方法可以参考另一篇文章：JavaScript常用内置对象API

RegExp

创建正则表达式的方法有三种，字面量或者构造函数：

;/ab+c/i
new RegExp('ab+c', 'i')
new RegExp(/ab+c/, 'i')

RegExp 对象有很多属性方法，比如获取 flag 相关的就有多个（JavaScript 的正则引擎一共支持 gimsuy 共六个 flag)，还有一些在 ES5 之前没有暴露给用户的属性方法（用 symbol 来指向这些内部方法），ES6 中我们可以通过内部定义的 symbol 来访问到这些方法，比如 Symbol.hasInstance 以及大多数和正则表达式相关的方法等，具体细节可以参考JavaScript常用内置对象API。属性中我们需要特别记得的一个就是静态属性 RegExp.lastIndex，每一个 RegExp 对象都有该属性，他表示下次匹配的起始索引，默认值为 0，这个属性是可读写的，只有正则表达式使用了表示全局检索的 g 标志时，该属性才会起作用（该属性的具体规则参考RegExp.lastIndex - MDN。

而关于 RegExp 对象我们主要要讨论的方法有两个。

exec：一个在字符串中执行查找匹配的 RegExp 方法，它返回一个数组（未匹配到则返回 null）。
test：一个在字符串中测试是否匹配的 RegExp 方法，它返回 true 或 false。

RegExp.prototype.exec()

RegExp.prototype.exec() 接受一个 str 作为参数，即用正则表达式在这个 str 中进行匹配。

在设置了 global 或 sticky 标志位的情况下（如 /foo/g or /foo/y），JavaScript RegExp 对象是有状态的。他们会将上次成功匹配后的位置记录在 lastIndex 属性中。使用此特性，exec() 可用来对单个字符串中的多次匹配结果进行逐条的遍历（包括捕获到的匹配），而相比之下， String.prototype.match() 只会返回匹配到的结果。如果只是为了判断是否匹配，可以使用 RegExp.test() 方法，或者 String.search() 方法。

我们重点来看一下 RegExp.prototype.exec() 的返回值

var re = /quick\s(?<group1>brown).+?(?<group2>jumps)/gi
console.log(re.lastIndex) //0
var result = re.exec('The Quick Brown Fox Jumps Over The Lazy Dog')
console.log(result)

//[
//  'Quick Brown Fox Jumps',
//  'Brown',
//  'Jumps',
//  index: 4,
//  input: 'The Quick Brown Fox Jumps Over The Lazy Dog',
//  groups: { group1: 'Brown', group2: 'Jumps' }
//]

console.log(re.lastIndex) //25

从上面的代码我么可以看书，返回值是一个数组，但是包含了三个额外属性 index input groups。具体含义参看表格。

| 属性/索引 | 描述 | 例子 | | -------------- | --------------------------------------------- | --------------------------------------------------------------------- | ---------- | | [0] | 匹配的全部字符串 | Quick Brown Fox Jumps | | [1], ...[n ] | 括号中的分组捕获 | [1] = Brown、[2] = Jumps | | index | 匹配到的字符位于原始字符串的基于 0 的索引值 | 4 | | input | 原始字符串 | The Quick Brown Fox Jumps Over The | Lazy Dog | | groups | 有命名的分组捕获对象 | { group1: 'Brown', group2: 'Jumps' } 若分组都未命名则为 undefined |

当我们使用 g 标志时，RegExp.prototype.exec() 执行后会更新正则表达式 lastIndex 属性。如果我们在匹配成功后再次执行 RegExp.prototype.exec()，下次匹配将会从 lastIndex 开始匹配，注意，即使再次查找的字符串不是原查找字符串时，lastIndex 也不会被重置，它依旧会从记录的 lastIndex 开始，test() 也会更新 lastIndex 属性。我们可以利用这一特性可以查找一个字符串中多个复合正则表达式的子串。

var myRe = /ab*/g
var str = 'abbcdefabh'
var myArray
while ((myArray = myRe.exec(str)) !== null) {
  var msg = 'Found ' + myArray[0] + '. '
  msg += 'Next match starts at ' + myRe.lastIndex
  console.log(msg)
}
//Found abb. Next match starts at 3
//Found ab. Next match starts at 9

不要把正则表达式字面量（或者 RegExp 构造器）放在 while 条件表达式里。由于每次迭代时 lastIndex 的属性都被重置，如果匹配，将会造成一个死循环。并且要确保使用了 g 标记来进行全局的匹配，否则同样会造成死循环。

RegExp.prototype.test()

RegExp.prototype.test() 方法要比 RegExp.prototype.exec() 方法简单很多，它只是执行一个检索，用来查看正则表达式与指定的字符串是否匹配。返回 true 或 false。唯一需要注意的是，当使用 g 标志时，test() 和 exec() 一样会改变 lastIndex 的值，并且多次执行也会越过已经匹配成功的部分，即从字符串的 lastIndex 索引开始下一次的匹配。

RegExp 的 flag

介绍以下 JavaScript 中的正则表达式支持的 flag。可以用 RegExp.prototype.flags 查看正则表达式对象使用的 flag。

| 标志 | 对应属性 | 描述 | | ---- | ----------------------------- | --------------------------------------------------------- | | g | RegExp.prototype.global | 全局搜索。 | | i | RegExp.prototype.ignoreCase | 不区分大小写搜索。 | | m | RegExp.prototype.multiline | 多行搜索。 | | s | RegExp.prototype.dotAll | 允许 . 匹配换行符。 | | u | RegExp.prototype.unicode | 使用 unicode 码的模式进行匹配。 | | y | RegExp.prototype.sticky | 执行“粘性(sticky)”搜索,匹配从目标字符串的当前位置开始。 |

需要特别说明的是 u 和 y。u 表示的是 unicode，使用这个标志，意味着支持 \u{} 形式的 unicode 表示，即非基本平面的 unicode 也能够被支持。

let regex = new RegExp('\u{1D306}', 'u')
let result = regex.test('𝌆')
console.log(regex.unicode) // true
console.log(result) // true

而 y 表示的是 stciky，使用这个标志意味着，要匹配成功，子串必须是从 lastIndex 开始的。

let str = '#foo#foo'
let regex = /foo/y

regex.lastIndex = 1
console.log(regex.test(str)) // true
regex.lastIndex = 2
console.log(regex.test(str)) // false
console.log(regex.lastIndex) // 匹配失败，lastIndex归零
regex.lastIndex = 5
console.log(regex.test(str)) // false

上面的代码设置了三个 lastIndex 分别进行了匹配，1 和 5 分别位于两个 f 的索引，自然能匹配成功。但是 2 然后后面还有能够成功匹配的 foo ，但是在 y 模式下返回 false（去掉 y 将返回 true）。若匹配失败则 lastIndex 归零。

替代匹配属性

在正则表达式语法结构图的左下角有一块是替代，在 JavaScript 中也支持，但是是非标准的，不过大部分浏览器都进行了实现。兼容性请查看Can I use。

支持的几个属性分别是：

RegExp.$1-$9 // 捕获括号分组，上线九个，只读属性，且只在成功匹配时有效。
RegExp.input ($_) // 返回整个输入字符串，括号中为别名。
RegExp.lastMatch ($&) // 静态只读属性，只在匹配成功时改变。返回最后匹配成功的子字符串，$&为别名，必须用方括号访问 RegExp['$&']。
RegExp.lastParen ($+) // 静态只读属性，只在匹配成功时改变。返回最后匹配到的括号分组，别名也要用方括号访问。
RegExp.leftContext ($`) // 静态只读属性，只在匹配成功时改变。返回最新匹配的左侧子串，别名也要用方括号访问

String

String 的方法中和正则表达式相关的有如下几个。

String.prototype.match(): 一个在字符串中执行查找匹配的 String 方法，它返回一个数组，在未匹配到时会返回 null。
String.prototype.matchAll(): 一个在字符串中执行查找所有匹配的 String 方法，它返回一个迭代器（iterator）。
String.prototype.search()：一个在字符串中测试匹配的 String 方法，它返回匹配到的位置索引，或者在失败时返回 -1。
String.prototype.replace(): 一个在字符串中执行查找匹配的 String 方法，并且使用替换字符串替换掉匹配到的子字符串。
String.prototype.split(): 一个使用正则表达式或者一个固定字符串分隔一个字符串，并将分隔后的子字符串存储到数组中的 String 方法。

String.prototype.match()

String.prototype.match() 内部调用的是 RegExp.prototype[@@match]()，接受一个正则表达式对象作为参数，如果传入一个非正则表达式对象，则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp 。如果你没有给出任何参数并直接使用 match() 方法，你将会得到一个包含空字符串的 Array ：[""]。

详细说一下返回值：

如果使用 g 标志，那么返回所有匹配正则表达式的子串的数组。不返回捕获组。
如果没有使用 g 标志，则返回包含第一个完整匹配及其相关的捕获组的数组。数组有三个额外属性 index input groups（和 RegExp.prototype.exec() 相同）。
如果匹配失败则返回 null。

我们可以看出如果没有 g 标志，String.prototype.match() 和 RegExp.prototype.exec() 是相同的。

//without g flag
var str = 'For more information, see Chapter 3.4.5.1'
var re = /see (?<group1>chapter \d+(?<group2>\.\d)*)/i
var found = str.match(re)

console.log(found)
//[
//  'see Chapter 3.4.5.1',
//  'Chapter 3.4.5.1',
//  '.1',
//  index: 22,
//  input: 'For more information, see Chapter 3.4.5.1',
//  groups:{ group1: 'Chapter 3.4.5.1', group2: '.1' }
//]

//with g flag
var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
var regexp = /[A-E]/gi
var matches_array = str.match(regexp)

console.log(matches_array) // ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']

// no arguments
var str = 'Nothing will come of nothing.'

str.match() // returns [""]

String.prototype.matchAll()

String.prototype.matchAll() 内部调用的是 RegExp.prototype[@@matchAll]()。接受一个正则表达式对象为参数，如果所传参数不是一个正则表达式对象，则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp 。RegExp 必须是设置了全局模式 g 的形式，否则会抛出异常 TypeError。

返回值为一个迭代器，可以配合 for...of...、扩展运算符 ... 或者 Array.from() 使用来替代 while 循环的 RegExp.prototype.exec() 方法。迭代器中的每一项和 RegExp.prototype.exec() 是相同的，包括额外属性。

const regexp = RegExp('foo[a-z]*', 'g')
const str = 'table football, foosball'
const matches = str.matchAll(regexp)

for (const match of matches) {
  console.log(`Found ${match[0]} start=${match.index} end=${match.index + match[0].length}.`)
}
//Found football start=6 end=14.
//Found foosball start=16 end=24.

console.log(Array.from(str.matchAll(regexp), (m) => m[0]))
//[ "football", "foosball" ]

String.prototype.matchAll() 内部做了一个正则表达式对象的复制，所以不像 RegExp.prototype.exec(), lastIndex 在字符串扫描时不会改变。

String.prototype.matchAll() 还有一个优势就是它可以一次性获取捕获组，无论是带 g 的 String.prototype.match() 还是循环匹配的 RegExp.prototype.exec() 都不能一次取得所有匹配的捕获组。如果有对应的需求，可以使用 String.prototype.matchAll()。

var regexp = /t(e)(st(\d?))/g
var str = 'test1test2'

console.log(str.match(regexp)) //[ 'test1', 'test2' ]

let array = [...str.matchAll(regexp)]
console.log(array)
//[
//  [
//      'test1',
//      'e',
//      'st1',
//      '1',
//      index: 0,
//      input: 'test1test2',
//      groups: undefined
//  ],
//  [
//      'test2',
//      'e',
//      'st2',
//      '2',
//      index: 5,
//      input: 'test1test2',
//      groups: undefined
//  ]
//]

String.prototype.search()

String.prototype.search() 内部使用的是 RegExp.prototype[@@search]()。接受一个正则表达式对象为参数，如果所传参数不是一个正则表达式对象，则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp 。如果匹配成功，则返回正则表达式在字符串中首次匹配项的索引，否则返回 -1。

类似于 RegExp.prototype.test() 方法，只是返回值不同。该方法比 String.prototype.match() 更快，如果不需要知道匹配的详细信息，则建议使用该方法。

String.prototype.replace()

String.prototype.replace() 内部使用的是 RegExp.prototype[@@replace]()。该方法返回一个由替换值(replacement)替换部分或所有的模式(pattern)匹配项后的新字符串。模式可以是一个字符串或者一个正则表达式，替换值可以是一个字符串或者一个每次匹配都要调用的回调函数。如果 pattern 是字符串，则仅替换第一个匹配项。该方法不会改变原字符串。

正则表达式语法结构图左下角的替换部分的内容在该方法中也是可用的，可以作为第二个参数使用。

$$: 插入一个 $。
$&: 插入匹配的子串。
$` : 插入当前匹配的子串左边的内容。
$': 插入当前匹配的子串右边的内容。
$n: 假如第一个参数是 RegExp 对象，并且 n 是个小于 100 的非负整数，那么插入第 n 个括号匹配的字符串.索引是从 1 开始。$

第二个参数可以是函数，在这种情况下，当匹配执行后，该函数就会执行。函数的返回值作为替换字符串。如果第一个参数是正则表达式，并且其为全局匹配模式，那么这个方法将被多次调用，每次匹配都会被调用。该函数有以下参数。

match：匹配的子串。(对应于上述的$&。）
p1,p2, ...: 假如 replace() 方法的第一个参数是一个 RegExp 对象，则代表第 n 个括号匹配的字符串。（对应于上述的$1，$2等。）例如，如果是用 /(\a+)(\b+)/ 这个来匹配，p1 就是匹配的 \a+，p2 就是匹配的 \b+。
offset: 匹配到的子字符串在原字符串中的偏移量。（比如，如果原字符串是 abcd，匹配到的子字符串是 bc，那么这个参数将会是 1）
string: 被匹配的原字符串。
NamedCaptureGroup: 命名捕获组匹配的对象。

function replacer(match, p1, p2, p3, offset, string) {
  return [p1, p2, p3].join(' - ')
}
var newString = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, replacer)
console.log(newString) // abc - 12345 - #$*%

精确的参数个数依赖于 replace() 的第一个参数是否是一个正则表达式（RegExp）对象，以及这个正则表达式中指定了多少个括号子串，如果这个正则表达式里使用了命名捕获，还会添加一个命名捕获的对象。

使用总结

如果你需要知道一个字符串是否与一个正则表达式匹配，可使用 RegExp.test() 。
如果你只是需要第一个匹配结果，你可以使用 RegExp.prototype.exec() 或者 String.prototype.match()，不使用 g 标志。
如果你想要获得捕获组，并且设置了全局标志，你需要用 RegExp.exec() 或者 String.prototype.matchAll()

参考文章

开源许可证的选择

Tue, 04 Aug 2020 12:00:00 GMT

前言

开源许可证授予任何人以任何目的使用，修改和共享许可软件的权限，但要遵守保护该软件的来源和开放性的条件。对于常用的开源许可证我们要理解他们的区别才能正确使用。常用的许可证区别可以看下图。

github 有一个页面帮助你选择开源许可证，另外还有一个网站choosealicense也有主要的许可证介绍。

许可证介绍

开源许可证可以分为两类：

宽松式（permissive）许可证：最基本的类型，对用户几乎没有限制。用户可以修改代码后闭源。用户可以使用代码，做任何想做的事情，不保证代码质量，用户自担风险，用户必须披露原始作者。常见的宽松式许可证有：BSD，MIT，Apache 2.0。
Copyleft 许可证：比宽松式许可证严格。如果分发二进制格式，必须提供源码修改后的源码，必须与修改前保持许可证一致，不得在原始许可证以外，附加其他限制。核心就是修改后的代码不可以闭源。

Copyleft 是理查德·斯托曼发明的一个词，作为 Copyright （版权）的反义词。Copyright 直译是"复制权"，这是版权制度的核心，意为不经许可，用户无权复制。作为反义词，Copyleft 的含义是不经许可，用户可以随意复制。

BSD

BSD 有两个版本，两个版本的共同要求是分发软件时，必须保留原始的许可证声明。另外一个附加条款是不得使用原始作者的名字为软件促销。

MIT License

Apache License 2.0

Apache License 和 MIT License 类似，都很宽松，但是他包含了贡献者向用户提供专利授权相关的条款，分发软件时，必须保留原始的许可证声明。凡是修改过的文件，必须向用户说明该文件修改过；没有修改过的文件，必须保持许可证不变。使用该许可证的项目有 Apache、SVN 和 NuGet。

GNU GPLv3

许可证。这是一种 Copyleft 许可证，要求修改项目代码的用户再次分发源码或二进制代码时，必须公布他的相关修改。

GNU LGPLv3

和 GPL 的区别是：如果项目采用接口调用该许可证的库，项目可以不用开源。

Mozilla Public License 2.0

只要该许可证的代码在单独的文件中，新增的其他文件可以不用开源。

不添加许可证

如果你不添加任何许可证，那么你的代码默认具有专有版权，别人不可以复制、分发和修改。当代码超过一个贡献者时，连你自己也不可以进行复制，分发和修改。Github 有用户协议，可以让其他用户查看和复制你的代码，但不代表可以用这个代码去做其他的事情。

Github 添加许可证

想要知道一个 Github 仓库的许可证，看项目的页面右边的 About 区域即可（老版的 Github 在文件列表上方的 tab 末尾）

如何为我们的项目添加一个 license 呢，我们只要点击页面上的 creat new file 然后文件名填写 LICENSE （全大写），右边会出现一个 choose a license template 按钮，点进去选择自己想要的 license 然后完成文件的创建即可。具体流程参考添加许可到仓库

参考文章

开源许可证教程

ES6 的 Map Set WeakMap 和 WeakSet

Wed, 29 Jul 2020 12:00:00 GMT

前言

本文讲一讲 ES6 新增的两种数据结构，Set 和 Map 以及和它们相对应的 WeakSet 和 WeakMap。Map 和 Set 是两种非常中要的数据结构，在其他语言中都是一种预设机制。JavaScript 在 ES6 中也引入了这种数据结构。它们都有对应的数学概念，Map 表示的是映射，而 Set 表示的是集合，其实理清这两个概念也就大致了解了 Map 和 Set 是什么样的结构了，Map 是一种双射形式的映射，集合的概念就不同多接受了，三大特性：确定性，互异性，无序性。

在 ES6 之前，我们能使用的主要数据结构就是：

存储带键的数据（keyed）集合的对象。
存储有序集合的数组。

其实在底层的实现中，它们都是 Map 这种数据结构。下面我们来讲一讲这个新的 Map 和 Set 具体有哪些不同。

Set

Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。Set 对象是值的集合，你可以按照插入的顺序迭代它的元素。 Set 中的元素只会出现一次，即 Set 中的元素是唯一的。

创建 Set 对象的方法是 new Set([iterable])，new 是必须的，Set 构造函数可以接受一个数组(或者具有 iterable 接口的其他数据结构)作为参数，用来初始化，它的所有元素将不重复地被添加到新的 Set 中。如果不指定此参数或其值为 null，则新的 Set 为空。

向 Set 加入值的时候，不会发生类型转换，所以 5 和 "5" 是两个不同的值。Set 内部判断两个值是否不同，使用的算法叫做 Same-value equality，它类似于精确相等运算符( === )，主要的区别是 NaN 等于自身，而精确相等运算符认为 NaN 不等于自身。

Set 结构的实例有以下属性。

Set.prototype.constructor:构造函数，默认就是 Set 函数。
Set.prototype.size ：返回实例的成员总数。
add(value):添加某个值，返回 Set 结构本身。支持链式添加
delete(value):删除某个值，返回一个布尔值，表示删除是否成功。
has(value):返回一个布尔值，表示该值是否为 Set 的成员。
clear():清除所有成员，没有返回值。
keys():返回键名的遍历器
value():返回键值的遍历器
entires():返回键值对的遍历器
forEach():使用回调函数遍历每个成员

Array.from 方法可以将 Set 结构转为数组。去除数组的重复成员 [...new Set(array)].

Set 的遍历顺序就是插入顺序。这个特性有时非常有用，比如使用 Set 保存一个回调函数列表，调用时就能保证按照添加顺序调用。

keys 方法、 values 方法、 entries 方法返回的都是遍历器对象。由于 Set 结构没有键名，只有键值(或者说键名和键值是同一个值)，所以 keys 方法和 values 方法的行为完全一致。Set 结构的实例默认可遍历，它的默认遍历器生成函数就是它的 values 方法。

Set 结构的实例的 forEach 方法，用于对每个成员执行某种操作，没有返回值。 forEach 方法的参数就是一个处理函数。该函数的参数依次为键值、键名、集合本身。另外， forEach 方法还可以有第二个参数，表示绑定的 this 对象。

let set = new Set([1, 2, 3])
set.forEach((value, key) => console.log(value * 2)) // 2
// 4
// 6

扩展运算符，数组的 map，filter 都可以用于 Set。

如果想在遍历操作中，同步改变原来的 Set 结构，目前没有直接的方法，但有两种变通方法。一种是利用原 Set 结构映射出一个新的结构，然后赋值给原来的 Set 结构;另一种是利用 Array.from 方法。

Set 转数组可以用 Array.from() 和扩展运算符。

WeakSet

WeakSet 结构与 Set 类似，也是不重复的值的集合。但是，它与 Set 有两个区别。

WeakSet 的成员只能是对象，而不能是其他类型的值，null 也不是一个合法的值。
WeakSet 中的对象都是弱引用，即垃圾回收机制不考虑 WeakSet 对该对象的引用，也就是说，如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于 WeakSet 之中。这也意味着 WeakSet 中没有存储当前对象的列表。正因为这样，WeakSet 是不可枚举的（没有方法能给出所有的值）。

因此，WeakSet 适合临时存放一组对象，以及存放跟对象绑定的信息。只要这些对象在外部消失，它在 WeakSet 里面的引用就会自动消失。由于上面这个特点，WeakSet 的成员是不适合引用的，因为它会随时消失。另外，由于 WeakSet 内部有多少个成员，取决于垃圾回收机制有没有运行，运行前后很可能成员个数是不一样的，而垃圾回收机制何时运行是不可预测的，因此 ES6 规定 WeakSet 不可遍历。

创建一个 WeakMap 使用 new WeakMap(value)，new 不可以省略。如果传入一个可迭代对象作为参数, 则该对象的所有迭代值都会被自动添加进生成的 WeakSet 对象中。null 会被当做 undefined，即和没有传入参数一样，创建一个空的 WeakSet。

WeakSet 结构有以下三个方法。

WeakSet.prototype.add(value):向 WeakSet 实例添加一个新成员。
WeakSet.prototype.delete(value):清除 WeakSet 实例的指定成员。
WeakSet.prototype.has(value):返回一个布尔值，表示某个值是否在 WeakSet 实例之中。

WeakMap 一个简单用法：

const foos = new WeakSet()
class Foo {
  constructor() {
    foos.add(this)
  }
  method() {
    if (!foos.has(this)) {
      throw new TypeError('Foo.prototype.method 只能在Foo的实例上调用!')
    }
  }
}

WeakSet 的一个应用是可以用来检测对象的循环引用。

// 对 传入的subject对象 内部存储的所有内容执行回调
function execRecursively(fn, subject, _refs = null) {
  if (!_refs) _refs = new WeakSet()

  // 避免无限递归
  if (_refs.has(subject)) return

  fn(subject)
  if ('object' === typeof subject) {
    _refs.add(subject)
    for (let key in subject) execRecursively(fn, subject[key], _refs)
  }
}

const foo = {
  foo: 'Foo',
  bar: {
    bar: 'Bar'
  }
}

foo.bar.baz = foo // 循环引用!
execRecursively((obj) => console.log(obj), foo)
// { foo: 'Foo', bar: { bar: 'Bar', baz: [Circular] } }
// Foo
// { bar: 'Bar', baz: { foo: 'Foo', bar: [Circular] } }
// Bar

Map

JavaScript 的对象(Object)，本质上是键值对的集合(Hash 结构)，但是传统上只能用字符串（现在加入了 Symbol）当作键。这给它的使用带来了很大的限制。为了解决这个问题，ES6 提供了 Map 数据结构。它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串或者 Symbol，各种类型的值(包括对象)都可以当作键。也就是说，Object 结构提供了“字符串为 key 的映射，Map 结构提供了任意值为 key 的映射，是一种更完善的 Hash 结构实现。如果你需要键值对的数据结构，Map 比 Object 更合适。Map 对象能够记住键的原始插入顺序。

Map 和 Object 的区别如下：

| | Map | Object | | -------- | ------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | | 意外的键 | Map 默认情况不包含任何键。只包含显式插入的键。 | 一个 Object 有一个原型, 原型链上的键名有可能和你自己在对象上的设置的键名产生冲突。（也可以使用 Object.create(null) 创建一个没有原型的对象 | | 键的类型 | 一个 Map 的键可以是任意值，包括函数、对象或任意基本类型。 | 一个 Object 的键必须是一个 String 或是Symbol。 | | 键的顺序 | Map 中的 key 是有序的。因此，当迭代的时候，一个 Map 对象以插入的顺序返回键值。 | 自 ECMAScript 2015 规范以来，对象保留了字符串和 Symbol 键的创建顺序；因此，在只有字符串键的对象上进行迭代将按插入顺序产生键。 | | Size | Map 的键值对个数可以轻易地通过 size 属性获取 | Object 的键值对个数只能手动计算 | | 迭代 | Map 是 iterable 的，所以可以直接被迭代。 | 迭代一个 Object 需要以某种方式获取它的键然后才能迭代。 | | 性能 | 在频繁增删键值对的场景下表现更好。 | 在频繁添加和删除键值对的场景下未作出优化。 |

Map 的键实际上是跟内存地址绑定的，只要内存地址不一样，就视为两个键。这就解决了同名属性碰撞(clash)的问题，我们扩展别人的库的时候，如果使用对象作为键名，就不用担心自己的属性与原作者的属性同名。

如果 Map 的键是一个简单类型的值(数字、字符串、布尔值)，则只要两个值严格相等，Map 将其视为一个键，比如 0 和 -0 就是一个键，布尔值 true 和字符串 'true' 则是两个不同的键。另外， undefined 和 null 也是两个不同的键。虽然 NaN 不严格相等于自身，但 Map 将其视为同一个键。

Map 的属性和方法：

size：返回 Map 结构的成员总数。
set(key, value):设置键名 key 对应的键值为 value ，然后返回整个 Map 结构。如果已经有值，则键值会被更新，否则就新生成该键。
get(key):读取 key 对应的键值，如果找不到 key ，返回 undefined 。
has(key):返回一个布尔值，表示某个键是否在当前 Map 对象之中。
delete(key):删除某个键，返回 true 。如果删除失败，返回 false 。
clear():清除所有成员，没有返回值。
key():返回键名的遍历器。
value():返回键值的遍历器。
entries():返回所有成员的遍历器。
forEach():遍历 Map 的所有成员。

Map 的遍历顺序就是插入顺序。map[Symbol.iterator] === map.entries, Map 结构的默认遍历器接口 ( Symbol.iterator属性)，就是 entries 方法。一个 Map 对象在迭代时会根据对象中元素的插入顺序来进行，一个 for...of 循环在每次迭代后会返回一个形式为 [key，value] 的数组。

Map 结构转为数组结构，比较快速的方法是使用扩展运算符。结合数组的 map 方法、filter 方法，可以实现 Map 的遍历和过滤(Map 本身没有 map 和 filter 方法)。

const myMap = new Map().set(true, 7).set({ foo: 3 }, ['abc'])
;[...myMap]
// [ [ true, 7 ], [ { foo: 3 }, [ 'abc' ] ] ]

//数组转为Map
new Map([
  [true, 7],
  [{ foo: 3 }, ['abc']]
])
// Map {
// true => 7,
//   Object {foo: 3} => ['abc']
// }

如果所有 Map 的键都是字符串，它可以转为对象。

function strMapToObj(strMap) {
  let obj = Object.create(null)
  for (let [k, v] of strMap) {
    obj[k] = v
  }
  return obj
}
const myMap = new Map().set('yes', true).set('no', false)
strMapToObj(myMap)
// { yes: true, no: false }

Map 转为 JSON 要区分两种情况。一种情况是，Map 的键名都是字符串，这时可以选择转为对象 JSON。

function strMapToJson(strMap) {
  return JSON.stringify(strMapToObj(strMap))
}
let myMap = new Map().set('yes', true).set('no', false)
strMapToJson(myMap)
// '{"yes":true,"no":false}'

另一种情况是，Map 的键名有非字符串，这时可以选择转为数组 JSON。

function mapToArrayJson(map) {
  return JSON.stringify([...map])
}
let myMap = new Map().set(true, 7).set({ foo: 3 }, ['abc'])
mapToArrayJson(myMap)
// '[[true,7],[{"foo":3},["abc"]]]'

Map 的迭代：

let myMap = new Map()
myMap.set(0, 'zero')
myMap.set(1, 'one')
for (let [key, value] of myMap) {
  //解构
  console.log(key + ' = ' + value)
}
// 将会显示两个log。一个是"0 = zero"另一个是"1 = one"

for (let key of myMap.keys()) {
  console.log(key)
}
// 将会显示两个log。 一个是 "0" 另一个是 "1"

for (let value of myMap.values()) {
  console.log(value)
}
// 将会显示两个log。 一个是 "zero" 另一个是 "one"

for (let [key, value] of myMap.entries()) {
  console.log(key + ' = ' + value)
}
// 将会显示两个log。 一个是 "0 = zero" 另一个是 "1 = one"

myMap.forEach(function (value, key) {
  console.log(key + ' = ' + value)
})
// 将会显示两个logs。 一个是 "0 = zero" 另一个是 "1 = one"

合并 Map:

let original = new Map([[1, 'one']])

let clone = new Map(original)

console.log(clone.get(1)) // one
console.log(original === clone) // false. 浅比较 不为同一个对象的引用

//合并的 Map 中存在重复的键名，后面的会覆盖前者
let first = new Map([
  [1, 'one'],
  [2, 'two'],
  [3, 'three']
])

let second = new Map([
  [1, 'uno'],
  [2, 'dos']
])

// 合并两个Map对象时，如果有重复的键值，则后面的会覆盖前面的。
// 展开运算符本质上是将Map对象转换成数组。
let merged = new Map([...first, ...second])

console.log(merged.get(1)) // uno
console.log(merged.get(2)) // dos
console.log(merged.get(3)) // three

//也可以与数组合并
let first = new Map([
  [1, 'one'],
  [2, 'two'],
  [3, 'three']
])

let second = new Map([
  [1, 'uno'],
  [2, 'dos']
])

// Map对象同数组进行合并时，如果有重复的键值，则后面的会覆盖前面的。
let merged = new Map([...first, ...second, [1, 'eins']])

console.log(merged.get(1)) // eins
console.log(merged.get(2)) // dos
console.log(merged.get(3)) // three

WeakMap

WeakMap 结构与 Map 结构类似，也是用于生成键值对的集合，其中的键是弱引用的。WeakMap 与 Map 的区别有两点。首先， WeakMap 只接受对象作为键名( null 除外)，不接受其他类型的值作为键名。其次，WeakMap 的键名所指向的对象，不计入垃圾回收机制。WeakMap 的 key 是不可枚举的 (没有方法能给出所有的 key)。

创建 WeakMap 的语法 new WeakMap([iterable])，Iterable 是一个数组（二元数组）或者其他可迭代的且其元素是键值对的对象。每个键值对会被加到新的 WeakMap 里。null 会被当做 undefined，即和没有传入参数一样，创建一个空的 WeakMap。

WeakMap 的设计目的在于，有时我们想在某个对象上面存放一些数据，但是这会形成对于这个对象的引用。请看下面的例子。

const e1 = document.getElementById('foo')
const e2 = document.getElementById('bar')
const arr = [
  [e1, 'foo 元素'],
  [e2, 'bar 元素']
]

上面代码中， e1 和 e2 是两个对象，我们通过 arr 数组对这两个对象添加一些文字说明。这就形成了 arr 对 e1 和 e2 的引用。一旦不再需要这两个对象，我们就必须手动删除这个引用，否则垃圾回收机制就不会释放 e1 和 e2 占用的内存。

// 不需要 e1 和 e2 的时候 // 必须手动删除引用
arr[0] = null
arr[1] = null

上面这样的写法显然很不方便。一旦忘了写，就会造成内存泄露。WeakMap 就是为了解决这个问题而诞生的，它的键名所引用的对象都是弱引用，即垃圾回收机制不将该引用考虑在内。因此，只要所引用的对象的其他引用都被清除，垃圾回收机制就会释放该对象所占用的内存。也就是说，一旦不再需要，WeakMap 里面的键名对象和所对应的键值对会自动消失，不用手动删除引用。基本上，如果你要往对象上添加数据，又不想干扰垃圾回收机制，就可以使用 WeakMap。

一个典型应用场景是，在网页的 DOM 元素上添加数据，就可以使用 WeakMap 结构。当该 DOM 元素被清除，其所对应的 WeakMap 记录就会自动移除。

const wm = new WeakMap()
const element = document.getElementById('example')
wm.set(element, 'some information')
wm.get(element) // "some information"

总之，WeakMap 的专用场合就是，它的键所对应的对象，可能会在将来消失。该数据结构有助于防止内存泄漏。注意，WeakMap 弱引用的只是键名，而不是键值。键值依然是正常引用。

WeakMap 只有四个方法可用: get()、set() 、has() 、 delete() 。

WeakMap 的一个例子： myElement 是一个 DOM 节点，每当发生 click 事件，就更新一下状态。我们将这个状态作为键值放在 WeakMap 里，对应的键名就是 myElement 。一旦这个 DOM 节点删除，该状态就会自动消失，不存在内存泄漏风险。

let myElement = document.getElementById('logo')
let myWeakmap = new WeakMap()

myWeakmap.set(myElement, { timesClicked: 0 })

myElement.addEventListener(
  'click',
  function () {
    let logoData = myWeakmap.get(myElement)
    logoData.timesClicked++
  },
  false
)

实现一个带有 clear() 方法的 WeakMap 类：

class ClearableWeakMap {
  constructor(init) {
    this._wm = new WeakMap(init)
  }
  clear() {
    this._wm = new WeakMap()
  }
  delete(k) {
    return this._wm.delete(k)
  }
  get(k) {
    return this._wm.get(k)
  }
  has(k) {
    return this._wm.has(k)
  }
  set(k, v) {
    this._wm.set(k, v)
    return this
  }
}

参考文章

《ES6 标准入门》 —— 阮一峰
MDN
深入理解 Set Map WeakSet WeakMap

ignore文件语法

Mon, 27 Jul 2020 12:00:00 GMT

前言

在使用 Github 的时候我们有 .gitignore 文件来避免提交一些不需要提交的文件（比如 node_modules），在使用 eslint 和 prettier 时也有对应的 .eslintignore 和 .prettierignore，它们的功能都类似，语法也差不多，本文就总结一下 ignore 文件的常用语法。

语法

这里的语法主要是结合 Git 官方文档和自己的理解写的。pattern 就是匹配的模式，我们每一条规则就是一个 pattern。ignore 文件的作用就是让程序不再跟踪 track 某些文件。根目录指的是跟 ignore 文件在同一层级的目录。

空行没有任何意义，可以用来分隔不同的规则增强可读性。
以 # 开头的行即注释行将被忽略，可用反斜杠转义。
pattern 中的空格会被忽略除非用反斜杠转义
! 用来否定 pattern，比如 !pattern，如果有一个文件被某一条规则排除了，这条文件又能匹配 ! 之后的 pattern，那么它将被重新跟踪 track。如果一个文件的父级目录被排除跟踪，那么将没有办法重新将它包含进来。比如你的 src 文件夹被排除了，src 文件夹下有一个 index.js，此时即使你加上 !/src/index.js 也不能让这个文件恢复跟踪。这样做是问了性能考虑，即一个文件夹只要被排除了，和文件内相关的所有 pattern 都将被忽略。! 同样可以用反斜杠转义，比如 \!important!.txt，就是匹配 !important!.txt 这个文件。
/ 用来分隔目录，可以出现在一条 pattern 的任意位置。
如果没有使用 /，那么我们的 pattern 会递归到各个目录中去（沿着目录的嵌套一直向下寻找），比如你写了一个 common 不仅根目录中的 common 会被排除，你整个项目中所有的 common 都会被排除。如果 common 是一个目录，那么该目录就会被排除跟踪。
如果 / 在 pattern 中出现，就意味着找到 / 前的目录（必须是一个目录，因为 / 是目录分隔符），比如 src/app，就代表找到 src 目录，然后在这个目录下（不能递归，只能在目录下的第一层）找 app。
找到 / 前对应的目录之后，在目录的第一层寻找 / 之后对应的文件或者目录。注意这里不像没有 / 的情况可以一直像更深的层级递归寻找，因为 / 指定了目录，所以只能在目录的第一层寻找。
如果 / 出现在 pattern 的第一个字符，就代表在根目录下寻找。如果 / 出现在 pattern 的最后一个字符，表示你要找的是一个目录而不是文件。所以如果你要找根目录下的一个 test 的文件夹 /test，/test/ 和 test 都能找到，但是只有 /test/ 是确保找的根目录下的 test 文件夹，/test 有可能找到的是一个文件，而不是文件夹，而 test 则会往更深的嵌套目录去寻找 test，可能会匹配到其他 test 文件和文件夹。
*用来匹配零个或多个字符（不包括 /)，如 *.[oa] 忽略所有以 ".o" 或 ".a" 结尾，*~ 忽略所有以 ~ 结尾的文件（这种文件通常被许多编辑器标记为临时文件）；
[] 用来匹配括号内的任一字符，如 [abc]，也可以在括号内加连接符，如 [0-9] 匹配0至9的数，类似正则表达式；
? 用来匹配单个字符（不包括 /)。
** ：与嵌套目录匹配，比如 a/**/z 与以下项匹配 a/z、a/b/z、a/b/c/z。
可以使用标准的 glob 模式匹配。所谓的 glob 模式是指 shell 所使用的简化了的正则表达式。

# 忽略 .a 文件
*.a

# 但否定忽略 lib.a, 尽管已经在前面忽略了 .a 文件
!lib.a

# 忽略 doc/notes.txt, 不包括 doc/server/arch.txt
doc/*.txt

# 忽略所有的 .pdf 文件 在 doc/ directory 下的
doc/**/*.pdf

# /dir 将匹配.gitignore所在层级一个文件，目录，链接，任何名为dir的内容
# /dir/  将只会匹配.gitignore所在层级一个名为dir的目录
# /dir/* 将匹配所有文件，目录和其他任何在名为dir的目录（也在.gitignore所在层级）里的内容（但是不包括这个目录本身）
# 如果你使用 !.gitkeep 并且有个 dir/.gitkeep 文件，对于 /dir 和 /dir/ 这两种匹配规则，你写的 !.gitkeep 不会生效，因为 Git不会去 dir 文件夹的内部检查；对于 /dir/*，Git会检查.gitkeep，并且dir文件夹会被提交，因为这条模式不会应用到文件夹，而是应用到文件夹里面的内容。

可以用 git check-ignore 来查看我们某个文件是否被忽略，命令的细节查看官方文档。

在 .gitingore 文件中，每一行指定一个忽略规则，Git 检查忽略规则的时候有多个来源，它的优先级如下（由高到低）： 1、从命令行中读取可用的忽略规则 2、当前目录定义的规则 3、父级目录定义的规则，依次递推 4、$GIT_DIR/info/exclude 文件中定义的规则 5、core.excludesfile 中定义的全局规则

git 对于 .gitignore 配置文件是按行从上到下进行规则匹配的，意味着如果前面的规则匹配的范围更大，则后面的规则将不会生效；如果你不慎在创建 .gitignore 文件之前就 push 了项目，那么即使你在 .gitignore 文件中写入新的过滤规则，这些规则也不会起作用，Git 仍然会对所有文件进行版本管理。所以在项目创建时就设计好对应的 .gitignore 文件是一个好习惯。

Github 官方有一个仓库提供了各种语言的 .gitignore 模版，可以用来进行参考，仓库地址 gitignore

本文虽然是以 .gitignore 进行语法说明，不过大多数的 ignore 文件语法都类似，可以直接套用。

参考文章

状态机和KMP算法

Fri, 24 Jul 2020 12:00:00 GMT

前言

字符串的匹配是编写程序的时候经常遇到的一个问题，也是计算机处理的基础问题之一。最简单的方法是循环字符串，一位一位地进行匹配，也可以使用正则表达式。今天本文讨论用状态机的模型如何理解和解决字符串匹配的问题。

状态机 FSM

状态机全称有限状态机（英语：finite-state machine，缩写：FSM）又称有限状态自动机（英语：finite-state automation，缩写：FSA），简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学计算模型。我个人的理解是我们的某一类型的问题在解决过程中能够抽象出有限个不同的状态，不同的问题只是问题解决过程中状态的转移过程不同，当我们将状态和状态之间的关系抽象出来，那么这一类问题我们全部能用一套逻辑来解决。每一个状态机应该能够接受相同的输出，每一个状态机都应该知道自己的下一个状态是什么（输出只依赖于当前状态，和输入无关的称为 moore 机，输出依赖于输出和当前状态的称为 mealy 机）。用 JavaScript 模拟状态机的模型大概如下面的形式。

function fsm_start(input) {
  //当前状态机的逻辑
  return next_fsm //返回下一个状态函数
}

let state = fsm_start //设置初始状态

while (condition) {
  state = state(input) //执行当前状态机函数，并将
}

状态机的字符串匹配

其实我们在编程的过程中其实一直和状态打交道，比如 if/else，switch/case等，有时候当我们面对一些比较复杂的问题的时候如果能够用有限状态机来描述，那么问题的逻辑可能更清晰。代码结构的可读性也更强。

比如字符串的匹配问题，当我们想要知道某个字符串中是否包含另一个字符串时，状态机就能够帮我们解决问题。比如我们要寻找一个字符串中是否有 abcdef 这串字符，如果使用状态机模型，我们可以这样实现：

function match(string) {
  let foundA = (foundB = foundC = foundD = foundE = false)
  for (let c of string) {
    if (c === 'a') {
      foundA = true
    } else if (foundA && c === 'b') {
      foundB = true
    } else if (foundB && c === 'c') {
      foundC = true
    } else if (foundC && c === 'd') {
      foundD = true
    } else if (foundD && c === 'e') {
      foundE = true
    } else if (foundE && c === 'f') {
      return true
    }
  }
  return false
}

console.log(match('abcdeabcdef')) //true

但是如果我们想要匹配的字符串时 abcabx 这种有重复部分的时候我们就没法用上面那种方法了，因为当我们匹配到 x 这一位的时候有可能是 c 我们需要回到检测到 c 的状态，这种情况用上面的方法就没法实现，因为 if/else 结构是没法跳转到某一步的。在不用状态机的情况下我们可以用下面的“暴力”方法实现，用 i 和 j 分别表示字符串和 pattern 当前正在匹配的字符的下标，匹配成功则都 +1，否则 i = i - j +1，j = 0。循环继续的条件是字符串还没匹配完，并且也没有成功匹配出 pattern。大概过程如下图。

function match(string, pattern) {
  let i = (j = 0)
  for (; i < string.length && j < pattern.length; i++) {
    if (string[i] === pattern[j]) {
      j++
    } else {
      i -= j
      j = 0
    }
  }
  if (j === pattern.length) {
    let s_index = i - pattern.length
    return [s_index, string.slice(s_index, s_index + pattern.length)]
  } else {
    return 'failed'
  }
}

console.log(...match('abababababcabcabxababab', 'abcabx'))

用上面的方式我们可以对任意 pattern 进行字符串的匹配。但有个问题是当匹配失败的时候我们是将 i 前进一位，然后对 pattern 从头进行匹配，对一些有重复部分的 pattern 显然是没有效率的。比如 abcabx，当我们匹配到 abcabc 的时候我们没必要从 bcabc 从头匹配，只需匹配第二个 abc 后面是不是 abx 就可以了。而如果使用状态机模型，则可以利用状态的跳转来实现这样的目的。

function match(string) {
  let state = start
  for (let c of string) {
    state = state(c)
  }
  return state === end
}

function start(c) {
  if (c === 'a') {
    return foundA
  } else {
    return start
  }
}

function foundA(c) {
  if (c === 'b') {
    return foundB
  } else {
    return start(c)
  }
}

function foundB(c) {
  if (c === 'c') {
    return foundC
  } else {
    return start(c)
  }
}

function foundC(c) {
  if (c === 'a') {
    return foundA2
  } else {
    return start(c)
  }
}

function foundA2(c) {
  if (c === 'b') {
    return foundB2
  } else {
    return start(c)
  }
}

function foundB2(c) {
  if (c === 'x') {
    return end
  } else {
    return foundB(c) //跳转到找到第一个b的状态
  }
}

function end() {
  return end
}

console.log(match('ababaabcabcabxab')) //true

用状态机模型的方式实现，代码结构也很清晰，每一个状态直接是没有关系的，我们可以通过控制状态的跳转来控制流程，提高匹配的效率。但是这样的实现方式显然也不好，每次出现一个新的 pattern 我们都要重新写代码，并没有将状态机的逻辑完全抽象出来。

KMP 算法

KMP 算法的主要思想是提前判断如何重新开始查找，而这种判断只取决于模式字符串本身。—— 《算法4》

在匹配字符串这个问题上，最重要的就是当一个字符匹配失败的时候，我们怎么进行下面的匹配才是最高效的。比如上面的非状态机的实现方法，当我们匹配失败的时候，我们已经匹配成功了 [0, j - 1] 位了，此时我们将 i 回退到未匹配状态并右移一位再从 j = 0 开始匹配，这显然是非常低效的。比如 abcabx 这样的 pattern，当我们在 x 这一位匹配失败的时候，我们并不一定需要全部重新匹配，因为如果我们当前这一位是 c 的话我们可以优化我们的匹配过程，如下图。

如果我们能找到 pattern 的规律就能够很好地优化我们的过程，kmp 算法正是一个很好字符串匹配的算法。kmp 算法有两种实现方式，一种是基于确定有限状态机的 DFM(deterministic finite-state automaton)，另一种是基于部分匹配表 PMT(Partial Match Table) 的。我个人觉得 PMT 的思路更容易理解一点，但是 DFM 则是一种更”优雅“的方式。

DFM

在谷歌上搜索 DFM 的中文结果很少，大部分的 KMP 算法的文章都是讲解 PMT 中的 next 数组的含义，通过状态机来讲解这个算法的非常少，而且质量也不是很高。大部分的 DFM 文章都来源于 《算法》第四版 中的 5.3 章节 Substring Search 中的 Knuth-Morris-Pratt substring search，以及作者 Robert Sedgewick 对该算法的讲解视频（视频地址贴在这里）。我最后也是直接看原文和视频来理解的（虽然英文很烂，硬着头皮看，不过视频还好，没有什么听力难点，学好英语对程序员太重要了），这里整理一下我的理解。我认为重点是要理解状态转移之间的关系，这是 DFM 的核心。

首先贴上《算法》中的对字符串 ABABAC 作为 pattern 的状态机图示。

对这两个图做一个简单的解释，上方的是一个矩阵，下方是一个图表，他们表达的是同一个有限状态机，只是形式不同。这两张图表达的就是 ABABAC 进行匹配的状态机。所有的数字表示的都是状态，而这个状态数字可以理解成当前已经成功匹配了几个字符，比如状态 4 表示已经成功匹配到了 ABAB 才进入状态 4。下方图表的箭头则表示状态的转移，注意每个箭头上都有一个字母，表示这个转移是因为这个字母的输入。以状态 3 为例，我们此时已经成功匹配到了 ABA 三个字符，下面我们接受的输入有三种可能 A B C，当接收 B 时，我们成功匹配进入状态 4，当接收 A 时，我们回到了状态 1，当我们接收 C 时回到状态 0。我们的状态机接收两个参数，一个是当前状态，一个是输入，得到的结果就是应该转移的状态。在矩阵图中，j 是当前所处的状态，pat.charAt(j) 表示 pattern 在当前要匹配的字符，纵向的 dfa[][j] 则表示输入，中间的矩阵表示要转移到的状态，比如矩阵中位置 [0,0] 的 1 表示，在状态 0 接收输入 A，状态转移到 1。

这里需要注意，我们的状态机只和 pattern 有关，就是不管我们要进行匹配的字符串是什么，只要我们的 pattern 不变，状态机就不变，举个例子就是不管待匹配的字符串是 ababababaaacaba 还是 abafabafagaba，只要 pattern 是 ABABAC，状态机就不变，所以在分析状态机的时候我们只需要分析在 pattern 中出现的字符。

我们将待匹配的字符串叫做 string，把要匹配的子串成为 pattern 这里的状态是我们自己分析的，但是要写成程序我们必须抽象出一个所有 pattern 的状态机规律。我们想一想我们是如何得到状态转移 (state transition) 的结果的。以状态 5 为例，当我们在状态 5 匹配失败 (mismatch) 的时候，我们如何确定我们要转移到哪个状态呢。这里可以借助上面的暴力解法来理解，当我们在状态 5 匹配失败的时候，我们已经成功匹配了 ABABA，此时按照暴力解法，我们应该是从 BABA 开始重新匹配。我们可以确定的是 BABA 也是 pattern 的子串，所以其实我们只要搞清楚 BABA 在状态机中执行后会到什么状态，这个状态被称为 restart state。也就是说，当我们在 j 处匹配失败，我们只要知道知道 1 ~ (j-1) 这个子串在状态机中运行后的状态，这个状态就是状态 j 的重启状态 restart state，所以 j 处的某个输入 c 匹配失败了，我们获得其状态转移的方法就是将这个输入 c 交给重启状态即可。而 j 的 restart state 也有自己的 restart state，我们只要找到重启状态之间的关系就可以用迭代来解决这个问题，因为状态 0 没有 restart 状态，而状态 1 的 restart state 肯定是 0（状态 1 去掉首位就是个空字符串），有了初始状态和迭代规律，我们并不需要真的把 BABA 放到状态机中运行然后记录结果，只是帮助我们理解这个算法。

我们用一个变量 X 表示当前状态下匹配失败要跳转到的状态。我们上面说过，当状态 5 匹配失败时，我们实际上是将 ABABA 去掉首位变成 BABA 进入状态机运算得到的结果作为状态 5 的 X，也就是说当我们在状态 j 匹配失败时，我们是将 pattern 中已经匹配成功的 pattern[0] - pattern[j - 1],去掉首位，也就是 pattern[1] - pattern[j - 1] 放入状态机中运算，得到的结果作为 X。我们还是以 ABABAC 为例，分析一下各个状态的 X。

语言能力不太好，下面的表述可能不太清晰。主要有三个概念：X是当前状态的restart state，目标字符是当前状态能匹配成功的字符，还有一个就是求X需要的当前状态已匹配的字符串（去掉首位，比如上面的 BABA)

状态 0，目标字符 A，一个字符都没有匹配成功，不考虑。
状态 1，目标字符 B，匹配成功 A 去掉首位为 ""，放入状态机中运算结果为 0，X 为 0。
状态 2，目标字符 A，匹配成功 AB 去掉首位为 B，放入状态机中运算结果为 0，X 为 0。
状态 3，目标字符 B，匹配成功 ABA 去掉首位为 BA, 放入状态机中运算结果为 1, X 为 1。
状态 4，目标字符 A，匹配成功 ABAB 去掉首位为 BAB，放入状态机中运算结果为 2，X 为 2。
状态 5，目标字符 C，匹配成功 ABABA 去掉首位为 BABA，放入状态机中运算结果为 3，X 为 3。

我观察一下可以发现，去掉没意义的状态 0，剩下的五个状态，求 X 所用的字符串分别是 ""，B，BA，BAB,BABA，而目标字符分别是 B，A，B，A，C，状态 2 的 X 值就是状态 1 的 X 对应状态输入状态 2的目标字符 A 得到的状态。注意这里的X代表的也是一个状态

可能有点绕，不是很好表述，状态 5 的 X 就是 BABA 在状态机中的运算结果，状态 4 的 X 就是 BAB 在状态机中的运算结果，BABA 的运算结果就是 BAB 的运算结果再输入一个 A，而这个 A 就是状态 4 的目标字符。也就是说我们知道状态 4 的 X 就已经能求得状态 5 的 X，以此类推我们从状态 1 就能求到之后所有状态的 X，而状态 1 的 X 为 0。

restart state 我认为两个作用： 1. j 和 j-1 状态的 restart state 有明确的迭代关系，我们可以利用状态 1 的 restart state 为 0和迭代关系两个信息求出所有状态的 restart state。 2. 当前状态的不匹配输入是交给 restart state 处理的（如果这个输入给 restart state 也不匹配，那么就会找 restart state 的 restart state也就是说，我们某个状态的不匹配输入 c 的结果是从其 restart state 上复制的。

根据这两条规律，我们只要有状态 0 的所有输入结果，我们就可以得到所有状态的状态跳转矩阵。具体到代码上，我们可以创建一个二维数组 dfa[][]，我们初始化 dfa[0][] 的所有项，然后根据上面两条规律，可以生成整个 dfa 矩阵，我们的问题也就迎刃而解。

《算法》第四版中有两张图可以来辅助理解。

下面就是具体代码，我们可以分成两个部分，一个部分是检索子字符串，另一部分是管理状态机。第一部分的代码非常简单，循环字符串，将字符交给状态机，当字符循环完毕没匹配成功则返回 false，若匹配成功则返回 success。第二部分则是生成对应 pattern 的状态机。

function match(s, p) {
  let M = p.length,
    N = s.length,
    i = 0,
    j = 0,
    dfa = KMP(p)

  for (; i < N && j < M; i++) j = dfa[j][s.charCodeAt(i)]
  if (j === M) return 'match success at index of ' + (i - M)
  return 'false'
}

function KMP(p) {
  let X = 0,
    R = 256,
    M = p.length,
    dfa = new Array(M)
  for (let i = 0; i < dfa.length; i++) dfa[i] = new Array(R) //创建长度为dfa.length的数组，每一项为一个对象

  //初始化dfa[0],即初始的X状态，后面的状态要用这一状态来复制
  for (let i = 0; i < R; i++) dfa[0][i] = 0
  dfa[0][p.charCodeAt(0)] = 1 //状态0时匹配到第一位总是进入状态1

  //生成后面的状态机
  for (let j = 1; j < M; j++) {
    for (let c = 0; c < R; c++) dfa[j][c] = dfa[X][c] //设置状态j的匹配失败项，从状态X复制
    dfa[j][p.charCodeAt(j)] = j + 1 //设置匹配成功项
    X = dfa[X][p.charCodeAt(j)] //计算下一状态的 X
  }
  return dfa
}

console.log(match('asdfasdfsafabababafabababacasdf', 'ababac'))

这里的代码使用 javascript 写的，所以 KMP 中我们需要手动初始化状态 0（也就是默认的 X）的状态跳转。《算法》中的代码使 Java，所以整形数组的项的默认值是 0，不需要处理。 javascript 中，new Array() 方法创建的固定长度的数组其实只是一个确定了 length 属性的数组对象，里面并没有任何元素（不要理解成都是 undefined）。

还有一点就是算法中是用 charAt，也就是 javascript 中的 charCodeAt 方法来设置状态机的输入，每个状态对应 256 种输入，也就是扩展 ASCII 码的全部字符数，这样做的好处是我们完全不需要考虑 match 函数中的输入字符（只要在扩展 ASCII 范围内）。不过这样创建的二维数组特别大，我认为可以先对 pattern 进行一个处理，取出 pattern 中所有的不重复的字符放入对象，只要匹配的字符不在这个对象中，直接将 j 设置为 0。具体代码如下。

function match(s, p) {
  let M = p.length,
    N = s.length,
    i = 0,
    j = 0,
    o = {},
    dfa = KMP(p)

  //生成pattern中不重复元素的对象
  for (let t of p) {
    if (!o[t]) o[t] = t
  }

  for (; i < N && j < M; i++) {
    j = !!o[s[i]] ? dfa[j][s[i]] : 0
  }
  if (j === M) return 'match success at index of ' + (i - M)
  return 'false'
}

function KMP(p) {
  let X = 0,
    R = 256,
    M = p.length,
    o = {},
    dfa = new Array(M)

  //生成pattern中不重复元素的对象
  for (let t of p) {
    if (!o[t]) o[t] = t
  }

  for (let i = 0; i < dfa.length; i++) dfa[i] = { ...o } //创建长度为dfa.length的数组，每一项为一个对象

  //初始化dfa[0],即初始的X状态，后面的状态要用这一状态来复制
  for (let key in dfa[0]) {
    dfa[0][key] = 0
  }
  dfa[0][p[0]] = 1 //状态0时匹配到第一位总是进入状态1

  //生成后面的状态机
  for (let j = 1; j < M; j++) {
    for (let c in o) dfa[j][c] = dfa[X][c] //设置状态j的匹配失败项，从状态X复制
    dfa[j][p[j]] = j + 1 //设置匹配成功项
    X = dfa[X][p[j]] //计算下一状态的 X
  }
  console.log(dfa)
  return dfa
}

console.log(match('asdfasdfsafabababafabababacasdf', 'ababac'))

//[
//  { a: 1, b: 0, c: 0 },
//  { a: 1, b: 2, c: 0 },
//  { a: 3, b: 0, c: 0 },
//  { a: 1, b: 4, c: 0 },
//  { a: 5, b: 0, c: 0 },
//  { a: 1, b: 4, c: 6 }
//]
//match success at index of 21

状态机的运用让我们在搜索的效率上得到了很大的提高，但是我们需要额外维护一个状态机，也是用空间换时间。暴力解法的时间复杂度最坏情况是 O(m*n)，DFM 的解法的时间复杂度则为 O(n).

PTM 部分匹配表

在搜索引擎上能找到的关于 KMP 算法的文章大部分都是 PTM 实现的，所以我也是最先看的 PTM 实现。相对于 DFM 的实现，PTM 的实现可能更简单粗暴一点，也更好理解。而且 PTM 的思维可能会影响你对 DFM 的理解。

PMT 叫做部分匹配表，其实就是把 DFM 中每个状态对应的 X 的值进行单独计算。在 DFM 中我们对 X 的理解是一个在匹配失败的时候跳转的状态，在 PTM 中对这个值的理解就是当前状态下的最长前后缀。

我们先来介绍前后缀的概念。对于一个字符串，包含该字符串的首位且不包含末位的子串就是这个字符串的前缀，而包含该字符串的末位且不包含首位的子串就是这个字符串的后缀。比如对于字符串 ababa ，他的前缀包括 a ab aba abab，他的后缀包括 a ba aba abab。我们在 DFM 中找的 X 在 PTM 的理解中就是寻找最长的相同前后缀。比如 ababa 的最长相同前后缀就是 aba，长度为 3。我们在 DFM 中的 ABABAC 的 j 为 5 的情况下对应的 X 就是 3。这个原理其实也很简单，看下图。

在 DFM 中我们理解这张图是我们在 j 为 5 的状态匹配失败，此时我们将前面匹配成功的五位 ABABA 去掉首位再放到状态机中计算得到的输出作为 X。在 PTM 中其实就没有所谓的状态了，我们在当前这一位匹配失败了，就找出前面匹配成功的字符串 ABABA 中的最长前后缀，也就是 ABA。其实我们仔细思考一下，这两种方法其实并没有本质的区别，把 BABA 放到状态机中计算就是找最长前后缀，只不过 DFM 更巧妙一些，我们不需要真的去找最长的前后缀。可以说 DFM 的做法是着眼于各个状态的关系，用这个关系来解决问题；而 PTM 则更简单直接一点，我这个状态的问题就利用这个状态自己解决。

所以在 PTM 中我们可以得出 pattern 的各位对应的最长相同前后缀的长度，这个长度所形成的表就叫做部分匹配表。我们用两个 pattern 来看一下对应的 PTM 。第一个是 ababac，第二个是 abababca。

如何求这个 PTM 呢？其实 PTM 就是 pattern 自己和自己匹配然后得出的结果，因为我们在用 pattern 和字符串匹配的时候，匹配成功的组合必然就在 pattern 中，匹配失败的时候我们需要移动的也只是 pattern 的指针，所以 PTM 只和 pattern 相关。大概的逻辑是：从 pattern[1] 开始不断用 pattern 进行匹配，用两个指针分别指向两个 pattern 当前的位置（如下图），用一个数组 arr 储存 i 指针对应位的最长前后缀的长度。匹配成功则两个指针都右移，arr[i] = j（得到当前位置的最长前后缀）；失败则 i 不动，j 赋值为 arr[j-1] 的值（在运行过程中就利用我们已经得到的结果）；如果 j 为 0，则 arr[i] = 0 并且 i 向右移动一位。整个过程就是 DFM 中的某一位匹配失败时，用前面匹配成功的部分去掉第一位放进状态机匹配的详细过程。详细的过程和代码看下图

function PMT(p) {
  let i = 1, //i和j错开
    j = 0,
    arr = [0] //第一位的最长前后缀为0

  while (i < p.length) {
    if (p[i] === p[j]) {
      j++
      arr[i] = j
      i++
    } else if (j === 0) {
      arr[i] = 0
      i++
    } else {
      j = arr[j - 1] //匹配失败的时候，j回到j-1位的最长前后缀的位置
    }
  }
  return arr
}
console.log(PMT('ababac'))
console.log(PMT('abababca'))
//[ 0, 0, 1, 2, 3, 0 ]
//[ 0, 0, 1, 2, 3, 4, 0, 1 ]

我们上面求得的这个 PTM 在实际编码中并不方便，我们上面的 i 指针实际上相当于我们在 i + 1 位匹配失败，求得前 1 ~ i 位的最长相同前后缀（即 DFM 中的把 1 ~ i 位放到状态机中执行），所以 i 位的 PTM 值其实是给 i + 1 位用的，基于这个原因，我们将 PTM 表向右移动一位，最左边补上一个 -1（单纯是为了编程方便），最右边的位舍去，得到如下的 next 表。

我们也可以直接求出 next 数组，代码如下。

function PTM2(p) {
  let arr = [-1]
  let i = 0,
    j = -1

  while (i < p.length) {
    if (j == -1 || p[i] == p[j]) {
      ++i
      ++j
      arr[i] = j
    } else j = arr[j]
  }
  //arr.pop();
  return arr
}
console.log(PTM2('ababac'))
console.log(PTM2('abababca'))
//[ -1, 0, 0, 1, 2, 3, 0 ]
//[ -1, 0, 0, 1, 2, 3, 4, 0, 1 ]

我们可以看出我们设置 arr[0] 和 j 为 -1 的情况下，我们可以将 j 回到第一位和匹配成功两个状况合并，因为 j 回到第一位理论上只要移动 i，但当我们设置 j 为 -1 的时候，我们也需要 j++，这就和匹配成功的逻辑相同了，让我们的代码更简单更清晰。得到 next 数组之后剩下的就是写 match 函数，逻辑和 next 数组的逻辑基本相同。

function match(s, p) {
  let i = 0,
    j = 0,
    arr = PMT(p)

  while (i < s.length) {
    if (j === -1 || s[i] === p[j]) {
      if (j === arr.length - 1) return 'success'
      i++
      j++
    } else {
      j = arr[j]
    }
  }
  return 'failed'
}

总结

我个人认为动态规划是有限状态机的一种特殊形态。DFM 的实现花了很长时间才领会，主要就是因 PTM 的想法有点先入为主的理解，他们的本质是一样的，但是 DFM 用状态之间的关系迭代直接避免了比较复杂的前后缀计算，我们只关心每个状态之间的关系，有一点动态规划中走楼梯问题的感觉。不过KMP 算法似乎也不是查找子串效率最高的方法，在《算法》第四版中还有一个 Boyer–Moore 算法。

参考文章

YDNJS学习笔记：上卷-第二部分

Sat, 18 Jul 2020 12:00:00 GMT

YDNJS 学习笔记

YDNJS学习笔记：上卷第一部分

前言

承接第一卷第一部分

this

关于 this 的行为我已经写过一篇文章：JavaScript中this的指向；关于 bind call apply 也写过一篇文章：apply和call, bing方法的应用。所以这一部分重复的内容就不写了。只补充一些自己没有掌握的细节。

为什么要使用 this

this 给我提供了一种优雅的方式来隐式传递一个对象的引用，因此我们可以将 API 设计的更加简介并且易于复用。随着代码越来越复杂，显示传递上下文的方式会让代码越来越混乱而难以理解和维护。特别是在 JavaScript 这样一个基于原型的面向对象语言中，this 更加显得重要。

// 用this隐式传递对象的引用
function identify() {
  return this.name.toUpperCase()
}

var me = {
  name: 'Kyle'
}

var you = {
  name: 'Reader'
}

identify.call(me) // KYLE
identify.call(you) // READER

//显式传入对象
function identify(context) {
  return context.name.toUpperCase()
}
function speak(context) {
  var greeting = "Hello, I'm " + identify(context)
  console.log(greeting)
}
identify(you) // READER
speak(me) //hello, I'm KYLE

熟练的运用 devtools 能够让我们更有效率地调试我们的代码。比如查看调用栈。

采用默认调用的函数只有内部使用严格模式才能限制 this 绑定到全局对象上，如果只是在函数调用的部分使用严格模式，而函数体内部使用非严格模式，函数内的 this 还是会绑定到全局对象上。

//函数内部为严格模式
function foo() {
  'use strict'
  console.log(this.a)
}
var a = 2
foo() // TypeError: this is undefined

//函数内部非严格，调用环境严格
function foo() {
  console.log(this.a)
}
var a = 2
;(function () {
  'use strict'
  foo() // 2
})()

不要在代码中混合使用严格模式和非严格模式，可能造成兼容性问题。

参数的传递也是一种隐式的赋值，在传递过程中也会丢失对象的绑定。不管是我们自己定义的回调函数还是内置方法的回调函数都一样，因为实参传递给形参的时候已经丢失了原来绑定的对象。

function foo() {
  console.log(this.a)
}
function doFoo(fn) {
  // fn 其实引用的是 foo fn(); // <-- 调用位置!
}
var obj = {
  a: 2,
  foo: foo
}
var a = 'oops, global' // a 是全局对象的属性 doFoo( obj.foo ); // "oops, global"

硬绑定在 ES5 中已经提供了标准化的内置方法 bind，它的原型如下。

function foo(something) {
  console.log(this.a, something)
  return this.a + something
}
// 简单的辅助绑定函数
function bind(fn, obj) {
  return function () {
    return fn.apply(obj, arguments)
  }
}
var obj = {
  a: 2
}
var bar = bind(foo, obj)
var b = bar(3) // 2 3
console.log(b) // 5

//ES5的bind
function foo(something) {
  console.log(this.a, something)
  return this.a + something
}

var obj = {
  a: 2
}

var bar = foo.bind(obj)

var b = bar(3) // 2 3
console.log(b) // 5

第三方库的许多函数，以及 JavaScript 语言和宿主环境中许多新的内置函数，都提供了一个可选的参数，通常被称为“上下文”(context)，其作用和 bind(..) 一样，确保你的回调函数使用指定的 this。这些函数实际上就是通过 call(..) 或者 apply(..) 实现了显式绑定，这样你可以少写一些代码。

四种绑定模式：默认绑定，隐式绑定，显示绑定和 new 绑定，优先级从低到高。其中比较容易忽略的一点就是 bind 和 new 的优先级以及应用。如果我们对一个 bind 硬绑定的函数执行 new 运算，那么函数执行过程中 new 运算新创建的对象会覆盖 bind 绑定的对象。书中有一处我觉得表述的比较有问题，就是模拟 bind 的那个函数的运行结果，代码如下。

//模拟 bind
function bind(fn, obj) {
  return function () {
    fn.apply(obj, arguments)
  }
}

function foo(something) {
  this.a = something
}

var obj1 = {}

var bar = bind(foo, obj1)

bar(2)
console.log(obj1.a) // 2

var baz = new bar(3)
console.log(obj1.a) // 3
console.log(baz.a) // undefined

//标准bind
function foo(something) {
  this.a = something
}

var obj1 = {}
var bar = foo.bind(obj1)
bar(2)

console.log(obj1.a) // 2
var baz = new bar(3)
console.log(obj1.a) // 2
console.log(baz.a) // 3

两段代码看似没什么不同，但是模拟 bind 中最后实际 new 的函数是

function() {
        fn.apply( obj, arguments );
};

在 fn 外面嵌套了一层，而标准中的则是直接 new 的 bind 返回的函数。内部嵌套的函数中的 this 和所在环境的 this 是不相关的，所以这两者的类比其实没什么意义。

嵌套的原因主要是 apply 和 call 是立即执行的，不像 bind 是返回一个带参数的函数，所以 new 和 call/apply 无法一起使用。new 和 bind 一起使用还有一个功能就是能够预设参数，达到和函数柯里化一样的效果。

最后说一下 mdn 给出的 bind的 polyfill，这个 polyfill 能够检测是否是 new 操作符，将标准中的 bind 对 new (funcA.bind(thisArg, args)) 的行为也实现。在 ES6 中有 new.target 可以轻松实现这个功能，但这个 polyfill 使用的场景是 bind 都没有，更不用说 new.target 了。

polyfill 就是我们常说的刮墙用的腻子，polyfill 代码主要用于旧浏览器的兼容，比如说在旧的浏览器中并没有内置 bind 函数，因此可以使用 polyfill 代码在旧浏览器中实现新的功能.

//  Yes, it does work with `new (funcA.bind(thisArg, args))`
//第一层
if (!Function.prototype.bind)
  (function () {
    var ArrayPrototypeSlice = Array.prototype.slice
    //第二层
    Function.prototype.bind = function (otherThis) {
      if (typeof this !== 'function') {
        // closest thing possible to the ECMAScript 5
        // internal IsCallable function
        throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable')
      }

      var baseArgs = ArrayPrototypeSlice.call(arguments, 1),
        baseArgsLength = baseArgs.length,
        fToBind = this,
        fNOP = function () {},
        //第三层
        fBound = function () {
          baseArgs.length = baseArgsLength // reset to default base arguments
          baseArgs.push.apply(baseArgs, arguments)
          return fToBind.apply(fNOP.prototype.isPrototypeOf(this) ? this : otherThis, baseArgs)
        }

      if (this.prototype) {
        // Function.prototype doesn't have a prototype property
        fNOP.prototype = this.prototype
      }
      fBound.prototype = new fNOP()

      return fBound
    }
  })()

我把代码分为了三层，第一层是判断 API 是否有 bind，第二层就是在 Function.prototype 上添加 bind 方法，第三层则是我们调用 bind 后返回的函数。对于非 new 调用，就直接是 apply 并传入 otherThis，非常简单。但对于 new 我还是有点疑问的。

我们 new 的实际上是 第三层 的 fBound 函数。根据 new 的行为会创建一个 [[prototype]] 指向 fBound.prototype 的新对象，然后以这个新对象作为 this 执行 fBound 并返回新对象。要注意的一点是，第二层中的 this 是调用 bind 的函数（我们设这个方法为 fn），而第三层中的 this 是 new 运算符创造的新对象。

我们最后 new 的新对象的 [[prototype]] 应该是第二层的调用 bind 函数（标准中的 bind 就是如此）的 prototype，这条线索也就是整个方法的核心，在第三层用 fNOP.prototype.isPrototypeOf(this) 来验证 this 的原型链上是不是有 fn.prototype，如果有就说明这是个 new 调用。但是在 mdn 的这个实现中，是用一个空对象 fNOP 的 prototype 指向fn.prototype，然后将 fBound.prototype 指向一个 fNOP 的实例。这样操作虽然 fn.prototype 还在 new 的对象的原型链上，但是和标准中的 bind 行为不一致，中间多了一个 fNOP 的实例。而且在第二层将 fBound.prototype 设为和 fNOP.prototype 一样的 this.prototype 并不影响整个方法的逻辑（这样设置 new 的新对象的 [[prototyep]] 指向 fn.prototype），执行结果也没有异常，不影响第三层 fNOP.prototype.isPrototypeOf(this) 的验证。不知道 mdn 上的方法是不是有什么其他我没想到的用意，如果哪位读者知道，希望指点一下。

书中总结的 this 的判断规则：

函数是否在 new 中调用(new 绑定)?如果是的话 this 绑定的是新创建的对象。var bar = new foo()
函数是否通过 call、apply (显式绑定)或者硬绑定调用?如果是的话，this 绑定的是指定的对象。var bar = foo.call(obj2)
函数是否在某个上下文对象中调用(隐式绑定)?如果是的话，this 绑定的是那个上下文对象。var bar = obj1.foo()
如果都不是的话，使用默认绑定。如果在严格模式下，就绑定到 undefined，否则绑定到全局对象。 var bar = foo()
如果你把 null 或者 undefined 作为 this 的绑定对象传入 call、apply 或者 bind，这些值在调用时会被忽略，实际应用的是默认绑定规则。

使用 null 作为参数的情况一般是用 apply 展开数组（有些函数只接受一个个单独的参数，我们想直接传入数组用 apply 是个方便的方法，当然 ES6 中有扩展运算符 ... 可以直接使用）；用 bind 进行函数柯里化（预先传入参数）。

绑定 null 作为 this 不是一个安全的方法，最好是用 var ø = Object.create( null ); 创建一个空对象来代替 null，这样可以避免发生意外。

(p.foo = o.foo)(); 会应用默认绑定，赋值表达式返回值是右值，此处为对应方法的引用。

YDNJS学习笔记-上卷-第一部分

Thu, 16 Jul 2020 12:00:00 GMT

YDNJS 学习笔记

YDNJS上卷第一部分

前言

本文整理阅读 YDNJS 过程中的一些自己没有掌握的知识点，查漏补缺。

作用域

所谓 作用域 就是由引擎管理的一套严格的规则，管理引擎如何在当前作用于以及嵌套的子作用域中根据标识符名称进行变量的查找。（任何语言有作用域的机制，JS 中的作用域机制比较特别）

LHS 和 RHS

LHS 就是 left-hand-side expression，RHS 就是 right-hand-side expression，在ecma-262的第 12 章有对 LHS 的详细定义，所有 LHS 都可以作为 RHS，非 LHS 的合法表达式都是 RHS。标准主要讲的是哪些是合法的左值表达式。这里的 left 和 right 指的是在赋值操作符的左边和右边，但语句中并不一定要出现赋值符号，比如 ++ 和 --，他们在执行的过程中实际是有赋值行为的，这也就是为什么 ++a++ 报错的原因。所以区分左手还是右手关键是看有没有赋值行为发生（赋值行为不一定需要赋值操作符，可以有其他形式），LHS 可以理解为 找到要赋值的目标，而 RHS 可以理解为 找到某个已经被赋值的结果。

回到作用域中，在引擎查找变量的时候，如果查找的目的是对变量进行赋值，就是用 LHS 查询，如果目的是获取变量的值，就是用 RHS 查询。引擎在处理未声明的 LHS 和 RHS 是不同的，RHS 如果在作用域链中查询不到引擎会抛出 ReferenceError 异常。而 LHS 如果沿着作用域链查询到顶层（全局作用域）中都没有查询到的话，在非严格模式下就会在全局作用域中创建一个该名称变量，返回给引擎，如果是在严格模式下，会和 RHS 一样抛出一个 ReferenceError 异常。

如果在作用域链中查询到 RHS 对应变量，但是尝试对这个变量进行不合理的操作，比如一个非函数类型的值进行函数调用，或者引用 null 或 undefined 的属性，引擎会抛出 TypeError。ReferenceError 异常和作用域判别失败相关，而 TypeError 则表示作用域判别成功了，但是对结果的操作是非法或不合理的。

词法作用域

编译的三个阶段： 1. 分词/词法分析（Tokenizing/Lexing），将代码分解成对编程语言来说不可再分的此法单元（token）。此法单元的识别是有状态的成为词法分析，无状态则成为分词。 2. 解析/语法分析（Parsing），将词法单元流（数组）转换成一个由元素逐级嵌套所著称的代表了程序与法结构的树，成为抽象语法树（Abstract Syntax Tree AST)。 3. 代码生成：将 AST 装换为可执行代码（机器指令）的过程成为代码生成。

作用域共有两种主要的工作模型。第一种是最为普遍的，被大多数编程语言所采用的词法作用域，我们会对这种作用域进行深入讨论。另外一种叫作动态作用域，仍有一些编程语言在使用(比如 Bash 脚本、Perl 中的一些模式等)。我们在 JavaScript 中使用的作用域模型也是比较普遍的词法作用域。

词法作用域顾名思义就是发生在上面编译三个阶段的第一阶段（由引擎的专门负责作用域的部分来管理），词法作用域是由你在写代码时将变量和块作用域写在哪里来决定的。这种机制能够保证代码在词法分析阶段的作用域保持不变（大部分情况下）。词法作用域某种意义上是一种静态的作用域，而另一种对应的模式被称为 动态作用域。结论：无论函数在哪里被调用，也无论他如何被调用，他的词法作用域都只由函数被声明时所处的位置决定。作用域查找会在找到第一个匹配的标识符时停止。

关于引擎对代码的处理可以看一个简单的例子 var a = 2;,事实上编译器会进行如下处理。

遇到 var a，编译器会询问作用域是否已经有一个该名称的变量存在于同一个作用域的集合中。如果是，编译器会忽略该声明，继续进行编译;否则它会要求作用域在当前作用域的集合中声明一个新的变量，并命名为 a。
接下来编译器会为引擎生成运行时所需的代码，这些代码被用来处理 a = 2 这个赋值操作。引擎运行时会首先询问作用域，在当前的作用域集合中是否存在一个叫作 a 的变量。如果是，引擎就会使用这个变量；如果否，引擎会继续查找该变量。

改变词法作用域

有两个方法可以改变我们静态的词法作用域，with 和 eval。两个方法都不推荐使用。

with 的作用是扩展作用域链。一般情况下我们的词法作用域是静态的，由我们的语句在代码中的位置决定的。引擎根据嵌套的作用域链来寻找变量，但是当使用 with 语句以后，我们的作用域链的第一层不再是当前所处的执行上下文的变量对象，而是 with 语句的参数，而执行上下文的变量对象则变为第二层。也就是 with 语句中的变量搜索会现在参数所给的对象中进行，找不到才会进入我们一般语句的搜索模式。

function a(obj) {
  with (obj) {
    a = 10
    var b = 20
  }
  console.log(b)
}
obj = {
  a: 1,
  b: 2
}
a(obj) //undefined 如果obj中没有b属性则此处输出20
console.log(obj) //{a:1,b:20}

因为 with 总是先在指定的对象中查找属性，如果我们在 with 语句中使用不是指定对象中的变量，查找起来就会变慢。还有如果我们在 with 语句中操作的变量不是指定对象的属性（比如上面代码中 obj 对象没有 a 属性），那么这个变量会被泄露到全局作用域上。如果是用 var 声明的变量在指定对象上不存在，这个变量相当于生命在 with 语句所处的执行上下文中。

严格模式不可以使用 with语句。

eval 函数是全局对象的一个方法，接收表达式或语句的字符串作为参数，把该参数当做 js 代码来执行，如果参数不是字符串，参数会被直接返回。

直接调用 eval，那么代码执行的执行环境就是当前环境（就好像我们把参数中的代码卸载当前位置一样），而如果间接调用（比如将 eval 引用赋值给其他变量让后通过赋值后的变量调用，或者类似 (0, eval)('x + y'); 的表达式计算也算间接调用），那么代码执行的执行环境就是全局作用域。在严格模式中，eval 在运行时有自己的词法作用域，所以无法修改内部声明的作用域。

eval 强烈不建议使用主要有以下几个问题：

eval 的可读性非常差，而且也不容易调试。
安全风险：eval 的参数是一个字符串，自然也可以拼接，如果我们的拼接字符串中有来自用户的输入（比如 input），那么就是一个非常危险的行为，并且 eval 会暴露自己的作用域。当然这种情况一般不太会发生
eval 的性能问题，eval 必须调用解释器来解释执行，而且现代 JavaScript 解释器会将 javascript 转换为机器代码，而在执行过程中才解析的 eval 中的代码很可能需要诉诸环境重新执行已经生成的机器码来应对，这必然造成性能的损失。引擎在编译阶段的各种优化方式也是依赖于词法的静态分析，预先确定变量和函数的位置，让代码在执行的时候能够快速找到对应的变量和函数，而 eval 函数中接受的代码使不确定的，所以很多优化是无法进行的。

由于 eval 中的代码相当于执行 eval 的位置，所以其内部的声明会影响到当前环境的词法作用域作用域。

function foo(str, a) {
  eval(str) // 此处执行的代码声明了一个新的变量，改变了当前环境的词法作用域
  console.log(a, b)
}
var b = 2
foo('var b = 3;', 1) // 1, 3

Function 函数也可以像 eval 一样把字符串当做代码执行，Function 可以使用 new 也可以不用，它们的效果是一样的，最后一个参数会被当做函数体，前面的参数是参数名，必须要要用 javascript 中合法的标识符字符串，所有被传递到构造函数中的参数，都将被视为将被创建的函数的参数，并且是相同的标示符名称和传递顺序，可以是 Function('a', 'b', functionBody) 的形式，也可以是 Function('a, b', functionBody) 的形式，functionBody 是一个含有包括函数定义的 JavaScript 语句的字符串。由 Function 构造器创建的函数不会创建当前环境的闭包，它们总是被创建于全局环境，因此在运行时它们只能访问全局变量和自己的局部变量，不能访问 Function 构造器创建时所在的作用域的变量。这一点与使用 eval 执行创建函数的代码不同。这种方式要比 eval 安全很多，但是依然不推荐使用，使用 Function 构造器生成的 Function 对象是在函数创建时解析的。这比你使用函数声明或者函数表达式并在你的代码中调用更为低效，因为使用后者创建的函数是跟其他代码一起解析的。

function foo(str, a) {
  Function(str)() //3
  console.log(a, b)
}
var b = 2
foo('var b = 3;console.log(b)', 1) // 1, 2

作用域

最小暴露原则：在软件设计中，应该最小限度地暴露必要内容，而将其他内容都“隐藏”起来，比如某个模块或对象的 API 设计。我认为有几点好处：

代码按功能分隔开来，可读性更强，更容易维护。对于模块和对象的使用完全不用关心内部的细节，只要知道对应的接口即可。
避免了变量名的冲突。特别是我们加载各种第三方库的时候很容易发生这样的情况。

区别函数声明和函数表达式的方法就是看函数声明的语句中 function 关键字是不是在语句的第一个词。如果是第一个词那么这就是一个函数声明，否则就是一个函数表达式（只要这是一个合法的语句）。另外就是函数表达式可以匿名，而函数声明则不可以。

匿名函数和 IIFE

函数表达式中可以使用匿名函数，但是匿名函数有几个缺点

匿名函数在栈追踪中不会显示出有意义的函数名，调试困难
匿名函数没有函数名，当函数需要调用自身的时候（比如递归中），就只能用已经不推荐使用的（arguments.callee）。另一个函数需要引用自身的例子，是在事件触发后事件监听器需要解绑自身。
函数名可以增加代码可读性，一个好的函数名能够让函数的功能一目了然。

所以，一个好的习惯是我们始终给函数表达式命名。

立即执行函数的独立词法作用域有个小技巧就是 undefined 在局部环境被赋值的情况，我们可以设置立即执行函数的形参为 undefined 但是不传入任何参数，在函数体内 undefined 就不会受外部的影响。当然最好是不要随便给 undefined 赋值，使用 undefined 的地方尽量用 void 0 代替。

立即执行函数有一种特殊的写法，将需要执行的内容当做参数传递进去，叫做 UMD(Universal Module Definition)

var a = 2
;(function IIFE(def) {
  def(window)
})(function def(global) {
  var a = 3
  console.log(a) // 3
  console.log(global.a) // 2
})

try...catch 语句

try...catch 语句是用来监测一段语句的执行是否抛出异常。如果try代码块中的语句（或者 try 代码块中调用的方法）一旦抛出了异常（也可以是我们主动 throw），那么执行流程会立即进入 catch 代码块。如果 try 代码块没有抛出异常，catch 代码块就会被跳过。finally 代码块总会紧跟在 try 和 catch 代码块之后执行，但会在 try 和 catch 代码块之后的其他代码之前执行。

try...catch 语句至少有一个 try 块（由要尝试执行的语句组成），一个 catch 块或者一个 finally 块，catch 和 finally 块可以两者都有，所以一共有三种形式：

try...catch
try...finally
try...catch...finally

你可以嵌套一个或者更多的 try 语句。如果内部的 try 语句没有 catch 子句，那么将会进入包裹它的 try 语句的 catch 子句（可以理解为离自己最近的 catch 语句）。try 块中抛出的异常会作为 catch 块的参数，这个参数只在 catch 内能够访问。无论是否抛出异常 finally 子句都会执行。如果抛出异常，即使没有 catch 子句处理异常，finally 子句中的语句也会执行。最后要注意的就是 try...catch 语句的返回值（语句只有在函数内返回值才有意义），三种块都能用 return 返回，但是有一定的规则，大致如下：

只要存在 finally 块的 return，无论是否抛出异常，也无论 try 和 catch 是否有 return ，最后的返回值都是 finnaly 块的 return。
如果没有 finally 块不存在，那么如果抛出异常就输出 catch 块的 return。
如果没有 finally 块不存在，如果没有抛出异常，那么输出 try 块的 return。

这里我们可以发现 return 的行为在 try...catch 里面是不同的。一般情况下 return 会中指当前函数的执行并返回值，但是在 try...catch 中并不会。

try...catch 语句中的 catch 块的参数是有独立的词法作用域的，也就是他无法在语句外访问，利用这一点我们可以在没有 let , const 的情况下（ES6 之前）实现块级作用域，因为 try...catch 语句在 ES3 就有了，并且一直都是这么工作的。比如 Google 的 Traceur （类似于 babel，将 ES6 代码转换成兼容 ES6 之前的环境）就是这样实现块级作用域的。

{
  try {
    throw undefined
  } catch (a) {
    a = 2
    console.log(a) //2
  }
}
console.log(a) //ReferenceError: a is not defined

大括号 {} 在 ES6 中可以作为块级作用域的（配合 let，const 和 class，函数声明也因为兼容性保持特殊行为），在 ES6 之前他只是一种组织代码的方式。

let 和 const

YDKJS 建议为块作用域进行显式的创建，能够让变量的附属关系更清晰。因为 {} 本身就是分隔代码块的一种方式，一般不会改变语义。

var foo = true
if (foo) {
  {
    // <-- 显式的块
    let bar = foo * 2
    bar = something(bar)
    console.log(bar)
  }
}
console.log(bar) // ReferenceError

let 在循环中的使用看似和 var 没太大区别，其实 for 循环头部的 let 不仅将 i 绑定到了 for 循环的块中，事实上它将其重新绑定到了循环的每一个迭代中，确保使用上一个循环迭代结束时的值重新进行赋值。所以 for 循环小括号和大括号并不是同一个词法作用域，小括号在大括号的上层。下面两段代码分别问一般的 for 循环和实际的迭代过程模拟。

//for 循环
for (let i = 0; i < 10; i++) {
  console.log(i)
}
console.log(i) // ReferenceError

//迭代过程模拟
{
  let j
  for (j = 0; j < 10; j++) {
    let i = j // 每个迭代重新绑定!
    console.log(i)
  }
}

函数作用域我个人认为也属于一个单独的块级作用域，所以他们在作用域的行为上是一致的，任何声明在某个作用域内的变量，都将附属于这个作用域。

垃圾回收问题

这个问题也是我一直思考的问题，当一个函数 a 内部返回了一个函数 b，那么即使 a 执行完了其内部变量也无法释放，因为 b 的闭包覆盖 a 的环境。当然我想现在的 JS 引擎应该有一定的优化，但是这个问题应该是无法彻底解决的，因为我们无法确定这个被返回的 b 函数何时会执行，也不知道他内部是否要访问在 a 内部定义的变量或者方法。YDNJS 也给出了一个类似的例子，不过不是用的返回函数，而是用的 DOM 事件监听。

function process(data) {
// 在这里做点有趣的事情
}

var someReallyBigData = { .. };

process( someReallyBigData );

var btn = document.getElementById( "my_button" );

btn.addEventListener( "click", function click(evt) {
    console.log("button clicked");
}, /*capturingPhase=*/false );

这个例子中事件监听函数的回调并不需要用到所在环境的其他变量或者方法，但是因为他的闭包覆盖了自己所在的环境，所以会导致那些已经 不需要 的变量或者方法不能被释放（取决于具体的引擎实现）。使用块作用域可以解决这个问题。

function process(data) {
// 在这里做点有趣的事情
}

// 在这个块中定义的内容完事可以销毁!
{
    let someReallyBigData = { .. };
    process( someReallyBigData );
}

var btn = document.getElementById( "my_button" );

btn.addEventListener( "click", function click(evt){
     console.log("button clicked");
}, /*capturingPhase=*/false );

提升

引擎会在执行代码前对代码进行编译，这里除了编译器的工作，还有一个重要的工作就是作用域。这些工作都为了提升代码的执行效率，编译成机器码让计算机能快速执行，而作用域的存在可以让引擎在运行时对变量的查找更加快速和有效率。当然中间还有很多其他的优化，在引擎的发展过程中不断进步（比如 JIT 可以延迟编译甚至实施重编译）。而对变量和函数声明的处理也是其中的重要一环。

关于变量和函数的提升，我已经在另一篇文章里面详细写过了，这里就不在重复了。

由于 YDNJS 第一版（第二版英文版在 github 上已经可以看了，只有 scope and closure 一本）已经是 2015 版本了，所以有些内容已经不适合现在的 JS，比如 提升 这个章节小结前的最后一段代码，在现在的 JS 宿主环境执行就会报 TypeError，具体原因就是函数声明在块级作用域中的行为发生了改变，后面随便版本的更新可能还会改变，现在的行为也是为了兼容以前的老代码而做的妥协，因为函数声明是很早就有的概念，而块作用域则是 ES6 才出现的，如果把函数声明也全部变成块作用域的话，很多以前的代码将无法运行。函数声明在块级作用域的具体行为查看上面链接的文章中的 let -> 没有变量提升 这一小节。

虽然我们要清楚引擎是如何处理变量和函数的提升的，但是在实际编码中还是要避免重复的声明，保持好的编码习惯。

作用域闭包

我个人对闭包的理解就是一个函数和函数对它定义时的词法环境的引用一起够成一个闭包，所以每一个函数都有自己的闭包。理解闭包就是理解词法作用域，也就是理解 JavaScript 中的变量和方法的访问机制。

function foo() {
  var a = 2
  function bar() {
    console.log(a)
  }
  return bar
}
var baz = foo()
baz() // 2 bar在定义时的词法作用域以外执行

function foo() {
  var a = 2
  function baz() {
    console.log(a) // 2
  }
  bar(baz)
}
function bar(fn) {
  fn() // baz在定义时的词法作用域以外执行
}

上面的例子中 foo 函数执行的结果被赋值给 baz（实际只是将 foo 内部函数 bar 的引用赋值给 baz，最后执行的也是 bar）。在 foo() 执行后，通常会期待 foo() 的整个内部作用域都被销毁，因为我们知道引擎有垃圾回收器用来释放不再使用的内存空间。由于看上去 foo() 的内容不会再被使用，所以很自然地会考虑对其进行回收。而事实上因为 bar 对 foo() 内部作用域的引用还存在，所以闭包会阻止 foo() 内部作用域的销毁，并且会一直存在，因为随时有可能再次执行 bar()。bar 函数和他对 foo() 的内部作用域的引用就是闭包（事实上整个作用域链都是可以访问的，只是对我们有意义的是已经执行完成的函数内部的作用域）。这个函数在定义时的词法作用域以外的地方被调用。闭包使得函数可以继续访问定义时的词法作用域。

事件绑定很多时候也是闭包：

function setupBot(name, selector) {
  $(selector).click(function activator() {
    console.log('Activating: ' + name)
  })
}
setupBot('Closure Bot 1', '#bot_1')
setupBot('Closure Bot 2', '#bot_2')
//setupBot函数执行完后为 #bot_1 和 #bot_2绑定了 click 事件，但是当事件触发时，我们依然可以访问name和selector

无论通过何种手段将内部函数传递到所在的词法作用域以外，它都会持有对原始定义作用域的引用，无论在何处执行这个函数都会使用闭包。

闭包在 JavaScript 中最重要的应用就是当我们把函数作为值到处传递的时候，这些函数在定义时的词法作用域之外执行，保持对定义时的词法作用域的引用，让我们还能访问到内部的变量或者方法。在定时器、事件监听器、 Ajax 请求、跨窗口通信、Web Workers 或者任何其他的异步(或者同步)任务中，只要使用了回调函数，实际上就是在使用闭包!

YDNJS 中的看法是函数在定义的词法作用域以外执行才算闭包，但我觉得每个函数都是闭包，都有对自己所在词法作用域的引用，只不过让函数在定义的词法环境以外执行时符合我们需求的一种重要应用。

模块

书中介绍了两种模块化方式，一种是利用立即执行函数进行包装，通过返回的函数闭包来访问立即执行函数内部的作用域，返回的函数就作为模块的 API。而模块的管理则一般利用模块加载器，书中给出了一个简单的实现。

var MyModules = (function Manager() {
    var modules = {};
    function define(name, deps, impl) {
        for (var i=0; i<deps.length; i++) {
            deps[i] = modules[deps[i]];
        }
        modules[name] = impl.apply( impl, deps );
        console.log(modules)
    }

    function get(name) {
        return modules[name];
    }
    return {
        define: define,
        get: get
    };
})();

MyModules.define( "bar", [], function() {
    function hello(who) {
        return "Let me introduce: " + who;
    }
    return {
        hello: hello
    };
});
MyModules.define( "foo", ["bar"], function(bar) {
    var hungry = "hippo";
    function awesome() {
        console.log( bar.hello( hungry ).toUpperCase() );
    }
    return {
        awesome: awesome
    };
});

var bar = MyModules.get( "bar" );  //{ bar: { hello: [Function: hello] } }
var foo = MyModules.get( "foo" );  //{bar: { hello: [Function: hello] },foo: { awesome: [Function: awesome] }}
console.log(bar.hello( "hippo" ));  //Let me introduce: hippo
foo.awesome(); //LET ME INTRODUCE: HIPPO
console.log(bar.hello()) Let me introduce: undefined

第二种则是 ES6 中的 import 和 export。ES6 为模块添加了语法支持，文件被当做单独的模块来处理，每个模块都可以导入其他模块或特定的 API 成员，同样也可以导出自己的 API 成员。ES6 的模块没有“行内”格式，必须被定义在独立的文件中(一个文件一个模块)。浏览器或引擎有一个默认的模块加载器，可以在导入模块时同步地加载模块文件。与基于函数的模块不同的是，ES6 的模块是静态的，API 不能再运行时改变，所以可以在编译时就检查模块是否存在，不存在则报错，模块文件中的内容会被当作好像包含在作用域闭包中一样来处理，就和前面介绍的函数闭包模块一样。。而基于函数的模块则是在运行时才能知道 API，并且我们可以随时改变（事实上我觉得基于函数的模块只是利用闭包的一种代码包装，本质还是函数）

关于模块化的内容书中并没有介绍太多，我认为模块化的内容还是非常重要的，需要单独拿出来学习一下。

附录

动态作用域

javascript 和大多数语言一样，作用域为词法作用域。词法作用域就是根据定义的位置来寻找变量和方法，可以理解为静态的，在编译的时候就已经确定变量的位置了，之后运行时引擎也根据这套规则寻找变量。而动态作用域则是根据调用的位置来确定变量。我们可以用下面的代码说明。

//静态
function foo() {
  console.log(a) // 2
}
function bar() {
  var a = 3
  foo()
}
var a = 2
bar()

//动态
function foo() {
  console.log(a) // 3
}
function bar() {
  var a = 3
  foo()
}
var a = 2
bar()

简单一点说就是词法作用域根据定义的位置寻找变量（在写代码或者说定义时确定的），而动态作用域则是根据调用的位置来寻找变量（在运行时确定的）。虽然 JavaScript 中并没有动态作用域，但是 this 关键字的机制却和动态作用域很类似。

定时器的一些思考

Wed, 15 Jul 2020 12:00:00 GMT

前言

JavaScript 中的定时器有两个 setTimeout 和 setInterval，在浏览器环境他们都是全局对象 window 的属性（在 web worker 中则是对应的 WorkerGlobalScope，本文主要讨论 window 其他的环境可以类推），他们不是 JavaScript 标准里的东西，是浏览器的 API，不过在 nodejs 中也模拟浏览器进行也实现，也是挂载在全局对象上的。定时器由于有自己的一些特殊行为，所以写一篇文章来总结一下。

nodejs 中的定时器的第一个函数不能是字符串，只能是一个函数。nodejs 上的实现虽然是浏览器的翻版，但是还是略有不同，本文主要讨论浏览器环境，具体的 nodejs 中的不同参考 nodejs 文档。

标准

我们直接一步到位，从标准中看定时器的定义，定时器 timer 在HTML标准的第 8.6 章节。

语法

handle = self . setTimeout( handler [, timeout [, arguments... ] ] )
//Schedules a timeout to run handler after timeout milliseconds. Any arguments are passed straight through to the handler.

handle = self . setTimeout( code [, timeout ] )
//Schedules a timeout to compile and run code after timeout milliseconds.

self . clearTimeout( handle )
//Cancels the timeout set with setTimeout() or setInterval() identified by handle.

handle = self . setInterval( handler [, timeout [, arguments... ] ] )
//Schedules a timeout to run handler every timeout milliseconds. Any arguments are passed straight through to the handler.

handle = self . setInterval( code [, timeout ] )
//Schedules a timeout to compile and run code every timeout milliseconds.

self . clearInterval( handle )
Cancels the timeout set with setInterval() or setTimeout() identified by handle.

self 就是 window 或者 web worker 的 WorkerGlobalScope，在 window 全局对象下我们可以直接写 window 也可以不写。handle 可以理解为定时器的编号，清除定时器的两个函数依靠 handle 在定时器列表中找到对应的定时器清除。setTimeout 和 setInterval 都至少接收一个参数作为回调函数，这个参数可以是一个函数也可以是一个字符串（不建议使用字符串，会有和 eval 一样的问题，在 nodejs 中默认不可以使用字符串）；第二个可选参数是回调函数的执行间隔，默认值为 0；从第三个参数开始就是回调函数执行的参数。

clearTimeout 和 clearInterval 虽然命名不一样，但他们都是依靠 handle 来取消定时器的，所以他们都能够清除 setTimeout 和 setIntervel 设置的定时器。

两个提示

标准中给出了两个提示，一个是定时器可以嵌套，但是当嵌套超过 5 层的时候，最短间隔将被设为 4ms，这个我已经在 chrome 测试过，确实如此。但是在 nodejs 中不受影响。

console.time('first')
setTimeout(function () {
  console.timeEnd('first')
  console.time('second')
  setTimeout(function () {
    console.timeEnd('second')
    console.time('third')
    setTimeout(function () {
      console.timeEnd('third')
      console.time('fourth')
      setTimeout(function () {
        console.timeEnd('fourth')
        console.time('fifth')
        setTimeout(function () {
          console.timeEnd('fifth')
          console.time('sixth')
          setTimeout(function () {
            console.timeEnd('sixth')
          })
        })
      })
    })
  })
})
//chrome 输出
//first: 1.2001953125ms
//second: 1.420166015625ms
//third: 1.416259765625ms
//fourth: 1.527099609375ms
//fifth: 4.43798828125ms
//sixth: 5.159912109375ms

//nodejs输出
//first: 1.678ms
//second: 1.792ms
//third: 1.270ms
//fourth: 1.599ms
//fifth: 1.561ms
//sixth: 1.259ms

第二点就是我们设置的 delay 延迟时间并不是精确的，要根据 CPU 负载，其他的任务的执行时间。关于这一点要理解浏览器工作过程中非常重要的 event loop （nodejs 也有相同的设施），这个要详细说明比较复杂。大致可以这么理解，引擎只负责处理要执行的任务，但是异步任务的执行时不确定的，所以宿主环境都提供了一种设施来管理异步任务何时进入引擎的调用栈执行。引擎遇到一个异步的回调函数交给管理异步任务的模块，当这个回调函数触发了（比如我们的定时器时间到了，或者元素绑定事件触发了等），并不是直接把这个回调函数交给引擎执行（JS 是单线程的，任务只能一个一个执行），而是放进浏览器管理的一个任务队列，触发的回调函数会加入这个队列，等待引擎执行完再到队列里面来取任务（这也就是所谓的 event loop）。也就是我们设定的这个 delay 指的是我们的回调函数什么时候进入任务队列，而不是什么时候执行。这里讲的只是一个大概的过程，具体的内容可以看我的两篇文章：JavaScript如何工作一：引擎，运行时和调用栈概述和事件循环 Event Loop

执行细节

WindowOrWorkerGlobalScope 的实例对象（即 window 或者 WorkerGlobalScope）都会管理一个 list of active timers，也就是活动的计时器的列表。列表中的每一个项都用一个唯一的数来标记。

setTimeout() 和 setInterval() 的执行过程类似，唯一不同的就是 repeat flag。关于执行的过程标准原文：The setTimeout() method must return the value returned by the timer initialization steps, passing them the method's arguments, the object on which the method for which the algorithm is running is implemented (a Window or WorkerGlobalScope object) as the method context, and the repeat flag set to false.大致意思是 setTimeout() 方法必须返回 timer initialization steps 的返回值，把方法的参数传递给 timer initialization steps ，setTimeout方法所处的对象（window 或者 WorkerGlobalScope 对象）作为方法的执行上下文，最后设置 repeat flag。从这里我们已经能看出方法的执行是在全局环境中，这也是为什么非严格模式下 setTimeout 中的函数内的 this 返回全局对象的原因。

timer initialization steps 的调用需要几个参数，方法参数（setTimeout 从第三个参数开始都是方法的参数），a method context（window 或者 WorkerGlobalScope对象），a repeat flag 和一个可选的 previous handle（用作 setInterval 的多次调用）。

设置方法的执行上下文 method context 为 window 或者 WorkerGlobalScope对象。
如果传递了 previous handle 就用 previous handle 作为 handle ，否则就创建一个大于 0 的整数作为 handle。
如果 previous handle 没有提供，那么就在 list of active timers 用生成的 handle 添加一项。
Let callerRealm be the current Realm Record, and calleeRealm be method context's JavaScript realm.
将初始化脚本作为活动脚本
断言：初始化脚本不为 null。
运行下面的子步骤
- 如果对应的 handle 在 list of active timers 中被清除了则终止这些步骤。
- 如果方法的第一个参数是 Function，用后续的参数调用该方法，将 method context proxy 作为回调函数的 this 对象。
- 如果 repeat flag 为 true，则再次调用 timer initialization steps，传递相同的参数，当前的 handle 作为 previous handle。
方法的第二个参数作为 timeout
如果当前正在运行的任务是相同的算法创建的（我的理解是都是 setTimeout，即当前的步骤是在一个 setTimeout 中或者是 repeat flag 为 true 的 setInterval），将嵌套层级设置为当前执行的定时器的其那套层级。否则嵌套层级为 0。
如果 timeout 小于 0，设 timeout 为 0。
如果嵌套层级大于 5,并且 timeout 小于 4 ，设置 timeout 为 4。
嵌套层级加一。
设置任务的嵌套层级为上面计算出的嵌套层级。
返回 handle，并行运行这个算法。
fully avtive 概念参考标准
等待其他开始于本计时器之前，并且事件小于等于本计时器 timeout 的计时器执行完成。
进入任务队列，等待 event loop 执行。

以上就是定时器的执行过程，内容完全是个人理解翻译，可能有理解错误，欢迎指正。

注意点

从标准我们可以看出，回调函数是在全局环境执行的，有一个特殊的地方就是，无论是否在严格模式下，回调函数的 this都返回 window 对象。想要获得 setTimeout 执行位置的词法作用域的 this，一个有效的方法就是箭头函数。

function a() {
  setTimeout(() => {
    console.log(this)
  }, 0)
}

let obj = {
  fun: a
}

obj.fun() // { fun: [Function: a] }

setTimeout 回调函数也可以获得块级作用域闭包。

{
  let a = 10
  setTimeout(function () {
    console.log(a) //10
  })
}
let a = 20
console.log(a) //20

我们上面说了 delay 的最短间隔问题，同时 delay 也是有上限的。javascript 规定 delay 是一个 32 位无符号整数，这意味着 delay 的上限是 $2^{32} - 1$ 即 2147483647。

想要清除定时器我们需要将 setTimeout 或者 setInterval 的返回值储存到一个变量中，当我们有嵌套的定时器或者管理的定时器较多时，如何命名和清除对应的定时器是一个要解决的问题。我今天就想到一个场景，两个嵌套的 setInterval，外层的 delay 比内层的 delay 要短的情况下，并且我们只希望内层的 setInterval 执行几次就停止，如何有效的清除对应的定时器。

我们将场景设置地具体一点，我们希望内层的每个定时器执行五次后被清除，我们要如何储存定时器 id，我们需要给每一个定时器不同的命名，同时需要确保我们使用的外部变量补鞥呢影响到其他定时器。我最终的解决方案是用一个对象 timerPool来保存所有的定时器，属性名用 timerPool[`timer${index}`]，index 是一个自增的变量，外层的定时器每执行一次就自增，这样就能确保每个定时器 id 保存在不同的变量中。同时这个 index 是在变化的，当我们进行 clearIterval(timerPool[`timer${index}`]) 的时候，index 已经不是我们要的那个 index 了，所以需要用一个立即执行函数将内层的定时器包裹起来，将 index 传递进去以保存，其他的可能会被影响的外部变量也可以参照处理。最后的代码如下：

let outer = 0
let timerPool = {}
setInterval(() => {
  ;(function (outer) {
    let index = 0,
      inner = 0
    timerPool[`timer${outer}`] = setInterval(() => {
      if (index >= 5) {
        inner = 0
        console.log(outer)
        clearInterval(timerPool[`timer${outer}`])
      } else {
        console.log(index, outer, inner)
        index++
        inner++
      }
    }, 1000)
  })(outer)
  outer++
}, 4000)

检验结果解释每一个 outer 都只执行了 5 次，比如 outer 为 1 的输出只有 5 次，分别对应 inner 为 0, 1, 2, 3, 4 的情况。

关于清除定时器还有一点需要注意的就是，如果我们在某个上下文内定义了一个定时器，同时想在该环境外部清除定时器，那我们需要将保存定时器 id 的变量在外部声明。

requestAnimationFrame

在没有 requestAnimationFrame 之前，我们用 JS 实现动画都是用定时器实现的，但是定时器实现动画有很多问题。

先说 setTimeout，setTimeout 的逻辑是过一个指定长度的时间执行代码，当执行一次的时候，这不存在什么问题。当我们要实现一些递归的效果，比如每个 1s 将 div 换个颜色，我们就需要递归的调用 setTimeout。那么这个时候我们会发现，每次执行的时间间隔不是我们指定的 1000ms，而是 1000ms 加上函数执行的时间。

let i = 0
setTimeout(function fn() {
  console.log(i++)
  setTimeout(fn, 1000)
}, 0)

setInterval 是定时将函数推入任务队列（参考事件循环 Event Loop），我们能确定的只是回调函数进入任务队列的时间间隔。而且如果 js 线程很忙碌，在我们下一个定时器要进去的时候发现上一个定时器的回调函数还没执行，那么这次插入任务队列就会失败。setInterval 会尝试在下一次间隔到了再次查看任务队列，只有任务队列没有来自同一个定时器的任务才会插入成功。此时还有一个问题就是我们会发现相邻的任务之间的时间间隔消失了，变成了连续执行。比如下面这段代码，我们会发现执行之间没有了间隔。

console.time('log')
setInterval(() => {
  console.timeLog('log')
  let start = new Date().getTime()
  while (new Date().getTime() - start < 1000) {}
  console.timeLog('log')
}, 500)

注意，NodeJS 的 setInterval 的逻辑和浏览器不同。NodeJS 中是回调函数执行完毕之后才会尝试向任务队列插入新的任务。

从这个角度看 setTimeout 比 setInterval 要好一些，我们的执行不会被丢弃，并且我们可以在回调函数中对时间进行修正来改善 setTimeout 时间不准的问题。但是它们两个都有一个问题是无法跟浏览器的渲染同步。

我们都知道 setTimeout 和 setInterval 是宏任务，一个 Event Loop 执行一次。但是可能很多人不知道，并不是每一次 Event Loop 都会执行 UI render 的。浏览器会根据自己的分析决定在哪一个 Event Loop 渲染。比如下面的代码：

setTimeout(() => {
  document.body.style.background = 'red'
  setTimeout(() => {
    document.body.style.background = 'blue'
  })
})

我们是希望页面先变成红色在变成蓝色，但是实际执行我们会发现很多时候浏览器并不会渲染红色，而是直接显示蓝色，有时候能够正常渲染出颜色的变化，这是为什么呢？其实道理也很简单，如果这两个 setTimeout 任务之间正好遇上了浏览器渲染，那么就能成功看到红色变蓝色。如果两次任务之间浏览器没有渲染，那么就只能看到蓝色。也就是说，丢帧了。如果我们用 setTimeout 或者 setInterval 做动画，很可能最后的效果不是很好，因为浏览器的渲染是不确定的。

如果是用定时器做动画，我们一般设置间隔为 17ms，因为一般情况下浏览器渲染是一秒钟 60 帧，也就是 16.7ms 渲染一次。但是根据具体的浏览器和机器，帧数不一定相同。细节参考事件循环 Event Loop

为了能够实现平滑的动画，HTML5 提供了 window.requestAnimationFrame() 这个 API，它的功能是告诉浏览器——你希望执行一个动画，并且要求浏览器在下次重绘之前调用指定的回调函数更新动画。该方法需要传入一个回调函数作为参数，该回调函数会在浏览器下一次重绘之前执行。所以 requestAnimationFrame 能够和页面渲染同步，能够完美解决我们平滑执行动画的问题。

若你想在浏览器下次重绘之前继续更新下一帧动画，那么回调函数自身必须再次调用 window.requestAnimationFrame()。返回值是一个 long 整数，请求 ID ，是回调列表中唯一的标识。是个非零值，没别的意义。你可以传这个值给 window.cancelAnimationFrame() 以取消回调函数。

使用 requestAnimationFrame 还有一些好处就是在页面被最小化或者我们切换到别的页面时，它是不会触发的，因为此时页面不会渲染，所以它能够节省 CPU 的开销。

参考文章

解构赋值的一些细节

Wed, 08 Jul 2020 12:00:00 GMT

前言

解构赋值 Destructuring assignment 是 ES6 提供的新语法，通过解构赋值我们可以从对象或数组（类数组对象也可）中取出属性或值，赋值给其他变量。本文整理一下比较容易忽略和不太好理解的点。

知识点

undefined 的确定

ES6 用严格相等运算符来判断一个位置是否有值。在解构赋值中只有一个位置的值严格等于 undefined，我们设置的默认值才会生效。

let [x = 1] = [undefined]
x // 1

let [x = 1] = [null]
x // null

默认值表达式惰性求值

如果解构赋值中某个变量的默认值是个表达式，那么这个表达式是惰性求值的，也就是只有需要执行的时候才会求值。

function f() {
  console.log('aaa')
}

let [x = f()] = [1] //f() 不会执行

对象解构机制

数组的解构赋值是根据变量的位置来确定其值的。由于对象不像数组一样是按次序排列的，所以对象的解构赋值只能根据变量的名称到对象中查找。但是需要注意的是，我们要区分好用于匹配的模式（可以理解为键值对中的键）和具体的对象，特别是在嵌套的对象解构中。我的理解就是解构表达式中的变量表示中不管嵌套多少层，有多少标识符，第一个无法在对象中找到的标识符就是变量的名称，如果每一个标识符都能找到，那么就是隐藏了一个和最后一个标识符同名的变量。

let { foo: baz } = { foo: 'aaa', bar: 'bbb' }
baz // "aaa"
foo // error: foo is not defined
//foo是匹配的模式，baz才是变量，模式只是用来到对象中查找属性，而变量则是最后赋值的目标

let {
  foo: { bar }
} = { baz: 'baz' } //foo 无法在对象中找到，所以是 undefined，此时再想向下找属性就会报错

//对象的解构赋值可以找原型上的属性
const obj1 = {}
const obj2 = { foo: 'bar' }
Object.setPrototypeOf(obj1, obj2)

const { foo } = obj1
foo // "bar"

//数组是特殊的对象，所以可以对数组进行对象属性的解构
let arr = [1, 2, 3]
let { 0: first, [arr.length - 1]: last } = arr
first // 1
last // 3

解构赋值用引擎的内部方法 toObject()（我们无法在 runtime 访问到这个方法）强制将源数据转为对象。也就是说如果 source 是一个原始数据类型，会被转为对应的包装对象。由于 null 和 undefined 无法转为对象，所以会报错。

let { length } = 'foobar'
console.log(length) // 6

let { constructor: c } = 4
console.log(c === Number) // true

let { _ } = null // TypeError

let { _ } = undefined // TypeError

如果解构赋值语句不是变量声明语句（前面没有 var，let，const），即对已经声明的变量进行进行解构赋值需要注意加上括号。

let x;
{x} = {x: 1}; //Uncaught SyntaxError: Unexpected token '='  行首的大括号会被引擎认为是代码块
({x} = {x: 1}); //这是正确写法，但是和立即执行函数一样，该语句的前面一行最好加上分号，否则可能会被当做函数调用。

嵌套的对象的解构赋值可以用来复制对象属性。

let person = {
  name: 'Matt',
  age: 27,
  job: {
    title: 'Software engineer'
  }
}
let personCopy = {}

;({ name: personCopy.name, age: personCopy.age, job: personCopy.job } = person)

// Because an object reference was assigned into personCopy, changing a property
// inside the person.job object will be propagated to personCopy:
person.job.title = 'Hacker'

console.log(person)
// { name: 'Matt', age: 27, job: { title: 'Hacker' } }

console.log(personCopy)
// { name: 'Matt', age: 27, job: { title: 'Hacker' } }

对于包含了多个属性赋值的解构赋值语句，多个属性的赋值是依次执行，相互独立的，也就是说如果第一个属性赋值成功，第二个失败报错的话，第一个赋值依然是成功的。

let person = {
  name: 'Matt',
  age: 27
}

let personName, personBar, personAge

try {
  // person.foo is undefined, so this will throw an error
  ;({
    name: personName,
    foo: { bar: personBar },
    age: personAge
  } = person)
} catch (e) {
  console.log(e) //TypeError: Cannot read property 'bar' of undefined
}

console.log(personName, personBar, personAge)
// Matt, undefined, undefined

结构赋值还可以配合 for ... of 进行使用：

var people = [
  {
    name: 'Mike Smith',
    family: {
      mother: 'Jane Smith',
      father: 'Harry Smith',
      sister: 'Samantha Smith'
    },
    age: 35
  },
  {
    name: 'Tom Jones',
    family: {
      mother: 'Norah Jones',
      father: 'Richard Jones',
      brother: 'Howard Jones'
    },
    age: 25
  }
]

for (var {
  name: n,
  family: { father: f }
} of people) {
  console.log('Name: ' + n + ', Father: ' + f)
}

// "Name: Mike Smith, Father: Harry Smith"
// "Name: Tom Jones, Father: Richard Jones"

解构赋值可以使用属性名表达式：

let key = 'z'
let { [key]: foo } = { z: 'bar' }

console.log(foo) // "bar"

剩余参数也可以运用到对象的解构赋值中：

let { a, b, ...rest } = { a: 10, b: 20, c: 30, d: 40 }
console.log(a) // 10
console.log(b) // 20
console.log(rest) // { c: 30, d: 40 }

解构赋值的属性查找会查找原型链上的属性：

// 声明对象 和 自身 self 属性
var obj = { self: '123' }
// 在原型链中定义一个属性 prot
obj.__proto__.prot = '456'
// test
const { self, prot } = obj
// self "123"
// prot "456"（访问到了原型链）

数组的解构赋值

数组的解构赋值表达式的右值不是一个可遍历结构，则会报错。

// 报错 Uncaught TypeError: xxx is not iterable
let [foo] = 1
let [foo] = false
let [foo] = NaN
let [foo] = undefined
let [foo] = null
let [foo] = {}

数组的解构赋值也可以这样使用 let [,m] = [2,3]。

数组的解构赋值还支持剩余模式：var [a, ...b] = [1, 2, 3];，但是要注意如果剩余元素右侧有逗号，会抛出 SyntaxError，因为剩余元素必须是数组的最后一个元素。

var [a, ...b] = [1, 2, 3]
// SyntaxError: rest element may not have a trailing comma

数值、字符串和布尔型

解构赋值的规则是，只要等号右边的值不是对象或数组，就先将其转为对象，字符串被转为类数组对象，数值和布尔型则转为包装对象。由于 undefined 和 null 无法转为对象，所以对它们进行解构赋值，都会报错。

const [a, b, c, d, e] = 'hello'
a // "h"
b // "e"
c // "l"
d // "l"
e // "o"

//字符串转为的对象有length属性
let { length: len } = 'hello'
len // 5

let { toString: s } = 123
s === Number.prototype.toString // true

let { toString: s } = true
s === Boolean.prototype.toString // true

let { prop: x } = undefined // TypeError
let { prop: y } = null // TypeError

函数参数的解构赋值

函数参数的解构赋值如果是一个对象，不会影响 arguments 的 length，它只是允许你在函数签名中声明变量，并且能够立即在函数体中使用它。

一个函数签名 (或类型签名，或方法签名) 定义了函数或方法的输入与输出。一个签名可以包括：

参数及参数的类型
一个返回值及其类型
可能会抛出或传回的异常
有关面向对象程序中方法可用性的信息 (例如关键字 public、static 或 prototype)。

let person = {
  name: 'Matt',
  age: 27
}

function printPerson(foo, { name, age }, bar) {
  console.log(arguments)
  console.log(name, age)
}

function printPerson2(foo, { name: personName, age: personAge }, bar) {
  console.log(arguments)
  console.log(personName, personAge)
}

printPerson('1st', person, '2nd')
// ['1st', { name: 'Matt', age: 27 }, '2nd']
// 'Matt', 27

printPerson2('1st', person, '2nd')
// ['1st', { name: 'Matt', age: 27 }, '2nd']
// 'Matt', 27

函数参数的解构赋值需要注意的是默认参数设定的机制。

//设置解构赋值的默认值
function move({ x = 0, y = 0 } = {}) {
  return [x, y]
}

move({ x: 3, y: 8 }) // [3, 8]
move({ x: 3 }) // [3, 0]
move({}) // [0, 0]
move() // [0, 0]
move({ x: undefined, y: undefined }) //[0, 0]

//设置参数默认值
function move({ x, y } = { x: 0, y: 0 }) {
  return [x, y]
}

move({ x: 3, y: 8 }) // [3, 8]
move({ x: 3 }) // [3, undefined]
move({}) // [undefined, undefined]
move() // [0, 0]
move({ x: undefined, y: undefined }) //[undefined, undefined]

//注意下面这种会直接报错
function move({ x = 0, y = 0 }) {
  return [x, y]
}
move() //Uncaught TypeError: Cannot read property 'x' of undefined

这里说实话不是很好理解，阮一峰老师的书里也没有讲的非常清楚，是一笔带过。最后我说一下自己的理解。

ES6标准入门 中关于函数的解构赋值的例子中关于默认值的设定都是非对象的，比如 let {x = 10, y = 20} = {x: 3} 。但是在函数参数的情况里面并不是这样。函数参数中的例子是 function move({x = 0, y = 0} = {}){} 这样的形式，用之前的那种理解无法解释这种行为。

函数的参数是一个 arguments，一个迭代器，类数组对象，所以上面的函数可以类比为这样的一个式子:

function move({ x = 0, y = 0 } = {}) {}
;[{ x = 10, y = 20 } = {}] = arguments[({ x = 10, y = 20 } = {})] = []

经过这种转化之后似乎清晰一些，但是如何理解呢。我们把 {x = 10, y = 20} 看做一个整体，上面的式子变为 [obj = {}] = []，也就是我们设置 obj 的默认值为 {}（也可以理解为设置参数默认值，是另一种思路，不过本质也没有区别），只要我们传入的 arguments 中有参数的话，就不会用这个默认值 {}，只有当我们的 arguments 的索引为 0 的元素严格等于 undefined 的时候才会用到默认值 {}，使用默认值就相当于执行 {x = 10, y = 20} = {} 的解构赋值。当 arguments 的索引为 0 的元素不严格等于 undefined 的时候则会把这个元素转为一个对象 object，执行 {x = 10, y = 20} = object 的解构赋值，如果找不到，则使用默认值 10 ，20，不管传入的是数字还是字符串等，都能正常执行；唯一会报错的就是 null。

有了这个逻辑，我们分析其他的两种情况就很简单了。比如 function move({x, y} = {x:0, y:0}){} 这种情况，就可以理解为 [obj = {x:0, y:0}] = []，只有当 arguments 索引为 0 的元素严格等于 undefined 的时候才会变成执行 {x, y} = {x:0, y:0}，否则就是把索引为 0 的元素转为对象 object 执行 {x, y} = object，这也是为什么只有 move() 不传参的时候才能输出 [0, 0]。

function move({x = 0, y = 0}){} 为什么在不传参的时候报错，它相当于执行 [{x = 0, y = 0}] = []，要在 arguments 索引为 0 的元素转为的对象上找 x 和 y 属性，但这个值是 undefined，所以最终报错。

逻辑可能有点绕，最后我总结一下比较重要的规则：

对于有嵌套结构（且嵌套的数组或对象没有设置初始值）的解构赋值，等号左右两边嵌套结构必须相同。属于模式匹配，所以等号两边模式要相同。
对对象或数组设置初始值（也必须是一个对象或数组），则该对象和数组被看做一个整体，在完成第一步结构赋值以后才能确定目标进行第二次解构赋值。比如 [{x = 10, y = 20} = {}] = [{x: 1}] 先进行 [obj = {}] = [{x: 1}]，确定了 obj 的解构赋值目标是 {x: 1} 之后进行第二步的解构赋值 {x = 10, y = 20} = {x: 1}，最后的结果是 x: 1, y: 20。
对于嵌套结构中的对象，如果设置了初始值（也是对应的对象），则等号右边结构的对应位置可以是除 null 以外的任何值，因为 undefined 会将目标设置为初始值，而其他值都能转为对象。
对于嵌套结构中的数组，如果设置了初始值（应是一个 Iterator），则等号右边结构对应位置必须是一个 Iterator，否则报错。比如 [[a = 1, b = 2]] = [1] 会报错，而 [[a = 1, b = 2]] = ['ab'] 则能正确解构赋值，结果为 a: 'a', b: 'b'。
多层的嵌套每一层都可以给任意结构设定初始值，逻辑和上面相同，不顾一般不会使用。

函数默认参数的使用也和解构赋值的默认值的生效类似，当传入的参数严格等于 undefined 即使用默认参数，[1, undefined, 3].map((x = 'yes') => x); // [ 1, 'yes', 3 ]

上面的函数用的是对象作为参数，其实数组作为参数的情形也是一样的。但是注意数组解构赋值的右值必须是一个可遍历结构。

//设置默认参数
function a([x, y] = [5, 6]) {
  console.log(x, y)
}
a() //5, 6
a([1]) //1, undefined
a('asdf') // a, s
a(1) //VM1241:1 Uncaught TypeError: undefined is not a function(不知道为什么不是not iterable的报错)

//设置默认值
function a([x = 5, y = 6] = []) {
  console.log(x, y)
}
a() // 5, 6
a([1]) //1, 6
a('asdf') // a, s
a(1) //VM1241:1 Uncaught TypeError: undefined is not a function

如果你希望能够在不提供任何参数的情况下调用该函数，就使用默认值模式。如果你只是想用解构赋值给函数一个默认参数则使用另一种。

解构赋值中的括号

解构赋值虽然很方便，但是解析起来并不容易。对于编译器来说，一个式子到底是模式，还是表达式，没有办法从一开始就知道，必须解析到（或解析不到）等号才能知道。由此带来的问题是，如果模式中出现圆括号怎么处理。ES6 的规则是，只要有可能导致解构的歧义，就不得使用圆括号。但是，这条规则实际上不那么容易辨别，处理起来相当麻烦。因此，建议只要有可能，就不要在模式中放置圆括号。

总结起来就是两个规则： 1. 变量声明语句中不可以使用（函数参数也属于变量声明） 2. 不可以把模式（键）包含在小括号中（数组的模式是按位置匹配，所以把数组元素括起来可以）

// 变量声明 报错
let [(a)] = [1];

let {x: (c)} = {};
let ({x: c}) = {};
let {(x: c)} = {};
let {(x): c} = {};

let { o: ({ p: p }) } = { o: { p: 2 } };

//函数参数 报错
function f([(z)]) { return z; }
function f([z,(x)]) { return x; }

//模式括号 报错
({ p: a }) = { p: 42 };
([a]) = [5];

[({ p: a }), { x: c }] = [{}, {}];

//正确
[(b)] = [3]; // 正确
({ p: (d) } = {}); // 正确
[(parseInt.prop)] = [3]; // 正确

除了大括号在行首用括号将表达式括起来，其他情况尽量不要使用

用途

将对象的方法赋值给某个变量

// 例一
let { log, sin, cos } = Math

// 例二
const { log } = console
log('hello') // hello

交换变量的值
```
let x = 1
let y = 2

;[x, y] = [y, x]
```

函数返回多个值

// 返回一个数组

function example() {
  return [1, 2, 3]
}
let [a, b, c] = example()

// 返回一个对象

function example() {
  return {
    foo: 1,
    bar: 2
  }
}
let { foo, bar } = example()

函数参数定义

// 参数是一组有次序的值
function f([x, y, z]) { ... }
f([1, 2, 3]);

// 参数是一组无次序的值
function f({x, y, z}) { ... }
f({z: 3, y: 2, x: 1});

提取 JSON 数据

let jsonData = {
  id: 42,
  status: 'OK',
  data: [867, 5309]
}

let { id, status, data: number } = jsonData

console.log(id, status, number)
// 42, "OK", [867, 5309]

函数参数默认值

jQuery.ajax = function (
  url,
  {
    async = true,
    beforeSend = function () {},
    cache = true,
    complete = function () {},
    crossDomain = false,
    global = true
    // ... more config
  } = {}
) {
  // ... do stuff
}

遍历 Map 解构

jQuery.ajax = function (
  url,
  {
    async = true,
    beforeSend = function () {},
    cache = true,
    complete = function () {},
    crossDomain = false,
    global = true
    // ... more config
  } = {}
) {
  // ... do stuff
}

// 获取键名
for (let [key] of map) {
  // ...
}

// 获取键值
for (let [, value] of map) {
  // ...
}

输入模块的指定方法

const { SourceMapConsumer, SourceNode } = require('source-map')

参考文章

《ECMAScript6入门》 —— 阮一峰
MDN

ECMAScript标准版本

Tue, 07 Jul 2020 12:00:00 GMT

前言

ECMAScript，简称 ES，是由 ecma-international（前身为欧洲计算机制造商协会,英文名称是 European Computer Manufacturers Association）按照 ECMA-262 和 ISO/IEC 16262 标准制定的一种脚本语言规范。本文讲一讲 ES 标准的发展历史以及几个重要版本的特性。

ES 是语言的标准 Standard，浏览器厂商根据标准的实现 Implementation 有多种，比如网景的JavaScript 和微软的 JScript，后来随着浏览器和标准的发展以及浏览器厂商之间的妥协，逐渐合并为现在的 JavaScript，但实际上 JavaScript 是 ECMA-262 标准的实现和扩展。

历史和发展

上图直观的展示了 JavaScript 标准和实现的发展时间轴。

事实上 JavaScript 的发展历程是比较奇葩的，1995 年浏览器厂商网景出于需求要开发一种能在浏览器使用的脚本语言，于是招募了布兰登·艾克，其在该年五月花了十天时间设计出了 JavaScript 的原型，这门语言最初是叫 Mocha，然后在同年发布的 Netscape Navigator 2.0 中被改名为 LiveScript，又随着 12月 发布的 Netscape Navigator 2.0 Beta 3 被改名为 JavaScript，一直沿用至今。使用这个名字的原因也只是当时网景和 Sun 结为开发联盟，为了搭上 Java 这个热词，导致了很多人对这个名字产生误解，其实 JavaScript 和 Java 没什么关系。

JavaScript 在浏览器上取得了成功，微软也马上跟进，在自己的 Internet Explorer 3 上推出了自己的 JScript。接着就是二者各行其是，很长一段时间，各大浏览器厂商的实现都不尽相同，对于语言标准化的推进造成非常大的阻力，也成为开发者的灾难，要让自己的网页兼容不同的浏览器需要耗费非常大的精力。

1996 年 11 月，网景正式向 ECMA（欧洲计算机制造商协会）提交语言标准。1997 年 6 月，ECMA 以 JavaScript 语言为基础制定了 ECMAScript 标准规范 ECMA-262。JavaScript 成为了 ECMAScript 最著名的实现之一。

ES 版本

| 版本 | 发表日期 | 与前版本的差异 | | ---- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 1 | 1997年6月 | 首版 | | 2 | 1998年6月 | 格式修正，以使得其形式与ISO/IEC16262国际标准一致 | | 3 | 1999年12月 | 强大的正则表达式，更好的词法作用域链处理，新的控制指令，异常处理，错误定义更加明确，数据输出的格式化及其它改变 | | 4 | 放弃 | 由于关于语言的复杂性出现分歧，第4版本被放弃，其中的部分成为了第5版本及Harmony的基础 | | 5 | 2009年12月 | 新增“严格模式（strict mode）”，一个子集用作提供更彻底的错误检查,以避免结构出错。澄清了许多第3版本的模糊规范，并适应了与规范不一致的真实世界实现的行为。增加了部分新功能，如getters及setters，支持JSON以及在对象属性上更完整的反射 | | 5.1 | 2011年6月 | ECMAScript标5.1版形式上完全一致于国际标准ISO/IEC 16262:2011。 | | 6 | 2015年6月 | ECMAScript 2015（ES2015），第 6 版，最早被称作是 ECMAScript 6（ES6），添加了类和模块的语法，其他特性包括迭代器，Python风格的生成器和生成器表达式，箭头函数，二进制数据，静态类型数组，集合（maps，sets 和 weak maps），promise，reflection 和 proxies。作为最早的 ECMAScript Harmony 版本，也被叫做ES6 Harmony。 | | 7 | 2016年6月 | ECMAScript 2016（ES2016），第 7 版，多个新的概念和语言特性 | | 8 | 2017年6月 | ECMAScript 2017（ES2017），第 8 版，多个新的概念和语言特性 | | 9 | 2018年6月 | ECMAScript 2018 （ES2018），第 9 版，包含了异步循环，生成器，新的正则表达式特性和 rest/spread 语法。 | | 10 | 2019年6月 | ECMAScript 2019 （ES2019），第 10 版 | | 11 | 2020年6月 | ECMAScript 2020 （ES2020），第 11 版 |

其中比较重要的几个版本分别是 ES3， ES5，ES6，现在的标准制定委员会TC39希望是每年提供一些新的特性，而不是进行非常巨大的改动，这样标准和实现更加能够协同。

从 ES3 到 ES5 经过了十年，各大厂商对于标准的跟进也是兴趣缺缺。我个人认为还是需求导致的，说白了就是目前有的就够用了，整个 10 年，除了 05 年的 Ajax 并没有什么太多的新技术和新需求出现。但是从 10 年开始，随着智能手机，平板电脑的出现，以及个人电脑性能的不断提升，我们在各种设备商能做的事情越来越多，而且前端作为直接与用户交互的一个重要部分，也随着这股浪潮出现了爆炸式的增长，需求的增加自然推动了新的技术的产生和标准化的需求，后面标准的更新就越来越频繁了。

想要查看各个版本的标准的新特性以及浏览器的支持情况可以查看 compat-table

TC39 和 ECMAScript

标准的制定是一个比较长的过程，可以参考关于查看W3C文档。

ECMAScript 的标准制定主要是由 TC39 这个组织进行的，该组织主要由各个主流浏览器厂商的代表构成。一个标准的落地基本都是从 stage0 到 stage4。分别对应 strawman，proposal，draft ，candidate 和 finished，可以参考精读 TC39 与 ECMAScript 提案。

一般来说最新的标准我们可以到 TC39 - lastest ecma262， stage3 的一些特性我们可以到 proposals - tc39 查看。

参考文章

JavaScript 中 Object 相关知识点整理

Sat, 04 Jul 2020 12:00:00 GMT

前言

本文介绍 JavaScript 中 Object 相关的知识点。

JavaScript 中的对象

ECMA-262 把对象定义为:“无序属性的集合，其属性可以包含基本值、对象或者函数。”严格来讲，这就相当于说对象是一组没有特定顺序的值。对象的每个属性或方法都有一个名字，而每个名字都映射到一个值。我们可以把 ECMAScript 的对象想象成散列表: 无非就是一组名值对，其中值可以是数据或函数。

我们创建对象有三种方法：new Object()，Object.create() 和字面量标记 {}。关于三者的区别，参考我的文章 Object.create(null) 和 {…}

下面介绍一些 Object 相关的知识点和 API，包括 ES5 和 ES6 之后的。

属性类型

在 JavaScript 中属性有两种，数据属性 data property 和访问器属性 accessor property。关于两种属性类型我在 JavaScript对象属性类型和赋值细节中已经详细介绍，想要了解可以去看一下。要对属性特性进行定义和修改，必须使用 ES6 给出的方法：Object.defineProperty 和 Object.defineProperties()，要读取属性特性则可以使用 Object.getOwnProperty 或者 Object.getOwnProperties()。

当我们尝试访问一个对象的属性时，会调用其 [[get]]，而当我们尝试修改一个对象的属性时，会调用其 [[set]]。对于数据属性而言，他们都是使用内置的 [[set]] 和 [[get]]。

合并对象

有时候我们需要将多个对象进行合并，这一般是为了实现多继承。很多时候这种操作也被称为混入 mixin，我们通过将源对象的属性 mixin 到目标对象上而实现对目标对象的增强。

ES6 为我们提供了一个 Object.assign() 的方法让我们合并对象的属性，它会将一个或多个源对象的可枚举属性复制到目标对象，键名为 String 类型或 Symbol 类型的属性都会被拷贝，返回合并后的对象（注意，目标对象也会改变）。如果目标对象中的属性具有相同的键，则属性将被源对象中的属性覆盖。该方法拷贝时无法拷贝属性的特性，而且访问器属性会被转换成数据属性（返回值为访问器属性的 getter 的返回值，如果访问器属性没有设置 getter，那么值为 undefined）。Object.assign 不会在那些 source 对象值为 null 或 undefined 的时候抛出错误。

Object.assign() 可以用于浅拷贝，参考我的文章 JavaScript浅拷贝和深拷贝

实现一个 Object.assign():

if (typeof Object.assign !== 'function') {
  // Must be writable: true, enumerable: false, configurable: true
  Object.defineProperty(Object, 'assign', {
    value: function assign(target) {
      // .length of function is 2
      'use strict'
      if (target === null || target === undefined) {
        throw new TypeError('Cannot convert undefined or null to object')
      }

      var to = Object(target)

      for (var index = 1; index < arguments.length; index++) {
        var nextSource = arguments[index]

        if (nextSource !== null && nextSource !== undefined) {
          for (var nextKey in nextSource) {
            // Avoid bugs when hasOwnProperty is shadowed
            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
              to[nextKey] = nextSource[nextKey]
            }
          }
        }
      }
      return to
    },
    writable: true,
    configurable: true
  })
}

Object.assign() 常用来为对象添加属性方法，克隆对象，合并多个对象，为对象的属性指定默认值（source 会覆盖 target 上的同名属性）

Object.create()

参考文章 Object.create(null) 和 {…}。

判断恒等

=== 恒等比较有两个问题，一个是 +0 和 -0 视为相等，而 NaN === NaN 则返回 false。ES6 的 Object 对象新增了一个静态方法就是 Object.is()，用来判断两个值是否相等，你可以理解为它是处理了上面了个情况的恒等。

实现一个 Object.is()

if (!Object.is) {
  Object.is = function (x, y) {
    if (x === y) {
      //如果 x !== 0 直接返回 `true`，如果 `x === 0`，判断 1 / x 和 `1 / y` 是否相等，1 / -0 返回 -Infinity，1 / 0 或者 1 / +0 都返回 Infinity
      return x !== 0 || 1 / x === 1 / y
    } else {
      // Step 6.a: NaN == NaN
      return x !== x && y !== y //利用 NaN === NaN 返回 false，判断x和y是不是都为 NaN
    }
  }
}

属性方法简写

ES6 提供了属性值的简写，我们在给对象创建属性的时候，经常会设置变量名为属性为，变量值为属性值。为了简化这种情况 ES6 提供了一种简写属性的方式。属性的赋值器(setter)和取值器(getter)，事实上也是采用这种写法。

var foo = 'bar'
var baz = { foo }
baz // {foo: "bar"}
// 等同于
var baz = { foo: foo }

//方法也可以简写
var o = {
  method() {
    return 'Hello!'
  }
}
// 等同于
var o = {
  method: function () {
    return 'Hello!'
  }
}

//Generator函数前要加 *
var obj = {
  *m() {
    yield 'hello world'
  }
}

这种简写的方式用在函数返回多个值，以及模块的输出都非常方便。

function getPoint() {
  var x = 1
  var y = 10
  return { x, y }
}
console.log(getPoint()) // {x:1, y:10}

module.exports = { getItem, setItem, clear } // 等同于
module.exports = {
  getItem: getItem,
  setItem: setItem,
  clear: clear
}

**注意：**简写的方法不能作为构造函数，会报错。大概是简写方法没有内部 [[construct]] 方法。

var obj = {
  method: function () {}
}
new obj.method() // 正确

var obj = {
  method() {}
}
new obj.method() // TypeError: obj.method is not a constructor

属性名表达式

在 ES6 之前，对象字面量的属性值只能是字符串，想要使用表达式作为变量的属性，只能使用 [] 成员访问运算符。ES6 允许字面量定义对象时，用表达式作为对象的属性名或方法名，即把表达式放在方括号内。属性名表达式与简洁表示法，不能同时使用，会报错（简洁表示法就是对象属性直接写一个变量，不用写键值对，表示键名就用这个变量的标识符）。

let propKey = 'foo'
let obj = {
  [propKey]: true,
  ['a' + 'bc']: 123
}

//方法名也可以
let obj = {
  ['h' + 'ello']() {
    return 'hi'
  }
}
obj.hello() // hi

属性名表达式和属性的简写不能同时使用，属性名表达式如果是一个对象，默认情况下会自动将对象转为字符串 [object Object] 。

const keyA = { a: 1 }
const keyB = { b: 2 }
const myObject = {
  [keyA]: 'valueA',
  [keyB]: 'valueB'
}
myObject // Object {[object Object]: "valueB"}

对象的解构赋值

解构赋值 destructuring 参考我的文章解构赋值的一些细节

对象的遍历

JavaScript 提供了很多遍历对象的方法，我们先来看看它们有什么不同，方便我们在对应的场景选择合适的遍历方法。

for ... in：遍历对象自身可其原型链上的可枚举属性，不包括 Symbol 属性。
Object.keys()：返回一个数组，包括对象自身的(不含原型链上的)所有可枚举属性 (不含 Symbol 属性)。
Object.getOwnPropertyNames()：返回一个数组，包含对象自身的所有属性(不含 Symbol 属性，但是包括不可枚举属性)
Object.getOwnPropertySymbols()：返回一个数组，包含对象自身的所有 Symbol 属性。
Reflect.ownKeys()：返回一个数组，包含对象自身的所有属性，不管属性名是 Symbol 或字符串，也不管是否可枚举。
Object.values()：返回一个给定对象自身的所有可枚举属性值的数组(不含 Symbol 属性)。
Object.entries()：返回一个给定对象自身可枚举属性的键值对数组（不含 Symbol 属性）。

他们遍历属性的顺序都遵循以下几点：

首先遍历所有属性名为数值的属性，按照数字排序。
其次遍历所有属性名为字符串的属性，按照生成时间排序。
最后遍历所有属性名为 Symbol 值的属性，按照生成时间排序。

深浅拷贝的实现

对象的深浅拷贝参考文章 JavaScript浅拷贝和深拷贝。

Object.getOwnPropertyDescriptors() 用法

Object.getOwnPropertyDescriptors() 可以用来获取所有自身属性的的描述对象（包括 Symbol 属性，不可枚举属性，不包括继承的属性）。这个属性有一些比较有用的用法这里列出来。

由于 Object.assign() 方法不能复制访问器属性（访问器属性会被调用 [[get]] 转为数据属性），所以 Object.getOwnPropertyDescriptors() 可以配合 Object.defineProperties() 成功拷贝访问器属性。

const source = {
  set foo(value) {
    console.log(value)
  }
}
const target2 = {}
Object.defineProperties(target2, Object.getOwnPropertyDescriptors(source))
Object.getOwnPropertyDescriptor(target2, 'foo')
// { get: undefined,
//   set: [Function: foo],
//   enumerable: true,
//   configurable: true }

Object.getOwnPropertyDescriptors() 的另一个用法就是方法的另一个用处，是配合 Object.create() 方法，将对象属性克隆到一个新对象，属于浅拷贝。

const clone = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj))
// 或者
const shallowClone = (obj) =>
  Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj))

获取和设置对象原型

我们都知道可以通过 __proto__ 属性访问到对象的原型，该属性没有写入 ES6 的正文，而是写入了附录，原因是 __proto__ 前后的双下划线，说明它本质上是一个内部属性 [[prototype]]，而不是一个正式的对外的 API，只是由于浏览器广泛支持，才被加入了 ES6。标准明确规定，只有浏览器必须部署这个属性，其他运行环境不一定需要部署，而且新的代码最好认为这个属性是不存在的。因此，无论从语义的角度，还是从兼容性的角度，都不要使用这个属性，而是使用下面的 Object.setPrototype() (写操作)、 Object.getPrototypeOf() (读操作)、Object.create() (生成操作)代替。

Object.setPrototypeOf(object, prototype) 用来设置对象的原型，返回被设置的对象。如果第一个参数不是对象，会自动转为对象。但是由于返回的还是第一个参数，所以这个操作不会产生任何效果。null 和 undefined 无法转为对象，所以第一个参数是 null 或者 undefined 会报错。

Object.setPrototypeOf(1, {}) === 1 // true
Object.setPrototypeOf('foo', {}) === 'foo' // true
Object.setPrototypeOf(true, {}) === true // true

Object.getPrototypeOf(obj) 用于读取一个对象的原型，如果参数不是对象，会被自动转为对象。同样 null 和 undefined 同样会报错。

// 等同于 Object.getPrototypeOf(new Number(1))
console.log(Object.getPrototypeOf(1)) // Number {[[PrimitiveValue]]: 0}
// 等同于 Object.getPrototypeOf(new String('foo'))
Object.getPrototypeOf('foo') // String {length: 0, [[PrimitiveValue]]: ""}
// 等同于 Object.getPrototypeOf(new Boolean(true))
Object.getPrototypeOf(true) // Boolean {[[PrimitiveValue]]: false}

Object.getPrototypeOf(1) === Number.prototype // true
Object.getPrototypeOf('foo') === String.prototype // true
Object.getPrototypeOf(true) === Boolean.prototype // true

警告: 由于现代 JavaScript 引擎优化属性访问所带来的特性的关系，更改对象的 [[Prototype]] 在各个浏览器和 JavaScript 引擎上都是一个很慢的操作。其在更改继承的性能上的影响是微妙而又广泛的，这不仅仅限于 obj.__proto__ = ... 语句上的时间花费，而且可能会延伸到任何代码，那些可以访问任何 [[Prototype]] 已被更改的对象的代码。如果你关心性能，你应该避免设置一个对象的 [[Prototype]]。相反，你应该使用 Object.create() 来创建带有你想要的 [[Prototype]] 的新对象。

Object.prototype.toString()

我在 JS数据类型和判断方法和 Symbol 中都介绍过Object.prototype.toString() 方法。当我们调用 Object.prototype.toString() 时，本质就是访问对象的 Symbol.toStringTag 属性。

当然，许多内置对象并没有 Symbol.toStringTag 属性，但是依然能够通过 toString() 获得其类型，这是引擎的内置。当然要注意，虽然 Object.prototype 在绝大多数对象的原型链上，不过内置对象大部分都重写了 toString() 方法。所以需要使用 call 或者 apply 来调用。内置对象的 toString() 结果如下：

let toString = Object.prototype.toString //=>Object.prototype.toString

console.log(toString.call(10)) //=>"[object Number]"
console.log(toString.call(NaN)) //=>"[object Number]"
console.log(toString.call('xxx')) //=>"[object String]"
console.log(toString.call(true)) //=>"[object Boolean]"
console.log(toString.call(null)) //=>"[object Null]"
console.log(toString.call(undefined)) //=>"[object Undefined]"
console.log(toString.call(Symbol())) //=>"[object Symbol]"
console.log(toString.call(BigInt(10))) //=>"[object BigInt]"
console.log(toString.call({ xxx: 'xxx' })) //=>"[object Object]"
console.log(toString.call([10, 20])) //=>"[object Array]"
console.log(toString.call(/^\d+$/)) //=>"[object RegExp]"
console.log(toString.call(function () {})) //=>"[object Function]"

另外一些对象类型则不然，toString() 方法能识别它们是因为引擎为它们设置好了 toStringTag 标签，我们能够通过 Symbol.toStringTag 来访问到对应的值：

Object.prototype.toString.call(new Map()) // "[object Map]"
Object.prototype.toString.call(function* () {}) // "[object GeneratorFunction]"
Object.prototype.toString.call(Promise.resolve()) // "[object Promise]"
// ... and more

如果是我们创建的对象如果想要有一个自定义的 toString() 效果，则需要自己手动设置对象的 Symbol.toStringTag 属性。

这里顺带说一下内置对象自己的 toString 方法的返回值，所有的返回值类型都是 String。

console.log((10).toString()) //10
console.log('clloz'.toString()) //clloz
console.log(true.toString()) //true
console.log([1, 2, 3].toString()) //1,2,3
console.log(function a() {}.toString()) //function a() {}
console.log(/abc/.toString()) // /abc/
console.log(new Date().toString()) //Thu Nov 05 2020 12:59:46 GMT+0800 (China Standard Time)
console.log(Symbol('a').toString()) //Symbol(a)
console.log(BigInt(10).toString()) //10

Object.prototype.valueOf()

Array：返回数组对象本身。
Boolean：返回布尔值。
Date：存储的时间从 1970 年 1 月 1 日 午夜开始计的毫秒数 UTC。
Function：函数本身。
Number：数字值。
Object：对象本身。这是默认情况。
String：字符串值。
Math 和 Error 对象没有 valueOf 方法。

toString() 和 valueOf() 会在类型转换时使用，参考深入 JavaScript 类型转换

对象的冻结、封闭

Object 构造函数提供了三组静态方法，设置对象的可扩展性和可配置性。

Object.preventExtensions()：方法让一个对象变的不可扩展，也就是永远不能再添加新的属性。一般来说，不可扩展对象的属性可能仍然可被删除。尝试将新属性添加到不可扩展对象将静默失败或抛出 TypeError（最常见的情况是 strict mode中，但不排除其他情况）。Object.preventExtensions() 仅阻止添加自身的属性。但其对象类型的原型依然可以添加新的属性。

数组作为一个对象，如果变成不可扩展就不能添加新的元素。并且如果你删除了一个元素，将不能再添加回去，数组长度变短是不可逆的，只能删不能加，元素值可以修改。如果属性是一个对象，该嵌套对象不受影响。

let arr = [1, 2, 3]

Object.preventExtensions(arr)
arr[3] = 10
console.log(arr) //[ 1, 2, 3 ]
arr.push(10)
console.log(arr) //TypeError: Cannot add property 3, object is not extensible
arr.pop()
console.log(arr) //[1, 2]
arr.push(10)
console.log(arr) //TypeError: Cannot add property 2, object is not extensible
arr[0] = 100
console.log(arr) //[100, 2]

let obj = {
  a: {
    name: 'clloz'
  }
}

Object.preventExtensions(obj)
obj.a.age = 28
console.log(obj.a) //{ name: 'clloz', age: 28 }

该方法使得目标对象的 [[prototype]] 不可变；任何重新赋值 [[prototype]] 操作都会抛出 TypeError 。这种行为只针对内部的 [[prototype]] 属性，目标对象的其它属性将保持可变。一旦将对象变为不可扩展的对象，就再也不能使其可扩展。

在 ES5 中，如果参数不是一个对象类型（而是原始类型），将抛出一个 TypeError 异常。在 ES2015 中，非对象参数将被视为一个不可扩展的普通对象，因此会被直接返回。

Object.isExtensible() 方法判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。在 ES5 中，如果参数不是一个对象类型，将抛出一个 TypeError 异常。在 ES6 中， non-object 参数将被视为一个不可扩展的普通对象，因此会返回 false 。

Object.seal() 方法封闭一个对象，阻止添加新属性并将所有现有属性标记为不可配置。当前属性的值只要原来是可写的就可以改变。一旦将对象变为封闭，就再也不能变为非封闭状态。

封闭一个对象会让这个对象变的不能添加新属性，且所有已有属性会变的不可配置。属性不可配置的效果就是属性变的不可删除，以及一个数据属性不能被重新定义成为访问器属性，或者反之，即不能修改属性描述符。但属性 writeable 为 true 的值仍然可以修改。尝试删除一个密封对象的属性或者将某个密封对象的属性从数据属性转换成访问器属性，结果会静默失败或抛出 TypeError（在严格模式中最常见的，但不唯一）。

数组作为一个对象，如果变成封闭就不能添加新的元素并且元素不可配置，并且不能删除元素，元素值可以修改。如果属性是一个对象，该嵌套对象不受影响。

let arr = [1, 2, 3]

Object.seal(arr)

arr[0] = 100
console.log(arr) //[ 100, 2, 3 ]

arr.pop() //TypeError: Cannot delete property '2' of [object Array]

不会影响从原型链上继承的属性。该方法使得目标对象的 [[prototype]] 不可变。

Object.isSealed() 方法判断一个对象是否被密封。在 ES5 中，如果这个方法的参数不是一个对象（一个原始类型），那么它会导致 TypeError。在 ES2015 中，非对象参数将被视为是一个密封的普通对象，只返回 true。

Object.freeze() 方法可以冻结一个对象。一个被冻结的对象再也不能被修改；冻结了一个对象则不能向这个对象添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性，以及不能修改已有属性的值。此外，冻结一个对象后该对象的原型也不能被修改。freeze() 返回和传入的参数相同的对象。

被冻结对象自身的所有属性都不可能以任何方式被修改。任何修改尝试都会失败，无论是静默地还是通过抛出 TypeError 异常（最常见但不仅限于 strict mode）。

数据属性的值不可更改，访问器属性（有 getter 和 setter）也同样（但由于是函数调用，给人的错觉是还是可以修改这个属性）。如果一个属性的值是个对象，则这个对象中的属性是可以修改的，除非它也是个冻结对象。数组作为一种对象，被冻结，其元素不能被修改，也不能添加或者删除元素。这个方法返回传递的对象，而不是创建一个被冻结的副本。

在 ES5 中，如果这个方法的参数不是一个对象（一个原始值），那么它会导致 TypeError。在 ES2015 中，非对象参数将被视为要被冻结的普通对象，并被简单地返回。

Object.isFrozen() 方法判断一个对象是否被冻结。在 ES5 中，如果参数不是一个对象类型，将抛出一个 TypeError 异常。在 ES2015 中，非对象参数将被视为一个冻结的普通对象，因此会返回 true。

我们可以看到从 preventExtensions() 到 seal() 再到 freeze()，对对象属性的限制越来越多，从不能扩展，到不可配置不能删除，在到不能修改。我们可以再需要的时候使用对应的功能（vue 中就使用到了 freeze()）

Object.fromEntries()

该方法把键值对列表转换为一个对象。Object.fromEntries() 方法接收一个键值对的列表参数，并返回一个带有这些键值对的新对象。这个迭代参数应该是一个能够实现 @@iterator 方法的的对象，返回一个迭代器对象。它生成一个具有两个元素的类数组的对象，第一个元素是将用作属性键的值，第二个元素是与该属性键关联的值。

Object.fromEntries() 执行与 Object.entries() 互逆的操作。

//Map -> Object
const map = new Map([
  ['foo', 'bar'],
  ['baz', 42]
])
const obj = Object.fromEntries(map)
console.log(obj) // { foo: "bar", baz: 42 }

//Array -> Object
const arr = [
  ['0', 'a'],
  ['1', 'b'],
  ['2', 'c']
]
const obj = Object.fromEntries(arr)
console.log(obj) // { 0: "a", 1: "b", 2: "c" }

//对象转换
const object1 = { a: 1, b: 2, c: 3 }

const object2 = Object.fromEntries(Object.entries(object1).map(([key, val]) => [key, val * 2]))

console.log(object2)
// { a: 2, b: 4, c: 6 }

in 和 delete

delete 操作符用于删除对象的某个属性；如果没有指向这个属性的引用，那它最终会被释放，即不会起任何作用，并返回 true。对于所有情况都是 true，除非属性是一个自身的不可配置的属性，在这种情况下，非严格模式返回 false。在严格模式下，会抛出 TypeError。

几个注意点：

如果你试图删除的属性不存在，那么 delete 将不会起任何作用，但仍会返回 true
如果对象的原型链上有一个与待删除属性同名的属性，那么删除属性之后，对象会使用原型链上的那个属性（也就是说， delete 操作只会在自身的属性上起作用）
任何使用 var 声明的属性不能从全局作用域或函数的作用域中删除。
- 这样的话，delete 操作不能删除任何在全局作用域中的函数（无论这个函数是来自于函数声明或函数表达式）
- 除了在全局作用域中的函数不能被删除，在对象(object)中的函数是能够用 delete 操作删除的。
任何用 let 或 const 声明的属性不能够从它被声明的作用域中删除。
不可设置的(Non-configurable)属性不能被移除。这意味着像 Math, Array, Object 内置对象的属性以及使用 Object.defineProperty() 方法设置为不可设置的属性不能被删除。
封闭和冻结的属性不能被删除。
对变量使用 delete 在非严格模式下返回 false，严格模式下报错。
删除数组元素不会改变数组长度，该数组会变成一个稀疏数组，被删除的元素位置变为 empty。

如果指定的属性在指定的对象或其原型链中，则 in 运算符返回 true。in 右操作数必须是一个对象值。例如，你可以指定使用 String 构造函数创建的字符串，但不能指定字符串文字。

如果你使用 delete 运算符删除了一个属性，则 in 运算符对所删除属性返回 false。如果你只是将一个属性的值赋值为 undefined，而没有删除它，则 in 运算仍然会返回true。

如果一个属性是从原型链上继承来的，in 运算符也会返回 true。

其实我们平时遍历对象时使用的 for ... in 也是 in 操作符的一种使用方式。

Reflect

ES6 新增了一个新的内置对象 Reflect，也就是新增了反射对象。主要是将一些原来放在 Object 或 Function 上的应该属于语言内部的方法集中起来，这样 API 的设计更合理更清晰。主要有如下 API：

Reflect.apply(target, thisArg, args)
Reflect.construct(target, args)
Reflect.get(target, name, receiver)
Reflect.set(target, name, value, receiver)
Reflect.defineProperty(target, name, desc)
Reflect.deleteProperty(target, name)
Reflect.has(target, name)
Reflect.ownKeys(target)
Reflect.isExtensible(target)
Reflect.preventExtensions(target)
Reflect.getOwnPropertyDescriptor(target, name)
Reflect.getPrototypeOf(target)
Reflect.setPrototypeOf(target, prototype)

关于 Reflect 的详细内容看另一篇文章代理和反射

参考文章

《Professional JavaScript for Web Developers, 4th Edition》
MDN
《ES6 标准入门》

call, apply 和 bing方法的应用

Fri, 03 Jul 2020 12:00:00 GMT

前言

JavaScript 中所有函数的构造函数为 ƒ Function() { [native code] }，所有函数的 [[prototype]] 默认指向 Function.prototype，在 Function.prototype 上有三个方法 call，apply 和 bind，他们共同的作用就是为函数调用指定的执行上下文，也是就是 this 的指向。本文来说一说这三个方法的区别和使用场景。

call 和 apply

call 和 apply 基本上没有什么区别，不同的地方是他们所接受的参数不同。两者的第一个参数都是函数执行时使用的 this 值，后面的参数就有所不同。apply 接受一个数组或类数组对象（比如 arguments），而 call 接受一组参数列表。

//apply
func.apply(thisArg, [argsArray])

//call
function.call(thisArg, arg1, arg2, ...)

在 JavaScript 中参数的个数是有上限的，JavaScriptCore 引擎中有被硬编码的参数个数上限：65536。但是实际能接受多少参数取决于当前的系统和浏览器，并不确定。比如我用下面的代码生成元素值为元素下标的数组，在 safari 中的上限是 65536，在 chrome 中是 125382。let a = Object.keys(Array.apply(null, {length:125382}))。任何用到超大栈空间的行为都有可能出现这个现象，超出限制则会报错 Uncaught RangeError: Maximum call stack size exceeded。

请注意，this 可能不是该方法看到的实际值：如果这个函数处于非严格模式下，则指定为 null 或 undefined 时会自动替换为指向全局对象，原始值会被包装。

应用

类数组对象调用数组方法

JavaScript 中有类数组对象，最常见的就是所有非箭头函数中都可以使用的局部变量 arguments，还有 DOM 操作返回的 NodeList 集合，它类似于 Array，但除了 length 属性和索引元素之外没有任何 Array 属性。例如，它没有 pop 方法。但是它可以被转换为一个真正的 Array。

var args = Array.prototype.slice.call(arguments)
var args = [].slice.call(arguments)

// ES2015
const args = Array.from(arguments)
const args = [...arguments] //扩展运算符

实际上我们也可以自己定义类数组对象，只要有索引和 length 即可，{'length': 2, '0': 'eat', '1': 'bananas'}。

数组拼接

我们可以用 push 方法为数组添加新的元素，虽然 push 方法接受可变参数，但是如果我们以数组作为参数的话，它只是把这个数组所谓一个元素添加，如果想把两个数组进行拼接，那么可以用 concat，但是 concat 是返回一个新的数组，如果只是想要将两个数组拼接，可以用 apply。

var array = ['a', 'b']
var elements = [0, 1, 2]
array.push.apply(array, elements)
console.info(array) // ["a", "b", 0, 1, 2]

用数组替代参数列表

其实从上面的例子就可以看出，对于一些可能需要很长参数列表的函数，apply 都可以让我们用数组来代替参数列表，比如 Math.max 和 Math.min 等。

/* 找出数组中最大/小的数字 */
var numbers = [5, 6, 2, 3, 7]

/* 应用(apply) Math.min/Math.max 内置函数完成 */
var max = Math.max.apply(
  null,
  numbers
) /* 基本等同于 Math.max(numbers[0], ...) 或 Math.max(5, 6, ..) */
var min = Math.min.apply(null, numbers)

这样使用的风险就是如果数组非常大，在函数调用的时候可能参数个数会超出引擎的限制（JavaScript 核心中已经做了硬编码参数个数限制在 65536，具体数值由引擎决定），如果遇到这种情况可以把数组切块循环执行。

继承

function Animal(name) {
  this.name = name
  this.showName = function () {
    console.log(this.name)
  }
}

function Cat(name) {
  Animal.call(this, name)
}

bind

bind 和前面两者不一样的是他并不是立即调用函数，而是返回一个新的函数。bind() 方法创建一个新的函数，在 bind() 被调用时，这个新函数的 this 被指定为 bind() 的第一个参数，而其余参数将作为新函数的参数，供调用时使用。bind 方法返回一个原函数的拷贝，并拥有指定的 this 值和初始参数。还有一点是如果 bind 函数的参数列表为空，或者第一个参数是 null 或 undefined，执行作用域的 this 将被视为新函数的 thisArg。apply 和 call 则是如果这个函数处于非严格模式下，则指定为 null 或 undefined 时会自动替换为指向全局对象，原始值会被包装。

bind 的 new 调用

bind 的另一个不同于 apply，bind 的特点就是 bind 创建一个指定了 this 的绑定函数，但是这个函数支持 new 调用。当绑定函数进行这种 new 形式的构造函数调用的时候，绑定的 this 将不再生效，而是用 new 创建的新对象作为 this，但是绑定的参数依然可用。可以看一下例子：

function Bound(a, b) {
  console.log(this.a, this.b)
  this.a = a
  this.b = b
  console.log(this.a, this.b)
}

let obj = { a: 10, b: 20 }

let bFun = Bound.bind(obj, 1, 2)
bFun() //10 20   1 2

let bObj = new bFun(3, 4) //undefined,undefined    1 2
console.log(bObj instanceof Bound) //true
console.log(bObj instanceof bFun) //true
console.log(bObj.__proto__ === Bound.prototype) //true
console.log(bFun.prototype) //undefined

我们可以看到当我们直接调用绑定函数，我们的绑定的 this 也就是 obj 生效了，传入的参数也生效了。当我们用 new 调用绑定函数，绑定的 this 并没有生效（第一个 console.log(this.a, this.b); 输出 undefined），但是传入的参数生效了（Bound 只接受两个参数，最后生效的是 bind 时传入的参数，而不是 new 的时候传入的参数）。

bind 的 new 比较奇怪的地方就是生成的绑定函数的 prototype 是 undefined，但是生成对象 bObj 进行 bObj instanceof bFun 依然返回 true，而且生成对象 bObj 的 [[prototype]] 指向的是原函数 Bound 的 prototype。这里我没有找到具体的原因，在模拟实现 bind 的时候也无法达到这个效果。

应用

创建绑定函数

this.x = 9 // 在浏览器中，this 指向全局的 "window" 对象
var module = {
  x: 81,
  getX: function () {
    return this.x
  }
}

module.getX() // 81

var retrieveX = module.getX
retrieveX()
// 返回 9 - 因为函数是在全局作用域中调用的

// 创建一个新函数，把 'this' 绑定到 module 对象
// 新手可能会将全局变量 x 与 module 的属性 x 混淆
var boundGetX = retrieveX.bind(module)
boundGetX() // 81

预设函数初始参数

这种用法可以为函数设置一些初始参数，有点类似函数柯里化。

function list() {
  return Array.prototype.slice.call(arguments)
}

function addArguments(arg1, arg2) {
  return arg1 + arg2
}

var list1 = list(1, 2, 3) // [1, 2, 3]

var result1 = addArguments(1, 2) // 3

// 创建一个函数，它拥有预设参数列表。
var leadingThirtysevenList = list.bind(null, 37)

// 创建一个函数，它拥有预设的第一个参数
var addThirtySeven = addArguments.bind(null, 37)

var list2 = leadingThirtysevenList()
// [37]

var list3 = leadingThirtysevenList(1, 2, 3)
// [37, 1, 2, 3]

var result2 = addThirtySeven(5)
// 37 + 5 = 42

var result3 = addThirtySeven(5, 10)
// 37 + 5 = 42 ，第二个参数被忽略

快捷调用

这是一个 mdn 上给出的示例。当我们需要频繁调用一个指定 this 的函数，我们可以用 bind 来实现快捷调用。举个例子子，我们相对类数组对象（比如 arguments）执行数组方法（比如 slice），我们一般是 Array.prototype.slice.apply(arguments)，当我们需要频繁使用这个方法的时候，我们可能会这样 let slice = Array.prototype.slice; slice.apply(arguments);。如果我们使用 bind，我们可以直接 slice(arguments) 这样调用，更方便，具体实现看下面的代码。

var slice = Array.prototype.slice

// ...

slice.apply(arguments)

// 与前一段代码的 "slice" 效果相同
var unboundSlice = Array.prototype.slice
var slice = Function.prototype.apply.bind(unboundSlice)

// ...

slice(arguments)

要理解这段代码我们需要理解 apply 本身也是一个函数，它是在 Function.prototype 上定义的一个函数，所有函数都能调用它。当我们用 func.apply() 调用 apply 的时候，本质就是以 func 作为 this 调用 apply。那么第二种实现就是用 Array.prototype.slice 作为 this 创建 apply 的一个绑定函数。当我们调用这个绑定函数的时候就相当于调用 Array.prototype.slice.apply()。

模拟实现 call，apply 和 bind

关于如何手写 call， apply，bind 我在另一篇文章中写下了详细的过程，点击查看模拟实现call，apply 和 bind。

参考文章

var，let，const和变量提升（hoist）

Wed, 01 Jul 2020 12:00:00 GMT

前言

在 ES6 以前，JavaScript 中是不存在块级作用域的，变量的作用域是靠执行环境来控制的，要么是在某个函数内要么是在全局作用于中。由于 JS 中的变量提升 Hoist 机制的存在，我们的定义的变量或者函数很可能发生命名冲突引发错误。所以在 ES6 中引入了 let 和 const 来应对这个问题，本文就讨论一下三个命令之间的区别，以及 JS 中的变量提升机制。

block 块语句

上面我们已经说过，在 ES5 中，JS 的作用域只有两种可能，要么在某个函数中，要么在全局作用域。对于像 if 或者 for 这样的语句，虽然他们也有大括号，但因为他们不是函数，所以在这些语句中定义的变量一样可以在外部访问的。

在 ES6 中引入了块级作用域，用于组合零个或多个语句。块级作用域由一对大括号界定，可以添加 label。块级作用域的出现主要是为了配合 let，const 和 class。现在我们在块级作用域中的 let，const 和 class 声明将不能在块级作用域之外访问。并且块级作用域可以任意嵌套，每一对大括号都是一个独立的块级作用域。

注意，块级作用域只对 let，const 和 class 生效。var 声明的变量是没有块级作用域的，无论严格模式还是非严格模式。函数声明的行为则比较特别，我在下面介绍。

{
  let m = 10
  const n = 20
}
console.log(m) //ReferenceError: m is not defined
console.log(n) //ReferenceError: n is not defined

var x = 1
{
  var x = 2
}
console.log(x) // 输出 2

没有块级作用域的情况下，结合变量提升机制，经常会产生一些奇怪的现象：

var arr = []
for (var i = 0; i < 5; i++) {
  arr[i] = function () {
    return i
  }
}
console.log(arr[0]()) //5
console.log(arr[1]()) //5
console.log(arr[2]()) //5
console.log(arr[3]()) //5
console.log(arr[4]()) //5

var tmp = new Date()
function f() {
  console.log(tmp) // 想打印外层的时间作用域
  if (false) {
    var tmp = 'hello world' // 这里声明的作用域为整个函数
  }
}
f() // undefined

ES6 引入了块级作用域，明确允许在块级作用域之中声明函数（ES5 中是不允许函数声明在块级作用域中）。ES6 规定，块级作用域之中，函数声明语句的行为类似于 let，在块级作用域之外不可引用。但是实际上各个浏览器并没有遵循标准进行实现，因为如果按标准进行实现的话对老代码的影响会非常大。具体规定参考标准：https://tc39.es/ecma262/#sec-block-level-function-declarations-web-legacy-compatibility-semantics

对于支持 ES6 的浏览器，块级作用域中的函数声明表现如下：

允许在块级作用域内声明函数。
在非严格模式中，函数声明类似于 var，即会提升到全局作用域或函数作用域的头部。同时，函数声明还会提升到所在的块级作用域的头部。
在严格模式中函数声明则只会提升到所在块级作用域的头部。

其他环境的 JavaScript 实现不用遵守这个规定，还是将块级作用域的函数声明当作 let 处理。可以看下面两个例子。

//非严格模式
// 'use strict';
function test() {
  console.log(a) //undefined
  {
    console.log(a) //[Function: a]
    function a() {
      console.log('a')
    }
  }
  a() //a
}
test()

//严格模式
;('use strict')
function test() {
  // console.log(a); //ReferenceError: a is not defined
  {
    console.log(a) //[Function: a]
    function a() {
      console.log('a')
    }
  }
}
test()

考虑到环境导致的行为差异太大，应该避免在块级作用域内声明函数。如果确实需要，也应该写成函数表达式，而不是函数声明语句。

有了块级作用域，原来一些为了防止全局环境被污染的立即执行函数 IIFE 不在必要。

// IIFE 写法
(function () {
    var tmp = ...;
    ...
}());

// 块级作用域写法
{
    let tmp = ...;
    ...
}

补充：block 块语句有一个用法就是我们可以在函数内部用花括号把函数分成一个个独立的小结，我们在小结内部可以放心地用 let 和 const 定义变量常量和方法。这也是现在框架发展的一个功能。

块语句还可以使用 label 标记，在块语句内进行 break。

test: {
  console.log(1)
  break test
  console.log(2) //这一句不会执行
}

var

var 语句会声明一个函数作用域或者全局作用域的变量，取决于声明所处的执行环境。当重复声明一个变量时，变量的值不会丢失。当赋值给未声明的变量, 则执行赋值后, 该变量会被隐式地创建为全局变量（它将成为全局对象的属性）。声明变量在任何代码执行前创建，而非声明变量只有在执行赋值操作的时候才会被创建。声明变量是它所在上下文环境的不可配置属性，非声明变量是可配置的（如非声明变量可以被删除）。在严格模式下，使用未声明变量时不合法的。

变量的声明有多种形式，特别是声明多个变量的时候。

var a = 0,
  b = 0

var a = 'A'
var b = a

// 等效于：
var a,
  b = (a = 'A')

var x = y,
  y = 'A'
console.log(x + y) // undefinedA

var x = 0

function f() {
  var x = (y = 1) // x在函数内部声明，y不是！
}
f()

console.log(x, y) // 0, 1
// x 是全局变量。
// y 是隐式声明的全局变量。
//JS在执行语句之前会先检查是否有未声明的变量，如果有则将其声明提升到全局作用域

需要注意的是，var 语句中的逗号不是逗号操作符，因为它不是存在于一个表达式中。尽管从实际效果来看，那个逗号同逗号运算符的表现很相似。但确切地说，它是 var 语句中的一个特殊符号，用于把多个变量声明结合成一个。

let

let 和 var 的不同主要有以下几点。

let 只在代码块内有效

{
  let a = 10
  var b = 1
}
a // ReferenceError: a is not defined. b // 1

上面 for 循环的问题也可以用 let 解决

var arr = []
for (let i = 0; i < 5; i++) {
  arr[i] = function () {
    return i
  }
}
console.log(arr[0]()) //0
console.log(arr[1]()) //1
console.log(arr[2]()) //2
console.log(arr[3]()) //3
console.log(arr[4]()) //4

需要注意的是，for 语句的作用域是比较特殊的，小括号内是一个父级块作用域，而大括号内是一个子级块作用域。

for (let i = 0; i < 3; i++) {
  let i = 'abc'
  console.log(i)
}
// abc
// abc
// abc

for 循环头部的 let 不仅将 i 绑定到了 for 循环的块中，事实上它将其重新绑定到了循环的每一个迭代中，确保使用上一个循环迭代结束时的值重新进行赋值。真实的执行过程如下：

{
  let j
  for (j = 0; j < 10; j++) {
    let i = j // 每次迭代重新绑定
    console.log(i)
  }
}

没有变量提升

当使用 var 语句声明的变量会发生变量提升，也就是进入执行环境的时候，引擎最先做的就是扫描所有的 var 语句，把这些变量声明提到执行环境顶部并赋值为 undefined。这样即使我们在变量声明之前使用变量也不会报错，因为引擎已经把变量提升到执行环境顶部，但是初始化依然要到执行到对应语句才会执行。

由于这种行为是有点违反逻辑的，所以 let 就修复了这个问题，我们必须在 let 语句执行之后才能使用对应的变量，否则会报错。

// var 的情况
console.log(foo) // 输出undefined var foo = 2;
// let 的情况
console.log(bar) // 报错ReferenceError let bar = 2;

暂时性死区

只要在一个块级作用域能用 let 语句声明了一个变量，那么在该块级作用域内，将只有一个该变量，外部的同名变量将无法被访问。可以理解为 let 语句创建的变量与所在的语句块绑定了。

var tmp = 123
if (true) {
  tmp = 'abc' // Uncaught ReferenceError: Cannot access 'tmp' before initialization
  let tmp
}

这个地方和上面的没有变量提升似乎是有冲突的，我们在块语句内的 let 语句声明 tmp 之前使用该变量，报错是 无法在tmp初始化之前访问，说明在声明语句之前就引擎就已经知道这个变量的存在了。我的理解是还是存在某种形式的变量提升，只不过这种提升并没有像 var 那样给变量一个个初始的 undefined，并且变量的使用在初始化之前是被拒绝的。也就是所谓的暂时性死区 temporal dead zone，简称 TDZ。

暂时性死区机制也意味着 typeof 不再是一个百分之百安全的操作，在 let 语句前对变量进行 typeof 操作一样会报错。

使用 let 声明变量时，只要变量在还没有声明完成前使用，就会报错。

var x = x //undefined

let x = x //Uncaught SyntaxError: Identifier 'x' has already been declared

另外还有一点就是函数参数似乎也有和 let 的相似的行为，我们不能再函数内部用 let 或 const给参数重新赋值，也不能像 x = x 这样给函数初始值。但是与 let 不同的是，用 var 可以给参数赋值。具体的过程可能需要查看标准。

function foo(x = 5) {
  var x = 1
  console.log(x) //1
}

function foo(x = 5) {
  let x = 1 // Uncaught SyntaxError: Identifier 'x' has already been declared
}

function a(x = x) {} //Uncaught ReferenceError: Cannot access 'x' before initialization

不允许重复声明

let 不可以在同一个块级作用域内重复声明。

// 报错
function () {
    let a = 10;
    var a = 1;
}

// 报错
function () {
    let a = 10;
    let a = 1;
}

全局环境下用 let 或 const 声明的变量不会作为属性挂载在全局对象上。

const

const 的大部分行为和 let 是保持一致的，不同的地方时，const 声明的是一个只读的常量，声明的时候必须进行初始化，且不能更改。

const PI = 3.1415
PI = 3 //Uncaught TypeError: Assignment to constant variable.

const foo // SyntaxError: Missing initializer in const declaration

但其实 const 并不是绝对安全的，因为当 const 声明的变量保存的是一个引用类型的时候，他保存的只是一个指向引用类型的指针，他能保证的是这个指针不变，但如果指针指向的的引用类型的内容发生变化，它是无法控制的。

const foo = {}
// 为 foo 添加一个属性，可以成功
foo.prop = 123
foo.prop // 123
// 将 foo 指向另一个对象，就会报错
foo = {} // Uncaught SyntaxError: Identifier 'foo' has already been declared

class

class 关键字也是有块作用域的，即使在非严格模式下。

{
  class A {}
  let a = new A()
  console.log(a) //A {}
}
let a = new A() //ReferenceError: A is not defined

变量提升

从概念的字面意义上说，“变量提升”意味着变量和函数的声明会在物理层面移动到代码的最前面，但这么说并不准确。变量和函数声明在代码结构里的位置是不会动的，而是在编译阶段被放入内存中。实际上变量提升行为是 JavaScript 预编译机制中的一种行为，搞懂预编译过程中发生了什么，我们自然就知道变量提升是如何进行的了。

引擎在接收到 JavaScript 文件到执行中间大概分为三步：

词法分析
预编译
解释执行

这里我们主要说一下第二步 预编译，全局环境的预编译和函数执行环境的预编译的略有不同的。全局预编译发生在页面加载完成时执行，而局部预编译发生在函数执行的前一刻。预编译阶段发生变量声明和函数声明的提升行为，但没有初始化行为（赋值），匿名函数不参与预编译，未声明的变量也不会参与提升（虽然未声明变量也是作为全局变量，但是未声明变量在预编译阶段是不会处理的，只有到解释执行阶段才会进行处理，严格模式下不可以使用未声明变量）。只有在解释执行阶段才会进行变量初始化。

//未声明变量只有在解释执行阶段才会处理，没有提升行为
console.log(b)
var a = (b = 110) //Uncaught ReferenceError: b is not defined

console.log(b)
b = 110 //Uncaught ReferenceError: b is not defined

b = 110
console.log(b) //110

//严格模式下不可以使用未声明变量
;('use strict')
m = 10
console.log(window.m) //Uncaught ReferenceError: m is not defined

//未声明的对象属性也会在解释执行之前提前创建
var a = { n: 1 }
var b = a
a.x = a = { n: 2 } //a.x 在执行完 a = {n:2} 表达式之后依然能正确赋值是因为执行之前已经县创建了 {n:1} 对象的 x属性，这一行语句可以等价为 {n:1}.x = a = {n:2}
console.log(a.x) //undefined
console.log(b.x) //{n:2}

对于全局环境，预编译大概分为如下几步：

创建 GO 对象（ Global Object ）全局对象。
找到用 var 语句进行的变量声明，将变量名作为 GO 属性名，值为 undefined
查找函数声明，作为 GO 属性，属性名为函数名，值为函数体（如果函数名与上一步的变量名冲突，那么上一步值为 undefined 的变量提升将被函数声明的提升所覆盖）

需要注意的是只有函数声明被提升，函数表达式和变量是没有区别的，因为引擎是扫描 var 语句来寻找变量，他在预编译阶段只关心 var 语句声明的变量名，而不关心初始化的值。

函数的执行环境是当引擎解释执行到函数调用的地方才会创建，预编译也是在这时进行，预编译完成后才会解释执行函数。函数执行上下文的预编译整体步骤和全局环境是差不多的，不同的地方就是在多了形参和实参的加入。

创建执行上下文的活动对象 AO（Activation Object）。
找形参和 var 语句进行的变量声明，将变量和形参名作为 AO 属性名，值为 undefined
将实参值和形参统一。
在函数体里面找函数声明，值赋予函数体。

在同一个执行环境中出现的形参，变量声明，函数声明，只要出现重名，在预编译中我们可以完全看做同一个东西，即 AO 对象中的一个属性。我们需要注意的是他们发生的先后顺序。

下面来分析几个例子

例一

function s() {
  m() //123
  var m = 10
  function m() {
    console.log(123)
  }
  m() //m is not a function
}
s()

这个例子比较简单，在进入 s 函数的执行环境，创建活动对象后，先是 var 语句声明的 m 变量被提升（在 AO 中创建一个属性 m，然后是 function m(){} 被提升，由于和 m 对象重名，直接覆盖变量的声明（即修改 AO.m 的值为函数体），所以第一个 m() 就是执行的 function m。但是之后出现的 m 变量的初始化语句再次将 AO.m 修改为初始化语句中的 10，所以当再次想要执行 m() 时，此时 m 已经不是一个函数。

函数声明的提升也就是为什么我们能够在函数声明之前调用函数的原因。在代码结构上我们好像是在函数声明之前调用了函数，其实对于引擎来说，我们还是在函数声明之后进行的调用。而且函数声明在预编译阶段被提前后，我们在解释执行阶段就可以无视它了。

例二

function fn(a) {
  console.log(a) //function a() {}
  // 变量声明+变量赋值（只提升变量声明，不提升变量赋值）
  var a = 123
  console.log(a) //123
  // 函数声明
  function a() {}
  console.log(a) //123
  // 函数表达式
  var b = function () {}
  console.log(b) //function () {}
  // 函数
  function d() {}
}
//调用函数
fn(1)

这个例子我们按照上面的局部环境预编译的四步来分析：

创建执行上下文的活动对象 AO（Activation Object）。
```
AO{

}
```
找形参和 var 语句进行的变量声明，将变量和形参名作为 AO 属性名，值为 undefined
```
AO{
     a : undefined,
     b : undefined
}
```

将实参值和形参统一。

AO{
     a : 1,
     b : function(){...}
}

在函数体里面找函数声明，值赋予函数体。

AO{
     a : function a(){...},
     b : undefined,
     d : function d(){...}
}

所以显然第一个 console.log(a) 输出的是 AO 中的 a，为 function a() {}，然后 a 被初始化语句修改为 123 ，所以第二个 console.log(a) 的结果为 123。下面的函数声明在解释执行阶段可以忽略，所以第三个 console.log(a) 依然输出 123。接下来是对 b 进行初始化，值为一个匿名函数的引用，所以 b 的值输出该匿名函数。

例三

var foo = { n: 1 }

;(function (foo) {
  console.log(foo.n) //1
  foo.n = 3
  var foo = { n: 2 }
  console.log(foo.n) //2
})(foo)

console.log(foo.n) //3

这个例子跟上面两个不一样的地方时这一题不再是单纯的变量，而是引用类型。在立即执行函数内部，预编译后的活动对象就是 {foo: {n:1}}，所以第一个输出结果为 1。然后改 foo.n 为 3。这里需要注意的是引用类型并不是值传递，所以我们此时的 foo 和全局那个 foo 指向同一个对象，也就是全局 foo 指向的对象也被修改了，所以最后一行的 foo.n 就是输出修改后的值 3。回到函数内部，var foo = {n:2} 这一句直接将 AO.foo 指向了一个新的对象 {n:2}，这个新对象已经跟全局的那个 foo 指向的对象没有关系了，所以函数内部的最后一个输出结果为 2。

参考文章

一道有趣的JS基础题

Tue, 30 Jun 2020 12:00:00 GMT

前言

在查阅资料的时候，看到一道考差 JavaScript 基础知识的题目，其中还是考查到一些自己掌握的不好的知识。

题目

function Foo() {
  getName = function () {
    console.log(1)
  }
  return this
}
Foo.getName = function () {
  console.log(2)
}
Foo.prototype.getName = function () {
  console.log(3)
}
var getName = function () {
  console.log(4)
}
function getName() {
  console.log(5)
}

Foo.getName() //2
getName() //4
Foo().getName() //1
getName() //1
new Foo.getName() //2
new Foo().getName() //3
new new Foo().getName() //3

需要注意的一点是这段代码因为牵扯到全局作用于下定义的对象是绑定在全局对象上的属性，所以这段代码使要运行在全局作用域，否则会报错。

第一问

第一问很简单，执行 Foo 函数上的 getName 属性上引用的匿名函数。每一个函数也同时是对象，也可以添加属性。很显然输出结果是 2。

第二问

第二问考查的是函数声明提升和变量声明提升之间的关系。最后的两个 getName 函数分别是函数表达式和函数声明，它们之间的覆盖关系是这一问的关键。

变量和函数声明的提升主要有这两点： 1. 变量和函数声明都会提升到函数顶部。 2. 初始化不会被提升。 3. 函数声明的提升优先级是高于变量的提升，且不会被变量的提升所覆盖，但是后面变量的初始化会覆盖函数声明提升。

所以最后两个同名的函数可以等同于下面的代码。

function getName() {
  console.log(5)
}
var getName

getName = function () {
  console.log(4)
}

可以看到最终变量的初始化覆盖了函数声明，所以这一问的结果就是 4。

第三问

这一问主要考察的是对 this 的理解，直接调用的函数在非严格模式下，其 this 是指向全局对象的（详细的 this 指向分析请看JavaScript中的this指向。

Foo 函数做了两件事，首先将全局作用域下定义的 getName 变量重新赋值（一个新的匿名函数引用），然后返回全局对象。所以 Foo().getName() 相当于 window.getName()，此时的全局对象上的 getName 函数已经在 Foo 函数中被重写，所以最后的结果是 1。

第四问

第四问是直接执行全局作用域下的 getName 函数，因为第三问中重新给 getName 重新赋值了，所以结果跟第三问是相同的。

第五~七问

其实最后三问的核心问题是相同的，就是 new 运算符的优先级问题，我在new操作符的解析和实现中最后也提到了，带参数的 new 运算符的优先级是高于不带参数的 new 运算符的。比带参数 new 优先级高的运算符只有圆括号和成员访问的两种方式 . 和 []。在带参数和不带参数 new 之间还有一个就是函数调用运算符 ()。

所以第五问的 new Foo.getName(); 可以理解为 new (Foo.getName)() ，把 Foo.getName 看做是一个整体，然后执行 new 运算符。最后的结果就是以 Foo.getName 作为构造函数实例化了一个对象，在实例化过程中会执行构造函数，所以返回 2。

第六问 new Foo().getName()中优先级最高的是 .，然后是 new ()，那么可以这么理解 (new Foo()).getName()，new Foo() 相当于以 Foo 为构造函数创建了一个新对象，对象的 [[ptototype]] 指向 Foo.prototype，新对象本身没有 getName 属性，但是 Foo.prototype 上有，所以相当于执行 Foo.prototype.getName()，结果为 3。

理论上 . 的优先级是高于带参数 new 的，这一问结果是先执行带参数 new 了。左边要么两种可能 Foo(). 或者 new Foo().，单参数 new 的优先级是高于函数调用的，所以在执行 . 的时候是把左边看做一个整体的。

第七问 new new Foo().getName() 可以理解为 new ((new Foo()).getName)() 就相当于 new Foo.prototype.getName()，最终结果也是 3，生成一个以 Foo.prototype.getName 为构造函数的实例。

运算符的优先级可以查看 mdn 或者是我的文章运算符优先级

总结

以上就是我对这道题目的分析，可能有错漏之处，欢迎指正。这样的题目虽然在看上去没什么实际意义，有点刁钻，但是一些背后的知识点还是有用的，比如 this 指向，命名冲突的变量和函数的表现等等。

JavaScript中的this指向

Tue, 30 Jun 2020 12:00:00 GMT

前言

JS 中的 this 指向是一个经常被问到的问题，网上也有很多文章是关于 this 的。本文整理一下我理解下的 this 以及一些我比较疑惑的关于 this 问题。

this 指向

有几个 this 的指向问题是几乎每篇文章都会说的，比如作为函数直接调用，作为对象的方法调用，new 运算符执行中的 this 行为。比较通用的说法是，this 指向的是直接调用该函数的对象。其实也很好理解，就是为什么需要 this 这个关键字，就是我们有需要在函数内部对调用函数的对象进行操作的需求。但是有时候我们遇到的情况并不是像书上或 mdn 上遇到的典型的情况，this 的行为可能就会让我们感到有点疑惑。

函数的直接调用

当我们直接调用一个已经声明的函数，那么在非严格模式下，该函数内部的 this 指向的是全局对象，浏览器环境下就是 window 对象。

function f1() {
  return this
}
//在浏览器中：
f1() === window //在浏览器中，全局对象是window

//在Node中：
f1() === global

当函数是在全局环境下定义的时候，这种现象是可以理解的，因为全局环境下定义的函数其实就是挂载在全局对象上的一个属性，比附上面的 f1 也可以理解为 window.f1。但我认为严格模式下的行为才是更符合 this 这个关键字的目的的，特别是我们的函数可能是在非全局环境（比如另一个函数中）定义和调用的，这种情况下 this 还指向 window 是不太合理的。所以在严格模式下，一个函数直接调用，它的 this 指向的是 undefined，如果我们想要得到非严格模式下的结果，那我们调用函数的方法就要改为 window.f1()，而如果函数是在非全局环境下定义的话，那么始终返回的是 undefined。我认为这样的行为是更符合逻辑的。

'use strict'
function d() {
  function e() {
    console.log(this)
  }
  console.log(this)
}

d()
//undefined
//undefined

window.d()
//Window{}
//undefined

这里在全局模式下使用 use strict 只是为了测试，实际使用还是尽量放在函数内局部使用严格模式，全局下的严格模式很容易导致出错。

函数作为对象的属性调用

这也是在代码中非常常见的场景，我认为这是比函数调用更好理解，也更能帮助我们理解 this 行为的场景。简单的来说就是 this 指向的是 直接 调用函数的那个对象。并且要注意的是，这跟函数在哪里定义的是无关的，我们看 this，看的就是从哪里调用的函数。

//在对象内部定义
var o = {
  prop: 37,
  f: function () {
    return this.prop
  }
}

console.log(o.f()) // 37

//在对象外部定义
var o = { prop: 37 }

function independent() {
  return this.prop
}

o.f = independent

console.log(o.f()) // 37

//在对象内部定义，但是给外部变量引用并执行
var o = {
  prop: 37,
  f: function () {
    console.log(this)
    return this.prop
  }
}
var prop = 100
var m = o.f
console.log(m())
//Window{}
//100

上面的段落我给 直接 这两个字加粗了，想要表达的意思是当我们通过多个对象的属性嵌套找到并调用函数，那么最后那个最接近函数的对象就是函数 this 的指向。

var o = {
  a: 10,
  b: {
    a: 12,
    fn: function () {
      console.log(this.a) //12
    }
  }
}
o.b.fn()

var o = {
  a: 10,
  b: {
    // a:12,
    fn: function () {
      console.log(this.a) //undefined
    }
  }
}
o.b.fn()

为什么我说这个场景能够帮助我们理解，原因就是它反映出 this 这个关键字的本质。JS 中的函数也是一种对象，在我们的执行环境中的活动对象保存的也只是函数对象的一个引用，如果这个引用是保存在活动对象中的某个对象的属性中（即我们通过活动对象中的某个对象的属性找到该函数），那么函数执行的时候 this 就会指向这个对象，这也是为什么多层对象的调用，还是最靠近函数的那个对象作为 this。虽然在代码中我们的函数是在对象中定义的，但是实际在内存中，对象中只保存着函数的引用，函数自己是在一个单独的内存空间中。所以我们通过哪个对象找到函数并执行，函数中的 this 就指向这个对象。上面的直接调用 this 返回 undefined 也是说得通的。

通过原型的调用

有时我们是通过原型来执行公用的函数，此时已然符合我们上面的逻辑，我们通过哪个实例 找到 函数，那么 this 就指向那个实例。

var o = {
  f: function () {
    return this.a + this.b
  }
}
var p = Object.create(o)
p.a = 1
p.b = 4

console.log(p.f()) // 5

箭头函数

箭头函数不会创建自己的 this，它只会从自己的作用域链的上一层继承 this （mdn 写的是封闭的词法环境）。当你遇到箭头函数中的 this 不确定的时候，你可以想象把这个箭头函数换成 console.log(this)，这个 console 的输出就是箭头函数中 this 的值，并且箭头函数的 this 是绑定的，不会改变（有时候看上去改变了是所在的 context 改变了）。还有一点需要注意的是，用 call，apply，bind 来调用箭头函数，第一个参数是没有意义的，也就是无法改变 this，如果仍需要使用，第一个参数应该传 null。看 mdn 给出的示例。

var globalObject = this
var foo = () => this
console.log(foo() === globalObject) // true

// 接着上面的代码
// 作为对象的一个方法调用
var obj = { foo: foo }
console.log(obj.foo() === globalObject) // true

// 尝试使用call来设定this
console.log(foo.call(obj) === globalObject) // true

// 尝试使用bind来设定this
foo = foo.bind(obj)
console.log(foo() === globalObject) // true

// 创建一个含有bar方法的obj对象，
// bar返回一个函数，
// 这个函数返回this，
// 这个返回的函数是以箭头函数创建的，
// 所以它的this被永久绑定到了它外层函数的this。
// bar的值可以在调用中设置，这反过来又设置了返回函数的值。
var obj = {
  bar: function () {
    var x = () => this
    return x
  }
}

// 作为obj对象的一个方法来调用bar，把它的this绑定到obj。
// 将返回的函数的引用赋值给fn。
var fn = obj.bar()

// 直接调用fn而不设置this，
// 通常(即不使用箭头函数的情况)默认为全局对象
// 若在严格模式则为undefined
console.log(fn() === obj) // true

// 但是注意，如果你只是引用obj的方法，
// 而没有调用它
var fn2 = obj.bar
// 那么调用箭头函数后，this指向window，因为它从 bar 继承了this。
console.log(fn2()() == window) // true

由于箭头函数没有自己的 this，所以在一些情况下不要使用箭头函数，会导出错误或者意外的行为。下面是一些总结的箭头函数的一些规则。关于 this 其实总的来说就是一条，箭头函数没有自己的 this，如果在箭头函数中使用 this，这个 this 指向函数定义时所在的环境中的 this，这一这个环境是可能变化的，这将导致箭头函数中的 this 发生变化。

对象的方法：对象的方法如果使用箭头函数则箭头函数中的 this 指向的是对象所在环境的 this。如果是在全局环境中创建的对象，this 指向全局对象 window。如果实在 node 模块中则指向 module.exports 对象。

let outerObj = {
  name: 'clloz'
}
function outer() {
  console.log(this) // outerObj { name: 'clloz' }
  const obj = {
    arr: [1, 2, 3],
    sun: () => {
      console.log(this) // outerObj { name: 'clloz' }
    }
  }
  obj.sun()
}
outer.apply(outerObj)

原型上的方法逻辑也和上面一样，不过要注意一点，在 class 中定义方法如果使用箭头函数的话，这个函数会被 babel 转换到构造函数中。结合上面一点，不要在对象的方法或类方法中使用箭头函数。

class Point {
  constructor(x, y) {
    // ...
    this.say = () => {
      // ...
    }
  }

  toString() {
    // ...
  }
}

//等同于
class Point {
  constructor(x, y) {
    // ...
    this.say = function () {
      const _this = this
      return function () {}.bind(_this)
    }
  }

  toString() {
    // ...
  }
}

箭头函数的 this 并不是不会变的，只是它确定指向它所在环境的 this，这个环境可能会变化。

var handler = {
  id: '123456',
  init: function () {
    let func = () => {
      console.log(this)
    }
    func()
  }
}
handler.init() //{ id: '123456', init: [Function: init] }
let m = handler.init
m() //全局对象

箭头函数不能作为构造函数。
箭头函数没有自己的 this，arguments，super 或 new.target。
箭头函数不能作为生成器函数。
由于箭头函数没有自己的 this 指针，通过 bind()，call() 或 apply() 方法调用一个函数时，只能传递参数（不能绑定 this），他们的第一个参数会被忽略。
箭头函数没有 prototype 属性。
箭头函数在参数和箭头之间不能换行。
箭头函数中的箭头不是运算符，但箭头函数具有与常规函数不同的特殊运算符优先级解析规则。
严格模式下函数中的 this 不能指向全局对象，如果箭头函数的 this 指向全局对象，会返回 undefined。

let callback;

callback = callback || function() {}; // ok

callback = callback || () => {};
// SyntaxError: invalid arrow-function arguments

callback = callback || (() => {});    // ok

vue methods 中的 this

在 vue 的 methods 中使用 throttle 的时候一般这样使用：

//...
methods: {
  func: throttle(function () {
    // function body
  })
}
//...

我们将一个函数作为参数传给 throttle 函数，返回的函数作为 methods 中的一个方法。在使用的时候我发现，如果 throttle 的函数参数用箭头函数，this 是 undefined（应该是在严格模式中）。这里分析一下原因，可以看下面的代码

const obj = {
  func: getFunc(() => {
    console.log(this)
  })
}

function getFunc(func) {
  console.log(this)
  return func
}

obj.func()

要获取 func 属性，我们先要计算 getFunc()，这相当于直接执行 getFunc 函数，和我们 2.1 中的函数直接调用是一样的，所以这里的 getFunc 中的 this 必然是全局对象(严格模式下是 undefined)。执行完之后返回了一个函数，我们的 obj.func 指向的就是这个返回的函数，而这个函数的调用方式是 obj.func，作为 obj 的属性调用，和 2.2 中是一样的，所以内部的 this 指向 obj。

当然我们的 throttle 实际返回的不是我们传入的参数，而是一个如下的形式

function throttle(fn, interval) {
  var executing = false
  return function () {
    if (executing) return
    executing = true
    setTimeout(() => {
      fn.apply(this, arguments)
      executing = false
    }, interval)
  }
}

内部 return 的 function 中的 this 是 obj，而我们的 fn 则用 apply 绑定了这个 this，而如果我们的 fn 是箭头函数的话，这个绑定则无法生效，因为箭头函数没有自己的 this，这也是我上面说的现象的原因。

vue 中的 throttle 使用的是 lodash，其内部也是用的 apply 绑定的 this。

定时器的 `this`

由于 setTimeout 和 setInterval 是全局对象的方法，所以它们回调函数中的 this 指向的是全局对象 window（注意：不管是严格模式还是非严格模式）。在 NodeJS 中，setTimeout 和 setInterval 的回到函数中的 this 指向的是一个 Timeout 对象。

解决 setTimeout 的 this 指向问题有如下几个方法：

使用箭头函数
使用中间变量
使用 bind

//箭头函数
let obj = Object.create(null)
obj.func = function () {
  setTimeout(() => {
    console.log(this)
  }, 1000)
}
obj.func()

// 使用中间变量
let obj = Object.create(null)
obj.func = function () {
  let that = this
  setTimeout(function () {
    console.log(that)
  }, 1000)
}
obj.func()

// 使用 bind
let obj = Object.create(null)
obj.func = function () {
  setTimeout(
    function () {
      console.log(this)
    }.bind(this),
    1000
  )
}
obj.func() //[Object: null prototype] { func: [Function] }

其他情况

还有一些情况我觉得比较简单，就一笔带过。 1. 当函数被用作事件处理函数时，它的 this 指向触发事件的元素。 2. 当代码被内联 on-event 处理函数调用时，它的this指向监听器所在的 DOM 元素，需要注意的是只有最外层的 this 是这样，如果里面还有嵌套函数，则嵌套函数的 this 在非严格模式下仍然指向全局对象。 3. 构造函数中的 this 请看之前的文章JavaScript中new操作符的解析和实现 4. bind，call 和 apply 都一样，函数的 this 被绑定到第一个参数上。 5. 在全局作用域中的 this 无论是否在严格模式下，都指向 window。在全局作用域中用 var 声明的变量都是 window 对象上的属性，函数声明和 var 声明的函数表达式则是全局对象上的方法。（用 var 声明的变量虽然是全局对象上的属性，但是不能用 delete 删除）

NodeJS 中的 this

这里特别提一下 NodeJS 中的 this。因为它和浏览器环境还是有些不同的。

在 NodeJS 中我们无法定义全局变量，所有变量都是在模块中的。不过 NodeJS 提供了一些全局对象，global，process 和 console，他们是所有模块都可以调用的。由于不能像浏览器一样直接声明全局变量，所以 global 就成为全局变量的一个宿主（Node 不推荐全局变量）。

浏览器的全局对象是 window，NodeJS 的全局对象是 global，为了应对不同环境全局对象的名称不一样，所以引入了 globalThis，它是指向当前环境全局对象的一个引用。

在 NodeJS 中，每一个模块中最外层的 this 指向的是 module.exports。这一点跟浏览器很不同，浏览器最外层的 this 是指向全局对象的，而且模块中用 var 声明的变量也不是 module.exports 的属性。node 中最外层的 this 和全局对象 global 没有关系。

console.log(this === module.exports) //true
console.log(this === exports) //true

而函数中的 this 则是指向全局对象，严格模式下则为 undefined，这和浏览器逻辑一致的。

function a() {
  console.log(this === globalThis) //true
}
a()
console.log(globalThis === global) //true

function a() {
  'use strict'
  console.log(this) //undefined
}
a()

其他的没有提到的，基本跟浏览器的逻辑保持一致。

总结

以上就是我所总结的 JS 中的 this 的一些要点，如果有什么遗漏或者错误的地方，欢迎指正。

参考文章

JS数据类型和判断方法

Mon, 29 Jun 2020 12:00:00 GMT

前言

JavaScript 中目前有 7 种基本（原始primitives）数据类型 Undefined， Null，Boolean， Number， String，BigInt，Symbol，以及一种引用类型 Object，Object 中又包括 Function，Date，JSON，RegExp等，除了 7 种原始类型，其他的所有能够用 new 实例化的内置类型都是 Object 构造的。

JavaScript 是一种弱类型或者说动态语言。这意味着你不用提前声明变量的类型，在程序运行过程中，类型会被自动确定。这也意味着你可以使用同一个变量保存不同类型的数据。

数据类型

对于数据了类型我们可以通过 typeof 运算符来判断，具体结果看下图。

基本数据类型

基本数据类型 primitive values 也成为原始数据或原始类型。它们是一种既非对象也无方法的数据。在 JavaScript 中，共有 7 种基本类型：string，number，bigint，boolean，null，undefined，symbol (ECMAScript 2016 新增)。多数情况下，基本类型直接代表了最底层的语言实现。

原始类型中两个比较特殊的就是 Undefined 和 Null，他们两个类型都只有一个值就是 undefined 和 null。除了 null 和 undefined 之外，所有基本类型都有其对应的包装对象：

String 为字符串基本类型。
Number 为数值基本类型。
BigInt 为大整数基本类型。
Boolean 为布尔基本类型。
Symbol 为字面量基本类型。

Undefined

undefined 一般表示我们未对变量进行初始化。使用 typeof 操作符的时候，如果是未声明变量，同样也会返回 undefined，再比如未设置返回值的函数执行的结果是 undefined，未设置的参数也会被默认为 undefined。最后还有一点需要注意的是，undefined 并不是 js 的保留字，并且是全局对象的一个属性，在浏览器环境中就是 window.undefined。当在局部环境中，我们是可以自己给 undefined 属性赋值的，也就是重写 undefined，所以为了确保我们使用的 undefined 是未被重写的，我们可以使用 void 0 来代替。

Null

null 可以简单理解为一个未被创建的对象，比如我们使用 document.getElementById 并没有找到对应元素的时候就会返回 null。null 和 undefined 有一些区别，在转换为 Number 的时候，null 会转换为 0 而 undefined 会转换为 NaN，执行 typeof 运算的时候，undefined返回 undefined 而 null 返回 object。使用 == 判断两者相等会返回 true，所以为了防止误判一般我们使用全等 ===。null 是所有对象原型链的终点，Object.prototype.__proto__ === null。

关于 null 的使用，当我们声明一个变量是用来存储对象我们可以先赋值为 null，当一个对象不再需要的时候，我们可以设置为 null 解除这个引用。

Number

根据 ECMAScript 标准，JavaScript 中只有一种数字类型：基于 IEEE 754 标准的双精度 64 位二进制格式的值。关于 Number 我已经在其他的文章中进行了深入的研究，你可以参考另外的文章：

这里特别提一点上面几篇文章没有说的小细节，数字类型中只有一个整数有两种表示方法（正负）： 0 可表示为 -0 和 +0（0 是 +0 的简写）。在实践中，这也几乎没有影响。例如 +0 === -0 为真。但是，你可能要注意除以 0 的时候：

42 / +0 // Infinity
42 / -0 // -Infinity

String

JavaScript 中的 String 类型用于表示文本型的数据. 它是由无符号整数值（16bit）作为元素而组成的集合. 字符串中的每个元素在字符串中占据一个位置. 第一个元素的 index 值是 0, 下一个元素的 index 值是 1, 以此类推. 字符串的长度就是字符串中所含的元素个数.你可以通过 String 字面值或者 String 对象两种方式创建一个字符串。

如果你想对字符串有更多的了解可以参考我的另外几篇文章：

Symbol 和 BigInt

这两个都是 ES6 新增的原始数据类型，Symbol 类型的数据通过 Symbol() 方法的执行产生，不过需要注意的是 Symbol 不能作为构造函数，每个从 Symbol() 返回的 symbol 值都是唯一的。一个 symbol 值能作为对象属性的标识符；这是该数据类型仅有的目的。

而 BigInt 则是为了精确表示超出双精度浮点数的最大安全表示范围的大数而新增的基本数据类型。

判断数据类型的方法

typeof 运算符

最简单的判断数据类型的方法是 typeof 运算符，返回值为字符串。typeof 的缺点是除了 Function 以外的其他所有对象的返回值都是 object （null 的返回值也是 object），如果我们需要区分不同的对象，就无法使用 typeof。

js 在底层存储变量的时候，会在变量的机器码的低位 1-3 位存储其类型信息：

000：对象
010：浮点数
100：字符串
110：布尔
1：整数
but, 对于 undefined 和 null 来说，这两个值的信息存储是有点特殊的。
null：所有机器码均为0
undefined：用 −2^30 整数来表示

所以，typeof 在判断 null 的时候就出现问题了，由于 null 的所有机器码均为 0，因此直接被当做了对象来看待。

instanceof 运算符

instanceof 运算符是检测构造函数的原型是否出现在某个对象的原型链上。通过 instanceof 运算符我们可以实现对 Object 类型的细分，确定属于哪种对象。但是 instanceof 的缺点是只能对对象进行检测，对于基本数据类型的实例无法检测（字面量无法检测，但是通过基本包装类型的构造函数创建的基本类型可以进行检测）。

constructor 属性

利用实例的 constructor 属性来辅助判断实例的数据类型也是一种手段。一般来说，实例本身是没有 constructor 属性的，我们所看到的属性都是 实例.__proto__.constructor，换言之也就是实例的构造函数，这种方式对基本数据类型也是有效的。这种方法的一个比较大的问题是 constructor 属性是个不受保护的属性，随时可能被更改，我们既可以给实例增加 constructor 属性，也可以修改构造函数的 prototype 的引用，也可以直接修改原型的 constructor 属性。

Object.prototype.toString.call()

这是最安全准确的检测数据类型的方法，每一种数据类型的构造函数的原型上都有 toString 方法，但是除了 Object.prototype上的 toString 是用来返回当前实例所属类的信息（检测数据类型的），其余的都是转换为字符串的。该方法可以准确检测所有内置类型。自定义类型的返回值为 Object Object。

所有 typeof 返回值为 "object" 的对象(如数组)都包含一个内部属性 [[Class]] (我们可以把它看作一个内部的分类，而非传统的面向对象意义上的类)。这个属性无法直接访问，一般通过 Object.prototype.toString(..) 来查看。所以当我们使用 Object.prototype.toString.call() 的时候，实际上访问的是对象的内容不属性 [[Class]]，基本类型会返回他们的包装对象的 [[Class]]。

let toString = Object.prototype.toString //=>Object.prototype.toString

console.log(toString.call(10)) //=>"[object Number]"
console.log(toString.call(NaN)) //=>"[object Number]"
console.log(toString.call('xxx')) //=>"[object String]"
console.log(toString.call(true)) //=>"[object Boolean]"
console.log(toString.call(null)) //=>"[object Null]"
console.log(toString.call(undefined)) //=>"[object Undefined]"
console.log(toString.call(Symbol())) //=>"[object Symbol]"
console.log(toString.call(BigInt(10))) //=>"[object BigInt]"
console.log(toString.call({ xxx: 'xxx' })) //=>"[object Object]"
console.log(toString.call([10, 20])) //=>"[object Array]"
console.log(toString.call(/^\d+$/)) //=>"[object RegExp]"
console.log(toString.call(function () {})) //=>"[object Function]"

参考文章

JavaScript中new操作符的解析和实现

Mon, 29 Jun 2020 12:00:00 GMT

前言

new 运算符是我们在用构造函数创建实例的时候使用的，本文来说一下 new 运算符的执行过程和如何自己实现一个类似 new 运算符的函数。

new 运算符的运行过程

new 运算符的主要目的就是为我们创建一个用户定义的对象类型的实例或具有构造函数的内置对象的实例（比如箭头函数就没有构造函数，所以是不能 new 的）。new 操作符的执行大概有以下几个步骤：

创建一个新的空对象
把新对象的 __proto__ 链接到构造函数的 prototype 对象（每一个用户定义函数都有一个 prototype 属性指向一个对象，该对象有一个 constructor 属性指向该函数），让我们的公共属性和方法可以从原型上继承，不用每个实例都创建一次。
将第一步创建的新的对象作为构造函数的 this 的上下文，执行构造函数，构造函数的执行让我们配置对象的私有属性和方法。
执行构造函数，如果构造函数没有返回值或者返回值不是一个对象，则返回 this。

我么可以用代码简单表示上面的逻辑：

function new_(constr, ...rests) {
  var obj = {}
  obj.__proto__ = constr.prototype
  var ret = constr.apply(obj, rests)
  return isPrimitive(ret) ? obj : ret //判断构造函数的返回值是否为对象，不是则直接返回创建的obj对象
}

new 的实现

上面讲了 new 运算符的执行过程，下面我们来自己动手实现一个 new 运算符。

function new_(constr, ...rests) {
  if (typeof constr !== 'function') {
    throw 'the first param must be a function'
  }
  new_.target = constr
  var obj = Object.create(constr.prototype)
  var ret = constr.apply(obj, rests)
  var isObj = typeof ret !== null && typeof ret === 'object'
  var isFun = typeof ret === 'function'
  //var isObj = typeof ret === "function" || typeof ret === "object" && !!ret;
  if (isObj || isFun) {
    return ret
  }
  return obj
}

function Person(name, age) {
  this.name = name
  this.age = age
}
Person.prototype.say = function () {
  console.log(this.name)
}
var p1 = new_(Person, 'clloz', '28')
var p2 = new_(Person, 'csx', '31')
console.log(p1) //Person {name: "clloz", age: "28"}
p1.say() //clloz
console.log(p2) //Person {name: "csx", age: "31"}
p2.say() //csx

console.log(p1.__proto__ === Person.prototype) //true
console.log(p2.__proto__ === Person.prototype) //true

以上就是一个简单的 new 实现，判断是否为对象那里可能不是很严谨，不过没有想到更好的方法。

一个小补充，在 mdn 的 Function.prototype.apply() 词条中看到的直接把方法写到 Function.prototype 上，也是个不错的思路，Function.prototype 在所以函数的原型链上，所以这个方法可以在每个函数上调用，方法内部的 this 也是指向调用方法的函数的。

Function.prototype.construct = function (aArgs) {
  var oNew = Object.create(this.prototype)
  this.apply(oNew, aArgs)
  return oNew
}

强制用 new 调用构造函数

function Clloz(...arguments) {
  if (!(this instanceof Clloz)) {
    return new Clloz(...arguments)
  }
}

new 的特殊行为

我今天偶然突然奇想，如果一个函数的 prototype 属性被我设为一个非对象的属性，再 new 会发生什么。结果非常出乎我的意料。

let a = function () {};

a.prototype = false;

let b = new a();

b instance of a; //Uncaught TypeError: Function has non-object prototype 'false' in instanceof check

a.prototype === false;  //true

b.__proto__ === Object.prototype //true

由 a 创建的对象 b 现在好像被 function Object() 创建的一样。我在标准中没有找到讲 new 执行细节的，标准中只是说执行构造函数内部的一个 [[contruct]] 方法。

Tips

补充三个关于 new 运算符的知识点。

上面提到 new 的执行过程的最后一步，如果构造函数没有返回值或者返回值不是一个对象，则返回 this。但是如果返回的是一个 null 的话，依然返回 this，虽然 null 也算是 object。
new 操作符后面的构造函数可以带括号也可以不带括号，除了带括号可以传递参数以外，还有一个重要的点是两种用法的运算符优先级不一样，在JS运算符优先级这篇文章中有提到，带参数的 new 操作符的优先级是比不带参数的要高的，new Foo() > Foo() > new Foo。
运算符优先级相关：对于 new，函数调用，成员访问三者结合的情况，比如 new obj1.obj2.obj3.fun().prop 这样的情况，我个人总结就是函数调用直接到前面的 new 先计算，得到的结果在进行成员访问。

一般不太会遇到，可能有些题目会问这些问题。

参考文章

能否实现JS的new操作符

Emacs的小技巧，注释，tab，undo和lsp补全

Tue, 03 Dec 2019 12:00:00 GMT

前言

在使用 emacs 的 tab 和 undo、redo 的时候，emacs 的反应和我们平常使用的一些编辑器或者 IDE 很不一样，有时候按 tab 缩进是 4 格，有时候缩进是 2 格，有时候不管怎么按都没反应。undo 一般大家都知道，一般有几个快捷键可用：C-_，C-x u 和 C-/，但是 redo 的操作新手可能不太了解。最后还有注释和 lsp 补全的使用，以及在命令行中用 emacs 的一些注意点。

本文的内容是在 spacemacs 的基础上的一些配置，可能有些内容需要单独在进行一些配置。

alt 问题

在 mac 的终端上会出现 alt 无法使用的情况，因为 mac 的 option 默认是用来输入特殊符号的，所以我们要禁用掉特殊符号这个功能，在 iTerm2 里面直接在 Profiles 里面的 keys 选项卡中的 left option 选择为 +ESC 即可。如果是 terminal 则直接在 preferences->Profiles->keyboard 的最下面勾选上 用 option 键作为 meta 键。如果是在 windows 中一般不会在终端使用 emacs，如果是通过 ssh 链接服务器，那么也可以在 xshell 中设置 将左alt键用作meta键。其实 emacs 中的 M-x 中的 M 就是 meta 键的意思，它在不同的系统代表不同的键，emacs 中的文档也说了 M-x, it means "press Alt/Esc/Option/Edit key and x together"，所以在 linux 中其实用 esc 也可以代替 meta 但是比较麻烦，所以我们还是对终端进行配置，一般是将 alt 或者 alt 设置为 meta。

tab 的使用

上面说到 emacs 中的 tab 并不像大家平时用的 IDE 或者编辑器的表现，刚开始很不习惯。其实你可以把 emacs 中的 tab 理解为格式化代码，对选中区域或光标所在行进行代码的格式化，类似在 vscode 中的快捷键 Shift + Alt + f 的作用，在有些插件里面，补全也会用到 tab 键。那么如果我们需要输入正常的 tab 要怎么做呢，emacs 默认提供了一个 quoted insert 方法来让你输入一些特殊的键或者字符的八进制编码，比如 <del> 或者 <tab> 等，所以要输入 tab 就用快捷键 C+q tab 就可以了，如果你觉得这很麻烦，也可以自己绑定快捷键。emacs 提供的一个方法 tab-to-tab-stop 来输入 tab，快捷键是 M + i。

关于 quoted insert 的内容可以查看官方文档 Insert Text，或者用 C-h k 来查看快捷键对应的用法。

另外关于 tab 的缩进 indent，不同的语言可以设置不同的缩进，如果你使用的是别人的配置那么可能你需要改多个地方的配置，可以用 M-x customize-variable 来查看 indent 相关的配置，比如 js 的 indent 设置在 js-indent-level 这个变量里面，而 html 的设置在 web-mode-code-indent-offset 这个变量里面，具体要更改哪个，要看你的语言对应的模式然后查找对应的变量。

最后再提一点就是 backtab 就是我们在其他编辑器常用的 Shift + tab，这个我是使用的一个自定义函数来实现的：

(defun un-indent-by-removing-4-spaces ()
    "remove 4 spaces from beginning of of line"
    (interactive)
    (save-excursion
      (save-match-data
        (beginning-of-line)
        ;; get rid of tabs at beginning of line
        (when (looking-at "^\\s-+")
          (untabify (match-beginning 0) (match-end 0)))
        (when (looking-at (concat "^" (make-string tab-width ?\ )))
          (replace-match "")))))

(global-set-key (kbd "<backtab>") 'un-indent-by-removing-4-spaces)

undo 和 redo

在 emacs 中提供了好几种 undo 的快捷键 C-_，C-x u 和 C-/，其中在命令行中 C-x u 可能无效，我一般是使用 C-_。redo 操作一般我们在其他编辑器中用 Ctrl + Shift + z 来操作，在 emacs 上显然不可以这样。其实在 emacs 中，每个缓冲区都有一个 undo 记录，每次更改缓冲区都会放入这个 undo 记录中，我们可以通过连续的 c-_ 进行 undo，如果在连续的 undo 命令序列中插入其他命令比如文档中提到的 C-f 或者是 C-g，那么前面的连续的 undo 操作都会被作为单独的修改集合放入 undo 记录中，从而可以重新应用刚才被 undo 的操作。

也就是说，比如你进行了 操作1 操作2 操作3，此时你是用 undo 回到了 操作2 执行后的状态，这时候你想要 redo 回到操作3 执行后的状态，就先输入一个非 undo 命令，比如 C-g，然后在输入 undo 就编程 redo 操作了，具体的说明请看官方文档：Undoing Changes。

当然更好的做法是使用 undo tree 这个插件，安装好插件后 C-x u 就称为打开undo-tree-visualizer-mode 这个 buffer 的快捷键，打开后我们能在一个新的 buffer 里面看到我们所有的历史操作，并且细分出了各个分支。undo tree 的操作方式有如下几种，p，n 在节点上上下移动，b，f 来选择分支（选中的分支会显示黑色），t 显示时间戳，q 退出。undo tree 同时提供了一个 undo tree redo 的方法，我们可以直接进行 redo 不在需要那么复杂的逻辑，比价符合我们正常的思维。

注释 comment`

emacs 提供的注释默认快捷键是 C-;，但是在命令行里面几乎所有和标点符号有关的快捷键都不能生效，这种情况下我们可以给 comment-line 这个函数定义两组快捷键，这样我们可以在命令行和 GUI 都能够使用注释的功能。

(global-set-key (kbd "C-c C-k") 'comment-line)
(global-set-key (kbd "C-;") 'comment-line)

lsp 自动补全

LSP (Language Server Protocol) 是微软领导开发的编程语言语法补全和代码分析框架，Emacs 的 lsp-mode 是 LSP 协议在 Emacs 的客户端实现. lsp-mode 现在能够很好的支持 C++, Python, Ruby, Golang, Haskell, OCamel, Rust, PHP 等语言. 当然也包括 JavaScript。

spacemacs 已经默认集成了 lsp，不过想要实现补全还需要安装对应语言的对应服务，比如补全 js 需要安装 typescript-language-server;，其他语言参考lsp-supported-languages。在 spacemacs 中要给对应的 mode 开启 lsp，加入如下内容

(use-package lsp-mode
  :hook (XXX-mode . lsp)
  :commands lsp)

也可以在 dotspacemacs-configuration-layers 对应的模块中直接设置，比如 (javascript :variables javascript-backend 'lsp)。需要注意的是，如果是手动启用，不是启动 lsp-mode，而是启动 lsp，如果出现 spacemacs-jump-handlers-xxx-mode 报错的话，在 user-config 里面加上 (defvar spacemacs-jump-handlers-xxx-mode nil)。

如果不小心将文件加入到 lsp 的 blacklist 中，可以用 lsp-workspace-blacklist-remove 方法来移除。

参考文章

Emacs的Tab键

tmux的基础用法

Wed, 27 Nov 2019 12:00:00 GMT

前言

在用 ssh 远程登录服务器的时候，长时间不操作，或不小心按了 ctrl + d，连接就断开了，在重连上去，一切又恢复到初始状态，想要查看之前的命令和一些操作都无法找到记录了。

命令行的典型使用方式是，打开一个终端窗口在里面输入命令。用户与计算机的这种临时的交互，称为一次"会话"（session）。会话的一个重要特点是，窗口与其中启动的进程是连在一起的。打开窗口，会话开始；关闭窗口，会话结束，会话内部的进程也会随之终止，不管有没有运行完。

tmux 就是为了解决这个问题，把窗口和会话分开，即使我们关闭窗口，会话也还在，我们在下次需要的时候又可以打开，继续上次的内容。

安装

# Ubuntu 或 Debian
$ sudo apt-get install tmux

# CentOS 或 Fedora
$ sudo yum install tmux

# Mac
$ brew install tmux

会话管理

# 新建会话
$ tmux new -s <session-name>

# 分离会话，关闭当前窗口，保留会话
$ tmux detach #或者用快捷键 ctrl+b d

# 查看所有会话
$ tmux ls

# 重新进入会话
$ tmux attach -t 0     # 使用会话编号，第一个启动的 tmux 窗口，编号是0，第二个窗口的编号是1，以此类推。
$ tmux attach -t <session-name>    # 使用会话名称

# 结束会话，关闭窗口也关闭会话
$ tmux kill-session -t 0    # 使用会话编号
$ tmux kill-session -t <session-name> # 使用会话名称 也可以直接使用快捷键 ctrl+d，和退出远程登录的ssh一样

# 切换会话
$ tmux switch -t 0    # 使用会话编号
$ tmux switch -t <session-name> # 使用会话名称

# 重命名会话
$ tmux rename-session -t 0 <new-name>

# 快捷键
Ctrl+b d：分离当前会话。
Ctrl+b s：列出所有会话。
Ctrl+b $：重命名当前会话。

窗格操作

tmux 可以将窗口分成多个窗格（pane），每个窗格运行不同的命令。以下命令都是在 Tmux 窗口中执行。

# 划分上下两个窗格
$ tmux split-window

# 划分左右两个窗格
$ tmux split-window -h

# 光标切换到上方窗格
$ tmux select-pane -U

# 光标切换到下方窗格
$ tmux select-pane -D

# 光标切换到左边窗格
$ tmux select-pane -L

# 光标切换到右边窗格
$ tmux select-pane -R

# 当前窗格上移
$ tmux swap-pane -U

# 当前窗格下移
$ tmux swap-pane -D

窗口操作快捷键

Ctrl+b %：划分左右两个窗格。
Ctrl+b "：划分上下两个窗格。
Ctrl+b <arrow key>：光标切换到其他窗格。<arrow key> 是指向要切换到的窗格的方向键，比如切换到下方窗格，就按方向键 ↓。
Ctrl+b ;：光标切换到上一个窗格。
Ctrl+b o：光标切换到下一个窗格。
Ctrl+b {：当前窗格左移。
Ctrl+b }：当前窗格右移。
Ctrl+b Ctrl+o：当前窗格上移。
Ctrl+b Alt+o：当前窗格下移。
Ctrl+b x：关闭当前窗格。
Ctrl+b !：将当前窗格拆分为一个独立窗口。
Ctrl+b z：当前窗格全屏显示，再使用一次会变回原来大小。
Ctrl+b Ctrl+<arrow key>：按箭头方向调整窗格大小。
Ctrl+b q：显示窗格编号。

窗口操作

# 创建新的窗口
$ tmux new-window

# 新建一个指定名称的窗口
$ tmux new-window -n <window-name>

# 切换到指定编号的窗口
$ tmux select-window -t <window-number>

# 切换到指定名称的窗口
$ tmux select-window -t <window-name>

# 重命名当前窗口
$ tmux rename-window <new-name>

窗口操作快捷键

Ctrl+b c：创建一个新窗口，状态栏会显示多个窗口的信息。
Ctrl+b p：切换到上一个窗口(按照状态栏上的顺序)。
Ctrl+b n：切换到下一个窗口。
Ctrl+b <number>：切换到指定编号的窗口，其中的 <number> 是状态栏上的窗口编号。
Ctrl+b w：从列表中选择窗口。
Ctrl+b ,：窗口重命名。

其他命令

# 列出所有快捷键，及其对应的 Tmux 命令
$ tmux list-keys

# 列出所有 Tmux 命令及其参数
$ tmux list-commands

# 列出当前所有 Tmux 会话的信息
$ tmux info

# 重新加载当前的 Tmux 配置
$ tmux source-file ~/.tmux.conf

参考文件

Tmux 使用教程

HTML character entity HTML字符实体

Tue, 19 Nov 2019 12:00:00 GMT

前言

我在搞懂字符编码这篇文章中对计算机字符编码的原理和常用的字符编码都进行了说明，编码的本质就是为了方便信息的传输，以及计算机对于信息的处理。

在文章中我也提到，而在 HTML 里面，我们的每一个字符其实也都是以 unicode 编码的形式保存和传递的。而 HTML，CSS 和 JavaScript 都给我们提供了对应的直接使用 unicode 的方法，具体使用方法可以看搞懂字符编码这篇文章。

在 HTML 中的 unicode 使用一般被称为 HTML character entity，是用 unicode 的字符串来表示对应的字符，使用情况主要是应对一些 reserved characters （保留字符），比如在 HTML 中的 < >，他们出现在 HTML 文档中时会被浏览器识别为标签，为了显示这些保留字，我们需要使用 entity。还有一种情况是我们要显示一些无法用键盘输入的特殊字符。

HTML entity 的使用

character entity 表示字符的方式有两种，一种是直接用 unicode 的形式表示字符，另一种是在 HTML 标准里面为了方便使用已经被命名的 entity，他们的使用方法如下：

unicode：&#nnnn; 或者 &#xhhhh;，前者是 unicode 编码的十进制，后者是十六进制。
name：&name;

两种方式并不冲突，他们可以用来表示同一个字符，name 的形式是 HTML 标准替一些常用的符号直接给出了命名，方便记忆。因为 unicode 需要使用的话每次都需要去查询，而命名的话比较方便记忆。比如 © 可以用 # copy; 也可以用 &# 169;

在 JavaScript 里面表示二进制用 0bXXXXXXX，八进制用 0XXXXXX，十六进制 0xXXXXXXX，X 表示数字。

想要查询字符和实体之间对应的编码和解码可以到HTML entity encoder/decoder

最后在分享两个前端的标准制定协会W3C - Wikipedia 和 WHATWG - Wikipedia给出的 HTML Named character references，WHATWG 主要是维护 HTML 相关的标准，W3C 则是维护几乎所有跟 Web 有关的标准，目前他们已经开始合作推动 web 标准：W3C AND WHATWG TO WORK TOGETHER TO ADVANCE THE OPEN WEB PLATFORM

在使用 markdown 的时候有时候会遇到需要转义一些有特殊含义字符的需要比如 $，或者是在代码块里面要加入转义的内容，可以用使用 <code></code> 中间加入 character entity。当你的 markdown 解析出现问题的时候可以看一看是不是某些有含义的字符解析出错导致的，如果是的话，将这些字符换成字符实体即可。

entity 中使用最多的应该是 < ;（lt>（lt 就是 left tag）的意思，当我们想在文档中插入标签结构的时候，如果直接使用 <> 会被解析成元素，此时我们可以将左标签用 < ; 来代替 <，就可以正常显示了。比如下面的代码用

<pre>
    < ;html>
        < ;head>
            < ;title>this is a title</title>
        < ;/head>
        < ;body>this is a body</body>
    < ;/html>
</pre>

由于实体在 markdown 会解析成对应的字符，所以我在 ; 前留一个空格。

参考文章

translate-shell 常用命令

Mon, 18 Nov 2019 12:00:00 GMT

前言

我在 Mac 的命令行里面使用的翻译工具是fanyi，安装方法为 npm install -g fanyi，这个工具只能进行中英文翻译，翻译的来源是金山词霸和有道词典，如果只是要翻译英文的话其实挺好用的。不过我日常经常需要查询日语，Mac 自带的 dictionary 里面的日语字典只有 大辞林 和 日英字典，所以对我来说翻译日语经常需要用 Google。

今天给大家介绍另一个功能更强的命令行翻译工具，叫做Translate Shell，它的翻译来源主要是 Google Translate (default), Bing Translator, Yandex.Translate, 和 Apertium。它的功能要比 fanyi 强很多，它能够在多种语言之间进行翻译，也能翻译句子。

$ trans 'Saluton, Mondo!'
Saluton, Mondo!

Hello, World!

Translations of Saluton, Mondo!
[ Esperanto -> English ]
Saluton ,
    Hello,
Mondo !
    World!

可以进行简要翻译，不限时那么多结果

$ trans -brief 'Saluton, Mondo!'
Hello, World!

可以在命令行进入翻译交互的状态，不用每次都输入命令，在阅读文章或资料的时候很有用

$ trans -shell -brief
> Rien ne réussit comme le succès.
Nothing succeeds like success.
> Was mich nicht umbringt, macht mich stärker.
What does not kill me makes me stronger.
> Юмор есть остроумие глубокого чувства.
Humor has a deep sense of wit.
> 學而不思則罔，思而不學則殆。
Learning without thought is labor lost, thought without learning is perilous.
> 幸福になるためには、人から愛されるのが一番の近道。
In order to be happy, the best way is to be loved by people.

Translate Shell 的安装和使用

安装

官方提供了三种安装方法

下载the self-contained executable，然后放置到 path 对应的位置。

wget git.io/trans
chmod +x ./trans
sudo mv trans /usr/bin/

通过 Git 安装，克隆 Translate Shell 的 GitHub 仓库然后手工编译。

$ git clone https://github.com/soimort/translate-shell
$ cd translate-shell/
$ make
$ [sudo] make install
# In case you have only zsh but not bash in your system, build with:
$ make TARGET=zsh
# The default PREFIX of installation is /usr/local. To install the program to somewhere else (e.g. /usr, ~/.local), use:
$ [sudo] make PREFIX=/usr install

通过包管理工具安装，有些发行版的官方仓库中包含了 Translate Shell，可以通过包管理器来安装。在 Mac 上直接通过 homebrew 安装即可。

brew install translate-shell

Translate Shell 的使用

Google Translate 能够自动识别待翻译文本，Translate Shell 会将系统 locale 中的语言作为目标语言。所以如果你可以根据你的日常翻译需求来设置 locale，一般来说就设为英语就可以了。当然不设置也可以，在使用 Translate Shell 的时候加上目标语言参数就可以了

这里科普一下 locale，区域设置（locale），也称作“本地化策略集”、“本地环境”，是表达程序用户地区方面的软件设定。通常一个区域设置标识符至少包括一个语言标识符和一个区域标识符。在UNIX 和 Windows 中，区域设置的控制是不同的。在 UNIX 下，通常通过环境变量来控制区域设置。这些环境变量包括：LC_ALL, LC_CTYPE, LC_TIME, 等等。你可以通过改变这些环境变量来控制你的程序或者命令所表现出来的区域设置，前提是这些程序或者命令必须是已经被国际化的和本地化的。在 Windows 下，你可以通过改变控制面板上的“语言/区域”中的区域的值来设定 Windows 的当前用户的区域设置。

在 Mac 中设置英文 locale 的方法如下，在 .bash_profile 中加入如下内容

$ vim ~/.bash_profile
export LC_ALL=en_US.UTF-8
export LANG=en_US.UTF-8

$ source ~/.bash_profile
# 再次查看locale
$ locale
LANG="en_US.UTF-8"
LC_COLLATE="en_US.UTF-8"
LC_CTYPE="en_US.UTF-8"
LC_MESSAGES="en_US.UTF-8"
LC_MONETARY="en_US.UTF-8"
LC_NUMERIC="en_US.UTF-8"
LC_TIME="en_US.UTF-8"
LC_ALL="en_US.UTF-8"

查看语言代码

想要翻译到对应的非 locale 语言，需要加入对应语言的参数，查看参数的方法如下

$ trans -R
┌───────────────────────┬───────────────────────┬───────────────────────┐
│ Afrikaans      - af │ Hebrew         - he │ Portuguese     - pt │
│ Albanian       - sq │ Hill Mari      - mrj │ Punjabi        - pa │
│ Amharic        - am │ Hindi          - hi │ Querétaro Otomi- otq │
│ Arabic         - ar │ Hmong          - hmn │ Romanian       - ro │
│ Armenian       - hy │ Hmong Daw      - mww │ Russian        - ru │
│ Azerbaijani    - az │ Hungarian      - hu │ Samoan         - sm │
│ Bashkir        - ba │ Icelandic      - is │ Scots Gaelic   - gd │
│ Basque         - eu │ Igbo           - ig │ Serbian (Cyr...-sr-Cyrl
│ Belarusian     - be │ Indonesian     - id │ Serbian (Latin)-sr-Latn
│ Bengali        - bn │ Irish          - ga │ Sesotho        - st │
│ Bosnian        - bs │ Italian        - it │ Shona          - sn │
│ Bulgarian      - bg │ Japanese       - ja │ Sindhi         - sd │
│ Cantonese      - yue │ Javanese       - jv │ Sinhala        - si │
│ Catalan        - ca │ Kannada        - kn │ Slovak         - sk │
│ Cebuano        - ceb │ Kazakh         - kk │ Slovenian      - sl │
│ Chichewa       - ny │ Khmer          - km │ Somali         - so │
│ Chinese Simp...- zh-CN│ Klingon        - tlh │ Spanish        - es │
│ Chinese Trad...- zh-TW│ Klingon (pIqaD)tlh-Qaak Sundanese      - su │
│ Corsican       - co │ Korean         - ko │ Swahili        - sw │
│ Croatian       - hr │ Kurdish        - ku │ Swedish        - sv │
│ Czech          - cs │ Kyrgyz         - ky │ Tahitian       - ty │
│ Danish         - da │ Lao            - lo │ Tajik          - tg │
│ Dutch          - nl │ Latin          - la │ Tamil          - ta │
│ Eastern Mari   - mhr │ Latvian        - lv │ Tatar          - tt │
│ Emoji          - emj │ Lithuanian     - lt │ Telugu         - te │
│ English        - en │ Luxembourgish  - lb │ Thai           - th │
│ Esperanto      - eo │ Macedonian     - mk │ Tongan         - to │
│ Estonian       - et │ Malagasy       - mg │ Turkish        - tr │
│ Fijian         - fj │ Malay          - ms │ Udmurt         - udm │
│ Filipino       - tl │ Malayalam      - ml │ Ukrainian      - uk │
│ Finnish        - fi │ Maltese        - mt │ Urdu           - ur │
│ French         - fr │ Maori          - mi │ Uzbek          - uz │
│ Frisian        - fy │ Marathi        - mr │ Vietnamese     - vi │
│ Galician       - gl │ Mongolian      - mn │ Welsh          - cy │
│ Georgian       - ka │ Myanmar        - my │ Xhosa          - xh │
│ German         - de │ Nepali         - ne │ Yiddish        - yi │
│ Greek          - el │ Norwegian      - no │ Yoruba         - yo │
│ Gujarati       - gu │ Papiamento     - pap │ Yucatec Maya   - yua │
│ Haitian Creole - ht │ Pashto         - ps │ Zulu           - zu │
│ Hausa          - ha │ Persian        - fa │                       │
│ Hawaiian       - haw │ Polish         - pl │                       │
└───────────────────────┴───────────────────────┴───────────────────────┘

也可以通过 trans -T 来查询，不过语言名称显示的就不是英语了，而是对应的文字，比如 Japanese 显示的就是 日本語。

基础用法

# 翻译到locale语言
$ trans [Words]

# 翻译到指定语言
$ trans :zh [word]

# 翻译到多种目标语言
$ trans :zh+ja word

# :可用=代替，但是在zsh中=是有特殊含义的，需要用引号或{}转义。:也可以用参数-t代替
$ trans {=zh+ja} word
$ trans '=zh+ja' word
$ trans -t zh+ja word
$ trans -t japanese word
$ trans -t 日本語 word

# Google Translate 可能无法准确分辨你的待翻译文本的语言，最好用后置冒号指定，也可以使用参数-s。
$ trans ja: 手紙
$ trans zh: 手紙
$ trans -s ja 手紙

# 翻译句子和短语
$ trans en:zh "word processor"
$ trans :zh "To-morrow, and to-morrow, and to-morrow,"

# 简洁模式：默认情况下，Translate Shell 尽可能多的显示翻译信息。如果你希望只显示简要信息，只需要加上 -b选项。
$ trans -b :fr "Saluton, Mondo"
$ trans -b :@ja "Saluton, Mondo" #显示发音符号，如果有的话，如日语罗马音，汉语拼音

# 字典模式：当待翻译文本和目标语言一致的时候进入字典模式，或者使用-d参数，不是每种语言都支持
$ trans :en word
$ trans -d fr: mot

# 识别源文本的语言，用-id参数
$ trans -id 言葉

# 听取翻译结果或源文本的发音
$ trans -b -p :ja "Saluton, Mondo"
$ trans -sp "你好，世界"

# 翻译文件或网页
$ trans :fr file://input.txt
$ trans :fr http://www.w3.org/

# 查看语言的详情
$ trans -L fr
$ trans -L de+en

# 进入交互模式
$ trans -shell
$ trans -shell en:fr

总结

跟 fanyi 比起来，Translate Shell 功能更强大，不过美中不足的是，它的英语翻译没有音标，fanyi 有英音和美音的音标，具体的使用可以根据自己的需求来调整。

参考文章

USB标准版本和接口类型

Sun, 17 Nov 2019 12:00:00 GMT

前言

对于 usb （Universal Serial Bus）大家都非常熟悉，通用串行总线，是连接计算机系统与外部设备的一种串口总线标准，也是一种输入输出接口的技术规范，被广泛地应用于个人电脑和移动设备等信息通讯产品，并扩展至摄影器材、数字电视（机顶盒）、游戏机等其它相关领域。

10 年我进入大学的时候，大部分电脑还是标配 usb2.0 的接口，后来才慢慢出了 usb3.0，usb3.1 等，现在接口越来越多，包括我知道的早起安卓使用的 micro usb，现在的 type c 接口。而苹果的接口虽然不在 usb 标准里面，但是苹果的设备市场占有率也很大，他的 lighting接口，thunderbolt接口 使用率也很高，很多时候这么多的接口类型让人困惑，本文就来讲一讲 usb 标准的版本和接口类型。

串口和并口

不管什么接口，作用都是为了连接外部设备，然后传递数据，而接口发展的目标当然是能够连接更多不同的设备以及获得更高的传输速率。但凡事都要考虑实现的难度和实现的成本，很多时候由于技术或成本的限制我们只能在具体的应用场景采取最合适的方案。串口和并口就是在早起传输速率不是很快的情况下，针对不同的应用场景采取的不同方案。

串口和并口的定义：在一个独立的信道上，每次同时传输1bit为串口，每次同时传输多个bit为并口。从定义上看，并口的传输速率似乎要比串口快，但是为什么在大部分应用场景下并口已经慢慢被淘汰了呢。我们知道就是在我们使用的 usb 以及以前的主办上的并行接口，串行接口内部都是有很多条线路的（比如 usb 或者 lighting接口 上的触电），他们有的用于供电，有的用于接地，有的用于传输信号，还可能有一些其他操作比如控制等。我们想要提高接口的传输速率无非两种方法，一种是提高单根线路的传输速率，另一种是增加线的数量。但是在并行接口的实践中已经发现，多条线路的信号会相互干扰，并且传输距离要有限制，不能太远，比如主板上的并行接口一次传 8bits，如果其中一个信号出错，8 个全部要重发。而串行的结构要简单很多，干扰的问题要小很多，同时成本也更低，我们只要提高单根线路的传输速率就好了，这要比解决干扰的问题成本小很多，而且并口的多条线路之间还要解决数据同步的问题。

简单的说就是串口形容一下就是一条车道，而并口就是有 8 个车道同一时刻能传送8位（一个字节）数据。但是并不是说并口快，由于 8 位通道之间的互相干扰（串扰），传输时速度就受到了限制，传输容易出错。串口没有互相干扰。并口同时发送的数据量大，但要比串口慢。如果并口的干扰问题解决，同时单线速率能够跟串口相同，它的传输速率必然更快，这也是在 21 世纪之前，在单根线路传输速度很慢的情况下，在需要较大传输速度的地方，例如打印机，并口得到广泛使用的原因。但是当前，并口只能在一些需求特殊的场景下发挥作用。

串行接口、并行接口是按照数据传输方式来划分的，串行接口是一大类接口。USB、RS232、SATA、PS/2、RS485 等等，这些都属于串行接口；但一般情况下，如果没有特殊说明而只是说“串口”的话，通常特指 RS232 接口。

usb 标准和接口类型

多媒体电脑刚问世时，外接式设备的传输接口各不相同，如打印机只能接 LPT、调制解调器只能接 RS232、鼠标键盘只能接 PS/2 等。繁杂的接口系统，加上必须安装驱动程序并重启才能使用的限制，都会造成用户的困扰。因此，创造出一个统一且支持易插拔的外接式传输接口，便成为无可避免的趋势，USB 应运而生。

USB 最初是由英特尔与微软倡导发起，最大的特点是尽可能得实现热插拔和即插即用。当设备插入时，主机枚举到此设备并加载所需的驱动程序，因此其在使用上远比 PCI 和 ISA 等总线方便。

USB 可以连接的外设有鼠标、键盘、游戏手柄、游戏杆、扫描仪、数字相机、打印机、硬盘和网络等部件。对数字相机这样的多媒体外设 USB 已经是缺省接口；由于大大简化与计算机的连接，USB 也逐步取代并行接口成为打印机的主流连接方式之一。2004 年已经有超过 1亿 台 USB 设备；到 2007 年时，高清晰度数字视频外设是仅有的 USB 未能染指的外设类别，因为他需要更高的传输速率，不过 USB3.1 和 2019 年 USB4 的问世，高清晰度数字视频外设和外接式显卡也能在 USB 播放。

现 USB 标准中，按照速度等级和连接方式分为以下七种版本。注意 USB-IF （USB开发者论坛，USB标准的制定组织）当前正式的主版本号只有 USB 2.0 和 USB 3.2 两个。

USB开发者论坛负责 USB 标准制订，其成员包括：Apple、HP、NEC、Microsoft 和 Intel。2001 年底，USB-IF 公布 USB 2.0 规范，与之前的 USB 0.9、USB 1.0 和 USB 1.1 一样，该规范完全向下兼容。随后，USB-IF 公布 USB On-The-Go（USB OTG，当前版本：1.0a）作为 USB 2.0 规范的补充标准，使其能够用于在便携设备之间直接交换数据。

USB 的连接器分为 A、B 两种，分别用于主机和设备；其各自的小型化的连接器是 Mini-A, Mini-B 和 Micro-A, Micro-B，另外还有 Mini-AB（可同时支持 Mini-A 及 Mini-B）的插口。USB 3.1 版本中引入了支持正反面不区分插入的 C 型。每一种连接器有对应的公口和母口，并且我们用来连接两种不同设备的 USB 线两端会用不同的连接器，这些内容在 USB-IF 都有规定。

紫色的 Type-C 充电速度最高支持 5A 充电、充电功率最高达 100W；

具体的版本和对应的接口看下图：

从上面的内容中可以看出，所谓的 2.0，3.0，3.1，3.2 对应的就是 USB-IF 制定的新的 USB 标准的命名，而所谓的 type C，type A 则是在某个标准实现下具体使用的物理接口（连接器），同一个标准会为不同的设备设计不同的接头。不过几家参与制定标准的大厂都是向着统一接口的目标努力的。

USB Connectors 接头

单独说一下接头，其实真正让使用者搞不清的其实并不是 USB 标准的版本，其实大部分用户也不会去真的把版本区分那么清楚，只要大致知道哪个快哪个慢就行了。真正让大家搞不清的是花样百出的各种接头，Android 上的早起 Micro-B 和现在的 Type-C，Type-A 里面的 2.0，3.0，3.1，3.2，再加上苹果自己的 lighting 和 thunderbolt，种类繁多，眼花缭乱。

首先我们要知道接头是由 USB-IF 所指定，接头的设计一方面为了支持众多 USB 的基本需求，另一方面也避免以往许多类似串行接头所出现的问题。

接头设计的相当耐用。许多以往使用的接头较脆弱，即使受力不大，有时针脚或零件也会折弯甚至断裂。而 USB 接头的金属导电部分周围有塑料作为保护，而且整个连接部分被金属的保护套围住，因此 USB 接头不论插拔，都不容易受损。由于金属保护套和外围塑料护套的保护，需要较大的力量才能造成 USB 接头明显的损坏。
具有防呆设计，方向相反的插头不可能插到插座里，方向正反很容易感觉出来。所以不可能把 USB 接口插错。
接头能相对便宜地大量生产。
在 USB 网络中，接头被强制使用定向拓扑。USB 不支持环形网络，因此不兼容的 USB 设备之间接口也不兼容。不像其他通讯系统（如 RJ-45 电缆）不能使用转换插头，防止环形 USB 网络产生。
适度的插拔力。USB 电缆和小型 USB 设备能被插口卡住（不需要夹子、螺丝或者其他接口那样的锁扣）。只需要适当力量插拔即可连接周边设备。
由于接头的构造，在将 USB 插头插入 USB 座时，插头外面的金属保护套会先接触到 USB 座内对应的金属部分，之后插头内部的四个触点才会接触到 USB 座。金属保护套会连接到系统的地线，提供路径使静电可以放电，避免因静电通过电子零件而造成损坏。
USB 电缆最长允许 5 米，更长的距离需要 HUB。

USB 的连接器的插头和插座配对，以及连接不同设备的 USB 线的两端连接器标准都是有规定的，见下两张图。

大部分的连接器都是只能和合身对应的插头插座连接，USB 3.0 的插座大部分都向下兼容。而在 USB 线的部分我们可以看到应用的最广泛的 Type-A 和 Type-C 是适用场景最多的。

这里提一下 USB 4，USB 4 于 2019年9月3日 发布。采用 Thunderbolt 3 协议规格，使 Thunderbolt 3设备将能兼容于 USB 4，现有 3.2 及 2.0 也向下兼容。速度方面加倍来到两条通道总共 40Gb/s 的传输速度。

苹果的接口

最后单独说一下苹果的接口，苹果作为一家特立独行，什么东西都自己来的公司，它的接口也都是自己的一套标准。目前在 iphone，ipad，ipod 还有一系列周边设备上使用的都是苹果自己的闪电接口 lighting。

闪电是由苹果公司所制作的专属连接器规格，首次出现在 2012 年所发表的 iPhone 5、 iPod Touch 及 iPod nano 等新款手持式消费性电子产品。此连接器针脚为 8 pin，正反面皆可插，尺寸与 Micro USB 相近。闪电取代了使用多年的 30pin 连接器。闪电连接器也是移动市场首个成为主流的正反可插接口，由于插头采用了对称式设计，所以插头的上下两面均分布有相同的针脚。无论用户以何种方向将插头插入接口，其中一组针脚都会同基座中的针脚相连接。当前还有 USB Type-C 也跟着采用这种设计。不同的是，闪电接头的引脚在外面，USB-C 接头的引脚则在里面，且闪电的插座引脚只有一边，USB-C 则两边都有。

相对于移动设备上的 Lighting，在 Mac 上苹果自家的接口就是 Intel 发表的 Thunderbolt 高速串行接口标准，是用来连接电脑和其他设备通用总线。13 年的 Macbook Pro 开始搭载 thunderbolt2，16 年的 Macbook Pro 开始搭载 Thunderbolt3，而 Thunderbolt3 的连接器也选择了 Type-C 标准，而最新的 USB 4 标准也采用了 Thunderbolt 3 的协议。

由于支持 Thunderbolt 1, 2 的厂商不多，而且采用 Thunderbolt 的设备大多是高端产品，价格昂贵，加上接口使用的是苹果 Mini Displayport，配件无法用在其他电子设备，普及程度远低于对手 USB。所以 Thunderbolt 3 才与 USB Type-C 的接头兼容，使 Thunderbolt 接口变得更普及。

总结

本文整理了一些关于硬件接口的知识，看完后相信对于各种流行的高速串行接口的标准以及各种连接器的标准都能够有一定的了解。如有错漏，欢迎指正。

参考文章

mac和iphone之间传输文件

Mon, 11 Nov 2019 12:00:00 GMT

前言

以前我在 mac 和 iphone 之间传输文件都是用 icloud，如果是一些链接我则是通过微信的文件传输助手。不过这两天研究了一下 apple 产品的文件传输功能，在官方的文档中找到了很多原来不知道的功能，本文整理和总结一下比较实用的交互方法。

本文主要介绍使用方法，具体的版本要求和使用条件请参阅下方的 apple 官方文档。

Handoff 接力

接力的意思就是对支持接力的 apple 应用或者第三方应用可以跨设备继承之前的应用状态，比如你正在手机上用 Chrome 浏览一个网页，这个网页的移动端支持不是很好，这时候可以在 mac 的 dock 栏直接看到一个如下图的图标，点击以后会直接打开你当前正在手机上浏览的网页。

同样，在 mac 上使用的应用只要支持 handoff 同样可以在手机上打开。见下图中的红框，点击最下方的横条，就可以打开当前在 mac 上浏览的网页，不过奇怪的是我在 mac 上是使用 Chrome 浏览的，在 iphone 上却是用 Safari 打开。

通用剪贴板

只要你在设备上开启了 Handoff（开启方式看参考文档中的链接），那么通用剪贴板功能自动就开启了，这个功能我觉的是非常有用的，借助通用剪贴板，可以在一台 Apple 设备上拷贝文本、图像、照片和视频等内容，然后在另一台 Apple 设备上粘贴该内容。

原来我要发送链接的时候都是通过微信上的文件传输助手，但其实只要 mac 和 iphone 上的接力功能都开启（也可以是其他 apple 设备，比如 ipad 和 touch），然后两台设备都打开蓝牙，在同一个 wifi 下，我们就能够像在同一个设备上一样使用剪贴板，比如我在 iphone 的浏览器里面复制了一个网页的链接，或者在微信里面复制了一段话，这时候我在 mac 上直接使用 ⌘ + v 就会粘贴上我们在 iphone 上复制的内容。而且这个内容不限于文本，图片和其他类型的文件都可以，不过经过我的测试，照片里的图片复制后是不能粘贴的，必须是在 文件 应用中复制的文件才能够直接粘贴，不管是图片或者音频。

用 mac 接听和拨打电话

这个功能我一直都在使用，具体的使用条件查阅在 Mac、iPad 或 iPod touch 上拨打和接听电话。

利用 mac 收发短信的方式也和电话类似。智能热点的使用方法也类似。

连续互通相机

在 mac 上可以直接开启 iphone 或者 ipad 的相机，并且直接将拍摄的照片传到指定的位置或应用，也可以用相机扫描文稿，然后传递到指定的位置或应用。

使用方法就是在指定的应用需要插入图片或扫描文稿的地方右键，然后选择 import from iphone，然后选择 take photo 或者 scan documents，在一些第三方应用（比如 outlook）没有 import from iphone 而是菜单栏直接显示 take photo 和 scan documents 选项，选中之后会打开 iphone 或 ipad 上的相机，然后拍摄或者扫描，最后保存即可。apple 自带应用支持连续互通相机的有：

访达
Keynote 讲演 8.2 或更高版本
邮件
信息
备忘录
Numbers 表格 5.2 或更高版本
Pages 文稿 7.2 或更高版本
文本编辑

第三方应用是否支持可以实际进行测试。

速绘和标记

借助速绘连续互通和标记连续互通功能，您可以使用 iPad、iPhone 或 iPod touch 将速绘轻松插入 Mac 文稿中，或在 Mac 上对 PDF 和图像进行实时标记。

在支持的应用中右键选择 import from iphone，然后选择 add sketch 就会在你的 iphone 或者 ipad 上打开速绘页面，绘制好后点击完成，这个速绘的内容就会添加到 mac 上对应的应用中。

借助标记连续互通，还可以使用 Mac 请求从 iPad、iPhone 或 iPod touch 来标记文稿。在设备上添加标记时，您会在 Mac 上实时看到这一过程。这是签署文稿、改考卷或圈出重要详情的绝佳方式。

使用方法就是找到要标记的图片或 pdf，然后按下空格键以打开预览窗口。点按窗口顶部的标记按钮。然后从预览窗口顶部的标记工具栏中，点按注解按钮。此时iphone 或 ipad 上将打开标记窗口。然后我们就可以利用 Apple Pencil 或手指与速绘工具搭配使用，或点按加号并使用标记工具添加文本、签名、放大镜或形状和箭头。

隔空投送 Airdrop

在 mac 上有一个 airdrop 文件夹，在 iphone 的文件共享选项中第一个就是 airdrop 的图标，当我们的设备靠近时就能够在 airdrop 中发现其他设备从而进行文件的互传。

在 iPhone 和电脑之间传输文件

Catalina 已经取消了 itunes，现在 iphone 直接显示在 finder 测侧边栏中，我们要在电脑和 iphone 间传输文件，可以选择用 usb连接，也可以选择通过无线局域网同步，后者显然更方便，只要在 finder 的 iphone 中钩上如下选项即可。然后我们就可以在上方的 file 选项中进行文件的传输。

参考文章

Shell脚本语法

Fri, 01 Nov 2019 12:00:00 GMT

前言

Shell 是一个用 C 语言编写的程序，一般是一个命令行界面，是 UNIX 操作系统下传统的用户和计算机的交互界面。之所以称为 Shell，即壳，是和内核相对应，因为它隐藏了操作系统底层的细节，用户通过这个界面访问操作系统内核的服务，Ken Thompson 的 sh 是第一种 Unix Shell，Windows Explorer 是一个典型的图形界面 Shell。Shell 既是一种命令语言，又是一种程序设计语言。Shell 编程跟 JavaScript、php 编程一样，只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。常见的 Shell 程序有：

Bourne Shell（/usr/bin/sh或/bin/sh）
Bourne Again Shell（/bin/bash）
C Shell（/usr/bin/csh）
K Shell（/usr/bin/ksh）
Shell for Root（/sbin/sh）

等，其中 bash 是大部分 Linux 系统默认的 Shell。本文整理一下 linux 下常用的的 shell 命令，方便查询。在一般情况下，人们并不区分 Bourne Shell 和 Bourne Again Shell，所以，像 #!/bin/sh，它同样也可以改为 #!/bin/bash。

注意 Shell Script 都是在一个子 Shell 中运行，所以如果像执行 cd 这样的命令会发现不生效，因为在子 Shell 中完成后又退出了，像这样的命令应该用 alias 或者函数

shell 中的一些操作符和规则

首行 `#!/bin/bash`

Shell 脚本的第一行 #! 告诉系统其后路径所指定的程序即是解释此脚本文件的 Shell 程序。Shell 脚本的后缀名并不影响其执行，不过一般是使用 sh，以免引起误解。

执行脚本的方法

运行 Shell 脚本有两种方式。 1. 作为解释器参数：直接调用对应的 Shell 解释并执行脚本，比如 sh test.sh，/bin/sh test.sh，用这种执行方法在脚本的第一行就不用指定 Shell 程序了，指定也会被忽略。 2. 作为可执行程序：需要先给对应的脚本文件添加执行权限 chmod +x ./test.sh，然后直接执行 ./test.sh。需要注意的是，不能够直接用 test.sh，必须加上 ./，因为如果直接用 test.sh 的话系统会去 PATH 里寻找有没有叫 test.sh，加上 ./ 就是告诉 Shell 在当前目录下找。

shell 中的变量

变量名和等号之间不能有空格，命名只能使用英文字母，数字和下划线，首个字符不能以数字开头。中间不能有空格，不能使用标点符号，不能使用bash里的关键字。使用一个定义过的变量，只要在变量名前面加美元符号即可，变量名外面的花括号是可选的，加不加都行，加花括号是为了帮助解释器识别变量的边界。

运行 shell 时，会同时存在三种变量： 1. 局部变量局部变量在脚本或命令中定义，仅在当前 shell 实例中有效，其他 shell 启动的程序不能访问局部变量。 2. 环境变量所有的程序，包括 shell 启动的程序，都能访问环境变量，有些程序需要环境变量来保证其正常运行。必要的时候 shell 脚本也可以定义环境变量。 3. shell 变量 shell 变量是由 shell 程序设置的特殊变量。shell 变量中有一部分是环境变量，有一部分是局部变量，这些变量保证了 shell 的正常运行

your_name="clloz"
echo $your_name
echo ${your_name}

for skill in Ada Coffe Action Java; do
    echo "I am good at ${skill}Script"
done

# 重新定义已定义的变量
your_name="tom"
echo $your_name
your_name="alibaba"
echo $your_name

# 用readonly命令将变量变为只读
#!/bin/bash
myUrl="http://www.clloz.com"
readonly myUrl
myUrl="http://www.clloz1992.com" #This variable is read only.

#删除变量，unset不能删除只读变量
unset variable_name

字符串

字符串是 Shell 编程中最常用最有用的数据类型(除了数字和字符串，也没啥其它类型好用了)，字符串可以用单引号，也可以用双引号，也可以不用引号。单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的，单引号必须成对出现。双引号中除了美元符号、\、反引号有特殊含义外，其余字符(如IFS、换行符、回车符等)没有特殊含义，所以双引号里面可以引用变量，并且可以转义特殊字符。

your_name="clloz"
# 使用双引号拼接
greeting="hello, "$your_name" !"
greeting_1="hello, ${your_name} !"
echo $greeting  $greeting_1 #hello, clloz ! hello, clloz !
# 使用单引号拼接
greeting_2='hello, '$your_name' !'
greeting_3='hello, ${your_name} !'
echo $greeting_2  $greeting_3 #hello, clloz ! hello ${your_name} !

# 获取字符串长度
string="abcd"
echo ${#string} #输出 4

# 提取字符串
string="clloz.com"
echo ${string:1:5}  # 输出 lloz.

数组

# 定义数组
array_name=(value0 value1 value2 value3)

array_name=(
value0
value1
value2
value3
)

# 单独定义数组分量，下标可以不连续，且下标的
array_name[0]=value0
array_name[1]=value1
array_name[n]=valuen

# 读取数组
valuen=${array_name[n]}
echo ${array_name[@]} #输出所有数组元素

# 取得数组元素的个数
length=${#array_name[@]}
# 或者
length=${#array_name[*]}
# 取得数组单个元素的长度
lengthn=${#array_name[n]}

`|`

竖线 |，在 shell 中是作为管道符的，将 | 前面命令的输出作为 | 后面的输入。

`||`

用双竖线 || 分割的多条命令，执行的时候遵循如下规则，如果前一条命令为真，则后面的命令不会执行，如果前一条命令为假，则继续执行后面的命令。比如判断文件是否存在，不存在则创建，存在就什么都不执行。

`&`

& 同时执行多条命令，不管命令是否执行成功。

`&&`

&& 可同时执行多条命令，当碰到执行错误的命令时，将不再执行后面的命令。如果一直没有错误的，则执行完毕。

`.`

一个 dot 代表当前目录，两个 dot 代表上层目录。dot 如果位于文件或目录的第一个字符，该档案就属特殊档案，用 ls 指令必须加上 -a 选项才会显示。

`~`

~代表使用者的 home 目录：cd ~；也可以直接在符号后加上某帐户的名称：cd ~user或者当成是路径的一部份。~+ 表示当前工作目录，和 pwd 相同；~- 表示上次工作目录。

`;`

在 shell 中，担任"连续指令"功能的符号就是"分号"。譬如以下的例子：cd ~/backup ; mkdir startup ;cp ~/.* startup/。

` 倒引号 backticks

倒引号中的字符串会被当做命令执行。

`[]` 方括号

常出现在流程控制中，扮演括住判断式的作用。

 if [ "$?" != 0 ] then echo "Executes error" exit 1 fi

`[[]]`

与 [] 基本上作用相同，但允许在其中直接使用 || 与&& 逻辑等符号。

`()` 指令群组

用括号将一串连续指令括起来，这种用法对 shell 来说，称为指令群组。如下面的例子:

(cd ~ ; vcgh=`pwd` ;echo $vcgh)

指令群组有一个特性，shell 会以产生 subshell 来执行这组指令。因此，在其中所定义的变数，仅作用于指令群组本身。

`(())`

这组符号的作用与 let 指令相似，用在算数运算上，是 bash 的内建功能。所以，在执行效率上会比使用 let 指令要好许多。

美元符号

$0  表示shell的命令本身，包括完整路径，$0 是脚本本身的名字
$1 - $9 表示shell 的第几个参数
$# 表示传递到脚本的参数个数
$* 表示以一个单字符串显示所有向脚本传递的参数
双$ 表示脚本运行的ID号
$! 表示后台运行的最后一个进程的ID号
$@ 与$*相同。
$- 显示shell使用的当前选项。
$? 显示最后命令的执行状况。0表示没有错误。

文件描述符

在 Linux 系统中一切皆可以看成是文件，文件又可分为：普通文件、目录文件、链接文件和设备文件。文件描述符（file descriptor）是内核为了高效管理已被打开的文件所创建的索引，其是一个非负整数（通常是小整数），用于指代被打开的文件，所有执行 I/O 操作的系统调用都通过文件描述符。程序刚刚启动的时候，0 是标准输入 stdin，1是标准输出 stdout，2是标准错误 stderr。如果此时去打开一个新的文件，它的文件描述符会是 3。POSIX 标准要求每次打开文件时（含 socket）必须使用当前进程中最小可用的文件描述符号码。

重定向 `<` `>`

大多数 UNIX 系统命令从你的终端接受输入并将所产生的输出发送回到终端。一个命令通常从一个叫标准输入的地方读取输入，默认情况下，这恰好是你的终端。同样，一个命令通常将其输出写入到标准输出，默认情况下，这也是你的终端。

command > file：将输出重定向到 file。
command < file：将输入重定向到 file。
command >> file：将输出以追加的方式重定向到 file。
n > file：将文件描述符为 n 的文件重定向到 file。
n >> file 将文件描述符为 n 的文件以追加的方式重定向到 file。
n >& m 将输出文件 m 和 n 合并。
n <& m 将输入文件 m 和 n 合并。
<< tag 将开始标记 tag 和结束标记 tag 之间的内容作为输入。

在输出重定向中，> 代表的是覆盖，>> 代表的是追加。

# 实例
command >file #以覆盖的方式，把 command 的正确输出结果输出到 file 文件中。
command >>file #以追加的方式，把 command 的正确输出结果输出到 file 文件中。
command 2>file #以覆盖的方式，把 command 的错误信息输出到 file 文件中。
command 2>>file #以追加的方式，把 command 的错误信息输出到 file 文件中。
command >file 2>&1 #以覆盖的方式，把正确输出和错误信息同时保存到同一个文件（file）中。
command >>file 2>&1 #以追加的方式，把正确输出和错误信息同时保存到同一个文件（file）中。
command >file1 2>file2 #以覆盖的方式，把正确的输出结果输出到 file1 文件中，把错误信息输出到 file2 文件中。
command >>file1  2>>file2 #以追加的方式，把正确的输出结果输出到 file1 文件中，把错误信息输出到 file2 文件中。
command <file #将 file 文件中的内容作为 command 的输入。
command <<END #从标准输入（键盘）中读取数据，直到遇见分界符 END 才停止（分界符可以是任意的字符串，用户自己定义）。
command <file1 >file2 #将 file1 作为 command 的输入，并将 command 的处理结果输出到 file2。

关于 shell 中的单引号和双引号的用法请看我的另一篇文章shell中的引号和转义

常用命令

在 Linux 中，可执行的文件也进行了分类：

内置命令：出于效率的考虑，将一些常用命令的解释程序构造在 Shell 内部。外置命令：存放在 /bin、/sbin 目录下的命令实用程序：存放在 /usr/bin、/usr/sbin、/usr/share、/usr/local/bin 等目录下的实用程序用户程序：用户程序经过编译生成可执行文件后，可作为 Shell 命令运行 Shell 脚本：由 Shell 语言编写的批处理文件，可作为 Shell 命令运行

关于 Linux 常用命令已经在另一篇文章Linux常用命令中进行了详细的介绍。

参考文章

Mac自带拼音输入法的使用技巧

Thu, 31 Oct 2019 12:00:00 GMT

前言

自从大学毕业以后我几乎就没有用过 360，baidu 以及 sougo 等国内的软件了，一方面是安全考虑，另一方面是越来越喜欢简单，直接，没有花里胡哨的功能和广告的应用，这也是我为什么后来转向 Mac，不管是硬件还是软件系统，都很简单，直接，虽然 Mac 也又很多这样那样的问题，不过总的来说设计理念跟我的想法还是比较契合的。说会主题输入法，我在 Windows 和 Mac 上都用的是自带的输入法，其实现在无论是 Windows 和 Mac 默认的一些软件，包括输入法和杀毒软件都已经做的非常好了，完全没必要另外安装第三方的，特别是我这种追求极致的简单的，功能一目了然的。但是其实 Mac 上的默认拼音输入法还是又很多小技巧，可能是大家不知道的，这篇文章整理一下 Mac 上的输入法使用技巧。

也曾经试过 Rime 输入法，在 Mac 上的版本是叫做鼠须管，严格来说它是一个输入引擎，几乎所有东西都可以自己定制的，但是使用起来过于麻烦了，想要真的制定到自己非常满意成本太高了，不过源码可以学习一下。另外也想过学五笔，五笔其实本身我到觉得很不错，不过我发现五笔输入的词库是一个很大的问题，比如我想输入 长泽雅美，新垣结衣，基本都是没有的，如果完全单字输入跟我的思维习惯是不符合的，所以也放弃了。

使用技巧

拼音转大写

Mac 上的拼音输入法是用大写锁定 CapsLock 键来切换中英文的，这和我们通常在 Windows 中使用 Shift 键不同，不过很多人不知道如何在拼音状态下切换到大写锁定的状态。

在 System Preferences -> Keyboard -> Input Sources 中勾选下面的第二项，如下图。现在在拼音输入状态下，长按 CapsLock 键就是切换到大写英文，短按就是切换到小写英文。在这里另外给大家推荐一个软件 CapsLocker，这个软件在大写锁定切换的时候会发出声音，对我这种使用蓝牙键盘且看不到大写锁定状态的还是很有用的。

不同应用不同输入法

在上图中的第三个复选框就是不同的应用不同的输入法的功能，钩上即开启。这个功能刚开始用可能有点反直觉，至少我觉得输入法不全局有时候会造成混乱，但是如果习惯了还是挺有用的。比如我们写程序或者在终端一般都是英文状态，但是当我们切换到聊天软件或者浏览器的时候可能需要输入中文，这样在频繁切换的时候就会很麻烦，这时候钩上不同的应用自动切换输入法就会比较方便，不过这个需要适应一段时间。

选择文字注音

我们可以在输拼音的时候按 tab 会在四声之间切换，比如 tān，tán，tǎn，tàn，有时候这个功能还是有用的，能够帮我们快速找到目标字。

显示生僻字和繁体字

在使用 Mac 默认的拼音输入法的时候，有时候会发现有些字找不到，或者发现一个读音的字非常少，可能是你没有钩上下图中的 show traditional and rare characters。

中英文数字混输

在输入拼音的状态下，按住 Shift 就能输大写字母，按住 Option 则能输数字。

拆字输入

当遇到我们不知道一个字的读音的时候，可以通过拆字来输入这几个字的部分来输入这个字。这个功能在 Windows 和 搜狗 输入法中是按 u 然后输入，在 Mac 中是先输入单独部分然后使用快捷键 Shift+空格键，比如输入 jiji 然后按 Shift+空格键，就能输入 喆。

查找输入码

通过快捷键 Option+Shift+L 可以打开查找输入码的界面，然后复制字到里面就可以查看各种输入法中的输入码，在遇到不认识的字，或者想要查看五笔的输入码的时候都可以使用。

使用手写和虚拟键盘

快捷键 Control+Shift+空格键 可以打开手写界面，点击上方任务栏中的输入法图标点击 show keyboard viewer 可以打开虚拟键盘。

emoji 以及特殊符号

Command+Control+空格键 可以打开 emoji 界面，点击右上角的图标可以选择更多图标。Option+Shift+B 也可以选择一些特殊符号以及颜文字。

自定义文本

在 System Preferences -> Keyboard -> Text 中我们可以自定义一些我们常用的短语或一些很生僻的字，甚至可以是一些我们常用的颜文字，自定义对应的输入码，这样我们就能够快速地输入这些内容。

任务栏图标

最后说一个和输入法不相关的 Mac 使用技巧，就是按住 ⌘ 拖动顶部任务栏的图标能够排列任务栏图标的顺序，并且下次打开应用还是按这个顺序排列的。

参考文章

Mac 自带输入法这么好用，不看不知道

英语国际音标

Thu, 24 Oct 2019 12:00:00 GMT

前言

英语一直是我学生生涯最差的一门学科，我的学生时代好像是从六年级开始学的英文，不过几乎是上着玩的，也不用考试。我正式学习英语是从初中开始，我上学那会儿，书上的单词还是有有音标的，不过我印象中老师并没有教过，很多比较有兴趣或有上进心的同学都自己学音标。我以前英语很差，导致自己对英语也非常没兴趣，几乎学生生涯的英语老师对我的印象都很差，我自然也没有自学过音标，单词的读音都是模仿，很多读的都不对，看到一个陌生的单词也完全不知道该怎么发音，有些单词知道发音也不知道该怎么拼，我也没在意过。自从学了日语以后，我开始注重发音，因为很多读音你不开口根本不知道自己读的完全变形，甚至有些音因为是我们的母语中是没有的，根本发不出来。

我现在学习语言并不是为了考试，开口说并能够灵活运用是我的最主要的目标。其实母语者一般不学习音标，因为一直在母语的环境里耳濡目染，自然而然就对发音养成了习惯。但是当你想学习另一门语言的时候，音标还是很重要的，因为不同的语言发音是不同的，可能你要学的语言里面有些音是你的母语里没有的，这时候音标就很有用，能够让你准确的知道某个音应该怎么发，国际音标就相当于给全世界不同的民族不同的语言制定了一套通用的标准，能够套用到各种语言的发音上。

KK 音标、DJ 音标和 IPA

比较流行的音标有三种，KK 音标，DJ 音标和 IPA ，其中 KK 音标是主要在台湾地区流行的美式英语的音标，而大陆和香港地区主要使用的是英式英语的 DJ 音标，我印象中我们上学的时候课本上的音标都是 DJ 音标。下图展示了三种音标对之间的关系。

维基百科图中的几个问题，DJ 音标中的 [ɔ] 应该为 [ɒ] 才对。[ɑ] [ɑː] 那行举的例子似乎不太对，hot 的英音音标为 [hɒt]，美音音标为 [hɑt]，用 father 来做例子更好。最后漏了DJ 音标中的 [eə] [ʊə] 两个双元音。

DJ 音标一共 20 个元音，24 个辅音，对比国内常说的 48 个国际音标，少了 [dr] [dz] [tr] [ts] 这几个辅音，原因是一些语音学者认为它们不是独立的音素，而是辅音连缀。KK 音标一共 17 个元音，24 个辅音。两者的辅音是相同的，但是元音有一些不同，我感觉区分起来还是挺有难度的，主要有很多长得很像的。比如 [ɛ] 和 [ɜː]，[e] 两者都有但是表达不同的音，[ɑ]，[ɑː]和 [ɒ]。总结起来，两者的元音共有一下这些不同，[i:] vs [i]，[ɑ:] vs [ɑ]、[ɔ:] vs [ɔ]，[u:] vs [u]，[e] vs [ɛ]，[ɒ] vs [ɔ]，[eɪ] vs [e]，[əʊ] vs [o]，[ɜː] vs [ɝ] 和[ə] vs [ɚ]，最后还有 DJ 音标中的三个双元音 [ɪə]，[eə] 和 [ʊə] 在 KK 音标中没有，其实它们可以用辅音表示为 [ir]，[ɛr] 和 [ur]，具体例子分别为 near，care 和 tour。

KK 和 DJ 的主要几个区别： 1. [e] vs [ɛ] 和 [eɪ] vs [e] 表示的是同一个音，很容易混淆，比如 [bet] 这个音标在两种音标表示下是完全不同的意思。 2. KK 音标中没有长音符号，[i:] vs [i]、[ɑ:] vs [ɑ]、[ɔ:] vs [ɔ]、[u:] vs [u]。 3. [eɪ] vs [e] 和 [əʊ] vs [o]，DJ音标认为这2个音标是双元音, 而KK音标认为这2个音标是单元音。因为在美式发音中, 很多人的确是把这2个音按照单元音来发的。 4. [ɔ:] vs [ɔ] 和 [ɒ] vs [ɔ]，DJ 音标中的 2 个音标到了 KK 音标变成了 1 个音标，但其实部分 [ɒ] 到 KK 音标里面实际发音是 [ɑ]，比如 hot 这个单词。 5. [ɜː] vs [ɝ] 和 [ə] vs [ɚ]，KK 音标给这 2 个音标符号后边加上了小尾巴表示卷舌。在英音中一般比较少涉及卷舌，如果要用来标注美式发音, 则会写作 [ɜːr] 和 [ər] 来表示卷舌。实际上, 现在一些词典已经不对这两个音区分了, 不论是 [ɝ] 还是 [ɚ], 都统一写作 [ər]。

需要注意的是 KK 音标和 DJ 音标都是根据 IPA 所编的音标符号，本质上发音是同一个东西，只是使用的符号不同，一个主要用于标注英式发音，一个主要用于标注美式发音。并且我们在英语中使用的 48 个音标只是 IPA 中的一部分，一般也称为英语国际音标。

如果想听并跟读标准的英式和美式音标可以看下面两个视频： 1. 英式音标发音和口型：BBC音标教程 2. 美式音标和口型：KK美式英语音标发音口型教学

英式英语中的翘舌音非常少，在发音中最让我迷惑的是 [r]，在美式英语中位于句首类似于 若，句尾就是翘舌，但是在英式英语中就比较微妙。具体大家可以看上面的两个视频体会。

音标发音（ DJ 标注）

软件

在这里推荐两个在手机上的发音软件，一个是 IPA Phonetics，另一个是英语标准国际音标，前一个完全根据 IPA 来的，有发音的口腔视频，虽然看着有点恶心，不过还是挺有用的。不过对于我们这样的初学者，第二个软件我认为更好用，每个音都有很多例子，讲解也挺详细

元音

元音包含 12 个单元音与 8 个双元音，其中单元音又包含 5 个长元音与 7 个短元音。

长元音：[ɑː] [ɔː] [ɜː] [iː] [uː]。这样的排列顺序是可以和我们的拼音韵母 ɑ o e i u 对应起来
短元音：[ʌ] [ɒ] [ə] [ɪ] [ʊ] [æ] [e]
双元音：[eɪ] [aɪ] [ɔɪ] [eə] [ʊə] [ɪə] [aʊ] [əʊ]

汉语拼音中的单韵母没有长短音之分，英语中的单元音又分长元音和短元音。双元音由两个元音组成，发音时由前一个元音向后一个元音滑动，口型有变化。前一个元音发音清晰响亮，且时间长；后一个元音发音模糊较弱，且时间短。

辅音

清辅音：[p] [t] [k] [f] [θ] [s] [ʃ] [tʃ] [ts] [tr] [h]
浊辅音：[b] [d] [ɡ] [v] [ð] [z] [ʒ] [dʒ] [dz] [dr] [r] [m] [n] [ŋ] [l] [w] [j]

其中前面九个清辅音和浊辅音是一一对应的，清辅音声带不震动，浊辅音声带震动。

大部分辅音还是比较容易发音的，我认为有几个点需要注意： 1. [m] [n] [ŋ] 的发音区别 2. [r] [m] [n] [l] 这几个音在词中的不同位置发音有所不同，当这几个音位于元音前面的时候需要带动后面的元音，就会感觉多出一个 [ə]，比如 [r] 就发音类似 若。当这几个音位于元音后面时，就发他们本来的音，具体可以听上面的视频中的标准发音。

音节与重音

音节是读音的基本单位，任何单词的读音，都是分解为一个个音节来朗读。在英语中元音发音特别响亮，是构成音节的主要音，一个元音可构成一个音节，一个元音和一个或几个辅音结合也可以构成一个音节。通常情况下，一个单词中有几个元音就有几个音节（看音标而不是看字母）。汉语拼音中的声母和韵母拼在一起构成一个汉字，英语中的辅音就相当于声母，元音相当于韵母，因此，英语单词中元音前的辅音要给该元音当头，划在一起，构成一个音节。划分音节时，先从最后一个元音开始，其前的辅音要划给该元音当头，依次向前按此划分。

如： ru-ler['ru: lə] 尺子(最后一个元音是[ə]，其前的辅音l要给该元音当头，构成一个音节 [lə] ；依次向前的元音是 [u:]，其前的辅音 [r] 要给该元音当头，构成一个音节 [ru:]，两个音节合起来读作 ['ru: lə]), e-le-phant ['e lɪ fənt] 大象(最后一个元音是 [ə]，其前的辅音 [f] 要给该元音当头，构成一个音节 [fənt]；依次向前的元音是 [ɪ]，其前的辅音 [l] 要给该元音当头，构成一个音节 [lɪ]，最前面的元音 [e] 单独构成一个音节，三个音节合起来读作 ['e lɪ fənt]）

关于重读音节的规律可以看这篇文章：重读音节规律

拼读

看到陌生的单词如何把音标写出来并读出来，以及如何根据音标拼出单词可以看这个在网上流传很广的视频：周育如音标教学，里面的规律总结的很不错，不过教学用的是 KK 音标。拼读的主要规律就是把字母和音标对应起来，辅音对应的字母一般变化较少，可以直接标注，元音则根据不同的情况来分辨，最后在记住一些特殊的固定组合。这几种规律基本可以应对大多数单词，剩下的一些不在这些规律中的单词则需要单独记忆。规律总结如下表（用 KK 音标标注）：

| 字母 | 音标 | 字母 | 音标 | 字母 | 音标 | 字母 | 音标 | | ---- | ---------------- | ---- | ------ | ---- | ------------------ | ---- | ------ | | a | [e][æ] [ə] | b | [b] | c | [k][s] | d | [d] | | e | [i][ɛ] [ə][ɪ] | f | [f] | g | [g] | h | [h] | | i | [ai][ɪ] [ə][ɪ] | j | [dʒ] | k | [k] | l | [l] | | m | [m] | n | [n] | o | [o][ɑ][ɔ][ʌ] [ə] | p | [p] | | q | [kw] | r | [r] | s | [s][z] | t | [t] | | u | [ju][ʌ] [ə][ʊ] | v | [v] | w | [w] | x | [ks] | | y | [j][ɪ] | z | z | ar | [ɑr] | er | [ɝ] |

当元音字母 a e i o u 位于重读音节的时候，最常发的音是 [æ] [ɛ] [I] [ɑ] [ʌ]，其次是跟它们本身的读音一样的 [e] [i] [ai] [o] [ju]，字母 o 还有其他两种变化 [ɔ][ʌ]。当它们不位于重读音节的时候，绝大多数情况五个字母都发 [ə]，另外的情况就是 e 和 i 发 [ɪ]，u 发 [ʊ]。当然元音变化非常多，这里只是一些常见的规律，还有很多的特殊情况需要单独记忆。

特殊规则： 1. 当字母 e 位于单词末尾不发音，则单词中其他元音字母发它们本身的读音，比如 name 发音 [nem]，ride 发音 [raid]，came 发音 [kem]，take 发音 [tek]。 2. er ir or ur 位于重读音节时，发音 [ɝ] ，比如 bird work her，不是重读音节且在字尾发 [ɚ]，比如 worker [wɝkɚ] doctor Mister（现在很多字典直接将[ɝ] 和 [ɚ] 统一写作 [ər]）。位于重读音节时，ar 可能发作 [ɑr]，or 可能发作 [or] [ɔr]。 3. oo 常常发音 [ʊ][u]. 4. au ou aw ow 常常发音 [au]，比如 house hour how。 5. th 通常发音 [θ][ð]，ch 通常发音 [tʃ]，sh 通常发音 [ʃ]，ph 通常发 [f]，ng 在通常发 [ŋ][ŋg]，nk 通常发 [ŋk]。

这里只是一些简单的规则，其实要搞清楚各种拼读规则这些远远不够，而且规则只是辅助，最好还是通过多练习单词的拼读然后查看音标来熟悉拼读规则，练多了自然能够掌握。这里还有一个比较详细的拼读规则总结：OneDrive分享链接 - 密码9527

总结

音标的规律总结如上，剩下的就是不断地练习，融会贯通了，一方面是单词的拼读，另一方面就是发音的练习。

参考文章

Linux和Mac系统目录结构

Tue, 08 Oct 2019 12:00:00 GMT

前言

介绍一下 Linux 系统的目录结构，MacOS 的目录结构也类似。

目录结构

/bin：bin 是 Binary 的缩写, 这个目录存放着最经常使用的命令。

/boot：这里存放的是启动 Linux 时使用的一些核心文件，包括一些连接文件以及镜像文件。

/dev ：dev 是 Device (设备)的缩写, 该目录下存放的是 Linux 的外部设备，在 Linux 中访问设备的方式和访问文件的方式是相同的。

/etc：这个目录用来存放所有的系统管理所需要的配置文件和子目录。

/home：用户的主目录，在 Linux 中，每个用户都有一个自己的目录，一般该目录名是以用户的账号命名的。

/lib：这个目录里存放着系统最基本的动态连接共享库，其作用类似于 Windows 里的 DLL 文件。几乎所有的应用程序都需要用到这些共享库。

/lost+found ：这个目录一般情况下是空的，当系统非法关机后，这里就存放了一些文件。

/media：linux系统会自动识别一些设备，例如 U 盘、光驱等等，当识别后，linux 会把识别的设备挂载到这个目录下。

/mnt：系统提供该目录是为了让用户临时挂载别的文件系统的，我们可以将光驱挂载在 /mnt/ 上，然后进入该目录就可以查看光驱里的内容了。

/opt：这是给主机额外安装软件所摆放的目录。比如你安装一个 ORACLE 数据库则就可以放到这个目录下。默认是空的。

/proc：这个目录是一个虚拟的目录，它是系统内存的映射，我们可以通过直接访问这个目录来获取系统信息。这个目录的内容不在硬盘上而是在内存里，我们也可以直接修改里面的某些文件，比如可以通过下面的命令来屏蔽主机的 ping 命令，使别人无法 ping 你的机器：echo 1 >/proc/sys/net/ipv4/icmp_echo_ignore_all

/root ：该目录为系统管理员，也称作超级权限者的用户主目录。

/sbin：s 就是 Super User 的意思，这里存放的是系统管理员使用的系统管理程序。

/selinux：这个目录是 Redhat/CentOS 所特有的目录，Selinux 是一个安全机制，类似于windows 的防火墙，但是这套机制比较复杂，这个目录就是存放 selinux 相关的文件的。

/srv：该目录存放一些服务启动之后需要提取的数据。

/sys：这是 linux2.6 内核的一个很大的变化。该目录下安装了 2.6 内核中新出现的一个文件系统 sysfs。

sysfs 文件系统集成了下面 3 种文件系统的信息：针对进程信息的 proc 文件系统、针对设备的 devfs 文件系统以及针对伪终端的 devpts 文件系统。该文件系统是内核设备树的一个直观反映。

当一个内核对象被创建的时候，对应的文件和目录也在内核对象子系统中被创建。

/tmp：这个目录是用来存放一些临时文件的。

/usr：这是一个非常重要的目录，用户的很多应用程序和文件都放在这个目录下，类似于 windows 下的 program files 目录。

/usr/bin：系统用户使用的应用程序。

/usr/sbin：超级用户使用的比较高级的管理程序和系统守护程序。

/usr/src：内核源代码默认的放置目录。

/var：这个目录中存放着在不断扩充着的东西，我们习惯将那些经常被修改的目录放在这个目录下。包括各种日志文件。

/run：是一个临时文件系统，存储系统启动以来的信息。当系统重启时，这个目录下的文件应该被删掉或清除。如果你的系统上有 /var/run 目录，应该让它指向 run。

Mac 文件系统结构

查看 Mac 的文件系统结构很简单，在终端输入 man hier 查看即可。

     /             #root directory of the filesystem

     /bin/        # user utilities fundamental to both single-user and multi-user environments

     /dev/         #block and character device files

                   fd/  #file descriptor files; see fd(4)

     /etc/         #system configuration files and scripts

     /mach_kernel  #kernel executable (the operating system loaded into memory at boot time).

     /sbin/        #system programs and administration utilities fundamental to both single-user and multi-user environments

     /tmp/         #temporary files

     /usr/         #contains the majority of user utilities and applications

                   bin/     # common utilities, programming tools, and applications
                   include/  #standard C include files

                             arpa/       #C include files for Internet service protocols
                             hfs/        #C include files for HFS
                             machine/    #machine specific C include files
                             net/        #misc network C include files
                             netinet/   # C include files for Internet standard protocols; see inet(4)
                             nfs/        #C include files for NFS (Network File System)
                             objc/       #C include files for Objective-C
                             protocols/  #C include files for Berkeley service protocols
                             sys/        #system C include files (kernel data structures)
                             ufs/        #C include files for UFS

                   lib/      #archive libraries
                   libexec/  #system daemons & system utilities (executed by other programs)
                   local/   #executables, libraries, etc. not included by the basic operating system
                   sbin/     #system daemons & system utilities (executed by users)
                   share/    #architecture-independent data files

如果要从终端进入 U 盘或者移动硬盘的存储设备，可以进入 /volumes 目录。

总结

以上就是 Liunx 和 Mac 文件系统的目录结构。

日语送气音和不送气音

Sun, 06 Oct 2019 12:00:00 GMT

前言

在刚接触日语的时候都会遇到一个疑问，而且一般教科书上都没有给出这个问题的答案，就是不送气音和送气音的问题，比如 わたし 我们在听录音的时候感觉日本人好像都说的是 わだし，在比如说 ですか，录音里面好像说的 ですが，很让人摸不着头脑，教材或者老师也很少解答这个问题，我是在初学日语的时候对这点很疑惑，带着不了解的问题学习感觉就很难受，但是一直都没找到合理的解释，现在学日语也有好一段时间了，结合自己的练习和一些资料总算有了一些了解。

送气音和不送气音

先说一说常用的几个词语的意思： 1. 清音：发音时声带不震动的音 2. 浊音：发音时声带震动的音 3. 元音：发音过程中由气流通过口腔而不受阻碍发出的音 4. 辅音：发音时气流在口腔或咽头受到阻碍而形成的音 5. 送气音：发音时呼出的气流较强的塞音或者塞擦音 6. 不送气音：发音时气流呼出较弱的音其中清音和浊音相对，元音和辅音相对，送气音和不送气音相对。

先要说明的是送气音和不送气音在日语里面是对意思的表达没有影响的，所以如果是初学者，即使不会发不送气音也没关系，就直接按照假名读就行了，不要为了发不送气音而把清音发成浊音。

在中文里面，清音有 b，p，d，t，g，k，z，c，zh，ch，j，q，其中送气音有 p，t，k，c，chi，q，剩下的都是不送气音，在中文里面我们的送气不送气是区分意思的，但是在我们的中文里面浊音非常少，汉语普通话的 22 个辅音中共有 5 个浊音，其中鼻音三个：n、m、ng，边音一个：l，擦音（也是翘舌音）一个：r。

普通话中p[pʰ]和 b[p] 均为清音，其分别在于送气与不送气，是两个音位。由于普通话中 b[p]、 d[t]、g[k]实为清音却标作浊音字母，使得中国大部分学习有浊音和不送气清音的外语（如法语、日语等）时时常把不送气清音跟浊音混淆，因为在普通话中的 b[p]、p[pʰ] 等都是一个音，就是清辅音。

因为上面的这些原因，我们汉语母语者在学习日语的时候很难区分不送气清音和浊音的区别，因为在我们的概念里很少遇到浊音，都是送气和不送气，所以我们对送气和不送气十分敏感，对清浊不敏感。日语母语者和我们相反，他们很难分辨送气音和不送气音，但是对声带是否震动十分敏感。比如日本人很难区分中文的 兔子跑了 和 肚子饱了，而我们则对所谓的不送气清音和浊音就有点分辨不清。

另外根据我的经验，由于日语经常出现一句话很长，所以如果一直发送气音的话，气会不够，所以因为气的关系，日语母语者在说话的时候就会有各种省气的方式，比如不送气清音。而我们也可以试一试一口气快速的念 た，到后面就会就会发成不送气的形式。这应该是在漫长的过程中自然而然地形成的语言习惯，这样念起来比较轻松，比如 仕事　しごと 这个词，按理说应该发音 shigoto，但是在听日本人说的时候经常听到他们在 ご 的前面有一个 n 的鼻音，这是他们的语言习惯，但是这样确实读起来更轻松。

最后还是那句话，由于日语区分意思是根据清浊，而不是送气不送气，所以我们在初学的时候尽量还是按照假名的正确发音读，不要刻意把清音发成浊音，至于地道的感觉我们可以在后面熟练了以后在慢慢地模仿锻炼，其实都是水到渠成的。

送气音的一些规律

一、音读音变规则： 1. 当两个送气音相遇时，就会将前一个送气音变为“っ”

 学（がく）＋　校（こう）→　学校（がっこう）
 日（にち）＋　記（き）　→　日記（にっき）
 一（いち）＋　冊（さつ）→　一冊（いっさつ）
 察（さつ）＋　する　　　→　察する(さっする)

前一个送气音变“っ”后，后一个送气音如为は行则变为半浊音。

 失（しつ）＋　敗（はい）→　失敗（しっぱい）
 一（いち）＋　匹（ひき）→　一匹（いっぴき）
 烈（れつ）＋　風（ふう）→　烈風（れっぷう）
 鉄（てつ）＋　片（へん）→　鉄片（てっぺん）
 一（いち）＋　本（ほん）→　一本（いっぽん）

前一个汉字以ん结尾，后一汉字发音的第一假名若是は行开头的变为ぱ行,也有少数变成ば行的。

 先（せん）＋　輩（はい）→先輩（せんぱい）
 心（しん）＋　配（はい）→　心配（しんぱい）
 神（しん）＋　秘（ひ）　→　神秘（しんぴ）
 何（なん）＋　分（ふん）→　何分（なんぷん）
 南（なん）＋　北（ほく）→　南北（なんぼく）

二、训读汉字发音规则 1. か、さ、た、は即送气音开头的单词，接在其他词后构成复合词时，发生浊音化。

 物（もの）　＋　語り（かたり）→　物語（ものがたり）
 鼻（はな）　＋　血（ち）　　　→　鼻血（はなぢ）
 足（あし）　＋　取り（とり　）→　足取り（あしどり）
 昔（むかし）＋　話（はなし）　→　昔話（むかしばなし）
 人（ひと）　＋　人（ひと）　　→　人々（ひとびと）

三、例外的情况： 1. 但本身含浊音的训读词，不发生连浊。 紙屑（かみくず）大風（おおかぜ） 2. 动词与动词或动词与宾语的复合不发生连浊。 読み書き（よみかき）飯炊き（めしたき） 3. 前一个汉字最后一个假名在え段的，变为同一行的あ段假名。 雨（あめ）水（みず）雨水（あまみず） 稲（いね）光（ひかり）稲光（いなびかり）

总结

这篇文章是我对结合自己的经验以及一些网络上的资料整理的关于日语学习中送气音和不送气音的一些只是，如有错误，希望指正。

参考文章

阿里云OSS和CDN的配置

Thu, 03 Oct 2019 12:00:00 GMT

前言

我的网站是部署在阿里云上面的，使用差不多两年了，随着自己对于建站的知识了解的更多，以及网络和 web服务器 的更多的了解，在解决问题的过程中也遇到过不少坑。这篇文章说一下阿里云的 oss 和 cdn 的配置问题。

关于搭建个人网站

其实我搭建个人网站主要是让自己在建站的过程中了解一个网站的开发，部署过程，从实践中来学习，因为看书或者看别人的文章有很多细节是无法了解的，自己试过了才知道会遇到哪些问题，以及哪些自己不知道的知识点。就好像看别人做菜感觉很简单，真的上手发现很多东西其实并不像表面那样简单，有很多细节别人得心应手没有讲，但是你并不知道，甚至连切菜都不同的菜不同的切法。同时自己搭建个人网站也能把自己的一些学习笔记记录下来，和别人分享，把自己对于网站的一些想法付诸实践，也是挺有趣的。

虽然可能个人网站的访问量不会很大，不过能用上的东西还是尽量用上，比如 cdn，https，比如对象存储，虽然对于我们的这种没什么人访问的网站可能并没有什么本质的区别，但是在使用的过程中我们会去了解这些内容，能学到很多。

CDN

cdn 其实说简单点就是我们网站的资源存储在一台服务器上，不论哪个用户从什么地方发起请求最后都要到我们的服务器去取对应的资源，这样可能会造成拥堵和延迟，为了解决这个问题才有 Content Delivery Network 内容分发网络，将源站内容分发至最接近用户的节点，使用户可就近取得所需内容，提高用户访问的响应速度和成功率。解决因分布、带宽、服务器性能带来的访问延迟问题，适用于站点加速、点播、直播等场景。

最简单的CDN网络由一个DNS服务器和几台缓存服务器组成： 1. 当用户点击网站页面上的内容URL，经过本地DNS系统解析，DNS系统会最终将域名的解析权交给CNAME指向的CDN专用DNS服务器。 2. CDN的DNS服务器将CDN的全局负载均衡设备IP地址返回用户。 3. 用户向CDN的全局负载均衡设备发起内容URL访问请求。 4. CDN全局负载均衡设备根据用户IP地址，以及用户请求的内容URL，选择一台用户所属区域的区域负载均衡设备，告诉用户向这台设备发起请求。 5. 区域负载均衡设备会为用户选择一台合适的缓存服务器提供服务，选择的依据包括：根据用户IP地址，判断哪一台服务器距用户最近；根据用户所请求的URL中携带的内容名称，判断哪一台服务器上有用户所需内容；查询各个服务器当前的负载情况，判断哪一台服务器尚有服务能力。基于以上这些条件的综合分析之后，区域负载均衡设备会向全局负载均衡设备返回一台缓存服务器的IP地址。 6. 全局负载均衡设备把服务器的IP地址返回给用户。 7. 用户向缓存服务器发起请求，缓存服务器响应用户请求，将用户所需内容传送到用户终端。如果这台缓存服务器上并没有用户想要的内容，而区域均衡设备依然将它分配给了用户，那么这台服务器就要向它的上一级缓存服务器请求内容，直至追溯到网站的源服务器将内容拉到本地。

以上就是 cdn 的一些基础只是，cdn 最主要的目的就是加速网站的访问。

对象存储

阿里云的 oss 就是对象存储的一种实现，对象存储是和快存储，文件存储相对应的概念，想了解对象存储的可以看知乎上的这个问题块存储、文件存储、对象存储这三者的本质差别是什么？，我一般是用来放一些网站要用的图片、视频以及其他小文件。

OSS 和 CDN 相关问题

oss 和 cdn 的配置都很简单，而且阿里云的文档也很详细，我就不介绍了，下面把我遇到的一些问题跟大家说一说。

OSS 跨域

关于跨域的问题可以看我的这篇文章：浏览器同源策略和跨域方法如果你想要在页面上有对 oss 资源的请求，或者是脚本中要请求对应资源，都会因为浏览器的同源策略而请求失败，比如我在我的服务器上就有一个文件夹专门放文章要用到的页面实例，之前做的一个音乐播放器要访问 oss 上的图片和音频文件，就报错了。我们可以在 阿里云控制台 -> 对象存储OSS -> 对应bucket -> 基础设置 -> 跨域设置 中来配置我们的对应的域名，比如我可以配置 *.clloz.com 来完成跨域访问。

网站字体跨域问题

配置了 cdn 以后，我们的页面会到 cdn 服务器去请求字体文件，此时我们的 origin 是我们的网站域名，所以访问字体文件会导致跨域，解决方法是我们在 cdn 控制台对应域名的配置中选择 缓存配置 -> http头，然后添加 Access-Control-Allow-Origin，值为 * 或者你的网站域名。需要注意的是这里是服务器请求 cdn 服务器的资源导致跨域，而不是服务器上的资源被请求跨域，所以在服务器上配置是无效的。

配置防盗链

当没有为 oss 绑定 cdn 域名的时候，我们可以直接在 oss 里面配置，不过这样的做法不好，我咨询过阿里云的工程师，他们还是建议把 oss 的 bucket 设置为私有，然后通过 cdn 来访问 bucket 中的资源。需要注意的是，当 bucket 设置为私有以后，我们通过设置白名单来访问 bucket 上的资源都是有时间限制的，所以一定要通过 cdn 访问。当我们为 bucket 配置了 cdn 以后，我们就可以通过 cdn 的域名来访问对应资源，我们打开 oss 中的文件还是能看到长长的链接后面跟着 expire 等各种参数，但其实我们只要选择自由域名，后面的参数不要管就可以了，相当于 oss 为 cdn 开辟了一个绿色通道，我们虽然访问私有的 oss 有各种限制，但是通过 cdn 我们可以直接访问，这里也体现出 cdn 的另一个有点，对网站其实有一定的保护作用，因为很多内容的访问都是访问的 cdn 服务器，请求并不会发送到真正的服务器。当 cdn 和 oss 绑定以后，对 cdn 的配置会覆盖 oss 的配置，比如 cdn 和 oss 都可以设置白名单，但是真正生效的是 cdn 的。

工单系统

最后说一下阿里云的工单系统，我用过几次，总的来说体验还是不错的，反应很及时，问题也都解决了，如果你的服务器遇到什么问题，不妨试一试。

总结

以上就是我对 cdn 和 oss 的一些理解和使用心得，希望对你有用。

参考文章

阿里云云栖社区知乎回答

静态资源的一些问题

Thu, 03 Oct 2019 12:00:00 GMT

前言

在写 cdn 和对象存储文章的时候，看到了一些跟静态资源有关的问题，这里就来做一些整理。

什么是静态资源

不根据访问的条件变化的资源就是静态资源，比如 html，js，css，webfont 等文件。

为什么很多网站的静态资源使用独立的域名

避免发送无意义的 cookie，当我们的浏览器第一次请求服务器的时候，会根据服务器响应报文中的 set-Cookie 来保存 cookie，以后再次向这个服务器发送请求的时候都会带上 cookie，所以我们即使向服务器请求静态资源，这个 cookie 也会发送，并且服务器对于这些 cookie 不会做任何处理，它们只是在毫无意义的消耗带宽。所以你应该确保对于静态内容的请求是无coockie的请求。需要注意的是子域名也会受到感染，所以要使用独立域名。
动静分离。静态资源与动态内容分离，有利于部署于CDN。
HTTP 协议对同一个域名的同时下载线程数有限制。主要是为了优化下载速度，防止同一域名下下载线程数过多，导致下载速度变慢。各个浏览器都会遵守这个规定，但是限制的数目可能不一致。基于这个原因，可将资源部署于不同的域名，以达到最大化并发下载。
静态资源独立部署，为全局产品服务。方便复用，放在一个服务器上的文件可以共其他服务器上的产品使用。比如 taobao.com 和 tmall.com 都会用到 tbcdn.cn 上的静态资源，这样同时也有利于最大化利用客户端缓存。比如访问 taobao.com，缓存了 tbcdn.cn 上的某个 js 文件，之后再访问 tmall.com 时，也用到此 js 文件，不必再从 tbcdn.cn 上下载，直接用客户端缓存即可。

静态资源加速方法

Web静态资源缓存及优化

参考文章

静态资源放置于独立域名下的好处

SSH简介和使用

Wed, 02 Oct 2019 12:00:00 GMT

前言

ssh 是 Secure Shell 的缩写，是应用层上的协议，主要是保证远程登录的安全。我们使用 GitHub 以及登录远程服务器都经常需要使用 ssh，这篇文章简单介绍一下 ssh 和使用方法。ssh 有多种实现，一般我们使用的是免费开源的 openssh。

ssh 基本原理

传统的网络服务程序，如FTP、Pop和Telnet其本质上都是不安全的；因为它们在网络上用明文传送数据、用户帐号和用户口令，很容易受到中间人（man-in-the-middle）攻击方式的攻击。就是存在另一个人或者一台机器冒充真正的服务器接收用户传给服务器的数据，然后再冒充用户把数据传给真正的服务器。为了解决这个问题，ssh 协议提供了两种身份验证方式，都是使用非对称加密，关于非对称加密的内容可以看我的这篇文章HTTPS。一般我们把被登录的服务器称为服务端，而请求登录的机器称为客户端。

基于口令的安全验证：只要你知道自己帐号和口令，就可以登录到远程主机。所有传输的数据都会被加密，但是不能保证你正在连接的服务器就是你想连接的服务器。可能会有别的服务器在冒充真正的服务器，也就是受到“中间人”这种方式的攻击。
在客户端生成公钥和私钥，然后将公钥储存到服务端。当客服端请求连接到SSH服务器时，客户端软件就会向服务器发出请求，请求用你的密匙进行安全验证。服务器收到请求之后，先在该服务器上你的主目录下寻找你的公用密匙，然后把它和你发送过来的公用密匙进行比较。如果两个密匙一致，服务器就用公用密匙加密“质询”（challenge）并把它发送给客户端软件。客户端软件收到“质询”之后就可以用你的私人密匙解密再把它发送给服务器。

口令登录的过程大概如下：

远程 Server 收到 Client 端用户的登录请求，Server 把自己的公钥发给用户。
Client 使用这个公钥，将密码进行加密。
Client 将加密的密码发送给 Server 端。
远程 Server 用自己的私钥，解密登录密码，然后验证其合法性。
若验证结果，给 Client 相应的响应。

这种登录方式的风险是我们不知道现在响应我们的是不是目标服务器，如果一个攻击者中途拦截 Client 的登录请求，向其发送自己的公钥，Client 端用攻击者的公钥进行数据加密。攻击者接收到加密信息后再用自己的私钥进行解密，不就窃取了 Client 的登录信息了吗？这就是所谓的中间人攻击。所以我们使用口令登录的方式第一次登录的时候客户端会出现如下提醒：

The authenticity of host 'ssh-server.example.com (12.18.429.21)' can't be established.
RSA key fingerprint is 98:2e:d7:e0:de:9f:ac:67:28:c2:42:2d:37:16:58:4d.
Are you sure you want to continue connecting (yes/no)?

当你输入 yes 的时候，就会出现如下信息：

Warning: Permanently added 'ssh-server.example.com,12.18.429.21' (RSA) to the list of known hosts. Password: (enter password)

告诉你该 host 已被确认，并被追加到文件 known_hosts 中，以后你就可以正常使用口令登录了。

公钥登录的过程大概如下：

Client 将自己的公钥存放在 Server 上，追加在文件 authorized_keys 中。
Server 端接收到 Client 的连接请求后，会在 authorized_keys 中匹配到 Client 的公钥 pubKey，并生成随机数 R，用 Client 的公钥对该随机数进行加密得到 pubKey(R)，然后将加密后信息发送给 Client。
Client 端通过私钥进行解密得到随机数 R ，然后对随机数R和本次会话的 SessionKey 利用 MD5 生成摘要 Digest1，发送给 Server 端。
Server 端会也会对R 和 SessionKey 利用同样摘要算法生成 Digest2。
Server端会最后比较 Digest1 和 Digest2 是否相同，完成认证过程。

这个过程看起来有点复杂，还是建议线看一下文章HTTPS中的非对称加密的知识。这种方式在网络上传递的只有公钥，所以是相对来说安全很多的。并且免去了我们每次登录都要输入密码的麻烦，也很方便。

在 ~/.ssh 文件夹中一般会出现四种文件

id_rsa：保存私钥
id_rsa.pub：保存公钥
authorized_keys：保存已授权的客户端公钥 注意，该文件在服务器的 .ssh 文件夹中默认没有，需要自己创建，需要给该文件 600 的权限，否则可能出现 ssh 无法登录的情况
known_hosts：存储是已认证的远程主机 host key，每个 SSH Server 都有一个 secret, unique ID, 叫做 host key。

每次 Client 向 Server 发起连接的时候，不仅仅 Server 要验证 Client 的合法性，Client 同样也需要验证 Server 的身份，SSH client 就是通过 known_hosts 中的 host key 来验证Server 的身份的。

安装使用

安装 ssh

Mac 默认就安装了 ssh 的客户端和服务端，不过服务端默认是关闭的，开启和关闭的命令如下，不过一般我们是不需要开启的。

#启动服务：
sudo launchctl load -w /System/Library/LaunchDaemons/ssh.plist

#停止服务：
sudo launchctl unload -w /System/Library/LaunchDaemons/ssh.plist

#查看服务器状态：
sudo launchctl list | grep sshd
#0   com.openssh.sshd 开启成功

其他的环境安装都大同小异，我就用 CentOS 举个例子。

#查看是否已经安装ssh-server
rpm -qa | grep ssh #看看有没有openssh-server

#安装
yum install -y openssl openssh-server

#开启PermitRootLogin，RSAAuthentication，PubkeyAuthentication
vim /etc/ssh/sshd_config

#启动ssh的服务：
systemctl start sshd.service

#设置开机自动启动ssh服务
systemctl enable sshd.service

#查看ssh服务是否开启
ps -e | grep sshd

#设置文件夹访问权限
$ cd ~
$ chmod 700 .ssh
$ chmod 600 .ssh/*

使用

Mac 默认已经安装了 ssh-keygen 和 ssh-copy-id，如果这两个命令不能使用，请安装。

#在客户端生成密钥对
ssh-keygen -t rsa -C "your_email@example.com" #一路回车即可，中间有一个设置私钥口令passphrase，直接回车设置为空即可

#将公钥复制到远程主机
ssh-copy-id root@1.1.1.1 #填入服务器的用户名和ip，当然你也可以手动复制文件到服务器
ssh user@remote -p port 'mkdir -p .ssh && cat >> .ssh/authorized_keys' < ~/.ssh/id_rsa.pub #没有安装ssh-copy-id的话这条命令也可以

#远程登录服务器
ssh root@1.1.1.1 #如果修改了默认的22端口，可以加入 -P 参数来指定端口
ssh 192.168.1.100      # 默认利用当前宿主用户的用户名登录
ssh omd@192.168.1.100  # 利用远程机的用户登录
ssh omd@192.168.1.100  -o stricthostkeychecking=no # 首次登陆免输yes登录
ssh omd@192.168.1.100 "ls /home/omd"  # 当前服务器A远程登录服务器B后执行某个命令
ssh omd@192.168.1.100 -t "sh /home/omd/ftl.sh"  # 当前服务器A远程登录服务器B后执行某个脚本

ssh-keygen 参数说明：

-t: 密钥类型, 可以选择 dsa | ecdsa | ed25519 | rsa;
-f: 密钥目录位置, 默认为当前用户 home 路径下的 .ssh 隐藏目录, 也就是 ~/.ssh/, 同时默认密钥文件名以 id_rsa 开头. 如果是 root 用户, 则在 /root/.ssh/id_rsa, 若为其他用户, 则在 /home/username/.ssh/id_rsa;
-C: 指定此密钥的备注信息, 需要配置多个免密登录时, 建议携带;
-N: 指定此密钥对应的密码, 如果指定此参数, 则命令执行过程中就不会出现交互确认密码的信息了.

在配置好 ssh 以后我们也可以用 scp 来传输文件了，具体的使用方法看这篇文章Mac用scp上传或下载文件

总结

以上就是 ssh 的基础知识和使用方法了，对于 GitHub 的配置基本是一样的，将公钥复制到 GitHub 的设置中去即可。如果 .ssh 中有超过一对密钥，可以用 config 文件来配置，形式如下：

# --- Sourcetree Generated ---
Host Clloz-GitHub
    HostName github.com
    User Clloz
    PreferredAuthentications publickey
    IdentityFile /Users/clloz/.ssh/Clloz-GitHub
    UseKeychain yes
    AddKeysToAgent yes
# ----------------------------

ssh 配置文件

ssh 的配置文件的位置是 /etc/ssh/sshd_config，其中有几个会用到的配置

# 是否允许用密码登录
PasswordAuthentication yes

#启用密钥验证
RSAAuthentication yes
PubkeyAuthentication yes
#指定公钥数据库文件
AuthorsizedKeysFile.ssh/authorized_keys

配置文件修改后要重启 ssh 服务后才能生效 systemctl restart sshd。

ssh-agent

最后说一说 ssh-agent。一般我们在用 ssh-keygen 生成密钥的时候默认不给私钥设置 passphrase。如果你有安全需求，担心私钥泄露的风险，那么你可以为私钥设置密码，在创建密钥的时候可以使用 -N passphrase 来给生成的私钥设置密码，也可以用 ssh-keygen -p 来为已经生成的私钥设置或修改密码，如果你要取消密码也可以用这个命令，输入旧密码后新密码直接回车即可。

给私钥设置密码后，安全性是提高了，但是每次我们要用私钥进行登录的时候都需要手动输入一次密码，非常麻烦。ssh-agent 就能帮我们解决这个问题。它相当于一个代理，跟踪我们的私钥和私钥对应的 passphrase，当服务器请求私钥的时候，它会帮我们处理，我们也不用重复输入我们的密码了。

ssh-agent 在 mac 和 linux 中默认是开机自动启动的，你可以用 ps -ef | grep ssh-agent 查看，如果没有可以使用 eval "$(ssh-agent -s)" 启动。

要让 ssh-agent 处理对应的私钥要用 ssh-add 将私钥加入。我们可以先用 ssh-add -l 先查看是否已经加入 ssh-agent 的管理，如果没有则使用 ssh-add -K key_location 来加入。ssh-add 有如下一下参数：

-D #删除ssh-agent中所有私钥(指纹)

-d key_file #删除指定私钥

-L #列出agent当前主机上所有公钥参数，即公钥文件中的内容

-l #列出agent当前已保存的指纹信息

在 mac 上我们还要为对应的私钥添加配置，配置文件的路径是 ~/.ssh/config。

Host *
  AddKeysToAgent yes
  UseKeychain yes
  IdentityFile ~/.ssh/id_rsa

如果你为你的私钥进行了独立的命名，将上面的 id_rsa 换成对应的名字即可。

ssh-agent 还有一个比较好用的功能，就是 forwarding。如果你有服务器 a 和 b，你用自己的电脑登录上了 a，现在又想到 b 上进行某个操作，你不想退出 a 也不想把密钥放到 a 上，那么你知道配置 forwarding 就能够在 a 上直接登录 b。只要在 client， a， b 上的 ~/.ssh/config 里都加上如下配置即可。

Host *
　　ForwardAgent yes

关于 ssh-agent 的配置可以参考 Github 帮助文档还有配置SSH agent 和 SSH agent forwarding转发

参考文章

ffmpeg的安装和使用和gyao视频下载

Tue, 01 Oct 2019 12:00:00 GMT

前言

ffmpeg 是大名鼎鼎的开源免费跨平台的视频和音频流方案，提供了录制、转换以及流化音视频的完整解决方案。我以前用过来转视频格式，后来一直就没用过了。十月的日剧新番，暌违13年的经典日剧 結婚できない男 要出续作了，作为特别喜欢这部剧的忠实粉丝，我一直关注这关西电视台的 まだ結婚できない男 的主页，20 号的时候推出了 チェインストーリー　#0.5　中川家の人々，不过 gyao 上的视频似乎锁了 IP，而且我挂日本的 vpn 也无济于事，看不了。这时候 ffmpeg 就派上用场了。本文就介绍一下关于 ffmpeg 的安装和使用。

安装

Mac 上的安装十分简单，直接用 homebrew 就可以了，其他平台的自己 google 一下，应该也很容易。这里是 ffmpeg 的 GitHub 地址。

brew install ffmpeg

常用命令

ffmpeg Document 链接：https://ffmpeg.org/ffmpeg.html

常用命令参数

ffmpeg [global_options] {[input_file_options] -i input_url} ... {[output_file_options] output_url} ...

ffmpeg -i [输入文件名] [参数选项] -f [格式] [输出文件]

#主要参数
-i #设定输入流
-f #设定输出格式
-ss #开始时间

#视频参数
-b #设定视频流量(码率)，默认为200Kbit/s
-r #设定帧速率，默认为25
-s #设定画面的宽与高
-aspect #设定画面的比例
-vn #不处理视频
-vcodec #设定视频编解码器，未设定时则使用与输入流相同的编解码器

#音频参数
-ar #设定采样率
-ac #设定声音的Channel数
-acodec #设定声音编解码器，未设定时则使用与输入流相同的编解码器
-an #不处理音频

参数选项： 1. -an: 去掉音频 2. -vn: 去掉视频 3. -acodec: 设定音频的编码器，未设定时则使用与输入流相同的编解码器。音频解复用在一般后面加copy表示拷贝 4. -vcodec: 设定视频的编码器，未设定时则使用与输入流相同的编解码器，视频解复用一般后面加copy表示拷贝 5. –f: 输出格式（视频转码） 6. -bf: B帧数目控制 7. -g: 关键帧间隔控制(视频跳转需要关键帧) 8. -s: 设定画面的宽和高，分辨率控制(352*278) 9. -i: 设定输入流 10. -ss: 指定开始时间（0:0:05） 11. -t: 指定持续时间（0:05） 12. -b: 设定视频流量，默认是200Kbit/s 13. -aspect: 设定画面的比例 14. -ar: 设定音频采样率 15. -ac: 设定声音的Channel数 16. -r: 提取图像频率（用于视频截图） 17. -c:v: 输出视频格式 18. -c:a: 输出音频格式 19. -y: 输出时覆盖输出目录已存在的同名文件

查看媒体文件信息

ffmpeg -i video.mp4
ffmpeg -i video.mp4 -hide_banner

视频格式转换

ffmpeg -i input.avi output.mp4
ffmpeg -i input.mp4 output.ts
ffmpeg -i input.webm -qscale 0 output.mp4 #维持源视频文件的质量
ffmpeg -formats #检查支持的格式

一般我们在网站上看到的视频，都能够用 ffmpeg 下载下来，打开控制台，找到形如 https://vdn.vzuu.com/Act-ss-m3u8...... 的请求，然后用 ffmpeg -i "https://vdn.vzuu.com/SD/49c8..." output.mp4 即可下载下来。

提取音频和视频

ffmpeg -i input.mp4 -acodec copy -vn output.aac #提取音频
ffmpeg -i input.mp4 -vcodec copy -an output.mp4 #提取视频

剪切视频

ffmpeg -ss 00:00:15 -t 00:00:05 -i input.mp4 -vcodec copy -acodec copy output.mp4 #-ss表示开始切割的时间，-t表示要切多少

码率控制

码率 bitrate 就是单位时间内传输的位数。我们的视频音频传输的时候也是二进制流，我们说的视频音频大小就是一个媒体文件的总位数，比如一个 20M 的文件，它的总位数就是 20 * 1024 * 1024 * 8 = 167772160bit，如果这个视频的时常是 60s，那么它的码率就是 167772160 / 60 = 2796 kbps，所以码率的计算公式就为 bitrate = file size / duration，媒体文件越大，一般码率就越高，因为单位时间内要传输的内容更多。

ffmpeg -i input.mp4 -b:v 2000k output.mp4 #不破坏分辨率压缩码率
ffmpeg -i input.mp4 -b:v 2000k -bufsize 2000k output.mp4 #减少码率波动
ffmpeg -i input.mp4 -b:v 2000k -bufsize 2000k -maxrate 2500k output.mp4 #设置码率波动的阈值

编码格式转换

ffmpeg -i input.mp4 -vcodec h264 output.mp4
ffmpeg -i input.mp4 -vcodec mpeg4 output.mp4
#调用外部的x265或者X264编码器
ffmpeg -i input.mp4 -c:v libx265 output.mp4
ffmpeg -i input.mp4 -c:v libx264 output.mp4

滤镜 filter

ffmpeg -i input.mp4 -vf scale=960:540 output.mp4 #将输入的1920x1080缩小到960x540输出
ffmpeg -i input.mp4 -i logo.png -filter_complex overlay output.mp4 #为视频添加logo

抓去视频帧保存为图片

#-r 表示每一秒几帧
#-q:v表示存储jpeg的图像质量，一般2是高质量。
#-ss 表示开始时间
#-t表示共要多少时间。
ffmpeg -i input.mp4 -ss 00:00:20 -t 10 -r 1 -q:v 2 -f image2 pic-%03d.jpeg

提取 gyao 的视频

有了上面的内容，提取 gyao 上的视频就很简单了，只要找到文件的请求路径就可以了，我们可以到这个网站Gyao MMS URL来提取，进入网站直接输入就能得到不同分辨率的文件地址，得到地址后我们直接用 ffmpeg 下载到本地即可。不过下载的时候最好还是挂着梯子，文件很大的时候由于网络问题很难下载成功，我下 720p 的时候就失败了，最后只能下载低清晰度的。

趁着日本节点的网络环境比较好，顺利把 720p 的下载下来了，已经上传到百度云了，下载地址和提取码https://pan.baidu.com/s/1MlC7kHXHJXGyqH50e3SBgg jzaq

关于视音频技术

学习就像不断的画圆，自己掌握的知识越多，自己的半径就越大，面积也越大，不过同时增长的是自己未知的东西，并且增长更快，也就是所谓的知道的越多，不知道的就越多。ffmpeg 是视音频技术的基础和入门，如果想学习这方面技术的可以看： 1. 雷霄骅的专栏 2. FFMPEG视音频编解码零基础学习方法人的一生太短暂了，知识的汪洋能取一勺就不简单了，只能抓紧有限的时间尽量多的学习。

参考文章

如何使用IRC

Thu, 26 Sep 2019 12:00:00 GMT

前言

在 lazycat 的博客看到他对 emacs 学习的建议，了解到了 IRC 也就是 Internet Relay Chat，于是便做了了解，这篇文章告诉大家如何使用 IRC。关于 IRC 的介绍请看维基百科

安装

IRC 的使用形式有多种，可以有 GUI 程序，也可以在 shell 中使用，在 emacs 里也有相应的插件，这里我介绍两个客户端软件，一个是 GUI 软件 LimeChat，另一个是我在终端使用的 irssi。

LimeChat 可以直接在 app store 下载，是免费的。 irssi 的安装也很简单 brew install irssi。

注册

要进入目标频道聊天，我们先要连接服务器，比如freenode 的服务器。

/connect irc.freenode.net 6667

然后我们需要注册一个我们的 ID，注册方法（可以查看 freenode 的网站具体了解）

#设置昵称
/nick xxxx
#进行注册
/msg NickServ REGISTER password youremail@example.com
# 收到邮件后，执行邮件中收到的命令
/msg NickServ VERIFY REGISTER yourname xxxxxxx
# 如果不想公开邮箱可以设置隐藏:
/msg NickServ SET HIDEMAIL ON
# 登录
/msg NickServ IDENTIFY password

然后我们就可以用 join 命令加入我们想要加入的频道了，比如你想要加入 emacs 频道就执行如下命令。

/join #emacs

现在我们就可以在自己喜欢的频道聊天了。

使用

不管是用 GUI 软件还是在终端使用，基本都是用命令来控制，关于命令可以查看维基百科的页面List of Internet Relay Chat commands以及这个页面

常用的一些命令有：

/join ubuntu-cn # 中文频道  ubuntu-cn；linuxba
/list # 频道列表
/names [#聊天室] # 列出当前服务器或指定聊天室下的所有人员名称（无法列出隐藏人员）
/who # 查看频道的所有人
/whois [name] # 查看某人的基本资料
/ison <name1> <name2> … # 查询指定别名是否在线
/info # 查询服务器信息
/admin # 查询当前服务器上的Admin
/lusers # 查询当前服务器上的统计信息
/motd # 查询当前服务器今日的统计信息
/links # 查询当前的服务器，解析当前的有几个服务器
/msg <name> <msg> # 向某人发私消息（会打开新窗口）
/query <name> <msg> # 向某人发私消息（新开窗口且转换到这个窗口）
/say <name> <msg> # 向某人说话（不新开窗口）
/notice <name> <msg> # 向指定人发出注意消息
/me <动作>，在当前聊天室窗口中做出动作。 如做出晕倒动作：/me 晕倒
/away <auto reply msg> # 留下信息说明暂时离开，别人向你发出私聊时将会返回此消息，再重新输入 /away（不指定参数）则解除离开状
/ignore <name> # 忽略某人的聊天内容
/set autolog on # 自动保存聊天记录
/part <channel> <msg> # 退出一个频道，不加频道名退出当前频道，后面可以跟退出原因。
/disconnect #退出服务器

发送代码和图片

发送代码使用代码粘贴网站来发送，不要直接发送大段代码，代码粘贴网站可以使用 paste.ubuntu.com，发送图片可以使用img.vim-cn.com，当然也可以搜索其他可用的 paste 网站。

参考文章

Japanese Number 日语数字

Fri, 20 Sep 2019 12:00:00 GMT

前言

日语中的数字有很多种不同的说法，一般来说，一种是依据汉子的发音的读法：いち、に、さん、し、ご、ろく、しち、はち、きゅう、じゅう，另一种就是日语自己的读法：ひ、ふ、み、よ、いつ、む、なな、や、ここ、とお。但是在很多时候具体的使用并没有特定的规律，可能两种都可以，也可能有固定的用法，比如量词的使用，以及日期等，这篇文章整理一下目前我学到的数字用法。

知乎上有个回答对日语里面的几套数字做了更系统的整理，具体看回答如何正确地背诵日语中的日期？ - 雪见yukimi的回答 - 知乎

数字

单纯地数数还是比较简单的，没有太多特别的用法，也比较好记，而且一般学习日语的初期，这些数字接触非常多，所以印象还是比较深刻的。

千的说法除了列出的三千和八千其他都是 ～せん。

年龄

| 年齢 | 読み方 | | :--- | :--------------------- | | 0岁 | れいさい、ぜろさい | | 1岁 | いっさい | | 2岁 | にさい | | 3岁 | さんさい | | 4岁 | よんさい | | 5岁 | ごさい | | 6岁 | ろくさい | | 7岁 | ななさい | | 8岁 | はっさい | | 9岁 | きゅうさい | | 10岁 | じゅっさい | | 20岁 | にじゅうさい、はたち | | 30岁 | みそじ | | 40岁 | よそじ | | 50岁 | いそじ | | 60岁 | むそじ | | 70岁 | ななそじ | | 80岁 | やそじ | | 90岁 | ここのそじ |

时刻

日期

终端和chorme常用快捷键以及快捷键工具keycue

Wed, 18 Sep 2019 12:00:00 GMT

命令和快捷键系列

前言

快捷键能够有效提高我们使用工具的效率，不管是使用播放器还是用编辑器写程序，能够记住快捷键使用起来都会更流畅。不过大部分的工具快捷键都非常多，我们无法记住所有快捷键，所以尽量记住常用的就可以了。

终端常用快捷键

| 按键/命令 | 描述 | | ---------------------------------- | ----------------------------------------------------------------------------- | | 按住 option 同时点击要插入的位置 | 重新定位插入点 | | option + D | 向后删除一个字词 | | Ctrl + W | 向后删除到字词的开头 | | Control-T | 调换两个字符的顺序 | | Ctrl + A | 移动光标至行首 | | Ctrl + E | 移动光标至行尾 | | Command + K | 清屏 | | Ctrl + U | 删除光标前的所有文字。如果光标位于行尾则删除整行。 | | Ctrl + K | 删除到行尾 | | Ctrl + R | 检索使用过的命令 | | Ctrl + C | 终止当前执行 | | Ctrl + D | 退出当前shell | | Ctrl + Z | 将执行中的任何东西放入后台进程。fg可以将其恢复。 | | Ctrl + W | 删除光标之前的单词 | | Ctrl + K | 删除光标后的所有文字 | | Ctrl + T | 将光标前的两个文字进行互换 | | Option + → | 光标向前移动一个单词 | | Option + ← | 光标向后移动一个单词 | | Esc + T | 将光标前的两个单词进行互换 | | Tab | 自动补全文件或文件夹的名称 | | History + a number | 显示历史命令 | | !! | 这将执行输入的最后一个命令。如果遇到权限问题，请尝试在 !! 之前输入 sudo。 |

更多快捷键请查看 apple官网

Mac 常用快捷键链接。

chorme 常用快捷键

| 功能 | 快捷键 | | ---------------------------------------- | -------------------------------------------- | | 打开新窗口 | ⌘ + n | | 打开新的无痕窗口 | ⌘ + Shift + n | | 打开新的标签 | ⌘ + t | | 按标签关闭顺序重新打开之前的标签 | ⌘ + Shift + t | | 跳转到下一个标签 | ⌘ + Option + → | | 跳转到上一个标签 | ⌘ + Option + ← | | 跳转到特定标签页 | ⌘ + 1 到 ⌘ + 8 | | 跳转到最后一个标签页 | ⌘ + 9 | | 前进 | ⌘ + [ | | 后退 | ⌘ + ] | | 关闭当前窗口 | ⌘ + Shift + w | | 显示或隐藏书签栏 | ⌘ + Shift + b | | 打开书签管理器 | ⌘ + Option + b | | 打开设置页 | ⌘ + , | | 打开历史记录 | ⌘ + y | | 查找 | ⌘ + f | | 匹配下一条查找结果 | ⌘ + g | | 匹配上一条查找结果 | ⌘ + Shift + g | | 将选中的内容作为查找文本 | ⌘ + e | | 开发者工具 | ⌘ + Option + i 或 F12 | | 清除浏览记录 | ⌘ + Shift + Delete | | 切换地址栏搜索引擎 | 输入搜索引擎keyword然后按tab，在设置中设置 | | 跳转到地址栏 | ⌘ + l | | 使用 chrome 打开文件 | ⌘ + o | | 显示当前网页的 HTML 源代码（不可修改） | ⌘ + Option + u | | 打开 JavaScript 控制台 | ⌘ + Option + j | | 开启或关闭全屏模式 | ⌘ + Ctrl + f | | 放大 | ⌘ 和 + | | 缩小 | ⌘ 和 - | | 恢复默认大小 | ⌘ + 0 | | 向上/向下滚动 | space/Shift + space | | 跳转到地址栏搜索 | ⌘ + Option + f | | 页面全屏，关闭书签栏、地址栏和标签栏 | ⌘ + Shift + f |

查看全部快捷键点击 chrome快捷键

keycue

keycue 是一个软件，长按 command 可以显示当前所在软件的常用快捷键，比较方便，点击下载链接下载。激活码：KC-ERG-082019-S-1-473199-1019709-1。

参考文章

mac终端快捷键

如何给美服Apple ID充值

Mon, 09 Sep 2019 12:00:00 GMT

前言

由于国内的 app store 有很多应用是没有的，所以现在大家一般都有一个美服的 apple id，具体的注册方法大家可以自行搜索，不是特别困难。不过有些软件是收费的，比如 shadowrocket 从国内的 app store 下架以后，可以在美服的 app store 上搜索到，不过是收费的，价格为 $2.99。于是想着换成这个新的，至少软件是在更新的，而且也不贵。

下架后的 shadowrocket 即使在已够项目中也无法找到，所以如果你不小心删除了，那么就无法再下载了。

可选的付款方式

美服的 apple id 有个问题就是只能绑定美国的信用卡，以及美服的 paypal，所以绑定付款方式这种方法基本是堵死了，剩下的只能通过 gift card 了。很多人都会从淘宝去购买 gift card，不过我在多家淘宝店观察了一下，似乎都有黑卡现象，运气不好的话号直接就没了。当然有美国的朋友可以让他们帮你充值，不过大部分人只能靠自己了。

自己充值 gift card

进入 apple-gift-cards 页面，滚动到下方，点击下图中的 Email a gift card。

然后进入下图所示的页面，上面的 design 随便选择一个即可，然后填入要充值的金额，最小金额为 $10，在最下面填入发送和接收的邮箱，红框标注的位置是接收的邮箱，注意不要写错。

接下来进入检查的页面，看看自己的邮箱信息是否有填错，没错的话就 check out。

选择 check out 以后会让你登录，这里不要登录，直接选择 continue as a guest 即可。

然后就进入付款页面了，选择信用卡，用国内的信用卡即可，我使用的是工行的 visa。下面会有一个账单地址，随便到往上找一个美国地址就可以了。

到这一步完成以后，我们的付款就结束了，你的邮箱也会收到 apple 发来的邮件，然后会有一个账单好，你可以查看你的充值是否到账，我印象中大概扣款后 10 ~ 15 分钟充值就到账了。

总结

一开始我选择了登录充值，不过需要美国的电话号码，现在搞虚拟电话都很麻烦，本来想搞一个 Google Voice 的号码，不过似乎现在审查很严格，注册 Google Voice 的号码必须要有一个美国的真实电话号码才行，虚拟的不可以，我还花了 40 块买了个虚拟号码，结果注册失败，有点坑。总的来说，通过 gift card 充值的方法还是挺简单的，到账也很快，也不存在封号的风险，建议大家尝试。

黑卡指的是不是通过合法渠道取得的 gift card，apple 如果查到你充值的是黑卡，那么你的账号就会被永封，淘宝卖的有好的也有坏的，完全看你的运气，建议大家还是不要购买。

Homebrew更换源以及常用命令

Sat, 07 Sep 2019 12:00:00 GMT

命令和快捷键系列

前言

Homebrew 有时候更新会卡很久，换成国内的源会改善，更换和恢复的方法如下。

中科大源

官方文档：Homebrew 源使用帮助

# 替换 Homebrew
cd "$(brew --repo)"
git remote set-url origin https://mirrors.ustc.edu.cn/brew.git

# 替换 Homebrew Core
cd "$(brew --repo)/Library/Taps/homebrew/homebrew-core"
git remote set-url origin https://mirrors.ustc.edu.cn/homebrew-core.git

# 替换 Homebrew Cask
cd "$(brew --repo)"/Library/Taps/homebrew/homebrew-cask
git remote set-url origin https://mirrors.ustc.edu.cn/homebrew-cask.git

# 替换 Homebrew-bottles
# 对于 bash 用户：
echo 'export HOMEBREW_BOTTLE_DOMAIN=https://mirrors.ustc.edu.cn/homebrew-bottles' >> ~/.bash_profile
source ~/.bash_profile
# 对于 zsh 用户：
echo 'export HOMEBREW_BOTTLE_DOMAIN=https://mirrors.ustc.edu.cn/homebrew-bottles' >> ~/.zshrc
source ~/.zshrc

重设官方地址

cd "$(brew --repo)"
git remote set-url origin https://github.com/Homebrew/brew.git

cd "$(brew --repo)/Library/Taps/homebrew/homebrew-core"
git remote set-url origin https://github.com/Homebrew/homebrew-core

cd "$(brew --repo)"/Library/Taps/homebrew/homebrew-cask
git remote set-url origin https://github.com/Homebrew/homebrew-cask

#注释掉bash或zsh配置文件里的有关Homebrew Bottles即可恢复官方源。 重启bash或让bash重读配置文件。

#如果出现问题可以使用以下命令
brew doctor
brew update-reset

常用命令

#安装依赖工具
xcode-select --install
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

#查看帮助
brew help

#查看版本
brew -v

#更新homebrew
brew update

#显示更新信息
brew update -v

#安装软件包
brew install [包名]

#查询可更新的包
brew outdated

#更新所有
brew upgrade

#更新指定包
brew upgrade [包名]

#清理所有包的旧版本
brew cleanup

#清理指定包的旧版本
brew cleanup [包名]

#查看可清理的旧版本包，不执行实际操作
brew cleanup -n

#锁定某个包
brew pin $FORMULA
#取消锁定
brew unpin $FORMULA

#卸载软件包
brew uninstall [包名]

#查看包信息
brew info [包名]

#查看已经安装软件列表
brew list

#查询可用包
brew search [包名]

#卸载homebrew
cd `brew --prefix`
rm -rf Cellar
brew prune
rm `git ls-files`
rm -r Library/Homebrew Library/Aliases Library/Formula Library/Contributions
rm -rf .git
rm -rf ~/Library/Caches/Homebrew

安装位置

brew 安装软件后，

配置文件在 /usr/local/etc 中
软件安装在 /usr/local/Cellar 中
二进制可执行程序的软连接在 /usr/local/bin 中

目前比较新的 MacOS 12 中：

配置文件在 /opt/homebrew/etc 中
软件安装路径 /opt/homebrew/Cellar 中
二进制可执行程序的软连接在 /opt/homebrew/bin 中
日志文件在 /opt/homebrew/var/log 中

keg-only 的意思

我们在用 homebrew 安装一些软件特别是系统中本来就有的软件时，比如 llvm，flex，bison 等，都会看到安装日志中有 keg-only 的说明，然后有配置环境变量的命令。这个 key-only 的意思就是 homebrew 不会帮我们做符号链接，避免和系统中原有的软件冲突，如果我们需要使用 homebrew 安装的这个就需要自己手动配置环境变量。

参考文章

iTerm2+zsh实现好用美观的Mac终端

Sat, 07 Sep 2019 12:00:00 GMT

前言

我在 Mac 上一直都是使用的默认的终端 terminal，shell 也是使用的默认的 bash，一直也看到别人对于 iterm2+zsh 的推崇，不过觉得麻烦一直觉得没折腾。今天看到了一篇写的比较明了的文章，发现其实安装起来也不是很麻烦，于是就折腾了一下，确实很不错，不过对于 item2 和 zsh 我都还不是太熟悉，具体的使用要慢慢体会了。

安装 iTerm2

#第一次使用brew cask 命令
brew tap caskroom/cask

#cask安装iTerm2
brew cask install iterm2

安装成功后在 Launchpad 中可以看到有一个新图标出现，打开 iTerm2。如果你想用快捷键快速启动程序而不是点击图标，参考我的这篇文章。

快捷键修改

在自带的 terminal 中 ⌥ + 左右方向键 可以用来定位光标到前一个或后一个单词，不过在 iterm2 中这两个快捷键被用作其他功能，我们可以手动改回来。按 ⌘ + O 打开 profile 然后选择 edit profile，在 profile 中选择 keys 选项卡，找到 ⌥→ 和 ⌘← 选项，双击修改 Action 为 Send Escape Sequence，ESC+ 改为 b（左箭头）和 f （右箭头）。

选择配色方案

我们可以根据自己的喜好来选择 iTerm2 的配色方案，先检查下终端颜色配置为 xterm-256color，位置在 iTerm2 -> Preferences -> Profiles -> Terminal。

然后我们可以在 iTerm2 -> Preferences -> Profiles -> Colors 中选择我们的配色方案，不过自带的配色方案比较少，我们可以自己导入配色方案。

有人就开源了一款叫 iTerm2-Color-Schemes 的配色合集，里面有各种经典、常用的配色方案，来使用 Git下载到本地。

#克隆到自己想要的位置
git clone https://github.com/mbadolato/iTerm2-Color-Schemes

然后点击图中红框位置的下拉框选择其中的 import 然后选择刚刚克隆的 iTerm2-Color-Schemes 中的 schemes 文件夹中的全部文件导入，我们就有非常多的配色方案可用了，大家可以选择自己喜欢的，我使用的是 Dracula。

安装字体

想要让 iTerm2 显示图标我们就得用一些特别的字体，图标字体并不是 ASCII 码字体，在 iTerm2 中可以进行配置，所以先要安装这个字体。这款字体叫 nerd-fonts，它支持下面这么多种图标。

brew tap caskroom/fonts
brew cask install font-hack-nerd-font

安装的时候会去 Github 下载字体，现在 github 安装似乎非常慢，最好还是用梯子或者代理，否则可能安装失败。

安装成功后需要在 iTerm2 中配置一下，在 iTerm2 -> Preferences -> Profiles -> Text -> Font -> Change Font 栏位中，Text 下面勾选 Use a different font for non-ASCII text，然后再选择字体以及设置字体大小，需要注意的是 Font 和 Non-ASCII Font 所选择的字体和字体大小必须一致，否则会出现显示异常。

安装 zsh

我印象中我的 Mac 是没有手动安装 zsh 的，系统是 mojave 10.14.5，应该是现在的系统自带的，不过默认 shell 还是 bash。

#查看系统支持的shell
cat  /etc/shells

#如果没有zsh，则用brew安装
brew install zsh

#查看当前使用shell
echo $SHELL

#设置zsh为默认shell
chsh -s /bin/zsh

#设置bash为默认shell
chsh -s /bin/bash

更新 zsh 到最新版本

Mac 现在自带 zsh，据说下个 MacOS 版本 Catalina 会将 zsh 作为默认 shell。Mac 自带的 zsh 并不是最新版本的，想要安装最新版本的可以使用 Homebrew。

# check the zsh info
brew info zsh

# install zsh
brew install zsh

# add shell path
sudo vim /etc/shells

# add the following line into the very end of the file(/etc/shells)
/usr/local/bin/zsh

# change default shell
chsh -s /usr/local/bin/zsh

CentOS7 更新 zsh

CentOS7 的通过 yum 安装的 zsh 版本为 5.0.2，但是很多主题需要更高的版本。比如我使用的Powerlevel9k 主题，在使用 git init 的时候就经常会报错，每次都只能把主题换了再操作，很麻烦。这里给大家说一下如何通过源码安装最新的 zsh。

最新版 zsh 下载地址 zsh-5.8.tar.xz，下载速度可能比较慢，不过还好文件不大，耐心等待。

下载好 zsh-5.8.tar.xz 后用 scp 上传到服务器，然后执行以下操作。

yum -y install gcc perl-ExtUtils-MakeMaker
yum -y install ncurses-devel
# 编译安装
tar xvf zsh-5.8.tar.xz
cd zsh-5.8
./configure
make && make install
# 将zsh加入/etc/shells
vim /etc/shells # 添加：/usr/local/bin/zsh
#设置zsh为默认shell
chsh -s /usr/local/bin/zsh

我没有指定安装路径，默认的安装路径就是 /usr/local/bin/zsh，我们将这个路径添加到 /etc/shells 中然后设置为默认的 shell 即可。重启终端我们就可以看到版本已经变为最新的了。

安装 oh-my-zsh

 sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

安装完成后 iTerm2 已经产生了明显的变化了，同时我们的用户文件夹 ~ 中生成了一个 .zshrc 的 oh-my-zsh 的配置文件。到这一步基本已经大功告成了，下面我们要做的就是对这个配置文件进行改动来达到我们的目标。

关联 .bash_profile

需要注意的是当前我们使用的 shell 换成了 zsh，我们原来在 .bash_profile 中的配置不会被读取，所以我们要在 .zshrc 中加上一句 source ~/.bash_profile，这样我们原来的配置也会生效。

配置主题

oh-my-zsh 默认的主题是 robbyrussell，并不是很好看，我们可以使用 powerlevel10k 主题，让我们的 powerline 更酷炫。

#安装主题
git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k
# 或者 gitee 这个版本安装
git clone --depth=1 https://gitee.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k

#修改.zshrc中的ZSH_THEME参数
vim ~/.zshrc
ZSH_THEME="powerlevel10k/powerlevel10k"

#用source命令让配置立即生效
source ~/.zshrc
# 后面会出来 p10k 的配置向导，跟着配置即可。如果后面想要修改配置，一种方法是直接修改 ~/.p10k.zsh 文件，另一种方法是执行 p10k configure 命令

p10k 不需要像 p9k 那样自己进行复杂的定制，设置向导中已经囊括了比较常用的配置，如果你还是要自己定制可以参考 p10k - README

插件

oh-my-zsh 有很多非常好用的插件，下面是一些推荐的插件已经安装方法，安装好的插件只要在 ~/.zshrc 中的 plugins=(git autojump cp extract sudo z zsh-syntax-highlighting zsh-autosuggestions) 依次写入用空格分开即可。

autojump

能够记忆我们之前去过的目录，不需要多次 cd ，直接 j 目录名 就可以直接进入。

#安装
brew install autojump

#在 ~/.zshrc 中加入如下配置
[[ -s $(brew --prefix)/etc/profile.d/autojump.sh ]] && . $(brew --prefix)/etc/profile.d/autojump.sh
source $ZSH/oh-my-zsh.sh

zsh-autosuggestion

如图所示，输入命令时可提示自动补全(灰色部分)，然后按键盘 → 即可补全(详细介绍)

#安装
$ git clone git://github.com/zsh-users/zsh-autosuggestions $ZSH_CUSTOM/plugins/zsh-autosuggestions

zsh-syntax-highlighting

日常用的命令会高亮显示，命令错误显示红色，如下图(详细介绍)

#安装
$ git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

colorls

colorls 是一个 Ruby 实现的脚本，它可以配合 powerlevel9k 显示电脑上的文件图标(应该是通过后缀判断的)，效果如下

#安装
sudo gem install colorls

我在 CentOS 中安装 colorls 的时候提示 ruby 版本太低，用 rvm 安装高版本 ruby，但是重启后 rvm 加载有问题。google 后发现，要在 .zshrc 中加上 [[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"。

一些小技巧

连续按两次 tab 会补全列表，补全项可以使用 ctrl+n/p/f/b 上下左右切换
输入目录名即可进入，不用 cd 了，输入 .. 即可到上级目录，返回上次目录输入 -
输入 d 即可看到目录列表
智能的命令纠错功能（需开启 ENABLE_CORRECTION 配置）
Cmd + Shift + H 可以查看剪切板的历史记录
Cmd + Option + B 可以利用时间轴来查看之前输入的命令

vscode 的配置

为了能够在 vscode 中能够正常使用新的终端，我们需要在 vscode 的 setting.json 中加入如下配置。

"terminal.external.osxExec": "iTerm.app",
"terminal.integrated.shell.osx": "/bin/zsh",
"terminal.integrated.fontFamily": "Hack Nerd Font",
"terminal.integrated.fontSize": 14,

Linux 配置

zsh 和 oh-my-zsh 也是可以在 Linux 上配置的，我在自己的阿里云服务器上也配置了和 mac 上相同的效果，包括了上面所用到的插件，现在远程的服务器和本地的 Mac 操作上没什么差别，都非常好用。关于 nerd 字体的问题，如果是 ssh 远程连接自己的服务器，那么在远程的服务器上没有安装也没有关系，本地只要安装了就可以正常显示，比如我是用的 iTerm2 来连接阿里云的服务器，显示没有什么问题，而如果你用阿里云网站上给的在线远程连接即使安装了字体也无法正常显示。

参考文章

JavaScript中的Number

Tue, 11 Jun 2019 12:00:00 GMT

前言

由于 JavaScript 是个动态弱类型语言，入门也比较简单，所以刚开始大家不是那么关心类型的细节。今天这篇文章来说一说 JavaScript 中的 Number。

定点数和浮点数

我在原码，反码和补码这篇文章中介绍了关于计算机中如何存储和计算整数。不过我们的现实需求中显然不止又整数，小数的计算可能才是更加频繁的。但是我们知道计算机只能进行二进制的存储和计算，显然要加入小数点就和符号位不参与计算一样需要设计非常复杂的电路，这是没意义的。计算机科学家们自然要设计一种用二进制计算小数的方法，最终确定了两种方案，定点数和浮点数。

定点数其实很好理解，就是小数点后位数固定，比如一个 8 位存储单元，我们规定精度为 4，也就是说小数点后 4 位，11001001 和 00110101 分别表示 1100.1001 和 11.0101 两个数字。

浮点数借用了我们日常使用的科学计数法的思维，在字长中截取一段作为偏移量，剩下的部分表示有效数字 1.xxxxxxx，有效数字的第一位为1，通常省略。结构如下图所示

我们可以看出定点数和浮点数各自又自己的适用场景，比如定点数的精度不会变化，但是表示的范围很有限，比如我们想表示很大和很小的数都无法做到。为了解决这一问题才引入了浮点数，目前大部分编程语言和 cpu 都是按照 IEEE754 标准来进行浮点数的存储和运算的，在 JavaScript 中的 Number 类型都是标准中的双精度浮点数。

IEEE754 标准

我一直都做前端的工作，对定点数和浮点数的理解也仅限于大学中的计算机组成原理的课程中，虽然这些知识可能在前端工作中用处不大，不过我对计算机的工作原理和设计思路还是很好奇，并且不喜欢云里雾里的感觉，对于有能力搞懂的内容还是尽量搞懂，毕竟这个行业变化很快，这些底层的知识掌握肯定有用处，对于我们的整个知识框架肯定是很有帮助的。

IEEE754 标准是二进制浮点数运算标准，规定了计算机中的二进制浮点数的存储和计算的标准。我们在上面的已经介绍了浮点数的三个组成部分：符号位，指数偏移值和有效数字。浮点数又分为两种，单精度和双精度： 1. 单精度：符号位 1bit，指数偏移量 8bit，有效数字 23bit，共 32bit 2. 双精度：符号位 1bit，指数偏移量 11bit，有效数字 52bit，共 64bit 符号位不用讲了，0 为正，1 为负。我们主要说一说指数偏移值和有效数字的部分。

有效数字

有效数字和我们的科学计数法基本相同，小数点右边只保留一位，也就是 1 ≤ 有效数字 < 2。因为这一位都是 1，所以并不保存，相当于一个默认位。比如保存1.01的时候，只保存 01，等到读取的时候，再把第一位的 1 加上去。这样做的目的，是节省 1 位有效数字。以 32 位浮点数为例，留给有效数字只有 23 位，将第一位的 1 舍去以后，等于可以保存 24 位有效数字。

指数偏移值

指数偏移值理解起来很简单，就比如我们十进制的科学计数法 1.2 * 10 ^ 21，这个 21 就是指数偏移值，但是我们在 wikipedia 对标准中的指数偏移值的介绍中可以发现，这个指数偏移值并不是我们前面介绍的 补码 方式存储的，而是用了一种所谓的移码加偏移量的形式。

Wikipedia 对 移码 是这么介绍的：在计算机科学中，移码（英语：Offset binary ）是一种将全 0 码映射为最小负值、全 1 码映射为最大正值的编码方案。理解起来并不困难，但是我们可能很难理解为什么要这么做。我们想想我们对科学计数法的计算过程：

比较两个数的指数大小
把两个数化成相同指数
对有效数字进行计算
将结果格式化为科学计数法的正常格式

计算机对浮点数的计算其实也遵循这三个步骤：求阶差、对阶，尾数相加，结果规格化。也就是说我们首先要比较指数偏移量的大小。我们以单精度浮点数为例，我们的指数偏移值一共是 8bit，如果按照我们之前的补码方式存储，那么就是用 10000000 ～ 01111111 来表示 -128 ～ 127。但是我们可以发现，补码在整数的计算中虽然很方便不用考虑符号位，但是在大小比较的时候却并不方便。因为我们首先要比较符号位，然后在比较后面的值，这对我们来说可能很直观，可是在计算机的电路设计上会不方便，这就是使用移码的原因。

上面我们已经介绍了移码的概念，我们在补码那篇文章中也说了，同余运算我们只要数字成环即可，原点终点可以自定，所以我们可以给定任意偏移量生成一个新的环。移码的偏移量其实没有标准，IEEE 754标准规定该固定值为$2 ^ {n -1} - 1$，在这里就是 $2 ^ 7 - 1$ 127，于是我们从 10000000 ～ 01111111 来表示 -128 ～ 127 变成了 11111111 ～ 11111110 来表示 -128 ～ 127（其中 11111111 和 00000000 用来表示特殊值，具体说明在下一小节），更具体的说是 00000001 ～ 01111111 表示 -126 ～ 0，10000000 ～ 11111110 表示 1 ～ 127，符合上面我们对移码的定义。此时我们所有的数按照从小到大排列，此时要比较大小就非常简单了。我们计算真实指数也很容易，将指数减去偏移量即可。

上面我们给出的偏移值是 $2 ^ {n -1}$ ，但实际 IEEE754 标准中给出的偏移值是 $2 ^ {n -1} -1$ ，在单精度浮点数中就是 127（这样刚好将最小负数 -128 也就是 10000000，移动到 11111111，这样刚好用 11111111 和 00000000 做特殊情况使用），并且给出了几种 特殊情况 的定义($e$ 表示指数部分的位数即指数偏移量，64 位双精度就是 11，32 位单精度就是 8):

如果指数是0并且尾数的小数部分是 0，这个数 ±0（和符号位相关）
如果指数 = $2 ^e -1$并且尾数的小数部分是 0，这个数是 ±∞（同样和符号位相关）
如果指数 = $2 ^e -1$并且尾数的小数部分非 0，这个数表示为不是一个数（ NaN ）。

根据这几条规则，当偏移量为 127 的时候，11111111 ～ 11111110 表示 -128 ～ 127，由于全为 0或全为 1 都是特殊值，所以指数取值范围从 00000001 ～ 11111110 表示 -126 ～ 127。除上面的特殊规则以外还有一种情况：指数全为 0，并且有效数字不为 0，此时舍弃有效数字小数点右边的 1 （就是没有保存的默认 1 ），而指数则为 $0 - (2 ^e - 2)$，即 0 - 126 或者 0 - 1022（ IEEE 754标准规定：非规约形式的浮点数的指数偏移值比规约形式的浮点数的指数偏移值小1），这主要是用来表示非常接近 0 的小数，这类数称为非规约数，而其他指数在 0 到 $2 ^e -1$ (开区间)中的数字则为规约数。$2 ^e -1$ 即全为 1 的情况。

将上面的规则总结为下面的表格：

| 形式 | 指数 | 小数部分 | | ---------- | ---------------- | --------------------- | | 零 | 0 | 0 | | 非规约形式 | 0 | 大于 0 小于 1 | | 规约形式 | 1 到 $2 ^e -2$ | 大于等于 1 小于 2 | | 无穷 | $2 ^e -1$ | 0 | | NaN | $2 ^e -1$ | 非0 |

浮点数表示范围

以单精度浮点数为例：

| 类别 | 正负号 | 实际指数 | 有偏移指数 | 指数域 | 尾数域 | 数 | | ------------------ | ------ | -------- | ---------- | ----------- | ------------------------------ | ----------------------------------------------------------------- | | 零 | 0 | -127 | 0 | 0000 0000 | 000 0000 0000 0000 0000 0000 | 0.0 | | 负零 | 1 | -127 | 0 | 0000 0000 | 000 0000 0000 0000 0000 0000 | −0.0 | | 1 | 0 | 0 | 127 | 0111 1111 | 000 0000 0000 0000 0000 0000 | 1.0 | | -1 | 1 | 0 | 127 | 0111 1111 | 000 0000 0000 0000 0000 0000 | −1.0 | | 最小的非规约数 | * | -126 | 0 | 0000 0000 | 000 0000 0000 0000 0000 0001 | $\pm2^{23}\times2^{-126}=\pm2^{-149}\approx\pm1.4\times10^{-45}$ | | 中间大小的非规约数 | * | -126 | 0 | 0000 0000 | 100 0000 0000 0000 0000 0000 | $\pm2^{-1}\times2^{-126}=\pm2^{-127}\approx\pm5.88\times10^{-39}$ | | 最大的非规约数 | * | -126 | 0 | 0000 0000 | 111 1111 1111 1111 1111 1111 | $\pm(1-2^{-23})\times2^{-126}\approx\pm1.18\times10^{-38}$ | | 最小的规约数 | * | -126 | 1 | 0000 0001 | 000 0000 0000 0000 0000 0000 | $\pm2^{-126}\approx\pm1.18\times10^{-38}$ | | 最大的规约数 | * | 127 | 254 | 1111 1110 | 111 1111 1111 1111 1111 1111 | $\pm(2-2^{-23})\times2^{127}\approx\pm3.4\times10^{38}$ | | 正无穷 | 0 | 128 | 255 | 1111 1111 | 000 0000 0000 0000 0000 0000 | $+\infty$ | | 负无穷 | 1 | 128 | 255 | 1111 1111 | 000 0000 0000 0000 0000 0000 | $-\infty$ | | NaN | * | 128 | 255 | 1111 1111 | non zero | NaN |

* 符号位可以为 0 或 1。

对于 JavaScript 中使用的浮点数一共可以表示 $2^{64}-2^{53}+3$ 共 18437736874454810627 个值，至于计算很简单，64 位一共可以表示 $2^{64}$ 个数，但是上面 特殊情况 第 3 点中的指数为 $2 ^e -1$并且尾数的小数部分非 0排除掉了 $2 ^ {53}$ 个值（除指数位外还有 53 位），但是根据 2，3 两种情况，这$2 ^ {53}$个数中又有 正无穷，负无穷 和 NaN 三个数是有意义的，要加上，所以得出上面的结论。

精度

面试题中经常出现 0.1 + 0.2 为什么不等于 0.3，这就和浮点数计算的精度有关系了。

我们在使用十进制的时候也是又误差的，比如 1/3，或者 $\sqrt2$的时候我们是无法用有限的小数精确的表示这个值的，只能根据我们的使用场景来确定我们需要的精度。使用二进制也一样，二进制中的 0.1 表示十进制的 0.5，0.01 表示十进制的 0.25，显然又很多小数我们无法表示，比如 0.1 ～ 0.9 这九个小数（小数点后只有一位的小数），只有 0.5 在二进制中可以精确表示，其他都是有误差的。

IEEE二进制浮点数算术标准中定义了以下几种舍入规则:

朝0方向舍入: 即截尾，直接将需要精确的位数以后的数位舍去。
舍入到最接近: 即四舍五入，结果可能会变大或变小。
朝-∞方向舍入: 总是向数轴的左方向舍入。
朝+∞方向舍入: 总是向数轴的右方向舍入。

所以当我们计算无法精确计算的值的时候产生误差是不可避免的，可能有些同学会有疑问，为什么 0.3 能正确表示，而 0.1 + 0.2 却表示有问题呢？这是因为误差会在计算中被扩大，计算次数越多，误差越大。举个十进制的例子：1.6 + 2.8 = 4.4，但是如果我们的计算机精度只能到整数，那么我们的就算就变为了 2 + 3 = 5 ，虽然这个例子很简单，但其实计算机中的计算虽然字长长很多，但也是一样的道理。

0.1 + 0.2 != 0.3 的推导

这是一个非常常用的题目考察我们对浮点数的理解，大部分人都知道在 IEEE 754 标准下的双精度浮点数的计算结果位 0.30000000000000004，至于为什么下面给出具体的计算过程。

这个题目使用的非常多，甚至有人专门搞了一个https://0.30000000000000004.com/的网站。

JS中能表示的最大精确整数是多少呢？这个问题其实就是问 IEEE 754 标准下的双精度浮点数能表示的最大精确整数，结果很简单，64 个 bit 中，有 52 位用来表示有效数字，加上默认的 1 ，一共是 53 位，所以结果就是 $2 ^ {53} -1$ 9007199254740991。注意这里说的是最大精确整数，不是最大的数，要求精确就是从 0 到 9007199254740991 中的每一个整数都能准确表示，超过这个范围则会损失精度。64 位双精度浮点数能表示的最大规约数位 $(2 - 2 ^ {-52}) \times 2 ^ {1023}$，结果约为 1.7976931348623157e+308，具体的计算方法参考上面的 32 位单精度浮点数的计算方法，这两个值可以通过 Number.MAX_SAFE_INTEGER 和 Number.MAX_VALUE 来表示。

要知道 0.1 + 0.2 的计算结果，我们先要知道计算机是如何保存 0.1 和 0.2 这两个数的。

可以到这个Double (IEEE754 Double precision 64-bit) Converter进行转换，结果如下

0.1 ：
- sign 0
- exponent 01111111011
- mantissa 1001100110011001100110011001100110011001100110011010
0.2 ：
- sign 0
- exponent 01111111100
- mantissa 1001100110011001100110011001100110011001100110011010

我们可以看出两个数字的有效数字部分是完全相同的，唯一不同的就是阶码（指数偏移量），0.2 的阶码比 0.1 大 1，我们把这两个数进行十进制的转化可以得出结果（64 位双精度浮点数的指数偏移量为 $2 ^ {11 - 1} -1 = 1023$），由于计算精度要求较高，可以到这个网站进行求值Big online calculator

0.1：$(2702159776422298 \times 2 ^ {-52} + 1) \times 2 ^ {-4} = 0.1000000000000000055511151231257827021181583404541015625$
0.2：$(2702159776422298 \times 2 ^ {-52} + 1) \times 2 ^ {-3} = 0.200000000000000011102230246251565404236316680908203125$

你可以是试试在 javascript 中输出 0.1 === 0.1000000000000000055511151231257827021181583404541015625 是返回 true 的，而且不管你删除多少位（保留 0.1）都是 true。

这两个数相加，注意不能将上面的结果直接相加，计算机中的相加先对阶（低阶的向高阶对齐，减少精度损失），然后相加，在这里我们要先将 0.1 的阶也变为$2 ^ {-3}$,

0.1 ：
- sign 0
- exponent 01111111100
- mantissa 1100110011001100110011001100110011001100110011001101 0

相当于把 0.1 的小数点向左移一位，注意的是最左边还有一个隐藏的 1，最后一个 0 就被舍弃了，需要注意的是被截断的最后一位如果是 1 则需要在新数的末位再加一。

对阶完成后就是有效数字部分相加，需要注意的是 0.2 的左侧有一个隐藏的 1:

00.1100110011001100110011001100110011001100110011001101 + 01.1001100110011001100110011001100110011001100110011010 10.0110011001100110011001100110011001100110011001100111

可以看出结果溢出了，这时候我们需要截断最后一位，阶数加一，由于截断的是 1，在新的尾数末位要加一，结果就是：

sign 0
exponent 01111111101 十进制1021
mantissa 0011001100110011001100110011001100110011001100110100 十进制900719925474100

最后再将结果转化为十进制 $(900719925474100 \times 2 ^ {-52} + 1) \times 2 ^ {-2} = 0.3000000000000000444089209850062616169452667236328125$

这里就得到了我们在计算 0.1 + 0.2 时得到的 0.30000000000000004。误差的主要来源就是 0.1 和 0.2 在计算机中的保存就是存在误差的，之后在二者相加计算的时候又有舍入的误差。其实不仅仅是 0.1 + 0.2 有误差，包括我们连续将 0.1 相加，你会发现加 8 次会得到 0.7999999999999999，所以我们在进行对精度有要求的运算的时候一定要注意。

关于最后的浮点数计算这一部分，一定要记住把隐藏的 1 拿出来参与尾数的计算，因为这个隐藏的 1 也是尾数的一部分。

这里再插一点，上面提到在双精度浮点数中最大精确整数是9007199254740991，就是 9e16 这个数量级，而且 JS是不区分整形和浮点型，整数也是用浮点数的形式表示的，所以在 JS 中，超出 15 位的数就不一定是绝对精确的了。这会导致一个问题，就是 64 位整形能表示的最大数是 19 位，后端数据库的 id 通常是 64 位整型其大小有可能会超过 9e16，所以比较安全的方法是在后端转成字符串再传给前端。所以 JS 灵活的类型转换，带来的缺点就是整数的精确表达范围小了很多。

关于误差 Wikipedia 上还给出了几个具体的例子，比如 1990 年 2 月 25 日，海湾战争期间，在沙特阿拉伯宰赫兰的爱国者导弹防御系统因浮点数舍入错误而失效，该系统的计算机精度仅有 24 位，存在 0.0001% 的计时误差，所以有效时间阙值是 20 个小时。当系统运行 100 个小时以后，已经积累了 0.3422 秒的误差。这个错误导致导弹系统不断地自我循环，而不能正确地瞄准目标。结果未能拦截一枚伊拉克飞毛腿导弹，飞毛腿导弹在军营中爆炸，造成 28 名美国陆军死亡。

小数有误差，整数同样会产生误差。我们上面的表格给出了单精度最大的规约数大概是 $\pm(2-2^{-23})\times2^{127}\approx\pm3.4\times10^{38}$，但其实当我们超出了有效数字的表示范围以后就一样会产生误差，单精度的有效数字位数是 24，双精度的有效数字位数是 53（都要加上默认的 1），所以单精度的最大安全整数是 $2^{24}-1$，而双精度的最大安全整数是 $2^{24}-1$，所谓的最大安全整数是指能够连续表示的整数，在有效数字范围内的整数都是能连续表示的，而超出有效数字范围则会产生误差。

当我们要对浮点数进行比较的时候，比较安全的方式是用 Number.EPSILON。Number.EPSILON 表示 1 与 Number 可表示的大于 1 的最小的浮点数之间的差值，对于双精度浮点数，这个值为 $2^{-52}$，接近于 2.2204460492503130808472633361816E-16，利用这个属性比较浮点数可以得出正确的结果。

console.log(Math.abs(0.1 + 0.2 - 0.3) <= Number.EPSILON)

Number.EPSILON 是 ES6 添加的新属性，如果考虑兼容性，可以使用如下 polyfill：

if (Number.EPSILON === undefined) {
  Number.EPSILON = Math.pow(2, -52)
}

其他还有 Number.prototype.toprecision() 和 Number.prototype.toFixed() 方法，他们根据我们给出的精度返回一个字符串，我们可以再用 parseFloat 获得我们想要的数字。ECMA-262 只需要最多 21 位显示数字。

Number.prototype.toprecision() 和 Number.prototype.toFixed() 的区别是：

toPrecision 是处理精度，精度是从左至右第一个不为 0 的数开始数起。
toFixed 是小数点后指定位数取整，从小数点开始数起。

他们都能够对精度进行处理，进行四舍五入或添 0，不过需要注意的是，我们的有效数字部分一共只有 53 位，所以真正能精确表示的也就 9007199254740991 个数，16 位，超过这个范围，都是只能取近似了，小数也是一样。但是他们也会有 bug，比如 1.005.toFixed(2) 返回的结果是 1.00 而不是 1.01，因为 1.005 的实际值是 1.00499999999999989。

还有一个比较完美的解法就是第三方库 number-precision

JS 中的数字进制

在 JS 中我们也可以用不同的进制来表示数字字面量，0b 或 0B 前缀表示二进制，如果 0b 后面的数字不是 0 或者 1 会提示愈发爱错误 Missing binary digits after 0b；0o 前缀表示八进制，0 开头也可以表示八进制，假如 0 后面的数字不在 0 到 7 的范围内，该数字将会被转换成十进制数字。ECMAScript 5 严格模式下禁止使用八进制语法。八进制语法并不是 ECMAScript 5 规范的一部分， ECMAScript 6 中使用八进制数字是需要给一个数字添加前缀 0o；0x 或者 0X 前缀表示十六进制，假如 0x 后面的数字超出规定范围(0123456789ABCDEF)，那么就会提示这样的语法错误(SyntaxError)：Identifier starts immediately after numeric literal。

还有一点需要注意的是，JS 中的小数点只要一边有数字即为合法的字面量，也就是说 0. 和 .0 都是合法的字面量。当我们调用数字的 toString 方法的时候，如果表达式为 0.toString() 是会报错的，合法的写法是 0 .toString()，在 0 和 . 之间留一个空格。这其实是一个 bug，不过目前我们只能这么使用。其他进制转十进制用 parseInt，注意 parseInt 的第一个参数需要是 String，如果传入的不是一个字符串，会调用 toString 方法转换为字符（这里的机制还是比较复杂的，参考 MDN），第二个数字表示字符串的进制。十进制转其他进制使用 Number.prototype.toString()，toString 接受一个参数即要转换的进制。parseInt 和 Number.prototype.toString 的进制数都在 2-36 范围内，超出这个范围将会报错。

//JS中的进制转换
parseInt(num, 8) //八进制转十进制
parseInt(num, 16) //十六进制转十进制
parseInt(num).toString(8) //十进制转八进制
parseInt(num).toString(16) //十进制转十六进制
parseInt(num, 2).toString(8) //二进制转八进制
parseInt(num, 2).toString(16) //二进制转十六进制
parseInt(num, 8).toString(2) //八进制转二进制
parseInt(num, 8).toString(16) //八进制转十六进制
parseInt(num, 16).toString(2) //十六进制转二进制
parseInt(num, 16).toString(8) //十六进制转八进制

总结

这篇文章主要是讲了浮点数的标准和误差产生的原因，自己的总结可能会有一些错误，望指正。

参考文章

终端不区分大小写

Mon, 10 Jun 2019 12:00:00 GMT

前言

在使用 Linux 或者 Mac 的时候，有时候会遇到路径需要区分大小写并且 tab 不能自动补全的情况，非常不方便。其实只要稍微配置一下即可。

配置方法

在用户目录 ~ 中新建 .inputrc 文件输入如下内容：

set completion-ignore-case on
set show-all-if-ambiguous on
TAB: menu-complete

在 mac 中该文件可能需要 sudo 才能又权限编辑。

原码，反码和补码

Wed, 05 Jun 2019 12:00:00 GMT

前言

以前在学习计算机科学导论的时候，仔细研究过原码，反码，补码之间的关系以及他们是用来解决什么问题产生的。今天在看 JavaScript 中的 Number 的时候想到这三个概念，用一篇文章来整理一下相关的知识。

机器数和真值

虽然我们有反码补码的概念，但是对于硬件来说，他们完全不明白这是什么。对于硬件来说，有 n 位存储单元，就有 $2^n$ 个状态，也就能表示 $2^n$ 个数。也就是说原码，反码和补码都是人为创造出来的概念，其目的就是用数学的方法来简化硬件的设计。比如我们规定了最高位为符号位，那么一个 8 位的存储单元可以用 10000001 来表示 -1，其中这个 10000001 就是机器数，而 -1 就是真值。

原码

计算机要进行计算就必须存储数值，最简单的方法就是用机器码作为我们的真值，比如一个 8 位的存储单元可以存储 00000000 ～ 11111111 共 256 种数字，真值从 0 ～ 255，但是这样设计显然意义不大，因为我们需要计算负数。为了引入负数，所以设计出了原码：用存储单元的第一位表示符号，1 位负，0 为正，后面的位表示真值的绝对值。同样以 8 位存储单元位例，在用原码的方式下我们依然可以表示 256 个数，从 11111111 ～ 01111111，真值范围为 -127 ～ 127，可能你发现真值一共只有255 个，因为 10000000 和 00000000 表示的都是 0。

从真值的二进制到原码，我们可以看出，对于机器来说没有区别，只是我们用数学手段赋予了同一个二进制数不同的意义，为的是能够让计算机满足我们的计算需求。跟随这个思想，我们同样也能理解反码和补码。

反码

从真值的二进制到原码，我们跨出了一步，在计算机中引入了负数。但是原码存在很严重的问题，就是对于 -1：10000001和 +1：00000001，他们的和是 10000010，按照原码的约定规则，这个数是 -2，这样显然是不行的，电路也无法设计。对于人类来说，分辨第一位是符号为很简单，我们会根据符号选择对后面的绝对值进行加还是减并得出结果。但是对于计算机来说将符号位分开处理是一件非常复杂的事情，如果我们把基础的加减乘除运算的电路都设计的非常复杂，那么这个计算机的性能显然是很差的。现在的问题是如何让符号位能够参与运算，并且形成一个完善的逻辑。

为了解决这个问题，我们引入了反码，反码的定义是：如果是正数则保持不变，如果是负数，则除符号位之外按位取反。具体看下图。

通过反码逻辑的设计，我们可以发现现在正负数相加获得的都是 1111，也就是 -0，现在我们已经可以设计电路然后用计算机进行存储和计算了。

补码

反码解决了带符号位运算的问题，但是还有一个问题没有解决，就是现在我们有两个 0，一个 +0，一个 -0，这两者在数学上是没有区别的，并且占了两个编码。为了解决这个问题，又引入了补码。

补码的定义就是正数和 0 的补码不变，负数的补码是其对应的正数按位取反再 +1。负数也可以说成是反码 +1。还以 8 为存储单位为例，-1 的原码是 10000001，反码是 11111110，补码在反码的基础上 +1，即为 11111111。

从图中可以看出，-0 取补码后跟 0 是一致的，解决了两个 0 的问题。在 -1 ～ -7 之后，还多处一个编码 1000 可以用来表示 -8，这也就是我们今天计算机所用的存储和计算的方式。

数学原理

其实上面的补码定义肯定让很多人产生疑问，最后这个 -8 到底是哪来的？这是因为这个通用的教科书定义只是给出了补码之形，并没有告诉我们补码之质，表面上是要让我们更好的理解补码，其实更容易让人产生误导。上面的内容一步一步介绍补码，感觉似乎补码是 设计 出来的，但其实只是编码背后存在一定的数学规律，而补码正式最合适的那个，所以被用来实现计算机了。

同余

先来说一说同余概念，我们来看看下面的表盘

表盘上的指针指向 8，那如果我现在要调节指针指向 1 要如何操作呢？ 1. 顺时针拨动 5 个小时 (8 + 5) mod 12 = 1 2. 逆时针拨动 7 个小时 (8 -7) mod 12 = 1

对于表盘来说，我们顺时针拨动 5 个小时和逆时针拨动 7 个小时是没有区别的。甚至我们可以顺时针拨动 5 + 12n 个小时，或者逆时针拨动 7 + 12n 个小时。换一个角度，现在指针指向 8 ，如果只看这个表盘你并不能分辨现在是早上 8 点还是晚上 20 点。

从上面的现象我们可以总结出两点结论， 1. 如果把顺时针看作加法，把逆时针看作减法，那么一个闭合的连续自然数环的减法和加法是可以互相替代的。 2. 5 和 5 + 12n 的效果相同，也就是说只要相对于环的数字总数的余数相同，那么效果相同。

这个规律就是数学中的同余：两个整数 a，b，若它们除以整数 m 所得的余数相等，则称 a，b 对于模 m 同余。记作 a ≡ b (mod m)，a 与 b 关于模 m 同余。

5 mod 12 = 5

17 mod 12 = 5

29 mod 12 = 5

所以 5，17，29 关于模 12 同余。

同余的数学定义是：

$$ x \bmod y = x\,-\,y\,\llcorner\,x/y\,\lrcorner $$

x mod y 等于 x 减去y 乘上 x 与 y 的商的下界。举个例子 -3 mod 2等于$ -3 - 2 \times \llcorner -1.5\lrcorner $，等于 -3 - 2 * (-2)，结果为 1。

同余的深入

介绍完同余的概念，要理解为什么计算机使用补码，我们还需要知道一点：由于计算机的字长是有限的，所以计算机的运算本质就是同余运算，比如字长 32 位，一共能表示 $2^{32}$ 共 4294967296 个状态，当我们计算 1 + 2 的时候，本质是这样的：

a ≡ 1 (mod 4294967296)
b ≡ 2 (mod 4294967296)
r ≡ a + b ≡ 3 (mod 4294967296)

在回到上面的表盘，我们把表盘上的 12 写作 0，现在我们的表盘就表示从 0 ～ 11 一共 12 个数。我们以 0 为起点，12 为模，逆时针拨动指针就得到负数，顺时针拨动指针就是正数。比如我们逆时针拨动一格，我们就得到 -1，-1 和 11 关于模 12 同余，所以他们等价。利用同余的这种性质，我们引入了负数，

那么如果我们把00000000 ～ 11111111 放到一个表盘上呢，它的规律和只有 12 格的表盘是一样的，11111111 可以表示 255 也可以表示 -1，在同余计算中他们是等价的。那么8位 一共 256 个状态，我们既然要引入负数当然希望正数负数一样多，于是我们从 00000001 ～ 01111111 表示 1 ～ 127，11111111 ～ 10000001 表示 -1 ～ -127，还多出两个数 00000000 和 10000000。00000000 自然是表示 0，那么 10000000 表示什么呢？它既可以表示 128 也可以表示 -128，但是为了统一性以方便数据处理，我们用 10000000 来表示 -128，这样所有的负数的最高位都是 1。这些负数的二进制编码就是所谓的补码了。

介绍了半天，告诉大家 -8 到底是哪来的，可以好像又脱离的补码的概念了，补码的本质到底是什么？其实补码只是上面一段内容背后的数学规律，我们用 11111111 ～ 10000000 表示了 -1 ～ -128，那比如我想知道 -57 的二进制码是多少，要怎么计算呢？

在二进制计算中我们很容易可以发现一个规律就是 X + ~X + 1 = 0，~X 表示 X 的反码，我们将这个式子处理一下：-X = ~X +1，是不是很熟悉，我们要求一个负数的二进制表示，只要将其对应的正数的反码 +1 就可以了。

反码和补码的英文

反码的英文是 Ones' complement，这是因为原码加上反码得到的是全为 1 的二进制，所以这个翻译的意思就是原码相对于全 1 的编码的补，也就是字面意思，这里的 Ones' 就是很多一的意思。

补码的英文是 Two's complement，一个 n 位的二进制数，其模为 $2^n$，一个负数 m 的补码即为 $2^n + m$，所以这里的翻译就是相对于模来说的。

总结

补码的本质就是由于计算机字长的限制，让我们在计算机中的数的表示是有限的，形成了一个环，计算的本质也是同余运算。说直白一点，就像钟表上的 12 个点，我们可以认为是 0～11 ，也可以是 1～12 ，甚至可以是 3～14，它们都会遵循同余运算的特点，而我们选择哪一种取决于我们的计算需求。而在计算机中我们选择了对计算机设计最有利的一半负数，一半非负数的表示，并不是人为设计出来的。而在这种情形下的负数的二进制码是不直观的，书本上的补码概念正是阐述负数二进制码的数学规律，方便我们能够计算负数的编码。

可能内容讲的有点乱，写文章的花了很久，不知道如何用更通俗的语言表述，肯能是自己的理解还不够透彻，如果又表述的不清晰或者不对的地方欢迎指正。

参考文章

Github markdown 锚点

Tue, 04 Jun 2019 12:00:00 GMT

前言

一般的 HTML 锚点都是通过 url 中的 hash 来让浏览器知道要滚动到哪个元素。这里说的 hash 就是 location.hash 可以简单理解为 url 中 # 后面的内容。如果我们的页面中有元素的 id 和 hash 相同，并且它处在一个可滚动的容器中，那么浏览器会在页面加载的时候直接滚动到该元素。

这个功能很有用，通常是用在一个很长的页面中的目录上，比如我们经常看到的 HTML，CSS，ECMAScript 等标准一般都会给目录加上锚点，方便我们直接跳转到对应内容，否则靠滚动的话太不方便。markdown 自然也有需要锚点的场景，不过不同的 markdown 实现可能不相同，今天我在整理书单的时候想把书单也同步到 Github 上，README.md 中就需要用到锚点，这里说一下 Github 的锚点使用。

锚点使用

标题的锚点链接

在 markdown 中我们使用一个或多个 # 来创建段落标题，在 Github 上显示的 markdown 的标题默认会加上与标题名称相同的锚点标记也就是 id。所以我们可以使用如下方法来使用锚点。

[标题1](#标题1)
[标题2](#标题2)
[标题3](#标题3)

# 标题1

## 标题2

## 标题3

需要注意的是，我们经常使用中文标题，中文标题的锚点会进行 url 的编码操作，url 编码细节可以看这篇文章

锚点名称小写

[Github标题1](#github标题1)

## Github标题1

空格用 - 代替

[Github 标题2 Test](#github-标题2-test)

## Github 标题2 Test

void(0)和undefined

Mon, 03 Jun 2019 12:00:00 GMT

前言

我们经常看到在一些框架中用 void(0) 来代替 undefined，这篇文章来说一说这种做法的原因。

关键字和保留字

每种语言都有自己的关键字和保留字（ reserved words ），JavaScript 自然也不例外。在MDN可以查看保留字。值得注意的是我们经常使用的 window， undefined，都不是标准中的保留字，也就是说 window，undefined 都可以作为变量名或者属性名。虽然在浏览器实现中，我们在全局作用域中无法声明或改变这些变量，但是在函数作用域中我们可以使用 window 或者 undefined 作为变量名或者属性名。

function a() {
  var window = 'aaa'
  var undefined = 'bbb'
  console.log(window, undefined)
}
a() //aaa bbb

function b() {
  var window = {
    undefined: 'ccc'
  }
  console.log(window.undefined)
}
b() //ccc

从代码中可以看出我们在函数内可以重新声明并赋值，和我们声明的普通的标识符并没有什么区别，所以使用 undefined 或者 window.undefined 都是不可靠的。

在 nodejs 环境中，global 同样也不是保留字，可以赋值。

void 运算符

ECMA-262规范中对 void 运算符的定义

The void Operator The production UnaryExpression : void UnaryExpression is evaluated as follows: - Let expr be the result of evaluating UnaryExpression. - Call GetValue(expr). - Return undefined. NOTE: GetValue must be called even though its value is not used because it may have observable side-effects.

void 运算符的执行分为三步，先执行运算符后的表达式，对表达式的返回值执行 GetValue，返回 undefined。

GetValue 是规范内部的 Reference Specification Type 的一个方法，它将返回 Reference 的具体值。这个 Reference 和 js 中的引用不是同一个东西，这里的 Reference 是标准中的一个抽象类型，由三个部分组成：base， reference name，stict mode flag。比如 a.b，a 对应 base， b 对应 reference name。具体细节参考规范

由于 void 的底层实现是返回 undefined，所以用 void expr 来表示 undefined 是可靠的，通常我们用 void 0 或者 void (0) 来表示 undefined。

void 和其他运算符一样，可以让 JavaScript 引擎把一个 function 关键字识别成函数表达式而不是函数声明（语句）。

关于prototype和constructor的思考

Fri, 31 May 2019 12:00:00 GMT

前言

今天在看 get 和 set 语法的时候在知乎上看到一个提问，具体内容看下面的代码

function Dog() {
  this.tail = true
}
Dog.prototype.say = function () {
  return 'Woof'
}
var dog = new Dog()
dog.say() // "Woof"
dog.constructor // Dog()
Dog.prototype = {
  paws: 4
}
var newDog = new Dog()

newDog.constructor // ƒ Object() { [native code] }
typeof newDog.constructor.prototype.paws // "undefined"
typeof dog.constructor.prototype.paws // "number"

题主对这几个输出的结果比较疑惑，我也来分析一下这几个结果，看看自己对原型这部分知识掌握得如何。

分析图

要搞清楚这些对象之间的关系，我们来画一画这些对象的关系图

图中不同类型的连线我已经用不同颜色标注出来，还是可以清楚的看出我们的各个对象之间的关系的。对象被我分成了三行，下面的分析中有时我会用第几行来说名对象的位置。

细节

问题 1

第一个问题 newDog.constructor，我们先来看看 new 做了几件事

创建一个新的空对象
把新对象的 __proto__ 链接到构造函数的 prototype 对象（每一个函数都有一个 prototype 属性指向一个对象，该对象有一个 constructor 属性指向该函数）
将第一步创建的新的对象作为 this的上下文
执行构造函数，如果构造函数没有返回值或者返回值不是一个对象，则返回 this

通过上面的步骤我们可以知道我们的 newDog 对象有一个 __proto__ 属性指向代码中的 {paws: 4} 这个对象，因为在代码中我们人为地将构造函数的 prototype 引用改变了，它现在指向了一个我们自定义的对象。需要注意的是，我们上面的步骤中说函数的 prototype 指向的对象有一个 constructor 属性指向函数，这种情况只限于引擎自动生成的 prototype 对象，对于我们自己创建的对象是没有该属性的。

可能有些同学有个疑问就是通过构造函数实例化的对象（比如代码中的 dog 和 newDog ）是否有 constructor 属性呢？答案是没有，虽然我们经常看到有这样的用法，但是其实访问的是原型链上的某个 prototype 对象中的 constructor 属性。那么我们代码中的 newDog.constructor 是哪一个呢？

从图中我们可以看出 newDog 对象的 __proto__ 指向了自定义的 prototype 对象（第二行第三个），我们的 newDog 和这个自定义的对象中都没有 constructor 的属性，那么引擎自然会沿着原型链继续寻找。自定义对象的构造函数是 Object 对象（也就是ƒ Object() { [native code] }，这是引擎底层函数，用 C++ 编写），是函数自然就有 prototype 属性，这个属性指向的对象也是 newDog 原型链上的一个对象，并且它有 constructor 属性，指向 Object 对象，结果出来了，newDog.constructor 就是 ƒ Object() { [native code] }

实例化对象中没有 constructor 属性很好验证，用 hasOwnProperty 方法即可。另外提一点就是引擎沿着原型链搜索属性，Object.prototype 是最后一环，这里就是原型链的终点，Object.prototype.__proto__ === null。

问题 2

其实解决了问题 1，问题 2 也就迎刃而解了，typeof newDog.constructor.prototype.paws 等价于 Object.prototype.paws，显然这个属性是不存在的。

问题 3

问题 3 的核心是当我们手动改变了构造函数的 prototype 指向，之前实例化的对象的 __proto__ 指向会改变吗？从图中的对象关系和代码运行结果我们可以得出否定的结论。dog.__proto__ 此时依然指向 prototype 改变之前由引擎自动生成的对象，该对象中的 constructor 属性指向 Dog 构造函数，dog.constructor.prototype.paws 此时等价与 Dog.prototype.paws，Dog.prototype 此时指向 {paws: 4}，自然能够获取该属性。

总结

我们在构造函数原型上添加方法的时候尽量使用 Obj.prototype.xxx 的方式，而不要覆盖原型对象，这样会导致很多问题。即使在需要覆盖的时候，也要给新对象加上 constructor 属性。

文字跑马灯效果

Wed, 29 May 2019 12:00:00 GMT

前言

在前面制作音乐播放器的时候想要实现歌曲名称的跑马灯效果，因为有些歌曲的名字特别长，不能现实完全，大部分播放器都是在歌曲名称超过长度的时候滚动显示。但是跑马灯的效果一直无法做到完美衔接。因为整个页面是响应式的，所以歌曲名称所在的元素的长度也是不固定的，完美衔接的跑马灯是用两个相同的文本来进行动画滚动，如果长度无法固定那么效果肯定不好，这篇文章来研究一下如何实现比较流畅的跑马灯效果。

CSS 实现

用 CSS 来实现文字的滚动效果是可以的，不过有很多局限，特别是在文字和元素的宽度不确定的情况下。因为在动画的每个状态节点我们给出的属性必须是确定的属性而不能是一个动态的。可以很容易的分析出来，滚动的元素的长度必须是包含元素的整数倍才能够实现无缝的滚动，否则就会出现动画跳帧的情况，实现代码如下：

<style>
  .wrap {
    margin: 0 auto;
    width: 200px;
    border: 1px solid;
    white-space: nowrap;
    overflow: hidden;
  }

  .wrap .content {
    height: 20px;
    font-size: 0;
  }

  .wrap p {
    position: relative;
    display: inline-block;
    left: 0;
    margin: 0;
    width: 200%;
    font-size: 16px;
    line-height: 20px;
    background: lightblue;
    animation: scroll 6s infinite linear;
    overflow: hidden;
    white-space: nowrap;
  }

  .wrap .content:hover p {
    animation-play-state: paused;
  }

  @keyframes scroll {
    0% {
      left: 0;
    }
    100% {
      left: -200%;
    }
  }
</style>
<div class="wrap eg1">
  <div class="content">
    <p><span>1.当文字超出范围的时候开始滚动</span></p>
    <p><span>2.当文字超出范围的时候开始滚动</span></p>
  </div>
</div>

这样看上去效果尚可，不过用 CSS 实现是很容易出问题的，比如文字的长度超出了规定的长度（上面的代码中是 200% ）。不过如果我们只是需要一个简单的滚动效果，选择 CSS 是一个比较便捷的方式。

JS 实现

利用 transition

是用 JS 实现又两种思路，一种是结合 transition 属性来调节对应的CSS 属性。我的思路是两个相同的文本，inline-block 排列，改变第一个的 left，监听 transitioned 事件，当滚动结束后，将 left 归零然后重复上述步骤。需要注意的是，在归零的时候，比如去掉元素样式中的 transition 属性，否则归零的过程也是一个动画，就不符合我们的效果了。代码如下：

<style>
  .wrap {
    margin: 0 auto;
    width: 200px;
    border: 1px solid;
    white-space: nowrap;
    overflow: hidden;
  }

  .wrap .content {
    height: 20px;
  }

  .wrap p {
    position: relative;
    left: 0;
    display: inline-block;
    margin: 0;
    padding-right: 15px;
    font-size: 16px;
    line-height: 20px;
    background: lightblue;
    box-sizing: border-box;
  }

  .wrap p.transitioned {
    transition: left linear 3s;
  }
</style>
<div class="wrap eg1">
  <div class="content">
    <p>1.当文字超出范围的时候开始滚动</p>
    <p>1.当文字超出范围的时候开始滚动</p>
  </div>
</div>

var $text = $('.wrap p')
var $wrap = $('.wrap')
var t_w = $text.outerWidth()
console.log(t_w)
var wrap_w = $wrap.width()

function textScroll() {
  if (t_w > wrap_w) {
    $text.addClass('transitioned')
    $text.css('left', -t_w + 'px')
  }
}

$(document).ready(function () {
  textScroll()
})

$text.on('transitionend webkitTransitionEnd oTransitionEnd', function () {
  console.log('end')
  $(this).removeClass('transitioned')
  $(this).css('left', 0)
  setTimeout(() => {
    $text.addClass('transitioned')
    $text.css('left', -t_w + 'px')
  }, 4)
})

需要注意的是在归零后再次调用滚动方法的时候我用了 setTimeout 来延迟触发，这是因为如果不实用异步的话，浏览器会把这多个渲染步骤优化为一个，动画不会触发，具体大家可以去测试一下。还有一个问题就是想要作出效果比较好的暂停不是很容易，因为 transition 的时间是固定的，而我们鼠标移动到元素上的时间是不确定的，当我们移开鼠标的时候，transition 的时间又重新计算了。

点击查看效果。

纯 JS 实现

最后一种方法是纯 JS 的方法，利用定时器来实现动画。实现代码如下

<style>
  .wrap {
    margin: 0 auto;
    width: 200px;
    border: 1px solid;
    white-space: nowrap;
    overflow: hidden;
  }

  .wrap .content {
    height: 20px;
  }

  .wrap p {
    position: relative;
    left: 0;
    display: inline-block;
    margin: 0;
    padding-right: 15px;
    font-size: 16px;
    line-height: 20px;
    background: lightblue;
    box-sizing: border-box;
  }
</style>
<div class="wrap eg1">
  <div class="content">
    <p>1.当文字超出范围的时候开始滚动当文字超出范围的时候开始滚动</p>
    <p>1.当文字超出范围的时候开始滚动当文字超出范围的时候开始滚动</p>
  </div>
</div>

var $text = $('.wrap p')
var $wrap = $('.wrap')
var t_w = $text.outerWidth()
var wrap_w = $wrap.width()
var mouse = false
var timer = null

function init() {
  animation()
}

function animation() {
  timer = setInterval(() => {
    scroll()
  }, 10)
}

function scroll() {
  var left = parseInt($text.css('left'))
  if (left > -t_w) {
    //   console.log(left)
    $text.css('left', left - 1 + 'px')
  } else {
    $text.css('left', '0')
  }
}

$('.content').on('mouseenter', function (e) {
  e.stopPropagation()
  console.log(1)
  clearInterval(timer)
})
$('.content').on('mouseout', function (e) {
  console.log(2)
  e.stopPropagation()
  animation()
})

init()

使用 JS 我们能够非常容易的完成鼠标移动到文字上暂停滚动的效果。

点击查看效果。

解决hover生成border造成的元素移动

Mon, 27 May 2019 12:00:00 GMT

前言

我们有时候会遇到 hover 伪类给元素添加边框的时候，元素中的内容发生位移，虽然我们设置了 box-sizing: border-box并且规定了元素的宽高，但是内容依然被边框挤开了。如下面这种情况：

<style type="text/css" media="screen">
  .test {
    height: 30vmin;
    width: 30vmin;
    background: lightblue;
    box-sizing: border-box;
  }
  .test:hover {
    border: 5px solid black;
  }
</style>
<div class="test">this is a div.</div>

这里的原因很明显，我们的元素大小并没有变（如果没有设置元素宽高或者 box-sizing: border-box 则元素大小会改变），box-sizing: border-box 是生效的，但是元素中的内容因为突然添加的边框而被挤开了，我们的盒模型从外到内依次是margin，border，padding，content，所以新加入的 border 必然将 content 压缩的更小，并且 content 的边界坐标也变了，因为导致视觉上的内容移动。所以解决问题的办法就是让边框的添加不影响 content 的位置。

为元素添加边框

贸然出现的边框改变了原有的布局，让内容移动了，既然如此，我们可以在之前的布局中就让边框存在就可以了。

.test {
  height: 30vmin;
  width: 30vmin;
  background: lightblue;
  border: 5px solid transparent;
  box-sizing: border-box;
}
.test:hover {
  border: 5px solid black;
}

使用 box-shadow

使用不占用盒模型空间的 box-shadow 或者 outline 也是一种选择，

.test:hover {
  /* border: 5px solid black; */
  box-shadow: 0 0 0 5px black;
  outline: 5px solid black;
}

用 padding

我们可以通过改变 padding 大小来给 border 预留空间。

.test {
  height: 30vmin;
  width: 30vmin;
  background: lightblue;
  box-sizing: border-box;
  padding: 5px;
}
.test:hover {
  padding: 0;
  border: 5px solid black;
}

去掉模糊背景或图片的白边

Thu, 23 May 2019 12:00:00 GMT

前言

有时候我们会对页面的背景或者某个图片使用 blur 属性来达到模糊的毛玻璃效果，这样会让我们的内容更突出，不会被背景图片而干扰。但是使用模糊背景的一个问题是，在模糊的图片边缘，由于模糊效果会让底层的颜色露出来，比如我们对我们页面的背景进行模糊的时候会把 body 的背景色透出来，一般我们的 body 是白色的，所以会有一圈模糊的白边，下面来分享几种解决问题的方法。

查看代码点击页面

小图片

铺满全屏的背景和页面上的小图片的处理方法的不同的，对于页面上的小图片我们只需要给它的包含元素添加一个 overflow: hidden 就可以。

<style>
  html,
  body {
    height: 100%;
    width: 100%;
    margin: 0;
    padding: 0;
  }

  .wrap {
    height: 300px;
    width: 450px;
    margin: 20px auto;
  }
  .wrap.s2 {
    overflow: hidden;
  }
  .wrap img {
    height: 300px;
    width: 450px;
    filter: blur(5px);
  }
</style>
<div class="wrap s1"><img src="https://img.clloz.com/blog/writing/totoro.jpg" alt="" /></div>
<div class="wrap s2"><img src="https://img.clloz.com/blog/writing/totoro.jpg" alt="" /></div>

我们可以明显的看出第一个图片的边缘也是模糊效果，body 的白色透出，而第二张图片虽然也是模糊的，但是边缘却很清晰。

查看代码点击页面

全屏背景处理

处理小图片的方式非常简单，但是这个方法在页面背景上却不生效，至于为什么我也不太清楚，不过我尝试了多次，只使用 overflow: hidden 并不能让页面的背景边缘变清晰。

只能另辟蹊径了，大家的解决方法虽然代码有所不同，不过手段都差不多，都是通过扩大背景所在元素的大小来实现的，也就是说把模糊的那部分移动到可视范围之外，具体有如下几种做法。

transform: scale() 扩大

既然要改变大小，自然会想到 transform 属性，使用这个属性需要注意的是，扩大的比例。如果你的图片不需要考虑细节，那么你可以把比例调大一点。如果图片细节比较重要，那么就要选择适当的比例，还要考虑在不同大小的屏幕上的效果。

<style>
  * {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
  }
  html,
  body {
    height: 100%;
    width: 100%;
  }
  .cover {
    height: 100%;
    width: 100%;
    background: url('https://img.clloz.com/blog/writing/totoro.jpg');
    background-size: cover;
    filter: blur(5px) brightness(0.5);
    transform: scale(1.02);
  }
</style>
<div class="cover"></div>

查看代码点击页面

绝对定位

不设置背景所在元素的大小，用绝对定位的定位属性来设置图片的大小也可以达到效果。

<style>
  * {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
  }
  html,
  body {
    height: 100%;
    width: 100%;
  }
  .cover {
    position: absolute;
    top: -8px;
    right: -8px;
    bottom: -8px;
    left: -8px;
    background: url('https://img.clloz.com/blog/writing/totoro.jpg');
    background-size: cover;
    filter: blur(5px) brightness(0.5);
  }
</style>
<div class="cover"></div>

查看代码点击页面

总结

可能还有其他更好的方法，这几个方法都需要设置 body 的 overflow 为 hideen，不过这也不算什么问题，需要滚动的话再包一层就可以了。如果你有更好的办法欢迎回复。

参考文章

函数节流和函数防抖

Tue, 21 May 2019 12:00:00 GMT

前言

本文介绍函数节流 throttle 和函数防抖 debounce 的实现方法。

函数节流 throttle

函数节流就是高频触发事件，指定时间内只执行一次。

我们来想象一下需要函数节流的场景，比如典型的监听页面滚动触发回调函数，我们写一段测试代码，然后来看看多次触发的情况：

<style>
  div {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
  }
  .wrap {
    position: absolute;
    top: 50%;
    left: 50%;
    height: 200px;
    width: 200px;
    padding: 0 10px;
    transform: translate(-50%, -50%);
    border: 1px solid black;
    overflow: auto;
  }

  .content {
    width: 100%;
    height: 500px;
    background: lightblue;
  }
</style>
<div class="wrap">
  <div class="content"></div>
</div>
<script>
  var wrap = document.querySelector('.wrap')
  var content = document.querySelector('.content')
  wrap.addEventListener('scroll', function () {
    console.log('dispatch')
  })
</script>

我们为 wrap 绑定了一个滚动事件的监听，这种需求是经常用到的，比如我们需要根据用户的滚动显示不同的内容，但是很明显的是我们并不需要如此频繁地执行回调函数，我们需要让这个监听的回调函数执行的次数少一点，这时候就需要用到函数节流。

浏览器的监控肯定是固定频率持续发生的，这是我们无法控制的，我们能做的就是在执行流进入到回调函数的时候进行判断，如果不符合条件我们就不执行，这就是函数节流的原理。如何设计这个逻辑呢，我们可以利用 JavaScript 的定时器配合一个表示状态的锁来达到目的，代码如下：

wrap.addEventListener(
  'scroll',
  throttle(function () {
    console.log('dispatch: ' + new Date().getTime())
  }, 300)
)

function throttle(fn, interval) {
  var executing = false
  return function () {
    if (executing) return
    executing = true
    setTimeout(() => {
      fn.apply(this, arguments)
      executing = false
    }, interval)
  }
}

现在我们的回调函数在 executing 为 true 的时候会直接返回，而我们的功能代码也就是 fn 每隔 300ms 才会执行一次，效果如下:

需要注意的是 setTimeout 的回调函数中的 this 默认指向 window，因为 setTimeout 是 window 对象上的一个方法，调用 setTimeout 实际上是 window.setTimeout，而我们的 fn 中的 this 需要指向绑定事件的 DOM 元素，所以需要 bind ，箭头函数或者中间变量。这里我使用的箭头函数，用 apply 来设置函数执行的 this 和参数。

函数防抖 debounce

防抖 debounce 的概念其实是从机械开关和继电器的“去弹跳”（debounce）衍生出来的，基本思路就是把多个信号合并为一个信号。

编程中的函数防抖就是在事件被触发 n 秒后再执行回调，如果在这 n 秒内又被触发，则重新计时，也就是把一些高频触发事件的多次触发信号合并成一个，达到 debounce 的效果。主要针对的是回调只需要执行一次，但是事件却频繁触发，如果每次触发我们都执行回调，会造成性能的浪费。这在生活中也很常见，比如电梯门打开后默认 3s 后关闭，如果在这段时间中有人又按了按钮，会从头开始计算 3s。

这里我们用一个最常见的例子来说明，用户修改输入框输入后向后台发请求，如果用户每次修改输入我们都发请求，那么是很浪费的。我们可以设置一个 500ms 的延迟，500ms 内用户又进行了输入则重新计时，如果 500ms 内用户都没有输入则发送请求。

主要的实现思路就是用 setTimeout 和 clearTimeout，我们将待执行函数用一个 debounce 函数进行包装。当事件触发的时候我们首先进行 clearTimeout 删除之前设置的定时器，然后重新用 setTimeout 设置一个定时器。只有当事件在指定时间内没有触发了，setTimeout 的回调函数才会执行。

<!DOCTYPE html>
<html>
  <head>
    <title>debounce</title>
  </head>
  <body>
    <input id="inp" type="text" />
    <script>
      function debounce(fn, interval) {
        let timeout = null
        return function () {
          clearTimeout(timeout)
          timeout = setTimeout(() => {
            fn.apply(this, arguments)
          }, interval)
        }
      }
      function sayHi() {
        console.log('debounce success!')
      }
      var inp = document.getElementById('inp')
      inp.addEventListener('input', debounce(sayHi, 500)) // 防抖
    </script>
  </body>
</html>

总结

函数节流和函数防抖主要是应用在一些高频触发事件上，当我们的事件不需要那么高的触发频率的时候，可以用节流或者防抖处理。

想要查看文章中的示例请点击

参考文章

jQuery动画队列

Fri, 17 May 2019 12:00:00 GMT

前言

队列是 jQuery 内部的基础设施，animate 动画依赖的基础设施,整个 jQuery 中队列仅供给动画使用。

那么 jQuery 引入队列其实从一个角度上可以认为：允许一系列函数被异步地调用而不会阻塞程序。

$(selector).slideUp().fadeIn()

这是 jQuery 的一组动画链式序列，它的内部其实就是一组队列 Queue，当 slideUp 运行时，fadeIn 被放到 fx 队列中，当 slideUp 完成后，从队列中被取出运行。queue 函数允许直接操作这个链式调用的行为。同时，queue 可以指定队列名称获得其他能力，而不局限于 fx 队列。

jQuery 提供了 2 组队列操作的 API ： - jQuery.queue/dequeue - jQuery.fn.queue/dequeue

队列方法

$.queue : 显示或操作匹配的元素上已经执行的函数列队。

这个方法有两个作用，它既是 setter，又是 getter。第一个参数 elem 是 DOM 元素，第二个参数 type 是字符串，第三个参数 data 可以是 function 或数组。type 默认是 fx，也就是默认是给 fx动画队列使用的。

var body = $('body')
function cb1() {
  alert(1)
}
function cb2() {
  alert(2)
}

//set
$.queue(body, 'aa', cb1) // 第三个参数为function
$.queue(body, 'aa', cb2)

//get
$.queue(body, 'aa') //[function ,function]

Queue 源码，用 jquery 内部的 Data 对象进行缓存：

queue: function(elem, type, data) {
    var queue;
    if (elem) {
        type = (type || "fx") + "queue";
        queue = data_priv.get(elem, type);
        // Speed up dequeue by getting out quickly if this is just a lookup
        if (data) {
            if (!queue || jQuery.isArray(data)) {
                queue = data_priv.access(elem, type, jQuery.makeArray(data));
            } else {
                queue.push(data);
            }
        }
        return queue || [];
    }
},

$.dequeue : 匹配的元素上执行队列中的下一个函数。

var body = $('body')
function cb1() {
  console.log(11)
}
function cb2() {
  console.log(22)
}

//set
$.queue(body, 'aa', cb1) // 第三个参数为function
$.queue(body, 'aa', cb2)

$.dequeue(body, 'aa') //11
$.dequeue(body, 'aa') //22

将回调函数出列执行，每调用一次仅出列一个，因此当回调有 N 个时，需要调用 $.dequeue 方法 N 次元素才全部出列。源码：

var dequeue = jQuery.dequeue(elem, type),
  startLength = queue.length,
  fn = queue.shift(),
  hooks = jQuery._queueHooks(elem, type),
  next = function () {
    jQuery.dequeue(elem, type)
  }

动画队列

动画的链式调用就是用队列来实现的，当我们链式执行动画的时候，当前执行的动画在缓存中会变为 inprogress 状态，只有等这个状态结束了，后面的动画才能执行。当第一个动画执行完毕后，那么必须有一个回调通知这个去把队列中下一个执行给取出来，然后要删掉这个 inprogress 状态，依次循环。

参考文章 1. 动画队列

【翻译】JavaScript如何工作二：在V8引擎中的五个代码优化技巧

Tue, 14 May 2019 12:00:00 GMT

几个星期前我们开始了旨在深度挖掘 JavaScript 以及它是如何工作的系列文章，我们相信通过了解 JavaScript 的底层构建模块以及它们是如何工作的能够帮助我们写出更好的代码和应用。

第一篇文章主要关注的是引擎，运行时 runtime 和调用栈的概述。第二篇文章将深入剖析谷歌 V8 引擎的内部，我们还提供了一些关于如何编写更好的 JavaScript 代码的快速技巧 —— 我们 SessionStack 开发团队在开发产品的时候遵循的最佳实践。

概述

所谓 JavaScript 引擎就是一个用来执行 JavaScript 代码的程序或者解释器。一个 JavaScript 引擎可以被实现成一个标准解释器或者将 JavaScript 以某种形式编译成字节码的即使编译器。

下面是一些流行的实现 JavaScript 引擎的项目：

V8 — 由 Google 开发，使用 C++ 编写的开源引擎
Rhino — 由 Mozilla 基金会管理，完全使用 Java 开发的开源引擎
SpiderMonkey — 第一个 JavaScript 引擎，在当时支持了 Netscape Navigator，现在是 Firefox 的引擎
JavaScriptCore — 由苹果公司为 Safari 浏览器开发，并以 Nitro 的名字推广的开源引擎。
KJS — KDE 的引擎，最初是由 Harri Porten 为 KDE 项目的 Konqueror 网络浏览器开发
Chakra (JScript9) — IE 引擎
Chakra (JavaScript) — 微软 Edge 的引擎
Nashorn — 开源引擎，由 Oracle 的 Java 语言工具组开发，是 OpenJDK 的一部分
JerryScript — 这是物联网的一个轻量级引擎

为什么要创建 `V8` 引擎

由谷歌创建的 V8 引擎是一款用 C++ 开发的开源引擎，这款引擎被用在了谷歌的 Chrome 浏览器中。但是不同于其他引擎的是，V8 引擎同样被用到了非常流行的 Node.js 中。

最穿创建 V8 引擎是为了提高浏览器执行 JavaScript 的性能。为了获得更快的速度，V8 并没有使用解释器而是将 JavaScript 代码编译成了更有效率的机器码。它就像 SpiderMonkey 或者 Rhino (Mozilla) 等许多现代 JavaScript 引擎一样，通过运用即时编译器（ Just-In-Time Complier ）将 JavaScript 代码编译为机器码。而这之中最主要的区别就是 V8 不生成字节码或者任何中间代码。

`V8` 曾经有两个编译器

在 V8 引擎的 5.9 版本之前，有两个编译器：

full-codegen —— 一个简单快速的编译器，可以生成简单但是相对比较慢的机器码。
Crankshaft —— 一个更加复杂的（即时）优化编译器，可以产生高度优化的代码。

V8 引擎内部也使用了多个线程：

主线程完成你所期望的任务：编译并执行你的代码。
有一个独立的线程用来编译，当主线程执行的时候，前者可以优化代码。
分析器（ profiler ）线程可以告诉运行时 runtime 哪些方法会花费大量时间，以便 Crankshaft 可以优化他们。
其他的一些线程用来处理垃圾回收扫描

当第一次执行 JavaScript 代码的时候，V8 利用 full-codegen 直接将解析过的 JavaScript 代码不经过任何转换地翻译成机器码。这使它可以非常快速地开始执行机器码。需要注意的是，V8 不实用任何中间字节码表示，所以不需要解释器。

当你的代码已经运行了一段时间，分析器线程已经收集到足够多的数据来告诉运行时 runtime 哪些方法应该被优化。

接下来，Crankshaft 在另一个线程开始优化，它将 JavaScript 抽象语法树转换成一个叫 Hydrogen 的高级静态单元分配表示( SSA )，并且尝试去优化这个 Hydrogen 图。大多数优化都是在这个层级完成。

代码嵌入 `Inlining`

优化的第一步是尽可能多地提前嵌入代码。代码嵌入就是把调用函数的地方（函数被调用的行）用调用函数的函数体替换的过程。这简单的一步会使接下来的优化更有用。

隐藏类 `Hidden Classes`

JavaScript 是基于原型的语言：没有类或者对象是通过克隆的方法创建的。同时 JavaScript 也是一门动态的编程语言，这意味着为一个实例化的对象添加或删除属性是非常容易的。

大多数 JavaScript 解释器使用类似字典的结构 (基于散列函数) 去存储对象属性值在内存中的位置。这种结构使得在 JavaScript 中检索一个属性值比在像 Java 或者 C# 这种非动态语言中计算量大得多。在 Java 中, 编译之前所有的属性值以一种固定的对象布局确定下来了，并且在运行时不能动态的增加或者删除 (当然，C# 也有动态类型，但这是另外一个话题了)。因此，属性值 (或者说指向这些属性的指针) 能够以连续的 buffer 存储在内存中，并且每个值之间有一个固定的偏移量。根据属性类型可以很容易地确定偏移量的长度，而在 JavaScript 中这是不可能的，因为属性类型可以在运行时更改。

因为用字典的方式在内存中查找对象属性值的方法效率非常低，所以 V8 使用了一个不同的方法：隐藏类（ Hidden classes ）。隐藏类的工作方式和 Java 中的固定对象布局（类）类似，除了它是在运行时 runtime 创建的。现在，让我们来看看他们实际的样子：

function Point(x, y) {
  this.x = x
  this.y = y
}
var p1 = new Point(1, 2)

一旦 new Point(1, 2) 被调用， V8 会创建一个隐藏类叫做 C0。

由于Point 还没有被定义任何属性，所以 C0 是空的。

只要第一条语句被执行 this.x = x（在 Point 函数内），V8 将会基于 C0 创建第二个隐藏类叫做 C1。C1 描述了 x 属性在内存中的位置（相对于对象指针）。在这个例子中，x被保存在偏移量为 0 的位置。这意味着当把一个 point 对象看作内存中的连续 buffer 时，第一个偏移量对应的就是 x 属性。V8 也会使用类转换来更新 C0，当 x 属性被添加到一个 point 对象中的时候，隐藏类就从 C0 切换到 c1，此时 point 对象的隐藏类就是 c1 了。

每当一个新属性添加到对象，老的隐藏类就会通过一个转换路径更新成一个新的隐藏类。隐藏类转换非常重要，因为它们允许以相同方法创建的对象共享隐藏类。如果两个对象共享一个隐藏类，并给它们添加相同的属性，隐藏类转换能够确保这两个对象都获得新的隐藏类以及与之相关联的优化代码。

当执行语句 this.y = y (同样，在 Point 函数内部，this.x = x 语句之后) 时，将重复此过程。一个新的隐藏类 C2 被创建了，如果属性 y 被添加到 Point 对象(已经包含了 x 属性)，同样的过程，类型转换被添加到 C1 上，然后隐藏类开始更新成 C2，并且 Point 对象的隐藏类就要更新成 C2 了。

隐藏类的转换是根据属性添加到对象上的顺序来进行的，看看下面这段代码：

function Point(x, y) {
  this.x = x
  this.y = y
}
var p1 = new Point(1, 2)
p1.a = 5
p1.b = 6
var p2 = new Point(3, 4)
p2.b = 7
p2.a = 8

现在你可能认为 p1 和 p2 使用相同的隐藏类和转换。事实上并不是，对于 p1 来说首先是 a 属性被添加然后是 b 属性。对于 p2 来说，首先分配 b，然后才是 a。因此，p1 和 p2 会以不同的隐藏类和转化路径来执行。从这个例子中我们可以看出，以相同的顺序来初始化动态属性是更好的，因为这样隐藏类可以复用。

这里关于隐藏类有很多疑问，比如如果两个对象初始化顺序相同，但是数据类型不同，比如上面的 a，b 添加的顺序相同但是数据类型不同，比如一个是 Number 一个是 String，那么他们还能共享一个隐藏类吗，如果不能那么隐藏类的优势到底是什么呢？

内联缓存 `inline caching`

V8 还利用了另一种叫做内联缓存的技术来优化动态语言。内联缓存依赖于一个现象：同一个方法的重复调用是发生在相同类型的对象上的。关于内联缓存更深层次的解读请看这里。

我们来大致了解一下内联缓存的基本概念 (如果你没有时间去阅读上面的深层次的解读)。

内联缓存是如何工作的呢？V8 维护了一个对象类型的缓存，存储的是在最近的方法调用中作为参数传递的对象类型，然后 V8 会使用这些信息去预测将来什么类型的对象会再次作为参数进行传递。如果 V8 对传递给方法的对象的类型做出了很好的预测，那么它就能够绕开获取对象属性的计算过程，取而代之的是使用先前查找这个对象的隐藏类时所存储的信息。

那么隐藏类和内联缓存的概念是如何联系到一起的呢？当一个对象的方法被调用的时候，V8 引擎会查看这个对象的隐藏类以便获取访问这个对象虽对应的偏移量。当用同一个隐藏类成功调用了两次某个方法，引擎就会跳过查找隐藏类这个步骤，而把偏移量当作属性添加到对象指针里面。以后每次调用这个方法，V8 引擎都会假定对象的隐藏类没有变化，直接用对象属性上的偏移量到内存中获取特定的属性。这将大幅提高代码执行的速度。

内联缓存也是隐藏类如此重要的原因，如果我们使用不同的隐藏类创建了两个同类型的对象(就如同我们前面做的那样)，V8 就不能使用内联缓存，因为即使两个对象是相同的，但是它们对应的隐藏类对它们的属性分配了不同的偏移值。

编译成机器代码

一旦 Hydrogen 图被优化，Crankshaft 就会把这个图降低到一个比较低层次的表现形式 —— 叫做 Lithium。大多数 Lithium 实现都是面向特定的结构的。寄存器分配就发生在这一层次。最后，Lithium 被编译成机器码。然后，OSR 就开始了：一种运行时替换正在运行的栈帧的技术( on-stack replacement )。在我们开始编译和优化一个明显耗时的方法时，我们可能会运行它。V8 不会把它之前运行的慢的代码抛在一旁，然后再去执行优化后的代码。相反，V8 会转换这些代码的上下文(栈，寄存器)，以便在执行这些慢代码的途中转换到优化后的版本。这是一个非常复杂的任务，要知道 V8 已经在其他的优化中将代码嵌入了。当然了，V8 不是唯一能做到这一点的引擎。 V8 还有一种保护措施叫做反优化，能够做相反的转换，将代码逆转成没有优化过的代码以防止引擎做的猜测不再正确。

垃圾回收

对于垃圾回收，V8 使用一种传统的分代式标记清除的方式去清除老的数据。标记阶段会阻止 JavaScript 的运行。为了控制垃圾回收的成本，并且使 JavaScript 的执行更加稳定，V8 使用增量标记：与遍历整个堆去标记每一个可能的对象的不同，取而代之的是它只遍历部分堆，然后就恢复正常执行。下一次垃圾回收就会从上一次遍历停下来的地方开始，这就使得每一次正常执行之间的停顿都非常短。就像前面说的，清理的操作是由独立的线程的进行的。

如何写出优化的 `JavaScript` 代码

对象属性的顺序: 在实例化你的对象属性的时候一定要使用相同的顺序，这样隐藏类和随后的优化代码才能共享。
动态属性: 在对象实例化之后再添加属性会强制使得隐藏类变化，并且会减慢为旧隐藏类所优化的代码的执行。所以，要在对象的构造函数中完成所有属性的分配。
方法: 重复执行相同的方法会运行的比不同的方法只执行一次要快 (因为内联缓存)。
数组: 避免使用 keys 不是递增的数字的稀疏数组，这种 key 值不是递增数字的稀疏数组其实是一个 hash 表。在这种数组中每一个元素的获取都是昂贵的代价。同时，要避免提前申请大数组。最好的做法是随着你的需要慢慢的增大数组。最后，不要删除数组中的元素，因为这会使得 keys 变得稀疏。
标记值 (Tagged values): V8 用 32 位来表示对象的地址和数字。它使用最后一位一位来区分它是对象 ( flag = 1 ) 还是一个整型 ( flag = 0 )，也被叫做小整型( SMI )，因为它只有 31 位。然后，如果一个数值大于 31 位，V8 将会对其进行 box 操作，然后将其转换成 double 型，并且创建一个新的对象来装这个数。所以，为了避免代价很高的 box 操作，尽量使用 31 位的有符号数。

【翻译】JavaScript如何工作一：引擎，运行时和调用栈概述

Sun, 12 May 2019 12:00:00 GMT

前言

这是一篇翻译，在查 setInterval 的浏览器如何处理的过程中看到这一系列文章，感觉对自己理解 JS引擎 以及运行时 runtime 的工作细节有很大的帮助，决定翻译一下这一系列文章。英文水平非常烂，只能作为自己的一项练习了，虽然之前也写了浏览器渲染过程和 JS 引擎浅析，但是对很多细节理解的还不够，翻译这个系列文章应该能让我的理解更透彻和全面。

原文地址How JavaScript works: an overview of the engine, the runtime, and the call stack

随着 JavaScript 变得越来越流行，很多团队开始把它运用到不同的层级的技术栈中，前端，后端，混合式应用，嵌入式系统等。

这篇文章是系列中的第一篇，旨在深度挖掘 JavaScript 和它的工作原理：我们认为通过了解 JavaScript 的构建模块和它们如何协同工作能够帮助你写出更好的代码和应用。我们也将分享一些我们在开发 SessionStack 中的经验法则，为了保持竞争力而开发的健壮的高性能的轻量 JavaScript 应用。

如 Githut Stats 所示，JavaScript 拥有 GitHub 上最高的活跃仓库数和最高的总提交数，在其他方面也没有落后太多。

越来越多的项目开始依赖 JavaScript，也就意味着想要开发出惊艳的软件就必须深入理解这门语言和 JavaScript 生态圈提供的一切。

事实证明，虽然有大量的开发者每天用 JavaScript 作为工作但是并不理解内部的工作原理。

概述

几乎所有人都听说过 V8 引擎的概念，并且大部分人都知道 JavaScript 是单线程的以及它会用到一个回调队列。

在这篇文章中，我们将详细介绍这些概念并且说明 JavaScript 内部的运行机制。通过了解这些细节，你讲能够正确地运用提供的 API 写出更好的非阻塞的应用。

如果你是一个 JavaScript 新手，这篇文章能够帮助你理解 JavaScript 相比于其他编程语言的“奇怪”行为。

如果你是个有经验的 JavaScript 程序员，相信我，这篇文章会让你对于 JavaScript 运行时 runtime 如何工作有全新的理解。

JavaScript 引擎

最流行的 JavaScript 引擎是谷歌的 V8 引擎，他被用在 Chrome 和 Node.js 中，他的样子如下图所示：

这个引擎由两个主要部分组成： 1. 内存堆：用来分配内存。 2. 调用栈：代码执行栈帧所在位置。

运行时 runtime

浏览器提供了许多 API 供开发者使用（比如 setTimeout ），这些 API 并不是由引擎所提供。那么这些 API 到底是哪来的呢？想要说清楚这个有点复杂。

除了引擎我们还有很多其他东西。浏览器提供了很多叫做 Web APIs 的内容，比如 DOM，AJAX，setTimeout 等。

之后，我们还有非常受欢迎的事件循环（Event Loop）和回调队列（Callback Queue）。

调用栈 The Callback Queue

JavaScript 是一个单线程语言，这意味着它只有一个调用栈，同一时间只能做一件事。

调用栈是一种数据结构，它记录了我们在程序中的实际位置。当执行流进入一个函数，我们将这个函数压入调用栈顶，当这个函数执行完毕返回，我们将它从栈顶弹出。这就是调用栈所做的事情。

我们来看一个例子。看看下面这段代码：

function multiply(x, y) {
  return x * y
}
function printSquare(x) {
  var s = multiply(x, x)
  console.log(s)
}
printSquare(5)

当引擎开始执行这段代码的时候，调用栈是空的，然后执行步骤如下图所示：

每一进栈的函数都称为一个栈帧（ Stack Frame ）。

当一个异常被抛出的时候，栈轨迹（ Stack Traces ）被创建，从本质上来说这是调用栈的状态。看下面这段代码：

function foo() {
  throw new Error('SessionStack will help you resolve crashes :)')
}
function bar() {
  foo()
}
function start() {
  bar()
}
start()

如果这段代码在 Chrome 中运行（假定代码在一个叫做 foo.js 的文件中），将产生下面的栈轨迹。

Blowing the stack ——当你到达栈容量的上限就会发生。这非常容易发生，特别是当你使用递归而没有详细测试你的代码。看看下面这个例子：

function foo() {
  foo()
}
foo()

当引擎开始执行这段代码的时候，它先调用函数 foo ，但是这个函数会无限的调用它自身，所以每执行一次，同样的函数就会被添加到调用栈，一直添加到触发 Blowing the stack。具体情况大概如下图：

但是，当调用栈中的函数调用的数量超过调用栈的容量的时候，浏览器会抛出一个错误，像下图这样：

在单个线程下运行代码是一件很容易的事情，因为你不需要处理多线程环境下的复杂情况，比如死锁。

但是在单线程下运行也相当有局限，因为 JavaScript 只有一个调用栈，如果有一个任务执行的非常慢该怎么办？

并行和事件队列

如果在调用栈中有函数调用需要花费大量的时间会发生什么呢？举个例子，当你想用 JavaScript 在浏览器上实现复杂的图片变形。

你可能会问：这算是一个问题码？真正的问题是当调用栈的函数在执行的时候，浏览器什么也做不了——它被锁死了。这意味着浏览器无法渲染，也无法执行其他代码，它卡住了。如果你想让你的应用拥有流畅的 UI 这将是一个大问题。

而且这不是唯一的问题。如果你的浏览器开始处理非常多的调用栈任务，浏览器将开始陷入长时间的未响应状态。大部分的浏览器会采取抛出错误的解决办法，询问你是否要终止这个页面。这将会毁了你产品的用户体验。

那么我们如何执行复杂的代码但是不会令 UI 卡死，浏览器未响应呢？解决办法是异步回调。

关于异步回调的内容会在下一片文章详细介绍。

HTML attribute 和 DOM property 的区别

Sat, 11 May 2019 12:00:00 GMT

前言

jQuery 对象有两个方法 $(selector).prop() 和 $(selector).attr()，这两个方法分别对应 DOM 对象的 property 属性和 HTML 标签的 attribute。那么 property 和 attribute 之间有什么区别呢，一般为了区分我们把 property 翻译为属性，而把 attribute 翻译为特性。在 JS 中这两者还是存在一定的差异的。

语意

property 我们可以理解为事物本身的属性，与身俱来的，比如我们的头发是蛋白质构成的，那么蛋白质可以称为一个属性，这不可改变，改变了头发就不是头发了。

attribute 可以认为是附加在物体上的一些特性，比如我们可以改变头发的物理形状，烫卷拉直，或者改变头发的颜色，这样头发还是头发，但是外观变了。

在前端领域，我们可以认为 property 是一个 DOM 对象创建的时候就会初始化在对象中的一些属性（我们也可以自定义属性），而 attribute 是附在 HTML 文档中的某个元素上的特性，我们可以改变删除自定义一个特性，但是对 property 不可以，对于 DOM 内置的属性我们无法删除，也只能按照规定类型赋值，并且内置属性会在每次 DOM 对象初始化的时候产生，比如 name 属性，无论我们设置什么类型的值，最后返回的都是字符类型。但是对于我们自定义的 DOM 属性，则可以是任何 JS 支持的数据类型，而 attribute 的数据类型只能是字符串。

node.getAttribute(attr) 中的参数 attr 是大小写不敏感的。

两者之间的关系

对于非自定义的 attribute 特性，它和 property 之间有一一对应的关系，比如：id，class，title等。

<div id="test" class="button" foo="1"></div>
<script>
  document.getElementById('test').id // return string: "test"
  document.getElementById('test').className // return string: "button"
  document.getElementById('test').foo // return undefined 因为foo是一个自定义的attr特性
</script>

当我们通过 property 属性进行设置或获取 class 时，我们需要使用 className ，因为在 js 中 class 是关键字。

DOM 对象内置的 property 改变的时候通常对应的 attribute 也会改变。

<div id="test" class="button"></div>
<script>
  var div = document.getElementById('test')
  div.className = 'red-input'
  div.getAttribute('class') // return string: "red-input"
  div.setAttribute('class', 'green-input')
  div.className // return string: "green-input"
</script>

一些特殊情况

href

当我们在 HTML 中设置元素的 href 属性的时候，getAttribute() 方法返回的是我们设置的字符串，不管这是一个相对路径还是绝对路径，而 node.href 属性则是获得的能够访问的绝对路径。

input 的 value

当我们在 HTML 中设置 input 的 value 的时候，这个 value 只是给了 input 一个初始化的值，property 也被这个值初始化，但当我们改变 property 的时候，元素内的文本会被改变，但是 attribute 的 value 是不变的，它相当于保存这这个元素的初始化状态。

布尔型属性

因为 attribute 的值只能是字符串，当我们设置的 attribute 默认是一个布尔型的值的时候，不论我们是否设置值以及设置什么值，他的初始化值都是 true，比如 disabled 和 checked。并且我们只能通过 property 来修改他们。

如何使用

对于非自定义 attribute 使用 property 是一种比较安全并且有效率的做法，虽然对于 id， class 等会跟随 property 一起变化的属性我们也可以用 getAttribute() 或者 setAttribute() ，不过显然 property 是更好的选择。对于自定义属性，我们只能选择用 attribtue 的方法。

参考文章

前端数据Mock

Fri, 10 May 2019 12:00:00 GMT

前言

对于前后端分离的开发，两边的开发进度不同是常有的事情，对于已经开发的功能，如何快速有效地模拟接口的请求是提高开发效率的关键，下面来讲讲几种数据 mock 的方法。

http-server

如果我们只是测试一段 JS 代码在对应数据下是否能够跑通，那么我们可以直接使用 nodejs 提供的静态服务器 http-server，将我们需要的数据保存到一个 json 文件中，然后通过请求获取。需要注意的是我们访问请求发起的页面的时候必须也通过静态服务器访问，否则会因为同源策略禁止访问对应文件。

<!-- 前端 代码 index.html -->
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>test</title>
    <link rel="stylesheet" href="test.css" />
  </head>
  <body>
    this is a test page.
    <script>
      var xhr = new XMLHttpRequest()
      xhr.open('GET', './test.json', true)
      xhr.onload = function () {
        console.log(xhr.responseText)
      }
      xhr.send()
    </script>
  </body>
</html>

这样的话，我们只要在 index.html 的同级目录下创建对应的数据 json 文件，就可以模拟 GET 请求了。当我们访问 localhost:8080/index.html 的时候，对应文件夹的静态资源我们都能够请求到。

Mock.js

mock.js 是一个用于拦截前端 ajax 请求并生成随机数据响应的工具，可以用来模拟服务器响应。使用非常简单方便，不需要更改任何代码就可以直接拦截 ajax 请求并返回随机数据，支持多种数据类型，也支持正则表达式。

使用方法：

npm安装

安装：npm install mockjs

// 使用 Mock
var Mock = require('mockjs')
var data = Mock.mock({
  // 属性 list 的值是一个数组，其中含有 1 到 10 个元素
  'list|1-10': [
    {
      // 属性 id 是一个自增数，起始值为 1，每次增 1
      'id|+1': 1
    }
  ]
})
// 输出结果
console.log(JSON.stringify(data, null, 4))

bower

安装：npm install -g bower bower install --save mockjs 使用：<script type="text/javascript" src="./bower_components/mockjs/dist/mock.js"></script>

或者直接在页面引入 <script src="http://mockjs.com/dist/mock.js"></script>

mock.js 还可以用可视化工具 ease-mock，在线就可以添加接口和数据，使用也很方便

搭建后台

最好的 mock 数据的方法其实还是自己用 nodejs 写一个简单的后端来通信，这样可以自己制定各种数据，各种请求，实现起来也不是非常麻烦，接收请求，做好路由，返回数据就可以了，对于需要跨域的请求也可以更好的处理，比如：

var http = require('http')
var url = require('url')
var querystring = require('querystring')
var util = require('util')

var routes = {
  '/test': function (req, res) {
    console.log(req.method)
    if (req.method === 'GET') {
      console.log(req.headers.cookie)
      res.setHeader('Access-Control-Allow-Origin', 'http://localhost:8081')
      res.setHeader('Access-Control-Allow-Credentials', true)
      res.writeHead(200, 'Ok')
      res.write(`success`)
      res.end()
    } else {
      var post = ''
      req.on('data', function (chunk) {
        post += chunk
      })
      req.on('end', function () {
        res.setHeader('Access-Control-Allow-Origin', 'http://localhost:8081')
        res.setHeader('Access-Control-Allow-Credentials', true)
        res.setHeader('Access-Control-Request-Method', 'PUT,POST,GET,DELETE,OPTIONS')
        res.setHeader(
          'Access-Control-Allow-Headers',
          'Origin, X-Requested-With, Content-Type, Accept, t'
        )
        res.end('success')
      })
    }
  }
}

var server = http.createServer(function (req, res) {
  var pathObj = url.parse(req.url, true)
  var handleFn = routes[pathObj.pathname]
  if (handleFn) {
    handleFn(req, res)
  }
})

server.listen(8080)
console.log('server on 8080...')

参考文章

mock.js使用

URL特殊字符和JS编码解码方法

Thu, 09 May 2019 12:00:00 GMT

前言

我们在操作 URL 的时候经常需要处理其中的特殊字符，因为在 URL 中有很多字符是有特殊意义的，比如 ?，&，=等等，如果在处理 URL 的时候不对这些特殊字符进行转义，那么浏览器很可能会错误解析 URL，所以一般的编程语言都提供了对 URL 进行编码解码的 API，在 JS 中也有对应的方法 encodeURI，decodeURI 和 encodeURIComponent，decodeURIComponent。

escape 方法已经从标准中移除，虽然有些浏览器还支持，但是尽量使用上面的方法。

URL编码

URL 编码也称作百分号编码 Percent-encoding，是对我们在 HTTP 请求中的 URL 实行的编码机制。因为我们的资源路径中的字符很有可能是在 URL 中有特殊意义的字符，比如我在本地保存一个文件名叫 test test.txt，中间有一个空格，当我把这个文件上传到服务器比如说阿里云 oss 中的时候，如果我要复制这个资源的路径就会编程 https://cdn1.clloz.com/test%20test.txt，我们的空格被转义称为 %20（这里的百分号有点像我们平常用来转义的 \ ），如果不进行转义，浏览器无法明白这个 URL 到底是什么意思。我们对资源或者目录的命名是可以包含任意字符，比如空格，?甚至是各种不同的语言的字符编码，为了能让我们在请求资源的时候有一个统一的标准，必须对 URL 进行编码。

再举两个例子：例如 URL 参数字符串中使用 key=value 键值对这样的形式来传参，键值对之间以 & 符号分隔，如 /s?q=abc&ie=utf-8。如果你的 value 字符串中包含了 = 或者 &，那么势必会造成接收URL的服务器解析错误，因此必须将引起歧义的 & 和 = 符号进行转义，也就是对其进行编码。

又如，URL 的编码格式采用的是 ASCII 码，而不是 Unicode，这也就是说你不能在 URL 中包含任何非 ASCII 字符，例如中文。否则如果客户端浏览器和服务端浏览器支持的字符集不同的情况下，中文可能会造成问题。

URL中的字符

URL 中的字符分为保留字符和未保留字符，保留字符是那些具有特殊含义的字符，例如：斜线字符用于URL（或 URI ）不同部分的分界符；未保留字符没有这些特殊含义。百分号编码把保留字符表示为特殊字符序列。

保留字符： * ' ( ) ; : @ & = + $ , / ? # [ ] (RFC 3986 section 2.2 保留字符 (2005年1月))
未保留字符：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 - _ . ~ (RFC 3986 section 2.2 保留字符 (2005年1月))

URI 中的其它字符必须用百分号编码。

因为保留字符在 URL 中具有特殊的含义，所以当我们的路径中使用保留字符作为普通字符的时候就必须进行转义，其实保留字符的转义非常简单，就是在对应保留字符的 ASCII 码对应的十六进制数前面加上转义字符 % 即可。对于非 ASCII 字符, 需要转换为 UTF-8 字节序, 然后每个字节按照上述方式表示。

例如，/, 如果用作 URI 的路径成分的分界符, 则是具有特殊含义的保留字符. 如果该字符需要出现在 URI 一个路径成分的内部, 则三字符序列%2F或 %2f 就用于代替原本的 / 出现在该 URI 路径成分的内部。

| 保留字符 | 编码 | | -------- | ------ | | 空格 | %20 | | ! | %21 | | " | %22 | | # | %23 | | $ | %24 | | % | %25 | | & | %26 | | ' | %27 | | ( | %28 | | ) | %29 | | * | %2A | | + | %2B | | , | %2C | | / | %2F | | : | %3A | | ; | %3B | | < | %3C | | = | %3D | | > | %3E | | ? | %3F | | @ | %40 | | [ | %5B | | \ | %5C | | ] | %5D |

JS中的URL编码解码方法

JS 中提供了两组用来编码解码 URL 的方法，encodeURI，decodeURI 和 encodeURIComponent 和 decodeURIComponent。两组方法功能一样，都是用来对 URI 进行编码或者解码，不同的是对编码字符的范围有所不同，encodeURI 的范围要比 encodeURIComponent 小一些。

encodeURI 会转义除以下字符的所有字符：

| 类型 | 包含 | | ------------ | ----------------------------------------------------- | | 保留字符 | ; , / ? : @ & = + $ | | 非转义的字符 | A-Z a-z 0-9 - _ . ! ~ * ' ( ) | | 数字符号 | # |

encodeURIComponent 会转义除了转义除了字母、数字、(、)、.、!、~、*、'、-和 _ 之外的所有字符。

对于非 ASCII 码的字符，这两个方法都会将对应的字符的多字节的 UTF-8 编码转义成单字节的 16 进制数，比如 你好吗 的 UTF-8 编码是 E4BDA0 E5A5BD E59097 就会被这两个方法转义为 %E4%BD%A0 %E5%A5%BD %E5%90%97，每个字都是三个字节，就被转义为三个两位的 16 进制数。

参考文章

浏览器同源策略和跨域方法

Wed, 08 May 2019 12:00:00 GMT

前言

了解浏览器的同源策略和各种跨域方式是所有前端都必须熟练掌握的知识，因为在开发的过程中遇到跨域请求是常有的事情，包括我们自己 mock 数据的时候也可能遇到跨域的问题，如果不能理解同源策略那么每次遇到跨域都可能不能快速解决。

同源策略

同源策略是一个重要的安全策略，它用于限制一个 origin 的文档或者它加载的脚本如何能与另一个源的资源进行交互。它能帮助阻隔恶意文档，减少可能被攻击的媒介。

同源策略是浏览器的策略，会在请求从服务返回的时候检查响应头中的 Access-Control-Allow-Origin 和请求头中的 origin 是否匹配，如果不匹配则报错。

源 origin

我们使用浏览器浏览网页的时候，大多数情况都是通过 http 请求去访问对应主机（ host ）上的资源（ resource ），一般同一个主机同一个端口同一个协议就会被认为是一个源，一般我们会说同协议同域名同端口的请求浏览器会认为是同源的请求。可能很多人刚看到这个策略的时候跟我有一样的想法，为什么是同一个域名而不是同一个 IP 呢？在 MDN 的英文文档里面写的是 host 也就是主机，要更好的理解什么是源我们要从服务器的角度来理解。我们的服务器上用来处理 http 请求的一般是 web 服务器，比如 apapce 、 nginx 等，在 web 服务器的配置中我们会配置我们的网站域名和根目录一般默认绑定到 80 端口，比如 /var/www/html 当 web 服务器接收到 http 请求对应目录的资源的时候就会去我们绑定的目录搜索对应的资源。但是一个 web 服务器下面可以绑定多个主机，我们可以用虚拟主机来做域名和目录的映射，如下

<VirtualHost 127.0.0.1:80>
    ServerAdmin yourname@domain.com
    DocumentRoot "E:/server110.com/wordpress-latest"
    ServerName server110.com
    ServerAlias www.server110.com
    ErrorLog "logs/wplatest.com-error.log"
    CustomLog "logs/server110.com-access.log" combined
</VirtualHost>
<VirtualHost 127.0.0.2:80>
    ServerAdmin yourname@domain.com
    DocumentRoot "E:/server110.com/wordpress-2.9.2"
    ServerName server110.com
    ServerAlias www.server110.com
    ErrorLog "logs/server110.com-error.log"
    CustomLog "logs/server110.com-access.log" combined
</VirtualHost>

当 web 服务器接受到请求的时候会看看是请求头中的 host 参数，在根据配置文件到对应的目录寻找资源。正因为这个原因，同源的定义就是 same-host，同一个主机。而 web 配置目录的方法不止虚拟主机一种方式，还可以利用不同的端口进行映射，比如网站 a 的目录 /var/www/a 映射到 80 端口，而另一个网站 b 的目录 /var/www/b 的目录映射到 8080 端口，配置方法就是把上面的配置文件中的端口改成自己需要的。我们在往上购买的虚拟主机，大部分都是通过这种办法来配置多个网站的，也就是说这些网站的 IP 地址都是相同的，但是他们的拥有者不同，这也就是浏览器要对源之间的互动进行限制的原因。最后就是 http 和 https，这两者如果不同，那么通信的过程都是不相同的，浏览器自然是不允许的，而且一般网站配置了 https 那么所有的资源请求都会是 https ，一般不会出现混用。

根据上面的规则我们举个是否同源的例子，以我的域名 https://www.clloz.com 为例，我这个域名解析到了我阿里云主机的 ip，web服务器根据配置文件可以知道该 host 的请求去对应的文件夹取资源，比如有用户请求 https://www.clloz.com/index.html, 那么服务器就会返回这个页面。如果这个 index.html 中的脚本发送如下请求，我们可以判断是否同源：

| URL | 结果 | 原因 | | --------------------------------------- | ---- | ------------ | | https://www.clloz.com/study/test.html | 成功 | 只有路径不同 | | http://www.clloz.com/test.json | 失败 | 协议不同 | | https://www.clloz.com:8080 | 失败 | 端口不同 | | https://test.clloz.com/test.json | 失败 | 域名不同 | | https://clloz.com/test.json | 失败 | 域名不同 |

主机和域名的区别：一般来说我们申请一个域名是一个二级域名比如 clloz.com（也有认为顶级域和二级域之间还有一级域，阿里云就是这样的方式），顶级域名就是就是域名最后的那个部分，比如我们常见的 .com .cn .org .edu 等，顶级域名前面一个就是二级域名比如我的域名中的 clloz，以此类推。当我们购买了一个域名以后，我们可以为其添加主机记录进行解析，比如我可以添加一个 www 的主机记录解析到我的服务器 ip，也可以添加一个 test 主机记录解析到 http://www.clloz.com:8080，这些添加了主机记录的能访问到服务器上具体文件的域名就称为 host 主机名，在我们发送请求的时候，二者可以混用。

为什么要有同源策略

其实上面解释源的时候就已经能够明白为什么浏览器要使用同源策略了，我们来看看文档和历史。MDN 的解释如下 The same-origin policy is a critical security mechanism that restricts how a document or script loaded from one origin can interact with a resource from another origin. It helps isolate potentially malicious documents, reducing possible attack vectors. 大概意思就是同源策略限制了一个源上的文档或者脚本和另一个源上的资源互动的方式。主要的目的是为用户的安全，隔离潜在恶意文件的重要安全机制。

同源策略最早有网景在1995年引入，现在所有的浏览器都实行这个策略。最早同源是为了针对客户端上保存状态的 cookie。为了解决 http 协议无状态带来的用户状态无法保存的情况引入了 cookie，如果不同源的网站能够共享 cookie 会带来非常严重的安全问题，比如我们登录了某个支付网站或者网上银行没有登出，这时候点进了一个危险的网页，这个网页可以利用我们的 cookie 去登录，这是非常危险的，所以最早的同源策略就是针对这样的情况，每个源之间的 cookie 都是独立的（父域子域可以共享，后面会说）。但是随着 web 的发展，网站提供的服务越来越多，越来越复杂，也出现了更多的攻击手段，所以为了安全，浏览器不得不提升同源策略覆盖的范围。

再举个例子比如钓鱼网站，有人给你发邮件引诱你点击支付宝链接 alipay.com，但实际你打开的链接是一个 aliipay.com，这个页面用 iframe 显示支付宝页面。如果没有同源策略，它完全可以获取你输入的用户名和密码。

;<iframe name='alipay' src='www.alipay.com'></iframe>
// JS
// 由于没有同源策略的限制，钓鱼网站可以直接拿到别的网站的Dom
const iframe = window.frames['alipay']
const node = iframe.document.getElementById('你输入账号密码的Input')
console.log(`拿到了这个${node}，我还拿不到你刚刚输入的账号密码吗`)

安全和灵活的矛盾

同源策略确实提高了网站的安全性，让攻击者攻击网站的难度提高，用户也不会因为误点恶意链接而遭受损失，但是对于开发者来说，多个子系统之间的互动是必要的，浏览器一刀切的同源策略有时候会带来很大的麻烦，从这方面看安全性和交互的灵活性是一对矛盾。所以浏览器在同源策略的制定上还是对交互做了一定的妥协，比如我们都知道的直接用链接嵌入其他源中的 css，js 和 image，父域和子域之间可以共享 cookie等。

跨源交互细节

为了解决跨域导致的跨源交互不便，浏览器制定了跨源交互的规则，通常情况下： 1. 允许跨源写( cross-origin write )，例如链接(links)，重定向以及表单提交。特定少数的 HTTP 请求需要添加 preflight。经过测试，用 XMLHttpRequest 对象给后台发送文件也不会被同源策略拦截。 2. 允许跨域资源嵌入。 3. 不允许跨源读取资源，但常可以通过内嵌资源来巧妙的进行读取访问。例如，你可以读取嵌入图片的高度和宽度，调用内嵌脚本的方法。

之所以允许跨源写而不允许跨源读，我认为是跨源写的操作不会泄露关键信息，只是将信息发送到服务器。而跨源读操作则可能造成用户信息的泄露。

总的来说同源策略的影响是：

Cookie、LocalStorage 和 IndexDB 无法读取
DOM和JS对象无法获得
AJAX 请求无法接受响应(请求成功发出，响应也返回浏览器，但浏览器抛错)

跨域嵌入的方式：

<script src="..."></script> 标签嵌入跨域脚本
<link rel="stylesheet" href="..."> 标签嵌入CSS
<img>嵌入图片
<video> 和 <audio> 嵌入多媒体资源
<object>, <embed> 和 <applet>的插件。
@font-face 引入的字体。一些浏览器允许跨域字体( cross-origin fonts)，一些需要同源字体(same-origin fonts)
<frame> 和 <iframe> 载入的任何资源。站点可以使用 X-Frame-Options 消息头来阻止这种形式的跨域交互。

浏览器的具体同源策略没有找到标准的文档，不过大致的思路就是我们可以向不同源的发送信息，不可以从不同的源接收信息，我把上面的内容和查到的规则整理如下：

对于嵌入到页面的 ifram (如果 X-Frame-Options 允许)，无法访问 iframe 的文档，也就是不能操作 DOM 对象。
css 文件可以通过 link 标签嵌入或者 @import 方式引入，可能需要 Content-type 支持。
form 表单，action 可以使用跨源 URL，利用表单的提交可以将表单中的数据写入跨源目标。
可以用 img 标签嵌入图像，但是无法读取图像的数据(例如 canvas 使用 JavaScript 将跨源图像加载到元素中)，如果需要读取图像，需要为图片所在服务器开启 cors，并且为图片加上属性 crossOrigin=anonymous，其实是和开启 cors 的 ajax 请求没有区别。CORS_enabled_image
可以使用 video 和 audio 元素嵌入跨源视频和音频。
可以嵌入跨源脚本; 但是，可能会阻止对某些API的访问，例如跨源的 ajax 或者 fetch 请求。根据我的测试，用 ajax 对跨源接口发送文件并不会触发同源策略，能够成功发送。
存储在浏览器中的数据，如 localStorage 和 IndexedDB，以源进行分割。每个源都拥有自己单独的存储空间，一个源中的 Javascript 脚本不能对属于其它源的数据进行读写操作。
一个页面可以为本域和任何父域设置 cookie，只要是父域不是公共后缀( public suffix )即可。

对于嵌入图片的读取可以测试如下代码：

<!-- 嵌入一张跨域的google logo -->
<img
  crossorigin="anonymous"
  src="https://www.google.com/images/branding/googlelogo/2x/googlelogo_color_272x92dp.png"
  alt=""
/>
<script>
  function main() {
    var img = document.querySelector('img')
    img.onload = function () {
      var canvas = document.createElement('canvas')
      canvas.width = img.width
      canvas.height = img.height

      // Copy the image contents to the canvas
      var ctx = canvas.getContext('2d')
      ctx.drawImage(img, 0, 0)

      var dataURL = canvas.toDataURL('image/png')

      var data = dataURL.replace(/^data:image\/(png|jpg);base64,/, '')
      console.log(data)
    }
  }
  main()
</script>

执行这个 HTML 浏览器会告诉你跨域了，解决的方式就是给图片加上 crossorigin="anonymous" 属性，并且图片所在服务器要开启 cors。

对于 ajax 发送的文件，大家可以用 nodejs 写一个简单的服务端，前端用 formdata 发送即可，并不会被浏览器拦击。

CSRF 跨站请求伪造

由于同源策略允许跨源写操作，所以攻击者可以利用这一点来攻击，这种攻击称为跨站请求伪造 Cross Site Request Forgery，它通常发音为 sea-surf，也经常被称为 XSRF。

跨站点请求伪造(CSRF)迫使最终用户在当前已通过身份验证的Web应用程序上执行不需要的操作。在社会工程学的一点帮助下(例如通过电子邮件或聊天发送链接)，攻击者可能会诱骗 Web 应用程序的用户执行攻击者选择的操作。如果受害者是普通用户，则成功的 CSRF 攻击会迫使用户执行状态更改请求，例如转移资金，更改其电子邮件地址等。如果受害者是管理帐户，CSRF 可能会破坏整个 Web 应用程序。

当我们登录了一个网站，会将登录信息保存在 cookie 中，当我们下次发送请求的时候就连同 cookie 一起发送来验证身份，而不需要重新登录。跨站请求伪造就是利用这种机制，向你已经登录的网站再次发起请求，并带上自己的参数，这是一个跨源写操作，所以能够正常发送。

比如你登录了银行账户给别人转账，链接https://your-bank.com/transfer/xxx，此时如果攻击者给你发了个链接是一个表单：

<form action="https://your-bank.com/transfer" method="POST" id="stealMoney">
  <input type="hidden" name="to" value="attacker_account" />
  <input type="hidden" name="account" value="your_account" />
  <input type="hidden" name="amount" value="$1,000" />
</form>

攻击者将收款账户改为自己的，此时提交表单，由于发送给 https://your-bank.com/ 的请求会带上你刚刚登录的 cookie，验证成功，你的钱就打到了攻击者的账户。当然这只是一个例子，说明了攻击的可能性。在你没有登录的情况下，这种攻击是无效的。所以攻击者一般会利用社会工程学，诱骗你先登录银行账户，然后在诱骗你点击攻击用的链接。一般有两种情况：

发送带有 HTML 内容的未经请求的电子邮件
在受害者也进行在线银行业务时可能会访问的页面上植入漏洞利用 URL 或脚本，甚至可能只是一张图片。

关于跨站请求伪造攻击可以参考：跨站请求伪造（CSRF）

要避免跨站请求伪造可以在服务端检查 origin 和 referer，当然这也不是绝对安全的。

还可以通过将一个称为 CSRF 令牌的令牌发送到网页。每次发出新请求时，都会发送并验证此令牌。因此，向服务器发出的恶意请求将通过 cookie 身份验证，但 CSRF 验证会失败。大多数 Web 框架为防止 CSRF 攻击提供了开箱即用的支持，而 CSRF 攻击现在并不像以前那样常见。

跨域方法

同源策略我们已经掌握，但是浏览器的这种一刀切的做法有时候会为开发带来不便。特别是在有多个子系统的网站中，需要跨域通信的情况肯定会多，我们会把各个子系统布置在不同的主机上，所以如何饶考同源策略进行跨域请求，是每个前端必须熟练掌握的。

JSONP

JSONP就是利用同源策略中允许跨域资源嵌入的这条规定来进行跨域请求的，script 标签请求的脚本会立即执行，那么只要请求中传给后端一个函数名，后端将函数名和数据拼接成执行函数的字符串返回给前端，浏览器解析的时候就相当于直接执行这个带参数的函数。前端代码：

<body>
  <script>
    function success(data) {
      console.log(data)
    }
  </script>

  <script src="http://localhost:8080/test?callback=success"></script>
</body>

后端代码：

var http = require('http')
var url = require('url')

var routes = {
  '/test': function (req, res) {
    var cb_str = url.parse(req.url, true).search
    res.writeHead(200, 'Ok')
    var cb = cb_str.split('=')[1]
    console.log(cb)
    res.write(cb + `({result: "success"})`)
    res.end()
  }
}

var server = http.createServer(function (req, res) {
  var pathObj = url.parse(req.url, true)
  var handleFn = routes[pathObj.pathname]
  if (handleFn) {
    console.log(pathObj)
    handleFn(req, res)
  }
})

server.listen(8080)
console.log('server on 8080...')

前端嵌入的 script 标签在请求的时候带上了函数名 success 作为请求参数，后端接收到请求后将前端需要的数据 {result: "success"} 连带函数名拼接成 success({result: "success"}) 返回给浏览器，浏览器会直接将返回的字符串当作 js 执行，由于我们前面已经定义了 success 函数，所以这段代码会直接给 success 函数带上参数执行，这样就实现了跨域请求。

JSONP 只能发送 GET 请求

利用 form 提交跨域请求

由于 form 表单的功能是把数据发送给对应 action，所以并没有被同源策略限制，所以我们可以用在脚本中创建 form 并提交的方法来和跨域接口进行通信，用这种方法我们可以发送 GET 和 POST 请求，但是我们没法接收服务器返回的数据，不过可以利用设置 form 的 target 到一个空的 iframe 并监听 iframe 的 load 事件来确定请求是否发送成功。

CORS

跨域资源共享(CORS) 是一种机制，它是 HTTP 的一部分，它使用额外的 HTTP 头来告诉浏览器让运行在一个 origin(domain) 上的 Web应用被准许访问来自不同源服务器上的指定的资源。cors 的标准参考 Fetch - whatwg

CORS 需要浏览器和服务器同时支持。目前，所有浏览器都支持该功能，IE浏览器不能低于 IE10。

整个 CORS 通信过程，都是浏览器自动完成，不需要用户参与。对于开发者来说，CORS 通信与同源的AJAX通信没有差别，代码完全一样。浏览器一旦发现AJAX 请求跨源，就会自动添加一些附加的头信息，有时还会多出一次附加的请求，但用户不会有感觉。

因此，实现 CORS 通信的关键是服务器。只要服务器实现了 CORS 接口，就可以跨源通信。

跨源域资源共享（ CORS ）机制允许 Web 应用服务器进行跨源访问控制，从而使跨源数据传输得以安全进行。现代浏览器支持在 API 容器中（例如 XMLHttpRequest 或 Fetch ）使用 CORS，以降低跨源 HTTP 请求所带来的风险。

在哪些情况下需要使用 cors 呢：

由 XMLHttpRequest 或 Fetch 发起的跨源 HTTP 请求。
Web 字体 (CSS 中通过 @font-face 使用跨源字体资源)，因此，网站就可以发布 TrueType 字体资源，并只允许已授权网站进行跨站调用。
WebGL 贴图
使用 drawImage 将 Images/video 画面绘制到 canvas

浏览器将 CORS 请求分成两类：简单请求（ simple request ）和非简单请求（ not-so-simple request ）。只要同时满足以下两大条件，就属于简单请求。

请求方法是以下三种方法之一：
- HEAD
- GET
- POST
除了被用户代理自动设置的首部字段（例如 Connection ，User-Agent）和在 Fetch 规范中定义为禁用首部名称的其他首部，允许人为设置的字段为 Fetch 规范定义的对 CORS 安全的首部字段集合。该集合为：
- Accept
- Accept-Language
- Content-Language
- Last-Event-ID
- Content-Type：只限于三个值 application/x-www-form-urlencoded、multipart/form-data、text/plain
- DPR
- Downlink
- Save-Data
- Viewport-Width
- Width
请求中的任意 XMLHttpRequestUpload 对象均没有注册任何事件监听器；XMLHttpRequestUpload 对象可以使用 XMLHttpRequest.upload 属性访问。
请求中没有使用 ReadableStream 对象。

注意: 这些跨站点请求与浏览器发出的其他跨站点请求并无二致。如果服务器未返回正确的响应首部，则请求方不会收到任何数据。因此，那些不允许跨站点请求的网站无需为这一新的 HTTP 访问控制特性担心。

简单请求

对于简单请求，前端什么都不需要做，浏览器会自动在我们的请求头中加一个字段 origin 向后端说明我们的源，服务器根据这个字段来决定是否同意该请求，如果 Origin 指定的源，不在许可范围内，服务器会返回一个正常的 HTTP 回应。浏览器发现，这个回应的头信息没有包含 Access-Control-Allow-Origin 字段，就知道出错了，从而抛出一个错误，被 XMLHttpRequest 的 onerror 回调函数捕获。注意，这种错误无法通过状态码识别，因为HTTP回应的状态码有可能是 200。

如果服务器同意该次跨域请求，那么在响应头中会多出以下字段

Access-Control-Allow-Origin ：指定了允许访问该资源的外域 URI。对于不需要携带身份凭证的请求，服务器可以指定该字段的值为通配符，表示允许来自所有域的请求。
Access-Control-Allow-Credentials ：该字段可选。它的值是一个布尔值，表示是否允许发送 Cookie。默认情况下，Cookie 不包括在 CORS 请求之中。设为 true，即表示服务器明确许可， Cookie 可以包含在请求中，一起发给服务器。这个值也只能设为 true，如果服务器不要浏览器发送 Cookie，删除该字段即可。该字段为 true 的时候，Access-Control-Allow-Origin 必须为一个具体的值，不能设为通配符，并且需要前端配合设置 xhr.withCredentials = true;
Access-Control-Expose-Headers：该字段可选。CORS 请求时，XMLHttpRequest 对象的 getResponseHeader() 方法只能拿到6个基本字段：Cache-Control、Content-Language、Content-Type、Expires、Last-Modified、Pragma。如果想拿到其他字段，就必须在Access-Control-Expose-Headers里面指定。如 Access-Control-Expose-Headers: X-My-Custom-Header, X-Another-Custom-Header。

简单请求的前后端示例代码如下：

//前端请求
document.cookie = 'name=clloz'
var xhr = new XMLHttpRequest()
xhr.open('get', 'http://localhost:8080/test', true)
xhr.withCredentials = true //请求想要发送cookie必须设置withCreadentials
xhr.onload = function () {
  console.log(xhr.responseText)
}
xhr.send()

//后端代码
var http = require('http')
var url = require('url')
var querystring = require('querystring')
var util = require('util')

var routes = {
  '/test': function (req, res) {
    console.log(req.method)
    if (req.method === 'GET') {
      console.log(req.headers.cookie)
      res.setHeader('Access-Control-Allow-Origin', 'http://localhost:8081')
      res.setHeader('Access-Control-Allow-Credentials', true) //允许前端发送cookie
      res.writeHead(200, 'Ok')
      res.write(`success`)
      res.end()
    }
  }
}

var server = http.createServer(function (req, res) {
  var pathObj = url.parse(req.url, true)
  var handleFn = routes[pathObj.pathname]
  if (handleFn) {
    handleFn(req, res)
  }
})

server.listen(8080)
console.log('server on 8080...')

非简单请求

非简单请求是那种对服务器有特殊要求的请求，比如请求方法是 PUT 或 DELETE，或者 Content-Type 字段的类型是 application/json。

非简单请求的 CORS请求，会在正式通信之前，增加一次 HTTP 查询请求，称为"预检"请求（ preflight request ）。浏览器先询问服务器，当前网页所在的域名是否在服务器的许可名单之中，以及可以使用哪些 HTTP 方法和头信息字段。只有得到肯定答复，浏览器才会发出正式的 XMLHttpRequest 请求，否则就报错。看一个预检请求报文和响应报文：

var invocation = new XMLHttpRequest()
var url = 'http://bar.other/resources/post-here/'
var body = '<?xml version="1.0"?><person><name>Arun</name></person>'

function callOtherDomain() {
  if (invocation) {
    invocation.open('POST', url, true)
    invocation.setRequestHeader('X-PINGOTHER', 'pingpong')
    invocation.setRequestHeader('Content-Type', 'application/xml')
    invocation.onreadystatechange = handler
    invocation.send(body)
  }
}

OPTIONS /resources/post-here/ HTTP/1.1
Host: bar.other
User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.1b3pre) Gecko/20081130 Minefield/3.1b3pre
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Connection: keep-alive
Origin: http://foo.example
Access-Control-Request-Method: POST
Access-Control-Request-Headers: X-PINGOTHER, Content-Type


HTTP/1.1 200 OK
Date: Mon, 01 Dec 2008 01:15:39 GMT
Server: Apache/2.0.61 (Unix)
Access-Control-Allow-Origin: http://foo.example
Access-Control-Allow-Methods: POST, GET, OPTIONS
Access-Control-Allow-Headers: X-PINGOTHER, Content-Type
Access-Control-Max-Age: 86400
Vary: Accept-Encoding, Origin
Content-Encoding: gzip
Content-Length: 0
Keep-Alive: timeout=2, max=100
Connection: Keep-Alive
Content-Type: text/plain

"预检"请求用的请求方法是 OPTIONS，表示这个请求是用来询问的。头信息里面，关键字段是 Origin，表示请求来自哪个源。除了 Origin 字段，"预检"请求的头信息包括两个特殊字段。

Access-Control-Request-Method：该字段是必须的，用来列出浏览器的 CORS 请求会用到哪些 HTTP 方法
Access-Control-Request-Headers：该字段是一个逗号分隔的字符串，指定浏览器 CORS 请求会额外发送的头信息字段

服务器收到"预检"请求以后，检查了Origin、Access-Control-Request-Method 和Access-Control-Request-Headers 字段以后，确认允许跨源请求，就可以做出回应。如果服务器否定了"预检"请求，会返回一个正常的 HTTP 回应，但是没有任何 CORS 相关的头信息字段。这时，浏览器就会认定，服务器不同意预检请求，因此触发一个错误，被 XMLHttpRequest 对象的 onerror 回调函数捕获。控制台会打印出如下的报错信息。通过的预检请求，服务器响应头中会有如下字段：

Access-Control-Allow-Methods：该字段必需，它的值是逗号分隔的一个字符串，表明服务器支持的所有跨域请求的方法。注意，返回的是所有支持的方法，而不单是浏览器请求的那个方法。这是为了避免多次"预检"请求。
Access-Control-Allow-Headers：如果浏览器请求包括 Access-Control-Request-Headers 字段，则 Access-Control-Allow-Headers 字段是必需的。它也是一个逗号分隔的字符串，表明服务器支持的所有头信息字段，不限于浏览器在"预检"中请求的字段。
Access-Control-Allow-Credentials：和简单请求中相同。
Access-Control-Max-Age : 该字段可选，用来指定本次预检请求的有效期，单位为秒。

如果服务器通过了预检请求，在有效期内的正常的CORS请求，就都跟简单请求一样，会有一个 Origin 头信息字段。服务器的回应，也都会有一个 Access-Control-Allow-Origin 头信息字段。

非简单请求的示例代码如下：

//前端代码
var json = {
  name: 'clloz',
  age: '27',
  sex: 'male'
}
document.cookie = 'name=clloz'
var xhr = new XMLHttpRequest()
xhr.open('post', 'http://localhost:8080/test', true)
xhr.setRequestHeader('content-type', 'application/json')
xhr.withCredentials = true
xhr.onload = function () {
  console.log(xhr.responseText)
}
xhr.send(json)

//后端代码
var http = require('http')
var url = require('url')
var querystring = require('querystring')
var util = require('util')

var routes = {
  '/test': function (req, res) {
    console.log(req.method)
    if (req.method === 'GET') {
      console.log(req.headers.cookie)
      res.setHeader('Access-Control-Allow-Origin', 'http://localhost:8081')
      res.setHeader('Access-Control-Allow-Credentials', true)
      res.writeHead(200, 'Ok')
      res.write(`success`)
      res.end()
    } else {
      var post = ''
      req.on('data', function (chunk) {
        post += chunk
      })
      req.on('end', function () {
        res.setHeader('Access-Control-Allow-Origin', 'http://localhost:8081')
        res.setHeader('Access-Control-Allow-Credentials', true)
        res.setHeader('Access-Control-Request-Method', 'PUT,POST,GET,DELETE,OPTIONS')
        res.setHeader(
          'Access-Control-Allow-Headers',
          'Origin, X-Requested-With, Content-Type, Accept, t'
        )
        res.end('success')
      })
    }
  }
}

var server = http.createServer(function (req, res) {
  var pathObj = url.parse(req.url, true)
  var handleFn = routes[pathObj.pathname]
  if (handleFn) {
    handleFn(req, res)
  }
})

server.listen(8080)
console.log('server on 8080...')

大多数浏览器不支持针对于预检请求的重定向。如果一个预检请求发生了重定向，浏览器将报告错误。

XMLHttpRequest 或 Fetch 与 CORS 的一个有趣的特性是，可以基于 HTTP cookies 和 HTTP 认证信息发送身份凭证。一般而言，对于跨源 XMLHttpRequest 或 Fetch 请求，浏览器不会发送身份凭证信息。如果要发送凭证信息，需要设置 XMLHttpRequest 的某个特殊标志位 withCredentials 为 true。如果服务器端的响应中未携带 Access-Control-Allow-Credentials: true ，浏览器将不会把响应内容返回给请求的发送者。

对于附带身份凭证的请求，服务器不得设置 Access-Control-Allow-Origin 的值为 *（会有安全风险）。请求的首部中携带了 Cookie 信息，如果 Access-Control-Allow-Origin 的值为*，请求将会失败。而将 Access-Control-Allow-Origin 的值设置为请求的源，则请求将成功执行。

另外，响应首部中也携带了 Set-Cookie 字段，尝试对 Cookie 进行修改。如果操作失败，将会抛出异常。

代理

同源策略只是浏览器的限制，对于服务器上的 web 服务器是没有影响的，所以当我们需要请求跨域资源的时候，可以先向同源的 web 服务器提交请求，由 web 服务器再向对应的服务器请求到数据后返回给前端。

postMessage

window.postMessage() 方法可以安全地实现跨源通信。使用方法是获得对另一个窗口的引用（比如targetWindow = window.opener），然后在窗口上调用 targetWindow.postMessage() 方法分发一个 MessageEvent 消息。接收消息的窗口可以根据需要自由处理此事件。传递给 window.postMessage() 的参数（比如 message ）将通过消息事件对象暴露给接收消息的窗口。

postMessage 的语法是 otherWindow.postMessage(message, targetOrigin, [transfer]);，otherWindow 是其他窗口的引用，将要发送到其他 window 的数据。它将会被结构化克隆算法序列化。这意味着你可以不受什么限制的将数据对象安全的传送给目标窗口而无需自己序列化。

targetOrigin 指定哪些窗口能接收到消息事件，其值可以是字符串 *（表示无限制）或者一个 URI 。在发送消息的时候，如果目标窗口的协议、主机地址或端口这三者的任意一项不匹配 targetOrigin 提供的值，那么消息就不会被发送，有三者完全匹配，消息才会被发送。

这个机制用来控制消息可以发送到哪些窗口；例如，当用 postMessage 传送密码时，这个参数就显得尤为重要，必须保证它的值与这条包含密码的信息的预期接受者的 origin 属性完全一致，来防止密码被恶意的第三方截获。如果你明确的知道消息应该发送到哪个窗口，那么请始终提供一个有确切值的 targetOrigin，而不是 *。不提供确切的目标将导致数据泄露到任何对数据感兴趣的恶意站点。

transfer 是一个可选参数，是一串和 message 同时传递的 Transferable 对象. 这些对象的所有权将被转移给消息的接收方，而发送一方将不再保有所有权。

以上是发送发的 API 使用发放，接收方的使用方法如下：

window.addEventListener('message', receiveMessage, false)

function receiveMessage(event) {
  // For Chrome, the origin property is in the event.originalEvent
  // object.
  // 这里不准确，chrome没有这个属性
  // var origin = event.origin || event.originalEvent.origin;
  var origin = event.origin
  if (origin !== 'http://example.org:8080') return

  // ...
}

接收方监听 message 事件，回到函数 receiveMessage 的 event 中可以取到 data，发送过来的数据；origin，发送方的源，由协议，域名和端口组成（http 默认为 80 端口，https 默认为 443 端口）；source 是对发送消息的窗口对象的引用，可以使用此来在具有不同 origin 的两个窗口之间建立双向通信。

下面是一个例子：用 http-server 启动两个服务来测试，分别为 localhost:8080 和 localhost:8081:

<!-- localhost:8080 -->
<body>
  <button>btn</button>
  <iframe name="myframe" src="http://localhost:8081" frameborder="1"></iframe>
  <script>
    window.addEventListener('message', function (e) {
      if (e.origin === 'http://localhost:8081') {
        console.log(e.data)
      }
    })

    var iframe = window.frames['myframe']

    var btn = document.querySelector('button')
    btn.addEventListener('click', function () {
      iframe.postMessage('this is 8080', 'http://localhost:8081')
    })
  </script>
</body>

<!-- localhost:8081 -->
<body>
  this is frame!
  <script>
    window.addEventListener('message', function (e) {
      if (e.origin === 'http://localhost:8080') {
        console.log(e.data)
        e.source.postMessage('this is 8081', e.origin)
      }
    })
  </script>
</body>

点击第一个页面的按钮，会向第二页面发送消息，第二个页面收到消息会立即返回。

document.domain

这种方式只适合主域名相同，但子域名不同的 iframe 跨域。比如主域名是http://clloz.com，子域名是http://test.crossdomain.com，这种情况下给两个页面指定一下document.domain即document.domain = clloz.com就可以访问各自的window对象了。

location.hash + iframe跨域

实现原理： a 欲与 b 跨域相互通信，通过中间页 c 来实现。三个页面，不同域之间利用 iframe 的 location.hash 传值，相同域之间直接 js 访问来通信。具体实现：A域：a.html -> B 域：b.html -> A 域：c.html，a 与 b 不同域只能通过 hash 值单向通信，b 与 c 也不同域也只能单向通信，但 c 与 a 同域，所以 c 可通过 parent.parent 访问a页面所有对象。

<!-- a.html -->
<iframe id="iframe" src="http://www.domain2.com/b.html" style="display:none;"></iframe>
<script>
  var iframe = document.getElementById('iframe')

  // 向b.html传hash值
  setTimeout(function () {
    iframe.src = iframe.src + '#user=admin'
  }, 1000)

  // 开放给同域c.html的回调方法
  function onCallback(res) {
    alert('data from c.html ---> ' + res)
  }
</script>

<!-- b.html -->
<iframe id="iframe" src="http://www.domain1.com/c.html" style="display:none;"></iframe>
<script>
  var iframe = document.getElementById('iframe')

  // 监听a.html传来的hash值，再传给c.html
  window.onhashchange = function () {
    iframe.src = iframe.src + location.hash
  }
</script>

<!-- c.html -->
<iframe id="iframe" src="http://www.domain1.com/c.html" style="display:none;"></iframe>
<script>
  var iframe = document.getElementById('iframe')

  // 监听a.html传来的hash值，再传给c.html
  window.onhashchange = function () {
    iframe.src = iframe.src + location.hash
  }
</script>

WebScoket

WebSocket protocol 是 HTML5 一种新的协议。它实现了浏览器与服务器全双工通信，同时允许跨域通讯，是 server push 技术的一种很好的实现。原生 WebSocket API 使用起来不太方便，可以使用 Socket.io，它很好地封装了 WebSocket 接口，提供了更简单、灵活的接口，也对不支持 WebSocket 的浏览器提供了向下兼容。

window.name

window.name 有一个奇妙的性质，页面如果设置了window.name，那么在不关闭页面的情况下，即使进行了页面跳转 location.href=...，这个 window.name 还是会保留。

所以我们可以利用这一点，和跨域页面通信。当我们在 a.html 要访问一个跨域页面 b.html，此时我们可以在 a.html 中用一个 iframe 加载 b.html。b.html 加载时要自动设置 window.name，存放我们要传递的信息，然后进行跳转，跳转到一个和 a.html 同源的页面 c.html，此时由于 c.html 和 a.html 同源，我们可以拿到 iframe 的 $('iframe').contentWindow，这就是 iframe 的 window 对象，此时我们就取到了 b 中设置的 window.name。实际操作中，我们一般使用一个隐藏的 iframe，然后监听它第二次 onload 事件，就知道该 iframe 已经跳到同域页面了，然后使用 $('iframe').contentWindow.name 即可。

参考文章

实现一个简单的音乐播放器

Mon, 06 May 2019 12:00:00 GMT

[toc]

前言

花了一个下午带晚上的事件做了一个简单的音乐播放器，大部分时间都花在了 audio 的自动播放问题上，原来浏览器只是不允许在移动设备上自动播放，从 chrome66 开始 PC 端也不允许自动播放了，audio.play() 必须写在点击事件的回调函数中才能生效，不然就会报错 DOMException: play() failed because the user didn't interact with the document first.，也就是说现在想要让页面上的音频播放必须经过用户点击以后才行，不能不经过和用户的互动直接播放了。这方面的资料比较少，chrome 有一篇文档说明autoplay policy changes。除开这个问题，其他功能并没有遇到太大的问题，样式的事件花的多一点，播放器的逻辑比较简单，JS基本都是操作样式和 Audio 对象，下面来分享以下构思和实现的过程。

HTMLMediaElement 的属性、方法和事件很多，建议大家到MDN仔细阅读以下文档。

项目预览

项目完成后我放在了服务器上，访问地址是音乐播放器，GitHub 地址音乐播放器-github。其实本来是想在 GitHub Pages上也能够预览的，配置了 apache 的跨域访问，但是在请求阿里云的静态资源（专辑封面和歌曲）的时候一直403，明明以及把 GitHub Pages 的地址加入到白名单了，试了半天只能放弃了。下面是整个页面的预览图片：

项目需求

页面设计：歌曲封面，歌曲名，进度条，音量控制，歌曲播放控制（上一曲，下一曲，播放暂停），歌曲列表。
初始化：打开页面时需要根据后台的数据生成播放列表，以及初始化播放控件（进度条归零，初始化音量，待播放歌曲设置为第一首，显示第一首歌的名称和时间）
播放逻辑，点击播放暂停，上一首下一首和直接点击歌曲列表的逻辑
给播放列表做一个打开和关闭的动画
进度条控制：让用户可以自己选择歌曲的进度
音量控制
断网控制

页面结构和样式

背景

背景比较简单，我选了一张自己比较喜欢的龙猫的图片，设置了一个 filter: blur(5px)，效果还不错。

播放器主体

播放器主体就参照一般的音乐播放器，左边是歌曲封面，右边是播放控件，用display: inline-block，播放器的宽高都是固定的，inline-block 的空格空隙问题我是用 font-size: 0来处理的。需要注意的是要设置以下图片或者右边元素的 vertical-align，因为图片下边缘默认与当前 inline box 中的基线对齐的，如果不设置 vertical-align 图片默认和右边元素中的最后一行文本的基线对齐。结构如下：

<img src="" alt="cover" class="left" />
<div class="right"></div>

右侧的播放器控件部分就分为上中下三块，最上面显示歌曲信息，中间一层是进度条和音量按钮，最下面是几个播放按钮。结构如下：

<h4>music info</h4>
<div class="mid"></div>
<div class="controls"></div>

最上面的歌曲信息部分没啥好说的，设置合适的字体就可以了，white-space: nowrap，text-overflow: ellipsis，处理歌曲信息过长。中间一层我放了进度条和音量控制，进度条就是总长度一个元素，当前长度一个元素，两个元素选择不同的颜色重叠就可以了，时间我用的是总长度的进度条元素的伪元素来实现的，伪元素的 content 用进度条元素的属性来设置 content = attr(data-time)。本来我是想当前进度也用伪元素来实现的，但是伪元素并不算是 DOM 元素，无法用 JS 来操作，并且没法添加事件（虽然有各种黑科技）。

理论上来说伪元素不算 DOM 元素，所以无法用JS操作以及绑定事件，不过我看到 segmentfault上有两个答案对这两种行为都提出了解答，通过JS改变伪元素样式, pointer-event为伪元素绑定事件

中间这一层我直接给包裹层一个高度，内部的几个块都用绝对定位，保持两个进度条的位置一致，并且和音量键对齐。同时音量的控制模块也用绝对定位。用绝对定位是为了让这几个元素对齐比较方便，特别是音量和进度条都是两个元素重叠在一起，并且两个元素都是需要点击计算距离的，所以 1px 的误差都不能有，用绝对定位比较好处理。结构如下：

<div class="mid">
  <div class="progress" data-time="00:00/00:00"></div>
  <div class="current"></div>
  <div class="volume">
    <div class="vol-control"></div>
    <div class="vol-current"></div>
  </div>
  <div class="vol">
    <span><i class="fa fa-volume-up"></i></span>
  </div>
</div>

最下面的一层控制按钮，直接用列表 inline-block 就可以了，计算好宽度间隔。对于列表的横向排列，我们经常希望第一个元素和边界没有间隔，后面的元素留有相同的空间，处理方法有很多种。 1. 用 flex 布局 2. 对每个 li 使用相同的 margin-left，然后 ul 使用一个负 margin，这样做 ul 的宽度需要增加一个间隙的值 3. 使用 li + li 选择器，选择所有 li的相邻兄弟元素，第一个元素不会被选到 4. 使用 li:first-child 给第一个元素单独设置样式 5. 使用li:first-child ~ li 选择第一个元素的所有兄弟元素

最后每个元素添加一个 hover 样式，然后加上一个 transition: all .3s ease-in-out; 给 hover 效果添加一个过度状态。

歌曲列表

歌曲列表的样式并没有什么难的地方，一个列表就可以解决。不过我想给歌曲列表的打开和关闭制作一个动画，当打开的时候，歌曲列表从播放器主体下方滑出；当关闭的时候，列表缓慢上移，上移的部分在主体下方消失，效果如下面的动图：

上移的效果非常容易，transform: translateY(-300px) 就可以了，但是上移的部分还是会显示在画面中，并且挡住整个主体了。我的解决方案是在 ul 外面再套一层 div，div 设置一个 overflow: hidden;，在 ul 向上移动的过程中 div 的高度也同步减小，保持两者的 transition 的时间相同，这样两者的过度效果能保持相同。因为 overflow: hidden 的存在，ul 滑动到上方的部分将会被隐藏。具体代码看上面的 GitHub 链接。

功能实现

所有功能基本都围绕 HTMLMediaElement 的属性、方法和事件来实现，基本都是对 Audio 的操作，说以下主要思路。

播放逻辑

上一曲，下一曲和点击播放列表中的歌曲逻辑基本是相同的。在请求到歌曲信息后保存到一个对象中，除了将对象中的信息添加到歌曲列表中之外，也是我们操作按钮的时候取数据的地方。我们需要一个用来标记当前播放歌曲 index 的变量，初始化为 0，也就是打开播放器的时候默认从第一首开始播放。然后点击上一首就对变量 +1（需要判断是不是第一首，如果是第一首就跳到最后一首），点击下一曲就对变量 -1（需要判断是不是最后一首，如果是最后一首就跳到第一首），点击歌曲列表直接通过 li 的 data-num 属性来设置变量的值。剩下的初始化进度条，名称，时间等功能都是一样的，可以写到一个函数里，分别调用就可以了。

重复点击同一首歌曲默认不操作，也就是歌曲的 data-num 和当前播放的歌曲的 index 相同的时候不处理，但是当页面初始化完成直接点击第一首歌的时候 data-num 和 index 都是 0，这个逻辑需要处理一下。

播放和暂停时候按钮的样式不同，点击的时候需要处理一下，包括上面的第三个按钮点击的时候一样要看看播放按钮是否处于暂停的样式。

播放逻辑中要用到的 Audio 方法基本就是 audio.play() 和 audio.pause()，属性就是一个 audio.src，需要注意的是 audio 对象在一首歌播放结束后就会暂停，触发 ended 事件，此时我们要触发一下下一首的按钮就可以了。

audio.onended = function () {
  var event = new Event('click')
  nextBtn.dispatchEvent(event)
}

点击按钮获取歌曲信息的方式有两种，一种按照 index 到歌曲信息数组中去取；第二种是在生成歌曲列表的时候用 data-* 属性将信息保存到每个歌曲对应的 li 中。从操作上来说第一种方法是比较简单的，但可能播放器逻辑更复杂的时候第二种方法也有用武之地，比如用户有多个播放列表，后台给我们的是一个数组，数组中每个对象有一个 type 属性来标记歌单，可能第二种方法会更好一点。

进度条

进度条要处理的主要是三个方面：播放新的歌曲需要初始化进度条和时间，跟随歌曲播放的进度前进，可以让用户手动设置进度。

每次用户点击上一曲下一曲或者播放列表的时候就需要初始化进度条，我们可以用 audio.oncanplay 事件来监听，这个事件是当 audio 已经加载可以开始播放的时候触发，当这个事件触发的时候我们将时间归零，进度条的长度重置为 0 就可以了。

播放进度我们可以用 audio.ontimeupdate 事件来监听，在 Chrome 上这个事件一秒触发四次，每次触发我们就获取 audio.currentTime 属性，然后根据 currenTime 和 duration 之间的比值来设置我们的进度条长度即可，同时也可以设置时间，currentTime 和 duration 都是以秒为单位的浮点数，我们进行一些处理就行了。

点击进度条我们利用 MouseEvent 对象的 offsetX 属性来获取鼠标事件触发时，鼠标的坐标和触发事件的对象的左边缘在 X 轴上的偏移量，获得这个偏移量之后，我们将进度条的宽度移动至此，并且根据进度条长度和总长度的比例计算出 currenTime，然后设置 currentTime。currentTime 是一个可以赋值的属性，并且它的值的改变也会触发 timeupdate 事件。

音量的控制本来是想使用滑动的方式来处理的，奈何水平不行，对滑动的几个事件处理怎么都做到平滑，要改进这个功能要把滑动相关的几个事件深入了解一下。

音量控制

音量控制的原理本质上跟进度条一样的，只不过因为音量是竖直方向上的，所以用 offsetY 来获取偏移量，通过比例的计算来设置 audio.volume 属性即可，这个控件在手机上不生效，手机还是要通过自身的音量按钮来控制声音大小。

断网控制

当断网时，如果继续执行页面逻辑或出现请求不到资源，图片加载不出，页面报错。所以在断网发生时我们需要立即处理。通过 window 对象的 offine 和 online 事件我们可以很好地处理这个逻辑。当断网发生时我们应该禁止用户点击控件和歌曲列表，如果用解绑事件的方式太麻烦了，我直接采取用一个遮罩层盖住控件，收起播放列表，暂停当前播放，在遮罩层上显示一个断网信息。当网络恢复的时候我们再打开播放列表，如果断网前音乐是在播放的，那我们就恢复播放。效果如下:

思维拓展

要制作一个比较完善的播放器还有几个功能需要加上： 1. 显示歌词 2. 歌曲搜索

总结

虽然只是一个小小的音乐播放器，不过还是补充了不少知识的，当程序员永远都是 纸上得来终觉浅，绝知此事要躬行 啊，不过纸上得来的的也是多多益善，没有这个纸做铺垫，写再多代码也只是原地踏步。

CentOS7更新git版本

Fri, 03 May 2019 12:00:00 GMT

前言

今天在服务器上部署代码的时候，发现服务器上的 git 版本非常老，是 git 1.8.0，于是就把 git 的版本更新到了最新的 2.21.0。

更新步骤

卸载旧版本

yum remove git -y

安装依赖

yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel asciidoc gcc perl-ExtUtils-MakeMaker -y

编译安装libiconv

wget http://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.15.tar.gz
tar zxvf libiconv-1.15.tar.gz
cd libiconv-1.15
./configure --prefix=/usr/local/libiconv
make && make install

下载安装最新版本git

下载地址：release

wget https://github.com/git/git/archive/v2.21.0.tar.gz
tar xzvf v2.17.0.tar.gz
cd git-2.17.0
make configure
./configure --prefix=/usr/local/git --with-iconv=/usr/local/libiconv
make install

配置环境变量

echo "export PATH=$PATH:/usr/local/git/bin" >> /etc/profile
source /etc/profile

echo "export PATH=$PATH:/usr/local/git/bin" >> /etc/bashrc
source /etc/bashrc

完成上面的步骤就已经可以用 git --version 看到最新版本的 git 安装好了。

浏览器存储方案

Thu, 02 May 2019 12:00:00 GMT

前言

浏览器有多种存储数据的办法，包括 Cookie，web storage（ localStorage 和 sessionStorage ），indexedDB。它们的主要目的都是快速访问数据而不需要建立请求去服务器获取。它们有着不一样的大小，生命周期和作用域，所以需要在合适的场景选择合适的数据存储办法。

Cookie

cookie 是为了解决 HTTP 协议的无状态而引入的技术。HTTP Cookie（也叫 Web Cookie 或浏览器 Cookie）是服务器发送到用户浏览器并保存在本地的一小块数据，它会在浏览器下次向同一服务器再发起请求时被携带并发送到服务器上。通常，它用于告知服务端两个请求是否来自同一浏览器，如保持用户的登录状态。Cookie 使基于无状态的 HTTP 协议记录稳定的状态信息成为了可能。

Cookie主要用于以下三个方面：

会话状态管理（如用户登录状态、购物车、游戏分数或其它需要记录的信息）
个性化设置（如用户自定义设置、主题等）
浏览器行为跟踪（如跟踪分析用户行为等）

Cookie 曾一度用于客户端数据的存储，因当时并没有其它合适的存储办法而作为唯一的存储手段，但现在随着现代浏览器开始支持各种各样的存储方式，Cookie 渐渐被淘汰。由于服务器指定 Cookie 后，浏览器的每次请求都会携带 Cookie 数据，会带来额外的性能开销（尤其是在移动环境下）。新的浏览器API已经允许开发者直接将数据存储到本地，如使用 Web storage API（本地存储和会话存储）或 IndexedDB 。

创建Cookie

当服务器收到HTTP请求时，服务器可以在响应头里面添加一个 Set-Cookie 选项。浏览器收到响应后通常会保存下 Cookie，之后对该服务器每一次请求中都通过 Cookie 请求头部将 Cookie 信息发送给服务器。另外，Cookie 的过期时间、域、路径、有效期、适用站点都可以根据需要来指定。

服务器使用 Set-Cookie 响应头部向用户代理（一般是浏览器）发送Cookie信息，比如 Set-Cookie: status=enable; expires=Tue, 05 Jul 2011 07:26:31 GMT; path=/; domain=clloz.com;，服务器通过该头部告知客户端保存 Cookie 信息。

如果不对 Cookie 设置 expires 则该 Cookie 被认为是会话期 Cookie，会话期 Cookie 是最简单的 Cookie：浏览器关闭之后它会被自动删除，也就是说它仅在会话期内有效。会话期Cookie不需要指定过期时间（ Expires ）或者有效期（ Max-Age ）。需要注意的是，有些浏览器提供了会话恢复功能，这种情况下即使关闭了浏览器，会话期 Cookie 也会被保留下来，就好像浏览器从来没有关闭一样。而设置了 expires 的 Cookie 则被认为是持久性的 Cookie，规定了 Cookie 的过期时间，而 max-age 参数则规定了 Cookie 过期的相对时间。

Cookie的安全

标记为 Secure 的 Cookie 只应通过被 HTTPS 协议加密过的请求发送给服务端。但即便设置了 Secure 标记，敏感信息也不应该通过 Cookie 传输，因为 Cookie 有其固有的不安全性，Secure 标记也无法提供确实的安全保障。从 Chrome 52 和 Firefox 52 开始，不安全的站点（ http: ）无法使用 Cookie 的 Secure 标记。

为避免跨域脚本 ( XSS ) 攻击，通过 JavaScript 的 Document.cookie API无法访问带有 HttpOnly 标记的 Cookie，它们只应该发送给服务端。如果包含服务端 Session 信息的 Cookie 不想被客户端 JavaScript 脚本调用，那么就应该为其设置 HttpOnly 标记。

Cookie的作用域

Domain和 Path 标识定义了 Cookie 的作用域：即 Cookie 应该发送给哪些 URL。

Domain 标识指定了哪些主机可以接受 Cookie。如果不指定，默认为当前文档的主机（不包含子域名）。如果指定了 Domain，则一般包含子域名。

例如，如果设置 Domain=mozilla.org，则Cookie也包含在子域名中（如 developer.mozilla.org ）。

Path 标识指定了主机下的哪些路径可以接受 Cookie（该 URL 路径必须存在于请求 URL 中）。以字符 %x2F ("/") 作为路径分隔符，子路径也会被匹配。

例如，设置 Path=/docs，则以下地址都会匹配：/docs，/docs/Web/，/docs/Web/HTTP

JS操作Cookie

通过 Document.cookie 属性可创建新的 Cookie，也可通过该属性访问非 HttpOnly 标记的 Cookie 。由于 document.cookie 属性只给出了 cookie 字符串，而没有给出操作 cookie 的方法，所以 cookie 的读写删需要自己写方法封装。

JS 设置 cookie：document.cookie="age=12; expires=Thu, 26 Feb 2116 11:50:25 GMT; domain=sankuai.com; path=/"; 设置多个 cookie：

document.cookie = 'name=Jonh'
document.cookie = 'age=12'
document.cookie = 'class=111'

要想修改一个 cookie，只需要重新赋值就行，旧的值会被新的值覆盖。但要注意一点，在设置新 cookie 时，path/domain 这几个选项一定要旧 cookie 保持一样。否则不会修改旧值，而是添加了一个新的 cookie。

删除一个 cookie 也挺简单，也是重新赋值，只要将这个新 cookie 的 expires 选项设置为一个过去的时间点就行了。但同样要注意，path/domain /这几个选项一定要旧 cookie 保持一样。

cookie 其实是个字符串，但这个字符串中逗号、分号、空格被当做了特殊符号。所以当 cookie 的 key 和 value 中含有这3个特殊字符时，需要对其进行额外编码，一般会用 escape 进行编码，读取时用 unescape 进行解码；当然也可以用 encodeURIComponent/decodeURIComponent 或者 encodeURI/decodeURI。

Web Storage

Web Storage 包含如下两种机制：

sessionStorage ：为每一个给定的源（ given origin ）维持一个独立的存储区域，该存储区域在页面会话期间可用（即只要浏览器处于打开状态，包括页面重新加载和恢复）。
localStorage ：同样的功能，但是在浏览器关闭，然后重新打开后数据仍然存在。一般我们会在用户登出后清除 localStorage。

这两种机制是通过 Window.sessionStorage 和 Window.localStorage 属性使用（更确切的说，在支持的浏览器中 Window 对象实现了 WindowLocalStorage 和 WindowSessionStorage 对象并挂在其 localStorage 和 sessionStorage 属性下）—— 调用其中任一对象会创建 Storage 对象，通过Storage对象，可以设置、获取和移除数据项。对于每个源 （origin）sessionStorage 和 localStorage 使用不同的 Storage 对象——独立运行和控制。

sessionStorage

sessionStorage 属性允许你访问一个 session Storage 对象。它与 localStorage 相似，不同之处在于 localStorage 里面存储的数据没有过期时间设置，而存储在 sessionStorage 里面的数据在页面会话结束（tag 关闭）时会被清除。页面会话在浏览器打开期间一直保持，并且重新加载或恢复页面（浏览器以外关闭下次再打开会有恢复按钮）仍会保持原来的页面会话。在新标签或窗口打开一个页面时会在顶级浏览上下文（browsing context 指的就是 window， iframe 或者 tab）中初始化一个新的会话，这点和session cookies 的运行方式不同。用同一个 URL 打开的多个 tab 或者 window 中都会创建独立的 sessionStorage。复制 duplicate 一个 tab 会同时复制这个 tab 的 seesionStorage 到新的 tab 中。关闭 tab 或者 window 会结束会话并清除 sessionStorage 中的对象。

我们用 window.open 打开的新页面如果和原页面同源也能继承原 tag 的 sessionStorage，注意要同源，如果协议、域名或者端口不同则不可以继承。

sessionStorage 的 key 和 value 都是用 UTF-16 的形式存储的。和对象一样，integer 的 key 会自动转换为字符串。

// 保存数据到 sessionStorage
sessionStorage.setItem('key', 'value')

// 从 sessionStorage 获取数据
let data = sessionStorage.getItem('key')

// 从 sessionStorage 删除保存的数据
sessionStorage.removeItem('key')

// 从 sessionStorage 删除所有保存的数据
sessionStorage.clear()

localStorage

只读的localStorage 属性允许你访问一个Document 源（origin）的对象 Storage；其存储的数据能在跨浏览器会话保留。localStorage 类似 sessionStorage，但其区别在于：存储在 localStorage 的数据可以长期保留；而当页面会话结束——也就是说，当页面被关闭时，存储在sessionStorage的数据会被清除。

incognito 页面，也就是隐身窗口的 localStorage 是不和非隐身窗口的共享的，隐身窗口中的同源页面会共享 localStorage，在隐身窗口中的所有 tag 被关闭的时候即隐身窗口关闭的时候这个隐身窗口中的所有 localStorage 都会销毁。

localStorage 的 key 和 value 都是用 UTF-16 的形式存储的。和对象一样，integer 的 key 会自动转换为字符串。

对于 file: 协议的 URL 没有给出 localStorage 的定义，所以各个浏览器的实现可能不同。我在 Chrome 中的测试是各个 file: URL 共享一个 localStorage。

//增加了一个数据项目。
localStorage.setItem('myCat', 'Tom')

//读取 localStorage 项
let cat = localStorage.getItem('myCat')

//移除 localStorage 项
localStorage.removeItem('myCat')

// 移除所有
localStorage.clear()

参考文章

聊一聊Cookie

前端网络基础和HTTP

Thu, 02 May 2019 12:00:00 GMT

前言

在浏览器渲染过程及JS引擎浅析这篇文章里，解答了 在浏览器输入url回车后发生了什么 问题中的一部分，也就是浏览器获得了服务器返回的 html 文档(实际可能是其他类型的资源）后的一系列行为。但是还有一部分行为并没有涉及，就是浏览器是如何和服务器通信的，以及数据是怎么传输的。在 图解HTTP 这本书里面很好地解答了这部分问题。

本文主要是讲网络知识，关于 在浏览器输入url回车后发生了什么 可以参考另一篇文章从URL输入到页面展现

文章较长，主要内容是计算机网络的基础和HTTP协议

web 和 http 产生的背景

还是老样子，学习一个东西之前，我们先来了解以下他是为了解决什么问题而产生的，以及它是如何解决这些问题的。

什么是web

我们经常听到这个词，也经常说 web 开发，可是什么是 web 呢，是网页吗？我们平时见到的 www(worldwideweb) 和 web 指的是同一个东西，我们叫他万维网，是一个透过互联网访问的，由许多互相链接的超文本组成的系统，是1989年伯纳斯·李发明的。简单的说就是整个借助互联网形成访问超文本的系统构成这个所谓的 web 或是称作 www，为了在互联网上实现访问超文本设计的技术和程序都算是 web 系统的一部分，比如 http 超文本传输协议，html 超文本标记语言、浏览器、web 服务器等。而 www(worldwideweb) 这个名称则是来自于1990年伯纳斯·李写的世界上第一款网页浏览器和编辑器，它的名字就叫 worldwideweb，同时他也实现了第一个 web 服务器。

超文本的意思就是能够显示在电子设备上的包含超链接的文本（以及多媒体内容），允许从当前文本切换到超链接所指向的文字，超文本文档通过超链接互相连结。html 称为超文本标记语言，http 称为超文本传输协议，它们都是为了在 web 上浏览超文本产生的技术。

互联网、英特网和万维网

互联网 internet 是指凡是能彼此通信的设备组成的网络就叫互联网。英特网 Internet 指的是利用 TCP/IP 通讯协定所创建的各种网络，是国际上最大的互联网，也称“国际互联网”。万维网 www 是一个由许多互相链接的超文本组成的系统，通过因特网访问。在此定义下，万维网是因特网的一项服务，因特网是互联网的一种。国际互联网是互联网中的一个，也有独立于国际互联网之外的互联网，比如朝鲜的光明网。web 是一个依靠互联网访问超文本的系统，是互联网提供的服务之一，其他的服务比如邮件，文件共享等。

web 产生的原因

在 web 产生之前，计算机和网络只是极少数人使用的，当时出现的需求是希望能够实现借助超文本在全世界研究者中间共享知识和信息的需求，伯纳斯·李为了实现这个需求构建了 web 的三个关键技术： 1. 超文本标记语言 HTML 2. 统一资源定位符 URL 3. 超文本传输协议 HTTP

为什么要有 http

计算机与网络设备要相互通信，双方就必须基于相同的方法。比如，如何探测到通信目标、由哪一边先发起通信、使用哪种语言进行通信、怎样结束通信等规则都需要事先确定。不同的硬件、操作系统之间的通信，所有的这一切都需要一种规则。而我们就把这种规则称为协议 protocol。协议中存在各式各样的内容。从电缆的规格到 IP 地址的选定方法、寻找异地用户的方法、双方建立通信的顺序，以及 Web 页面显示需要处理的步骤，等等。而 http 协议就是众多网络协议中的一种，它产生的目的就是为了确定 web 中传输超文本的具体标准，让这一共享知识的设想能够实现。

web技术的标准化

随着 web 的诞生，浏览器和 web 服务器都开始飞速发展，浏览器方面由微软和网景齐头并进，而 web 服务器则由 apache 开疆拓土（ apache 如今已经成为 web 服务器的标准之一）。之后 web 技术不断的迅猛发展，并爆发了微软和网景之间的浏览器大战，两者无视标准的恶性竞争也让人们意识到 web 标准化的重要性，并成为了 web 业界一直到今天都在努力的目标。

而作为 web 技术中重要一环的 http 协议被正式标准化是在1996年，版本为 http/1.0，被记载于 RFC1945，该协议标准至今被广泛应用于 web 服务器。1997 年 1 月公布的 HTTP/1.1 是目前主流的 HTTP 协议版本。当初的标准是 RFC2068，之后发布的修订版 RFC2616 就是 HTTP/1.1 的最新版本。而新一代 HTTP/2 标准于2015年5月以 RFC 7540 正式发表。HTTP/2 的标准化工作由Chrome、Opera、Firefox、Internet Explorer 11、Safari、Amazon Silk 及Edge 等浏览器提供支持，多数主流浏览器已经在2015年底支持了该协议。apache、nginx 等主流web服务器也都支持新的标准，目前的主流网站都以启用新的标准。关于 HTTP/2 后面在讨论。

普通的 HTTPS 网站浏览会比 HTTP 网站稍微慢一些，因为需要处理加密任务，而配置了 h2 的 HTTPS，在低延时的情况下速度会比 HTTP 更快更稳定。

网络基础

TCP/IP 协议族

全世界有几十亿的电脑，加上网络设备还会多出更多，它们都在同一个互联网上，也就意味着在这个网络上的任意两个设备之间都是可以通信的。比如我在上海，我的电脑的网卡发出一个信号，而你在北京的电脑就能马上收到，甚至你在太平洋彼岸的美国也可以收到，要做到这些，就必须以来上面说的各种网络协议。互联网的核心是一系列协议，总称为"互联网协议" Internet Protocol Suite，通常也被我们称为 TCP/IP 协议族。它们对电脑如何连接和组网，做出了详尽的规定。理解了这些协议，就理解了互联网是如何设计的了。

上面的背景介绍中说明了计算机和网络设备要互相通信必须要制定详细的标准，于是产生了各种各样的网络协议，http 只是其中的一种，不同的协议都是因为不同的需求和使用场景而定制的，从电缆的规格到 IP 地址的选定方法、寻找异地用户的方法、双方建立通信的顺序，以及 Web 页面显示需要处理的步骤等等，比如 FTP 在计算机网络上在客户端和服务器之间进行文件传输的协议，而 SMTP 是互联网上传输电子邮件的协议，而我们常说的 DNS 域名系统也是应用层的一个协议，作用是将域名和IP地址相互映射的一个分布式数据库。而之所以这些协议的集合被称为 TCP/IP 协议族是因为该协议家族的两个核心协议：TCP（传输控制协议）和 IP（网际协议），为该家族中最早通过的标准。整个 TCP/IP 协议族非常庞大和复杂，在这里我们只讨论学习 HTTP 需要用到的网络基础。如果你想深入学习计算机网络的知识有这三本书推荐： 1. 计算机网络-自顶向下方法 2. 计算机网络 3. TCP/IP详解

网络分层管理

为什么网络设计要分层

网络的分层大家都知道，OSI 七层网络模型大家都听说过，要说为什么网络设计要分层，归根结底就是为了解耦，特别是在底层涉及到很多硬件的情况下，工作在高层的技术人员不需要了解底层的硬件的工作细节。如果互联网只由一个协议统筹，某个地方需要改变设计时，就必须把所有部分整体替换掉。而分层之后只需把变动的层替换掉即可。把各层之间的接口部分规划好之后，每个层次内部的设计就能够自由改动了。并且层次化之后，设计也变得相对简单了。处于应用层上的应用可以只考虑分派给自己的任务，而不需要弄清对方在地球上哪个地方、对方的传输路线是怎样的、是否能确保传输送达等问题。分层设计的有点可以归纳为三点： 1. 各层之间相互独立：高层是不需要知道底层的功能是采取硬件技术来实现的，它只需要知道通过与底层的接口就可以获得所需要的服务； 2. 灵活性好：各层都可以采用最适当的技术来实现，例如某一层的实现技术发生了变化，用硬件代替了软件，只要这一层的功能与接口保持不变，实现技术的变化都并不会对其他各层以及整个系统的工作产生影响； 3. 易于实现和标准化：由于采取了规范的层次结构去组织网络功能与协议，因此可以将计算机网络复杂的通信过程，划分为有序的连续动作与有序的交互过程，有利于将网络复杂的通信工作过程化解为一系列可以控制和实现的功能模块，使得复杂的计算机网络系统变得易于设计，实现和标准化。

OSI 七层模型和 TCP/IP 四层模型

网络模型不是一开始就有的，在网络刚发展时，网络协议是由各互联网公司自己定义的，比如那时的巨头网络公司 IBM、微软、苹果、思科等等，他们每家公司都有自己的网络协议，各家的协议也是不能互通的，那时候大家觉得这是可以的，但对消费者来说这实际上是技术垄断，因为你买了苹果的设备就不能用微软的设备，因为他们的协议不是一样的，没有统一的标准来规范网络协议，都是这些公司的私有协议。这样大大的阻碍了互联网的发展，为了解决这个问题，国际标准化组织 1984 提出的概念模型，简称 OSI（Open Systems Interconnection Model），这是一个概念，并非实现。TCP/IP 协议就是基于此模型设计实现的。

OSI 七层模型： 1. 物理层（ Physical Layer ）在局部局域网上传送数据帧（ data frame ），它负责管理计算机通信设备和网络媒体之间的互通。包括了针脚、电压、线缆规范、集线器、中继器、网卡、主机接口卡等。 2. 数据链路层（ Data Link Layer ）负责网络寻址、错误侦测和改错。当表头和表尾被加至数据包时，会形成帧。数据链表头（ DLH ）是包含了物理地址和错误侦测及改错的方法。数据链表尾（ DLT）是一串指示数据包末端的字符串。例如以太网、无线局域网（ Wi-Fi）和通用分组无线服务（ GPRS ）等。 3. 网络层（ Network Layer ）决定数据的路径选择和转寄，将网络表头（ NH ）加至数据包，以形成分组。网络表头包含了网络数据。例如:网际协议（ IP）等。 4. 传输层（ Transport Layer）把传输表头（ TH）加至数据以形成数据包。传输表头包含了所使用的协议等发送信息。例如:传输控制协议（ TCP）等。 5. 会话层（ Session Layer）负责在数据传输中设置和维护计算机网络中两台计算机之间的通信连接。 6. 表达层（ Presentation Layer ）把数据转换为能与接收者的系统格式兼容并适合传输的格式。 7. 应用层（ Application Layer ）提供为应用软件而设的接口，以设置与另一应用软件之间的通信。例如: HTTP，HTTPS，FTP，TELNET，SSH，SMTP，POP3等。

OSI 参考模型并没有提供一个可以实现的方法，而是描述了一些概念，用来协调进程间通信标准的制定。即OSI 参考模型并不是一个标准，而是一个在制定标准时所使用的概念性框架。

TCP/IP 四层模型 1. 应用层：网络应用程序使用的层，提供网络应用程序需要的接口，将程序中的数据包装成协议的标准格式。，对应 OSI 七层模型的最上面三层（会话层，表达层和应用层），如 HTTP，SSH，FTP，SMTP，TELENT，POP3 2. 传输层：提供计算机和网络设备之间的设备传输，确保数据传输的可靠和顺序。包括 TCP 和 UDP，对应 OSI 模型中的传输层 3. 网络层（网络互联层）：处理数据包，通过 IP 地址规定数据包的传输路径，并将数据从源发送到目的地。对应 OSI 模型中的网络层。主要协议是 IP 协议 4. 链路层：网络连接的硬件部分，将数据包从一个设备的网络层传输到另一个设备的网络层。包括控制操作系统、硬件设备的驱动、NIC 网卡，光纤，双绞线等物理可见部分。包括以太网，wifi 等。

更多模型细节可以看阮一峰的互联网协议入门

TCP/IP 网络通信流程

当我们在浏览器中输入 url 请求 web 服务器上的 HTML 文档的时候，通信的过程是什么样的呢？见下图

应用层浏览器将请求封装成符合 HTTP 协议的数据报文，将这个报文交给传输层。
传输层的 TCP 协议将从应用层收到的 HTTP 报文分割成数据包的形式，并在每个数据包上打上标记和序号，然后交给网络层。
网络层的 IP 协议给传输层传来的 TCP 报文段加上通信目的地的 mac 地址在转发给链路层。
链路层将封装好的数据通过物理设备传递给目标服务器，到达目标服务器的链路层以后再将封装好的数据按照网络分层一层层解封，最终服务器上的处理程序获得 http 请求，并找到对应的资源按照请求发送的方式再将资源发送给客户端。

HTTP 请求中的重要协议

在上面的http 请求的通信流程中，不同的层级涉及到了几个不同协议，它们都是 HTTP 请求中的

IP 协议（网际协议）

IP 协议 internet protocol 工作在网络层，它的作用是根据 IP 地址和 mac 地址规定数据包的传输路径，我们的网络上有无数台电脑，怎么选择一个合适的路线才能准确高效地进行数据包的传输是IP协议的主要目标。IP 地址指向一个网络，而 mac 地址指向一个具体的设备，一个网络中可以有很多台设备。虽然用 mac 地址就可以实现数据的传输，但是由于网络十分巨大，用 mac 地址进行广播的效率非常低下，并且会消耗网络设备上的很大的存储空间，而用 ip 地址进行广播不断缩小目标的范围，最后再利用 mac 地址定位到具体的设备是比较高效的。就像寄快递，我们从上海寄快递到北京的某个小区，在运输的过程中会有非常多的集散中心，每个集散中心的送货员不会关心最终的目的地，而是下一个集散中心选择哪个是最有效率的（比如有两个距离相同的集散中心，我们可以先打电话过去问问哪个比较不忙），随着这个过程的不断推进，我们会越来越接近我们的目的地，当快递寄到我们所属街区的集散中心以后，快递员就可以根据我们的真实地址来送货了，这当中的集散中心就像 IP 地址，而我们的真实住址就像 mac 地址一样，而且网络中的中间设备比我们想象的要多得多，没有任何一台设备能保存整个网络中所有的设备的 mac 地址以及线路细节，这就更需要我们利用 ip 缩小范围，它们工作的层级也不一样，IP 地址工作在网络层，mac 地址工作在链路层

每块网卡出厂的时候，都有一个全世界独一无二的 MAC 地址，长度是 48 个二进制位，通常用 12 个十六进制数表示，前6 个十六进制数是厂商编号，后 6 个是该厂商的网卡流水号。有了 MAC 地址，就可以定位网卡和数据包的路径了。

TCP 协议

TCP 协议位于传输层，提供可靠的字节流服务，TCP 协议会把应用层传来的 HTTP 报文分割成方便传输的报文段数据包，而 TCP 协议的关键之处在于要把分割后的数据包一个不差的准确地传输到目的地。

为了准确无误地将数据送达目标处，TCP 协议采用了三次握手 ( three-way handshaking )策略。用 TCP 协议把数据包送出去后，TCP 不会对传送后的情况置之不理，它一定会向对方确认是否成功送达。握手过程中使用了 TCP 的标志( flag )—— SYN ( synchronize )和 ACK ( acknowledgement )。

发送端首先发送一个带 SYN 标志的数据包给对方。接收端收到后，回传一个带有 SYN/ACK 标志的数据包以示传达确认信息。最后，发送端再回传一个带 ACK 标志的数据包，代表“握手”结束。若在握手过程中某个阶段莫名中断，TCP 协议会再次以相同的顺序发送相同的数据包。

DNS 服务

DNS ( Domain Name System )服务是和 HTTP 协议一样位于应用层的协议。它提供域名到 IP 地址之间的解析服务。计算机既可以被赋予 IP 地址，也可以被赋予主机名和域名。比如 www.clloz.com。用户通常使用主机名或域名来访问对方的计算机，而不是直接通过 IP 地址访问。因为与 IP 地址的一组纯数字相比，用字母配合数字的表示形式来指定计算机名更符合人类的记忆习惯。但要让计算机去理解名称，相对而言就变得困难了。因为计算机更擅长处理一长串数字。为了解决上述的问题，DNS 服务应运而生。DNS 协议提供通过域名查找 IP 地址，或逆向从 IP 地址反查域名的服务。

多协议在http请求中的工作流程

在 http 请求的过程中，上述协议的完整工作流程如下：

关于 URI 和 URL 的区别，看我的这篇文章从url输入到页面展现。RFC 文件为互联网规范、协议、过程等的标准文件，由互联网工程任务组（ IETF ）维护。

HTTP协议

上面的内容介绍了要学习 HTTP 协议的一些必备的网络基础，下面来讲一讲开发 web 应用面对的主要对象：HTTP 协议。我们的 web 开发主要是都是在应用层，但是理解应用层之下的网络传输过程对我们的开发也是很有用处的，现在前端也需要掌握后端的技能，特别是如果我们要接触 web 服务器以及后端开发的时候，计算机网络的知识储备是非常重要的。

其实刨开应用层底层之下的网络知识，单纯讨论工作在应用层的 HTTP 协议是非常简单的，HTTP 协议用于客户端和服务器之间的通信，常见的客户端主要就是浏览器，而常见的服务器就是 web 服务器，比如apache，nginx，IIS。发起请求的一端为客户端，而响应请求的一端为服务器。两台计算机之间使用 HTTP 协议通信时，必然有一端是客户端，一端是服务器。HTTP 协议能够区分哪端是发起请求的客户端，哪一端是响应请求的服务器。请求必然从客户端发起，经过传递后到达服务器，最后服务器响应请求并返回。也就是只有客户端可以主动联系服务器，但是服务器是无法主动联系客户端的。

HTTP 协议是一个文本型协议（和二进制协议相对），文本型协议意味着所有的内容都是字符串。比如我们要传一个 1，不是传一个 1 的 bit 或者一个字节，而是传一个 Unicode 的编码。HTTP 协议在 TCP 协议的上层，所以我们可以所有流淌在 TCP 协议中的流的所有内容都可以视为字符。TCP 传的是流，IP 传的是包，所谓 流 就是没有明显分割单位的事物，唯一能够确定的就是先后顺序，比如水流，字节流。

HTTP 协议不保存状态

HTTP 协议无状态的意思是对于客户端和服务器，只有当前正在进行的请求是有意义的，任何已经结束的请求或响应都不会在客户端和服务器上留下记录，也就是 HTTP 协议不会对发送过的请求或响应做持久化处理。正是因为这种简单化的设计，HTTP 协议能够快速地处理大量事务。但是随着web的不断发展，HTTP 协议的无状态设计在面对一些问题的时候无法很好地解决，比如我们登录了一个购物网站，那么当我们跳转到该网站的其他页面的时候我们也应该保持登录状态，为了实现这种保持状态的功能， HTTP 协议引入了 Cookie 技术。

HTTP协议中的请求方法

| 方法 | 说明 | 支持的 HTTP 协议版本 | | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------- | | GET | GET请求会显示请求指定的资源。一般来说GET方法应该只用于数据的读取，而不应当用于会产生副作用的非幂等的操作中。它期望的应该是而且应该是安全的和幂等的。这里的安全指的是，请求不会影响到资源的状态。 | 1.0、1.1 | | POST | POST请求会向指定资源提交数据，请求服务器进行处理，如：表单数据提交、文件上传等，请求数据会被包含在请求体中。POST方法是非幂等的方法，因为这个请求可能会创建新的资源或/和修改现有资源。 | 1.0、1.1 | | PUT | PUT请求会身向指定资源位置上传其最新内容，PUT方法是幂等的方法。通过该方法客户端可以将指定资源的最新数据传送给服务器取代指定的资源的内容。 | 1.0、1.1 | | HEAD | HEAD方法与GET方法一样，都是向服务器发出指定资源的请求。但是，服务器在响应HEAD请求时不会回传资源的内容部分，即：响应主体。这样，我们可以不传输全部内容的情况下，就可以获取服务器的响应头信息。HEAD方法常被用于客户端查看服务器的性能。 | 1.0、1.1 | | DELETE | DELETE请求用于请求服务器删除所请求URI（统一资源标识符，Uniform Resource Identifier）所标识的资源。DELETE请求后指定资源会被删除，DELETE方法也是幂等的。 | 1.0、1.1 | | OPTIONS | OPTIONS请求与HEAD类似，一般也是用于客户端查看服务器的性能。这个方法会请求服务器返回该资源所支持的所有HTTP请求方法，该方法会用'*'来代替资源名称，向服务器发送OPTIONS请求，可以测试服务器功能是否正常。JavaScript的XMLHttpRequest对象进行CORS跨域资源共享时，就是使用OPTIONS方法发送嗅探请求，以判断是否有对指定资源的访问权限。 | 1.1 | | TRACE | TRACE请求服务器回显其收到的请求信息，该方法主要用于HTTP请求的测试或诊断。 | 1.1 | | CONNECT | CONNECT方法是HTTP/1.1协议预留的，能够将连接改为管道方式的代理服务器。通常用于SSL加密服务器的链接与非加密的HTTP代理服务器的通信。 | 1.1 |

幂等：对同一个系统，使用同样的条件，一次请求和重复的多次请求对系统资源的影响是一致的。

PUT 和 DELETE 方法在 HTTP/1.1 中不带验证机制，任何人都可以上传或删除文件 , 存在安全性问题，因此一般的 Web 网站不使用该方法。

http 协议报文中的内容都是区分大小写的，所有不区分大小写的情况都是环境做的兼容，也就是我们的请求方法应该是都要大写的。

GET 和 POST 的区别

在 HTTP 协议标准中，GET 的语义是请求获取指定的资源，GET 方法是安全、幂等、可缓存的（除非有 Cache-ControlHeader的约束）,GET 方法的报文主体没有任何语义。POST 的语义是根据请求负荷（报文主体）对指定的资源做出处理，具体的处理方式视资源类型而不同。POST 不安全，不幂等，（大部分实现）不可缓存。对于 GET 请求，在参数相同的情况下，多次请求和一次请求获取的都是相同的资源，并且不会对服务器上的资源产生影响。而 POST 请求传输实体，会对服务器上的资源产生副作用。比如微博的获取最新的十篇微博就适用于 GET 方法，而发微博，评论则适用于 POST 方法。
在实际的浏览器环境中，GET 和 POST 有如下几点区别：
- 浏览器对 URL 的长度有限制（ URL 的最大长度是 2048 个字符），所以 GET 请求不能代替 POST 请求发送大量数据；
- HTML 标准规定 GET 使用 URL 或 Cookie 传参，而 POST 将数据放在 BODY 中；
- POST 比 GET 安全，因为数据在地址栏上不可见

持久连接

HTTP 协议的初始版本中，每进行一次 HTTP 通信就要断开一次 TCP 连接。以当年的通信情况来说，因为都是些容量很小的文本传输，所以即使这样也没有多大问题。可随着 HTTP 的普及，文档中包含大量图片的情况多了起来。比如，使用浏览器浏览一个包含多张图片的 HTML 页面时，在发送请求访问 HTML 页面资源的同时，也会请求该 HTML 页面里包含的其他资源。因此，每次的请求都会造成无谓的 TCP 连接建立和断开，增加通信量的开销。

为解决上述 TCP 连接的问题，HTTP/1.1 和一部分的 HTTP/1.0 想出了持久连接( HTTP Persistent Connections，也称为 HTTP keep-alive 或 HTTP connection reuse )的方法。持久连接的特点是，只要任意一端没有明确提出断开连接，则保持 TCP 连接状态。持久连接的好处在于减少了 TCP 连接的重复建立和断开所造成的额外开销，减轻了服务器端的负载。另外，减少开销的那部分时间，使 HTTP 请求和响应能够更早地结束，这样 Web 页面的显示速度也就相应提高了。

在 HTTP/1.1 中，所有的连接默认都是持久连接，但在 HTTP/1.0 内并未标准化。虽然有一部分服务器通过非标准的手段实现了持久连接，但服务器端不一定能够支持持久连接。毫无疑问，除了服务器端，客户端也需要支持持久连接。

持久连接使得多数请求以管线化( pipelining )方式发送成为可能。从前发送请求后需等待并收到响应，才能发送下一个请求。管线化技术出现后，不用等待响应亦可直接发送下一个请求。这样就能够做到同时并行发送多个请求，而不需要一个接一个地等待响应了。比如，当请求一个包含 10 张图片的 HTML Web 页面，与挨个连接相比，用持久连接可以让请求更快结束。而管线化技术则比持久连接还要快。请求数越多，时间差就越明显。

Cookie 管理状态

HTTP 协议是无状态的，无状态的优点是可以减少服务器的 CPU 和内存资源消耗，正是因为 HTTP 协议本身是非常简单的，所以才会被应用在各种场景里。但是如今的 web 应用已经有越来越多的状态保存需求，于是引入了 Cookie 技术，通过在请求和响应报文中写入 Cookie 信息来控制客户端的状态。

Cookie 会根据从服务器端发送的响应报文内的一个叫做 Set-Cookie 的首部字段信息，通知客户端保存 Cookie。当下次客户端再往该服务器发送请求时，客户端会自动在请求报文中加入 Cookie 值后发送出去。服务器端发现客户端发送过来的 Cookie 后，会去检查究竟是从哪一个客户端发来的连接请求，然后对比服务器上的记录，最后得到之前的状态信息。

HTTP 报文

我们的请求或响应数据会被客户端按照 HTTP 协议的标准封装成符合标准的 HTTP 报文再传递给传输层进行处理。我们平时在浏览器开发者工具中看到的 Request Header 等信息就是 HTTP 报文中的内容。有客户端发出的 HTTP 报文叫做请求报文，而服务器发出的 HTTP 报文叫做响应报文。HTTP 报文本身是由多行(用 CR+LF 作换行符)数据构成的字符串文本。

HTTP 报文大致可分为报文首部和报文主体两块。两者由最初出现的空行( CR+LF )来划分。通常，并不一定要有报文主体。

CR 对应 ASCII 码中的 13，表示 Carriage Return 回车符，LF 对应 ASCII 码中的 10，对应 Line Feed 空格符。

请求报文和响应报文的首部内容由以下数据组成: 1. 请求行:包含用于请求的方法，请求 URI 和 HTTP 版本。 2. 状态行:包含表明响应结果的状态码，原因短语和 HTTP 版本。 3. 首部字段:包含表示请求和响应的各种条件和属性的各类首部。一般有 4 种首部，分别是:通用首部、请求首部、响应首部和实体首部。 4. 其他:可能包含 HTTP 的 RFC 里未定义的首部(Cookie 等)。

报文 message 主体也叫做实体 entity 主体，实体包括实体首部和实体主体。实体会在传输前被压缩，达到客户端的时候再解压。

HTTP 状态码

状态码是 web 开发中经常需要面对的，比如 JS 原生 ajax 请求的回调函数就需要用到状态码：

var xhr = new XMLHttpRequest()
xhr.open(type, url, true)
xhr.onload = function () {
  if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304) {
    onsuccess(xhr.responseText)
  } else {
    onerror()
  }
}

其中的 xhr.status 就是返回的状态码。HTTP 协议中，HTTP 状态码负责表示客户端 HTTP 请求的返回结果、标记服务器端的处理是否正常、通知出现的错误等工作。状态码分类如下：

| 状态码 | 类别 | 原因短语 | | ------ | ------------------------------ | -------------------------- | | 1XX | Informational(信息性状态码) | 接收的请求正在处理 | | 2XX | Success(成功状态码) | 请求正常处理完毕 | | 3XX | Redirection(重定向状态码) | 需要进行附加操作以完成请求 | | 4XX | Client Error(客户端错误状态码) | 服务器无法处理请求 | | 5XX | Server Error(服务器错误状态码) | 服务器处理请求出错 |

200 OK

是我们最常遇到的状态码，表示客户端的请求已经被服务器正常处理了。根据请求的方法不同，返回的内容也不同，比如使用 GET 方法请求时，对应的请求资源会作为报文实体返回给客户端；而使用 HEAD 方法请求时只返回请求资源的实体首部，而实体主体（也就是报文主体）不会返回。

204 No Content

表示服务器接收的请求已成功处理，但在返回的响应报文中不包含实体的部分。一般用在只需要给服务器发送信息但不需要在客户端更新页面的时候使用。比如在 PUT 请求中进行资源更新，但是不需要改变当前展示给用户的页面，那么返回 204 No Content。如果新创建了资源，那么返回 201 Created 。如果页面需要更新以反映更新后的资源，那么需要返回 200 。204 响应默认是可以被缓存的。在响应中需要包含头信息 ETag。

206 Partical Content

该状态码表示客户端只请求了某个资源的一部分，比如客户端的HTTP报文首部有 Range: bytes=5001-10000 就意味着它只想请求对应资源的第 5001 字节至第 10000 字节的内容。服务器成功执行该请求后会返回状态码 206 Partical Content，响应报文中会包含指定的实体内容。

301 Moved Permarnently

永久重定向。当请求的资源已经被分配到新的 URL ，比如网站更换了域名，对应网站的 web 服务器配置了 301 重定向到新的域名，这时候我们用原来的域名访问网站就会返回 301，然后重定向到新的域名。

302 Found

和 301 类似，不同的是 302 的意思是网站资源被临时转移，所以这个重定下是临时的，只有本次请求生效，当你下次访问资源的时候还按原来的地址请求即可。

303 See Other

303 是 HTTP/1.1 中新加入的状态码，因为在 RFC1945 和 RFC2068 规范中，302 状态码是不允许客户端在重定向的时候更改请求方法的，比如你是用 POST 请求给服务器的程序接口发送数据，那么不能自动的向新的 URI 发送重复请求，必须跟用户确认是否该重发，因为第二次 POST 时，环境可能已经发生变化（ POST 请求不是幂等的）。为了应对这种情况添加了 303 状态码，当服务器对 POST 请求返回 303 状态码时，客户端直接用 GET 方法重定向到新的 URI 即可，而不需要询问用户。其实在标准制定之前，大部分浏览器就是按照 303 的方式来处理 302 状态码的

当 301、302、303 响应状态码返回时，几乎所有的浏览器都会把 POST 改成 GET，并删除请求报文内的主体，之后请求会自动再次发送。301、302 标准是禁止将 POST 方法改变成 GET 方法的，但实际使用时大家都会这么做。

304 Not Modified

当客户端发送附带条件的安全请求（采用 GET 或者 HEAD 方法的请求报文中包含 If-Match，If-Modified- Since，If-None-Match，If-Range，If-Unmodified-Since 中任一首部）时，服务器端允许请求访问资源，但因发生请求未满足条件的情况后，直接返回 304 Not Modified (服务器端资源未改变，可直接使用客户端未过期的缓存)。 304 状态码返回时，不包含任何响应的主体部分。304 虽然被划分在 3XX 类别中，但是和重定向没有关系。

307 Temporary Redirect

307 和 303 是配套产生的，它们将 302 的细分为了更换请求方法和不更换请求方法两种，303 会强制要求客户端用GET方法重定向，而 307 则是对于 POST 请求的重定向还是使用 POST 方法请求。 1. 303 :对于 POST 请求，它表示请求已经被处理，客户端可以接着使用 GET 方法去请求 Location 里的URI。 2. 307 ：对于 POST 请求，表示请求还没有被处理，客户端应该向 Location里的 URI 重新发起 POST 请求。

虽然标准中规定了 302 的细分 303 和 307，但是在浏览器的实现上把 302 实现成了标准中的 303，而且标准现在也妥协了，允许了浏览器的这种实现。2014 年 6 月的 RFC 7231 中，修改了对 302 的定义：The user agent MAY use the Location field value for automatic redirection.，原来这里是 must not。

400 Bad Request

该状态码表示请求报文中存在语法错误。当错误发生时，需修改请求的内容后再次发送请求。另外，浏览器会像 200 OK 一样对待该状态码。

401 Unauthorized

该状态码表示发送的请求需要有通过 HTTP 认证( BASIC 认证、 DIGEST 认证)的认证信息。另外若之前已进行过 1 次请求，则表示用户认证失败。返回含有 401 的响应必须包含一个适用于被请求资源的 WWW- Authenticate 首部用以质询( challenge )用户信息。当浏览器初次接收到 401 响应，会弹出认证用的对话窗口。这个状态类似于 403，但是在该情况下，依然可以进行身份验证。

403 Forbidden

该状态码表明对请求资源的访问被服务器拒绝了。服务器端没有必要给出拒绝的详细理由，但如果想作说明的话，可以在实体的主体部分对原因进行描述，这样就能让用户看到了。未获得文件系统的访问授权，访问权限出现某些问题(从未授权的发送源 IP 地址试图访问)等列举的情况都可能是发生 403 的原因。

404 Not Found

该状态码表明服务器上无法找到请求的资源。除此之外，也可以在服务器端拒绝请求且不想说明理由时使用。

500 Internal Server Error

该状态码表明服务器端在执行请求时发生了错误。也有可能是 Web 应用存在的 bug 或某些临时的故障。

503 Service Unavailable

该状态码表明服务器暂时处于超负载或正在进行停机维护，现在无法处理请求。如果事先得知解除以上状况需要的时间，最好写入 Retry- After 首部字段再返回给客户端。

不少返回的状态码响应都是错误的，但是用户可能察觉不到这点。比如 Web 应用程序内部发生错误，状态码依然返回 200 OK，这种情况也经常遇到。

HTTP首部

HTTP 首部是我们在 web 开发中了解请求和响应最重要的部分，能够读懂报文的首部才能处理好请求和响应。前面的内容我们已经看到了 HTTP 报文的结构，其中在开发中最重要的就是报文的首部，首部中包含了为客户端和服务器分别处理请求和响应提供的所需要的信息比如主体大小、所使用的语言、认证信息等内容。通过首部中字段的值，我们能了解这次请求或者响应的细节，以及采取对应的处理方式。同样的，对于有特定的需求的请求我们也可以通过改变封装报文的头部来传达给服务器。这一节就着重讨论 HTTP 首部中的重要字段，根据实际用途被分为四种类型： 1. 通用首部字段( General Header Fields )：请求报文和响应报文两方都会使用的首部。 2. 请求首部字段( Request Header Fields )：从客户端向服务器端发送请求报文时使用的首部。补充了请求的附加内容、客户端信息、响应内容相关优先级等信息。 3. 响应首部字段( Response Header Fields )：从服务器端向客户端返回响应报文时使用的首部。补充了响应的附加内容，也会要求客户端附加额外的内容信息。 4. 实体首部字段( Entity Header Fields )：针对请求报文和响应报文的实体部分使用的首部。补充了资源内容更新时间等与实体有关的信息。

HTTP 首部字段是由首部字段名和字段值构成的，中间用冒号“:” 分隔。：首部字段名: 字段值。

例如，在 HTTP 首部中以 Content-Type 这个字段来表示报文主体的媒体对象类型。Content-Type: text/html 首部字段名为 Content-Type，字符串 text/html 是字段值。

字段值对应单个 HTTP 首部字段可以有多个值 Keep-Alive: timeout=15, max=100.

HTTP 首部字段将定义成缓存代理和非缓存代理的行为，分成 2 种类型。 1. 端到端首部( End-to-end Header ) ：分在此类别中的首部会转发给请求 / 响应对应的最终接收目标，且必须保存在由缓存生成的响应中，另外规定它必须被转发。 2. 逐跳首部( Hop-by-hop Header ) ：分在此类别中的首部只对单次转发有效，会因通过缓存或代理而不再转发。HTTP/1.1 和之后版本中，如果要使用 hop-by-hop 首部，需要在 Connection 字段中写入。HTTP/1.1 一共提供了8个逐条首部的字段Connection，Keep-Alive，Proxy-Authenticate，Proxy-Authorization，Trailer，TE，Transfer-Encoding，Upgrade。

当 HTTP 报文首部中出现了两个或两个以上具有相同首部字段名时会怎么样?这种情况在规范内尚未明确，根据浏览器内部处理逻辑的不同，结果可能并不一致。有些浏览器会优先处理第一次出现的首部字段，而有些则会优先处理最后出现的首部字段。

通用首部字段

| 首部字段名 | 说明 | | ----------------- | -------------------------- | | Cache-Control | 控制缓存的行为 | | Connection | 逐跳首部、连接的管理 | | Date | 创建报文的日期时间 | | Pragma | 报文指令 | | Trailer | 报文末端的首部一览 | | Transfer-Encoding | 指定报文主体的传输编码方式 | | Upgrade | 升级为其他协议 | | Via | 代理服务器的相关信息 | | Warning | 错误通知 |

请求首部字段

| 首部字段名 | 说明 | | ------------------- | --------------------------------------------- | | Accept | 用户代理可处理的媒体类型 | | Accept-Charset | 优先的字符集 | | Accept-Encoding | 优先的内容编码 | | Accept-Language | 优先的语言(自然语言) | | Authorization | Web 认证信息 | | Expect | 期待服务器的特定行为 | | From | 用户的电子邮箱地址 | | Host | 请求资源所在服务器 | | If-Match | 比较实体标记(ETag) | | If-Modified-Since | 比较资源的更新时间 | | If-None-Match | 比较实体标记(与 If-Match 相反) | | If-Range | 资源未更新时发送实体 Byte 的范围请求 | | If-Unmodified-Since | 比较资源的更新时间(与 If-Modified-Since 相反) | | Max-Forwards | 最大传输逐跳数 | | Proxy-Authorization | 代理服务器要求客户端的认证信息 | | Range | 实体的字节范围请求 | | Referer | 对请求中 URI 的原始获取方 | | TE | 传输编码的优先级 | | User-Agent | HTTP 客户端程序的信息 |

响应首部字段

| 首部字段名 | 说明 | | ------------------ | ---------------------------- | | Accept-Ranges | 是否接受字节范围请求 | | Age | 推算资源创建经过时间 | | ETag | 资源的匹配信息 | | Location | 令客户端重定向至指定 URI | | Proxy-Authenticate | 代理服务器对客户端的认证信息 | | Retry-After | 对再次发起请求的时机要求 | | Server | HTTP 服务器的安装信息 | | Vary | 代理服务器缓存的管理信息 | | WWW-Authenticate | 服务器对客户端的认证信息 |

实体首部字段

| 首部字段名 | 说明 | | ---------------- | -------------------------- | | Allow | 资源可支持的 HTTP 方法 | | Content-Encoding | 实体主体适用的编码方式 | | Content-Language | 实体主体的自然语言 | | Content-Length | 实体主体的大小(单位 :字节) | | Content-Location | 替代对应资源的 URI | | Content-MD5 | 实体主体的报文摘要 | | Content-Range | 实体主体的位置范围 | | Content-Type | 实体主体的媒体类型 | | Expires | 实体主体过期的日期时间 | | Last-Modified | 资源的最后修改日期时间 |

Cookie 服务的首部字段

管理服务器与客户端之间状态的 Cookie，虽然没有被编入标准化 HTTP/1.1 的 RFC2616 中，但在 Web 网站方面得到了广泛的应用。

Cookie 的工作机制是用户识别及状态管理。Web 网站为了管理用户的状态会通过 Web 浏览器，把一些数据临时写入用户的计算机内。接着当用户访问该 Web 网站时，可通过通信方式取回之前存放的 Cookie。调用 Cookie 时，由于可校验 Cookie 的有效期，以及发送方的域、路径、协议等信息，所以正规发布的 Cookie 内的数据不会因来自其他 Web 站点和攻击者的攻击而泄露。

不仅服务器可以设置 cookie 传给客户端，客户端也可以设置 cookie 在 HTTP 报文中传递给服务器。

| 首部字段名 | 说明 | 首部类型 | | ---------- | -------------------------------- | ------------ | | Set-Cookie | 开始状态管理所使用的 Cookie 信息 | 响应首部字段 | | Cookie | 服务器接收到的 Cookie 信息 | 请求首部字段 |

Set-Cookie 字段：Set-Cookie: status=enable; expires=Tue, 05 Jul 2011 07:26:31 GMT; path=/; domain=clloz.com;

| 属性 | 说明 | | ------------ | ------------------------------------------------------------------------------- | | NAME=VALUE | 赋予 Cookie 的名称和其值(必需项) | | expires=DATE | Cookie 的有效期(若不明确指定则默认为浏览器关闭前为止) | | path=PATH | 将服务器上的文件目录作为 Cookie 的适用对象(若不指定则默认为文档所在的文件目录) | | domain= 域名 | 作为 Cookie 适用对象的域名(若不指定则默认为创建 Cookie 的服务器的域名) | | Secure | 仅在 HTTPS 安全通信时才会发送 Cookie | | HttpOnly | 加以限制，使 Cookie 不能被 JavaScript 脚本访问 |

其他首部字段

X-Frame-Options

HTTP 响应首部，用于控制网站内容在其他 Web 网站的 Frame 标签内的显示问题。其主要目的是为了防止点击劫持( clickjacking )攻击。DENY :拒绝；SAMEORIGIN :仅同源域名下的页面( Top-level-browsing-context )匹配时许可。( 比如，当指定 http://clloz.com/index.html 页面为 SAMEORIGIN 时，那么 clloz.com 上所有页面的 frame 都被允许可加载该页面，而 example.com 等其他域名的页面就不行了)。

所有主流浏览器都支持这个字段，我们也可以在 web 服务器中设置 X-Frame-Options 的默认值，比如在 apache2 中写入如下配置。

<IfModule mod_headers.c>
     Header append X-FRAME-OPTIONS "SAMEORIGIN"
</IfModule>

X-XSS-Protection

首部字段 X-XSS-Protection 属于 HTTP 响应首部，它是针对跨站脚本攻击( XSS )的一种对策，用于控制浏览器 XSS 防护机制的开关。首部字段 X-XSS-Protection 可指定的字段值如下。 1. 0 :将 XSS 过滤设置成无效状态 2. 1 :将 XSS 过滤设置成有效状态

HTTP 的瓶颈

现在无论是我们浏览网页还是用 app 订餐，都会大量使用 HTTP 协议，如今开发的接入互联网的软件大多都使用了 HTTP 协议，为什么 HTTP 协议为什么受欢迎呢。从底层来考虑的话，不同的协议在访问计算机或网络设备的时候需要通过不同的接口，如果你安装的应用使用的协议是当前设备上防火墙关闭的，那么你必须修改防火墙设置，而大部分用户不会特地去修改。在互联网功能中使用者最多的就是 Web ，不管你懂不懂电脑，你都会用浏览器浏览网页，所以绝大部分计算机或者网络设备都开放了Web访问的接口，Web 是基于 HTTP 协议运作的，因此在构建 Web 服务器或访问 Web 站点时，需事先设置防火墙 HTTP(80/tcp) 和 HTTPS(443/tcp) 的权限。大部分设备的 80 和 443 端口都是打开的，正是因为这一接入的优势使得大家开发应用的时候会选择 HTTP ，因为不再需要用户特地去修改防火墙设置，并且浏览器作为 HTTP 的客户端之一，可以说是全世界安装得最多的应用之一， HTTP 的服务器已经具有相当规模，也让 HTTP 更加有优势。

但是，正是由于 HTTP 的使用者越来越多，凸显出当前 HTTP 标准中的许多不足。比如如今有很多 SNS 网站，数以千万记的用户在网站上发布自己的内容，服务器在短时间内就会发生非常多的资源更新，但是HTTP却无法及时把这些更新显示到客户端，因为服务器是无法主动和客户端通信的，必须频繁地通过客户端发起请求询问服务器是否有更新，相信做过前端开发的同学都遇到过这种情况，如果有更新还好，可是如果没有更新，那么这次请求就是浪费了。虽然2005年的 AJAX 技术让我们可以做到局部刷新页面了，但是对于访问量众多的大型应用来说，这依然不是一个好的解决办法。

HTTP的瓶颈可以总结为以下几点： 1. 一条连接上只可发送一个请求。 2. 请求只能从客户端开始。客户端不可以接收除响应以外的指令。 3. 请求 / 响应首部未经压缩就发送。首部信息越多延迟越大。 4. 发送冗长的首部。每次互相发送相同的首部造成的浪费较多。 5. 可任意选择数据压缩格式。非强制压缩发送。

HTTP/2

为了消除HTTP瓶颈，Google在2010年首次作出了尝试，在 HTTP 和 SSL 之间加入了一个会话层，实现了一个 TCP 连接可以无限制地处理多个 HTTP 请求，所有的请求都在一次 TCP 连接上完成，并且支持给这些请求设置优先级。SPDY 压缩了 HTTP 首部，这样 HTTP 通信产生的数据包能够变得更小更少。SPDY 同时也支持服务器主动推送消息给客户端，不必等待客户端的请求。

于1999年制定的 HTTP/1.1 显然已经无法适应今天的 Web，下一代 HTTP 协议的标准呼之欲出。在SPDY和 WebScoket 等技术的基础上，HTTP/2 的首个草稿在2012年完成，内容基本和 SPDY 相同。HTTP/2 标准于2015年5月以 RFC 7540 正式发表。如今大多数浏览器和 web 服务器都支持 HTTP/2，同样标准也在一直向前推进，大部分网站以及启用 HTTP/2 标准。HTTP/2 带来的提升可以看http2.akamai.com/demo，这里的地球图片是用361块小图片拼接而成，两边分别是用 HTTP/1.1 和 HTTP/2 进行请求，可以看出速度差距很大。

总结

由于网络的内容太多，文章已经太长了，本来想加在本文中的 HTTPS 和 Web 安全的内容只能写到另一篇文章中了。这篇文章结合浏览器渲染过程及JS引擎浅析，我们已经能够清晰地了解从浏览器发送HTTP请求给服务器到服务器返回文档，再到浏览器接收到文档进行渲染，最后我们能够看到渲染好的画面的过程，也就可以回答从输入 URL 到页面展示中间发生了什么，两篇文章都非常长，因为内容真的很多，可能也有一些不正确和表述的不好的地方，欢迎指出问题，或者有遗漏的细节也欢迎讨论。

参考文章

HTTPS

Thu, 02 May 2019 12:00:00 GMT

前言

在上一篇介绍 HTTP 的文章中，我们了解了 HTTP 协议在通信过程中的细节，但是其实 HTTP 除了我们说的一些性能瓶颈之外，还有一些安全性的问题。

HTTP 的安全性问题

通信使用明文，不加密，内容可能会被窃听
不会验证通信方的身份，可能会被伪装的请求或响应欺骗
无法验证 HTTP 报文的完整性，内容可能被篡改

通信使用明文会被窃听

我们计算机之间的通信要经过很多中间设备才能传输到对方，这些数据包在中间设备上流动的时候是能够被看到的，如果我们遇到了恶意窥视，那么我们的信息就会被别人获取，如果这个信息是明文传输的，那么对方就直接能够知道我们所发送的内容。即使是信息加密过了，依然能够被通信线路上的其他人获取，但是如果我们通过安全的方法加密，那么黑客即使拿到我们的数据包也不能破解报文中的内容，那么就是没意义的，我们的数据仍然是安全的。就好像我们寄快递，如果没有包装，每个人人都能直接看到我们寄的什么，但是如果我们用纸箱抱起来（相当于简单加密，很容易被破解），那么我们寄的东西不那么容易被看到了，但是对于别有用心的人还是可以打开箱子看到里面的内容。所以我们可以采取更安全的加密方式，用密码箱把我们的东西放进去，然后再寄这个密码箱就可以了，现在除非有人能够知道我们密码箱的密码，否则是不能破解我们的内容了，基本就是安全的了。

对于 HTTP 请求，我们可以非常容易地获得报文中地内容，比如下图就是我用 wireshark 捕获的我本地的 HTTP 请求报文，我们可以看出报文是直接可以从 16 进制翻译过来地，我们的首部字段以及请求链接等信息都能看的一清二楚。

身份地伪装

HTTP 协议中地请求和响应不会对通信方地身份进行确认，比如任何人都可以伪装成用户想服务器发起请求，如果服务器不进行身份地验证，那么用户地资料很有可能泄漏。同样我们客户端发起地请求也有可能发送给一台伪装成目标服务器的设备，那么我们的信息安全也会受到威胁。甚至有人恶意地对服务器不断发送无效请求也会被受理最终导致服务器瘫痪。不能确定通信方的身份带来的风险可以归纳为以下几点： 1. 无法确定请求发送至目标的 Web 服务器是否是按真实意图返回响应的那台服务器。有可能是已伪装的 Web 服务器。 2. 无法确定响应返回到的客户端是否是按真实意图接收响应的那个客户端。有可能是已伪装的客户端。 3. 无法确定正在通信的对方是否具备访问权限。因为某些 Web 服务器上保存着重要的信息，只想发给特定用户通信的权限。 4. 无法判定请求是来自何方、出自谁手。 5. 即使是无意义的请求也会照单全收。无法阻止海量请求下的 DoS 攻击( Denial of Service，拒绝服务攻击)。

无法验证报文的完整性

既然我们的报文在传输过程中可能被监听，那么同样，在请求从客户端发出到服务器接收到请求的这一过程中，我们的报文也有可能被篡改，而我们的服务器是无法判断报文是否被修改过。

比如，从某个 Web 网站上下载内容，是无法确定客户端下载的文件和服务器上存放的文件是否前后一致的。文件内容在传输途中可能已经被篡改为其他的内容。即使内容真的已改变，作为接收方的客户端也是觉察不到的。

像这样，请求或响应在传输途中，遭攻击者拦截并篡改内容的攻击称为中间人攻击( Man-in-the-Middle attack，MITM )。

HTTPS

我们上面介绍了 HTTP 的三个安全性问题，如何解决这三个问题呢？ 1. 对明文进行加密 2. 对通信方身份进行认证 3. 保护报文完整性

HTTP 协议加上这三个技术就是我们所说的 HTTPS，HTTPS 并不是一个全新的协议，它只是在 HTTP 协议上增加了加密，认证和完整性保护机制的 HTTP 协议（将 HTTP 通信接口部分用 SSL ( Secure Socket Layer )和 TLS ( Transport Layer Security )协议代替），全称叫做 HTTP Secure。

经常会在 Web 的登录页面和购物结算界面等使用 HTTPS 通信。使用 HTTPS 通信时，不再用 http://，而是改用 https://。另外，当浏览器访问 HTTPS 通信有效的 Web 网站时，浏览器的地址栏内会出现一个带锁的标记。对 HTTPS 的显示方式会因浏览器的不同而有所改变。

通常，HTTP 直接和 TCP 通信。当使用 SSL 时，则演变成先和 SSL 通信，再由 SSL 和 TCP 通信了。简言之，所谓 HTTPS，其实就是身披 SSL 协议这层外壳的 HTTP。在采用 SSL 后，HTTP 就拥有了 HTTPS 的加密、证书和完整性保护这些功能。

SSL Secure Sockets Layer 是独立于 HTTP 的协议，和 HTTP 协议一样都是应用层协议，所以不光是 HTTP 协议，其他运行在应用层的 SMTP 和 Telnet 等协议均可配合 SSL 协议使用。可以说 SSL 是当今世界上应用最为广泛的网络安全技术。

加密

加密的方式有两种，一种是对称加密，加密和解密用同一个密钥；另一种是非对称加密，加密和解密用不同的密钥。对称加密需要把密钥通过网络进行发送，既然报文能被监听，那么密钥同样也会被监听，密钥被攻击者获取，我们的加密报文和没加密没区别，换句话说，如果密钥能够安全传递，那么我们的报文也能安全传递，对称加密是行不通的。

非对称加密是运用数学原理生成的一对公钥和私钥，公钥可以交给任何人，只能用来加密，而私钥保存在服务器，只能用来解密。公钥加密后的内容用公钥是无法解开的，这一点是非常重要的，至于为什么，你可以这么理解，有一个函数$ f(x) = a + b $，当你知道a和b的时候要你计算$ f(x) $很容易，但是如果给你$ f(x) $要你求a和b的值就有非常多的可能行，特别是当这个值足够大的时候，拿几乎就是不可能的，公钥的作用就是这样，给你公钥你进行加密非常容易，但是如果给你加密后的结果你是无法解密的。公钥和私钥是存在数学联系的，比如常用的RSA加密算法，就是利用大整数因式分解难以破解的性质来设计的，如果你对非对称加密的设计细节很感兴趣可以看这两篇文章： 1. RSA算法原理（一） 2. RSA算法原理（二）

李永乐老师的这个视频也能让你对 RSA加密算法 有一个简单的了解银行的密码系统安全吗

HTTP协议没有加密功能但可以通过和 SSL (Secure Socket Layer ，安全套接层)或 TLS ( Transport Layer Security，安全传输层协议)的组合使用，加密 HTTP 的通信内容。用 SSL 建立安全通信线路之后，就可以在这条线路上进行 HTTP 通信了。与 SSL 组合使用的 HTTP 被称为 HTTPS ( HTTP Secure，超文本传输安全协议)或 HTTP over SSL。

HTTPS 在通信过程中并不是一直采用非对称加密，而是采取一种混合加密的方式，也就是说我们将对称加密的密钥用非对称加密的方式进行传递，当确保对称加密的密钥安全地送达之后，我们就可以安全地使用对称加密来通信了，这样做的目的是因为非对称加密虽然安全，但是因为处理的过程要比对称加密更加复杂，所以效率比较低。混合加密的大致过程如下：客户端拿到服务端的公钥后，产生一个随机的 key 作为对称加密的共享密钥，然后用服务端的公钥加密传递给服务端，服务端拿到加密后的 key，利用服务端原有的私钥解密，得到 key 的原文。然后后面跟客户端通讯就使用key作为对称加密的私钥，进行通讯了。其实 https 真正的数据传递过程，走的是对称加密。

身份认证

加密虽然实现了，但是获得正确公钥的前提是我们当前通信的对象确实是目标服务器，而不是一个伪装的攻击者。如果我们收到的是攻击者替换过后的公钥，那么当我们以为通信已经安全，将数据用这个假的公钥加密后传给目标服务器，在这个过程中攻击者截获我们的报文，用它的私钥就可以解密得到我们的数据。所以非对称加密要想实现，前提就是能确定公钥发送者的身份。

为了解决这个问题，我们必须借助第三方数字证书认证机构( CA，Certificate Authority )和其相关机关颁发的公开密钥证书。这个数字认证机构必须是客户端和服务器都信任的第三方机构。有了这个第三方机构的证书我们才能够确定服务器端的身份。需要了解的一点是，我们在加密通信的时候是用公钥加密，私钥解密，这其中用的是加密算法。其实我们还可以用私钥加密，用对应的公钥解密，这种情况往往是用来发布一个公告或者广播信息，也正是我们数字签名当中用到的算法。 HTTPS中的证书验证的流程如下： 1. 服务器端将自己的公钥和信息发送给 CA，申请数字证书，CA 在验证过申请者身份之后，开始制作数字证书，制作过程如下：将我们发送给 CA 的公钥，以及证书签发单位，申请者等信息记录为内容 M，然后通过哈希运算获得 M 的摘要 H，用 CA 的私钥对 H 进行加密，加密得到的就是 CA 的数字签名 S。CA 会把数字签名 S 附在内容 M 之后，整个 M+S 就被称作数字证书，CA 会把这个数字证书返回给服务器。 2. 服务器获得数字证书之后将 CA 颁发的带着公钥数字证书发送给客户端 3. 客户端拿到数字证书之后会用 CA 的公钥（一般预装在浏览器中）对数字签名 S 进行解密，获得 M 经过哈希运算后的摘要 H，然后在对数字证书中的内容 M 进行哈希运算获得 H'，如果 H 和 H' 相同，说明服务器的数字证书是 CA 认证的，数字证书中的公钥也是可靠的，内容没有经过篡改。

之所以数字签名是可靠的，是因为私钥只有 CA 知道，而对摘要的加密只有私钥才能做到，所以只要验证出加密内容没问题，说明证书就是可靠的。而即使攻击者截获证书，将内容 M 改掉，由于数字签名 S 攻击者无法篡改，当客户端进行验证的时候就能够发现内容被篡改。

私钥可以用来解密和签名，公钥可以用来加密和验证。

一般来说，只有被请求方服务器需要证明自己的身份，但是如银行用户这样的特殊情况，客户端也需要证明自己的身份，这就是为什么在计算机上使用网上银行需要安装证书的原因。

HTTPS安全通信机制

运用SSL的加密和证书验证，我们已经能够确保通信的安全了，回顾一下HTTPS安全通信的全过程：

客户端通过发送 Client Hello 报文开始 SSL 通信。报文中包含客户端支持的 SSL 的指定版本、加密组件( Cipher Suite )列表(所使用的加密算法及密钥长度等)。
服务器可进行 SSL 通信时，会以 Server Hello 报文作为应答。和客户端一样，在报文中包含 SSL 版本以及加密组件。服务器的加密组件内容是从接收到的客户端加密组件内筛选出来的。
之后服务器发送 Certificate 报文。报文中包含公开密钥证书。
最后服务器发送 Server Hello Done 报文通知客户端，最初阶段的 SSL 握手协商部分结束。
SSL 第一次握手结束之后，客户端以 Client Key Exchange 报文作为回应。报文中包含通信加密中使用的一种被称为 Pre-master secret 的随机密码串。该报文已用步骤 3 中的公开密钥进行加密。
接着客户端继续发送 Change Cipher Spec 报文。该报文会提示服务器，在此报文之后的通信会采用 Pre-master secret 密钥加密。
客户端发送 Finished 报文。该报文包含连接至今全部报文的整体校验值。这次握手协商是否能够成功，要以服务器是否能够正确解密该报文作为判定标准。
服务器同样发送 Change Cipher Spec 报文。
服务器同样发送 Finished 报文。
服务器和客户端的 Finished 报文交换完毕之后，SSL 连接就算建立完成。当然，通信会受到 SSL 的保护。从此处开始进行应用层协议的通信，即发送 HTTP 请求。
应用层协议通信，即发送 HTTP 响应。
由客户端断开连接。断开连接时，发送 close_notify 报文。
最后发送 TCP FIN 报文来关闭与 TCP 的通信。

在以上流程中，应用层发送数据时会附加一种叫做 MAC ( Message Authentication Code )的报文摘要。MAC 能够查知报文是否遭到篡改，从而保护报文的完整性。

参考文章

rsa加密算法

在terminal中用daemon方式启动emacs

Sat, 27 Apr 2019 12:00:00 GMT

前言

由于个人喜好，虽然 emacs 不像 vim 那样在 Linux 中默认安装，不过我在 mac 上还是习惯于用 emacs 作为默认的 terminal 编辑工具，不过 emacs 有个坏毛病就是配置挺繁琐，没有 vim 那么轻量，并且当配置越来越多，启动会比较慢，用 emacs 命令的话每次都得等 emacs 加载会很头疼，下面就分享以下让 emacs 在后台驻留的方式。

如何快速启动 emacs

emacs 提供了 --daemon 的后台驻留启动参数，不过我们可以配置以下，让启动更便捷，首先创建一个 .emacs_client.sh 文件，在其中加入如下内容：

#!/bin/bash
#filename: emacs_client.sh

if [ `ps axu | grep "Emacs.*app" | grep daemon | wc -l` -eq 1 ]
# if [ `ps axu | grep "Emacs"` -eq 1 ]
then
    echo "Ready."
else
    echo "Starting server."
    /usr/local/bin/emacs --daemon
fi

emacsclient -c "$@"

这段的主要功能就是检查进程中是否有 emacs，如果没有则用 --daemon 方式启动，如果有就直接打开。然后我们在环境变量给我们的命令起个别名，并且加入一个关闭进程的方法，打开 .bash_profile，在其中加入如下内容：

alias emacs="~/.emacs_client.sh -t"
alias em="emacs"
# alias emd="emacs -e '(kill-emacs)'"
alias emd="kill-emacs"

# add kill emacs function
function kill-emacs(){
    emacsclient -e "(kill-emacs)"
    emacs_pid=$( ps x | grep "Emacs.*app" | grep daemon | awk '{print $1}' )
    if [[ -n "${emacs_pid}" ]];then
        kill -9 "${emacs_pid}"
    fi
}

这一段的主要功能就是用 em 代替 emacs 指令，然后 emd 指令表示关掉 emacs 进程。

现在如果你要启动 emacs 只要键入 em 就可以了，第一次会加载 emacs 配置，然后进程会一直在后台驻留，当你下次再要进入的时候再键入 em 命令，emacs 就会秒开。如果你想关掉进程，就直接输入 emd，不过下次再启动就有需要加载配置了。

获取文档中元素的宽高

Sat, 27 Apr 2019 12:00:00 GMT

前言

获取元素的尺寸和位置是我们经常需要遇到的问题，获取文档的高度有各种不同的方法，每个属性的作用各不相同。比如 window 对象的 innerHeight 和 outerHeight 就表示不一样的意思，元素的属性也一样。获取元素尺寸和位置的时间也很重要，如果我们在元素还没加载的时候获取肯定是得不到正确结果的。比较安全的方法当然是 load 事件触发以后获取。

load 事件和 onload 属性

我们一般都是使用 window 对象的 onload 属性来监控 load 事件，但其实文档中所有异步加载的资源都可以用 load 事件监控是否加载完成（非内联的 script，link ，以及 image ），这些资源的加载成功都会触发 load 事件。

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script defer src="js/test.js"></script>
    <link rel="stylesheet" href="css/test.css" />
    <style>
      div {
        height: 50px;
        width: 80px;
        background-color: lightblue;
      }
    </style>
    <script>
      console.log(123)
    </script>
  </head>
  <body>
    <img src="img/totoro.jpg" alt="" />
    <div>this is a div element!</div>
    <script>
      function get(selector) {
        return document.querySelector(selector)
      }

      function getAll(selector) {
        return document.querySelectorAll(selector)
      }
      var img = get('img')
      var link = get('link')
      var style = get('style')
      var script = get('script')
      var div = get('div')
      var inner = getAll('script')[1]

      img.onload = function () {
        console.log('img')
      }

      link.onload = function () {
        console.log('link')
      }

      style.onload = function () {
        console.log('style')
      }

      script.onload = function () {
        console.log('script')
      }

      inner.onload = function () {
        console.log('inner')
      }

      div.onload = function () {
        console.log('div')
      }
    </script>
  </body>
</html>

输出结果：

123
link
script
img

非内联的 js，css，image 的加载完毕都触发了 load 事件。

获取元素宽高

不要用 element.style.width

element.style 这个属性获取的是元素的内联样式，也就是写在标签中 style 属性里的样式，内联样式本来就不推介，如果你是用 style 标签或者外部样式表引入的样式，element.style.width 是无法获取值的。

<div style="width: 300px">this is a div element!</div>
<script>
  function get(selector) {
    return document.querySelector(selector)
  }

  var div = get('div')

  window.onload = function () {
    console.log(div.style.width)
  }
</script>

如果去掉div中的 style 属性，div.style.width 将输出空字符串。

offsetHeight, offsetWidth

offsetHeight 可以用来计算元素的物理空间，此空间包括内容，padding 和 border（还包括滚动条的宽度，但大多时候滚动条的宽度是计算到 padding 和内容中的）。

<style>
  div {
    height: 50px;
    width: 80px;
    padding: 10px;
    margin: 10px;
    border: 3px solid;
    background-color: lightblue;
    overflow: scroll;
  }
</style>
<div>sdfdsfsfdsfsdfdsfsfsfdsffsfsdfasfasfasfsafasfsafsafsafsafs</div>
<script>
  function get(selector) {
    return document.querySelector(selector)
  }
  var div = get('div')

  window.onload = function () {
    console.log(div.offsetHeight, div.offsetWidth) //76, 106
  }
</script>

scrollHeight,scrollWidth

scrollHeight 用来计算可滚动容器的大小，包括不可见的部分，比如一个 300*300 的容器放入一个 600*600 的图片，此时 scrollHeight 为 600，当然，scrollHeight 的值需要加上 padding 的值。

<style>
  div {
    height: 50px;
    width: 80px;
    padding: 10px;
    margin: 10px;
    border: 3px solid;
    background-color: lightblue;
    overflow: scroll;
  }
</style>
<div>sdfdsfsfdsfsdfdsfsfsfdsffsfsdfasfasfasfsafasfsafsafsafsafs</div>
<script>
  function get(selector) {
    return document.querySelector(selector)
  }
  var div = get('div')

  window.onload = function () {
    console.log(div.scrollWidth) //382
  }
</script>

clientHeight,clientWidth

clientHeight 表示可视区域，包括内容和 padding (不包括边框），如果有滚动条，还需要减去滚动条的宽度。

<style>
  div {
    height: 50px;
    width: 80px;
    padding: 10px;
    margin: 10px;
    border: 3px solid;
    background-color: lightblue;
    overflow: scroll;
  }
</style>
<div>sdfdsfsfdsfsdfdsfsfsfdsffsfsdfasfasfasfsafasfsafsafsafsafs</div>
<script>
  function get(selector) {
    return document.querySelector(selector)
  }
  var div = get('div')

  window.onload = function () {
    console.log(div.clientWidth) //100
  }
</script>

window.getComputedStyle

Window.getComputedStyle() 方法返回一个对象，该对象在应用活动样式表并解析这些值可能包含的任何基本计算后报告元素的所有 CSS 属性的值。私有的 CSS 属性值可以通过对象提供的 API 或通过简单地使用 CSS 属性名称进行索引来访问。这个方法是最推荐的，因为它是浏览器渲染引擎对外开放的接口，返回对象中的属性都是浏览器最终渲染计算的结果。需要注意的是，返回的宽高是跟你的 box-sizing属性有关的。

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script defer src="js/test.js"></script>
    <link rel="stylesheet" href="css/test.css" />
    <style>
      div {
        height: 50px;
        /* width: 80px; */
        padding: 10px;
        margin: 10px;
        border: 3px solid;
        background-color: lightblue;
        overflow: scroll;
        box-sizing: border-box;
      }
    </style>
  </head>
  <body>
    <img src="img/totoro.jpg" alt="" />
    <div>sdfdsfsfdsfsdfdsfsfsfdsffsfsdfasfasfasfsafasfsafsafsafsafs</div>
    <script>
      function get(selector) {
        return document.querySelector(selector)
      }
      var div = get('div')

      window.onload = function () {
        console.log(
          window.getComputedStyle(div, null).padding,
          window.getComputedStyle(div, null).border,
          window.getComputedStyle(div, null).width
        )
      }
    </script>
  </body>
</html>

返回结果： 1. box-sizing: border-box;:10px 3px solid rgb(0, 0, 0) 1003px 2. box-sizng: content-box:10px 3px solid rgb(0, 0, 0) 977px

div.getBoundingClientRect()

Element.getBoundingClientRect() 方法返回元素的大小及其相对于视口的位置。返回值是一个 DOMRect 对象，这个对象是由该元素的 getClientRects() 方法返回的一组矩形的集合, 即：是与该元素相关的 CSS 边框集合。

DOMRect 对象包含了一组用于描述边框的只读属性——left、top、right和bottom，单位为像素。除了 width 和 height 外的属性都是相对于视口的左上角位置而言的。

空边框盒（译者注：没有内容的边框）会被忽略。如果所有的元素边框都是空边框，那么这个矩形给该元素返回的 width、height 值为 0，left、top 值为第一个 css 盒子（按内容顺序）的 top-left值。

当计算边界矩形时，会考虑视口区域（或其他可滚动元素）内的滚动操作，也就是说，当滚动位置发生了改变，top 和 left 属性值就会随之立即发生变化（因此，它们的值是相对于视口的，而不是绝对的）。如果你需要获得相对于整个网页左上角定位的属性值，那么只要给 top、left 属性值加上当前的滚动位置（通过 window.scrollX 和 window.scrollY ），这样就可以获取与当前的滚动位置无关的值。

offsetTop,offsetLeft

offsetTop 和 offsetLeft 表示该元素的左上角（边框外边缘）与已定位的父容器（ offsetParent 对象）左上角的距离.

HTMLElement.offsetParent 是一个只读属性，返回一个指向最近的（ closest，指包含层级上的最近）包含该元素的定位元素。如果没有定位的元素，则 offsetParent 为最近的 table, table cell 或根元素（标准模式下为 html；quirks 模式下为 body ）。当元素的 style.display 设置为 none 时，offsetParent 返回 null。offsetParent 很有用，因为 offsetTop 和 offsetLeft 都是相对于其内边距边界的。

在 Webkit 中，如果元素为隐藏的（ display: none; ）（该元素或其祖先元素的 style.display 为 none），或者该元素的 style.position 被设为 fixed，则该属性返回 null。在 IE 9 中，如果该元素的 ˚ 被设置为 fixed，则该属性返回 null。（ display:none 无影响。）

clientLeft,clientTop

clientTop 和 clientLeft 返回内边距的边缘和边框的外边缘之间的水平和垂直距离，也就是左，上边框宽度

获取图片的原始大小

我们在js中获取的图片的 width 和 height 是被 css 修改过的大小，如果我们想在 JS 中获取图片的原始大小来操作 DOM 的话，我们有两个方法可以选择： 1. 新建一个 img 对象，把文档中的 img 对象的 src 赋值给新的对象，然后获取这个新的对象的宽高，不需要把新的对象添加到文档中。

<img src="img/totoro.jpg" alt="" />
<script>
  function $(selector) {
    return document.querySelector(selector)
  }
  var img = $('img')
  img.onload = function () {
    var image = document.createElement('img')
    image.src = img.src
    console.log(image.width, image.height)
  }
</script>

HTML5 提供了一个新属性 naturalWidth/naturalHeight 可以直接获取图片的原始宽高。这两个属性在 Firefox/Chrome/Safari/Opera 及 IE9 里已经实现。

<img src="img/totoro.jpg" alt="" />
<script>
  function $(selector) {
    return document.querySelector(selector)
  }
  var img = $('img')
  img.onload = function () {
    console.log(img.naturalHeight, img.naturalWidth)
  }
</script>

参考文档

动态加载的样式/脚本对渲染的影响

Fri, 26 Apr 2019 12:00:00 GMT

前言

在浏览器渲染过程和JS引擎浅析这篇文章里，我提到了用同步脚本异步加载（脚本同步，但是请求是由渲染引擎的异步请求线程异步请求的）的外部资源会影响 load 事件发生的时候，如果外部资源加载时间过长，那么 load 时间发生的时间也会推迟。但其实在脚本中动态加载脚本或者异步请求外部资源还有一些细节可以挖掘。

异步请求样式表

在脚本中异步请求样式或脚本是不会阻塞DOM的解析和渲染，唯一影响的就是 load 事件发生的时间以及 load 事件发生之前的最后一次渲染。看下面这段代码：

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script defer src="js/test.js"></script>
  </head>
  <body>
    <div id="test">test1</div>

    <script>
      let script = document.createElement('link')
      script.setAttribute('rel', 'stylesheet')
      script.setAttribute(
        'href',
        'https://cdn.bootcss.com/bootstrap/4.0.0-alpha.6/css/bootstrap.css'
      )

      var a = document.body.appendChild(script)
      console.log(123)

      window.onload = function () {
        console.log('window load...')
      }
    </script>
    <div>test2</div>
  </body>
</html>

//test.js
console.log('domcontentloaded')

通过设置浏览器的 network throttling（选择 slow 3g 就可以，或者你可以自定义到更慢，能够区分出效果就可以），让异步请求的 css 的加载时间变长，然后观察之后的脚本是否执行，脚本之后的元素是否被渲染到页面上。通过结果的观察我们可以发现在 css 还没有加载完成的时候 console.log(123) 已经执行，并且 test2 元素也已经被渲染到页面上，defer标签中的代码也已经执行，说明 DOMContentLoaded 事件已经触发，说明文档解析已经完成。当异步的 css 请求到的时候，页面会对新的 css 进行解析，然后对页面进行 load 之前的最后一次渲染，此时我们看到 test1 和 test2 的字体变了，随后触发 load 事件。

同步添加内联样式表

如果我们用同步 JS 为文档添加 style 标签会怎么样呢，下面一段代码可以测试出结果：

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script defer src="js/test.js"></script>
  </head>
  <body>
    <div id="test">test1</div>

    <script>
      var style = document.createElement('style')
      style.textContent = '*{ color: red }'

      document.body.appendChild(style)
      var el = document.getElementById('test')
      console.log(window.getComputedStyle(el, null).color)

      window.onload = function () {
        console.log('window load...')
      }
    </script>
    <div>test2</div>
  </body>
</html>

//test.js
console.log('domcontentloaded')

输出如下

rgb(255, 0, 0)
domcontentloaded
window load...

我们可以看到在页面还没有解析完成的时候我们获取 test1 元素的 computedstyle 已经是 rgb(255,0,0) 了，说明我们添加的 style 标签已经解析并渲染成功。也就是说同步的内联样式表是会阻塞解析和渲染的，不过同步的内联样式表基本不会产生延迟，也就不会影响页面的性能。

异步请求外部脚本

在同步的 JS 中异步请求外部脚本也会在 load 事件之前加载完成，但是对页面解析和渲染的影响，我们看如下的代码：

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script defer src="js/test.js"></script>
  </head>
  <body>
    <div id="test">test1</div>

    <script>
      var script = document.createElement('script')
      script.src = 'https://cdn.jsdelivr.net/npm/react@15.4.0/dist/react.js'
      document.body.appendChild(script)
      console.log('after script: ', window.React)

      window.onload = function () {
        console.log('window load...')
        console.log('onload: ', window.React)
      }
    </script>
    <div>test2</div>
  </body>
</html>

//test.js
console.log('domcontentloaded: ' + window.React)

输出结果：

after script:  undefined
domcontentloaded: undefined
window load...
onload:  {__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {…}, Children: {…}, Component: ƒ, PureComponent: ƒ, createElement: ƒ, …}

结果显而易见，和异步请求外部样式表的效果相似，请求外部脚本并不影响页面的解析和渲染，也没有阻塞后面的脚本执行，这意味着动态插入一个外部脚本后不可立即使用其内容，需要等待加载完毕。在这段代码中，直到 load 事件发生后，我们在 onload 函数中才能调用外部脚本中的变量。同时也佐证了 load 事件发生之前会加载执行完所有的异步请求的外部资源。

在 DOM 中插入内联脚本

这个直接说结论通过 DOM API （ appendChild()、append()、before() 等等）插入的 script 元素，如果这个 script 元素没有 src 属性且 type 属性不是 module，则这个 script 元素的 textContent 就会像你所说的那样，立刻“同步”执行。关于这一点whatwg的html文档中有详细说明4.12.1 The script element，按照文档的理解，这个内联的脚本会立即被压到执行栈的顶部立即执行，相当于包含脚本内的函数一样，具体看下面这段代码：

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script defer src="js/test.js"></script>
  </head>
  <body>
    <div id="test">test1</div>

    <script>
      let script = document.createElement('script')
      script.text = 'console.log(1)'
      document.body.appendChild(script)
      console.log(2)

      window.onload = function () {
        console.log('window load...')
        console.log('onload: ', window.React)
      }
    </script>
    <div>test2</div>
  </body>
</html>

//test.js
console.log('domcontentloaded')

输出如下：

1
2
domcontentloaded
window load...

从结果可以看书，添加的内联 script 立即执行了，比后面的 console.log(1) 还要更早执行，文档中说的是 Immediately execute the script block, even if other scripts are already executing.，这种感觉就像是包含脚本中的同步函数，执行到这里立即压栈执行。显而易见，动态添加的内联的脚本是会阻塞页面的解析和渲染的，和原本就在文档中的内联脚本并没有不同，如果把 script.test 换成如下代码：

script.text = `
        var now = new Date().getTime();
        while(new Date().getTime() - now < 3000) {
          continue;
        }
      `

我们可以看到页面会白屏直到这段代码执行完成，后面的脚本才能执行，文档才能继续解析和渲染。

未连接的 CSS/JS 不会被载入

如果你创建了一个 <link rel="stylesheet"> （或 <script> ）但并未连接到 DOM 树，那么它不会被加载。这是标准行为与浏览器实现方式无关，因此你可以放心地利用该特性。该特性很容易测试，只需创建一个 <link rel="stylesheet"> （或 <script> ）标签并查看是否产生网络请求：

var link = document.createElement('link')
link.rel = 'stylesheet'
link.href = 'https://cdn.jsdelivr.net/npm/animate.css@3.5.2/animate.css'
var script = document.createElement('script')
script.src = 'https://cdn.jsdelivr.net/npm/react@15.4.0/dist/react.js'

监听异步资源载入

我们可以利用 document.onload 事件来监听资源是否已经从外部加载完成，代码如下

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script defer src="js/test.js"></script>
  </head>
  <body>
    <div id="test">test1</div>

    <script>
      var link = document.createElement('link')
      link.rel = 'stylesheet'
      link.href = 'https://cdn.jsdelivr.net/npm/animate.css@3.5.2/animate.css'
      var script = document.createElement('script')
      script.src = 'https://cdn.jsdelivr.net/npm/react@15.4.0/dist/react.js'
      document.body.appendChild(script)
      script.onload = function () {
        console.log('source loaded!')
      }

      window.onload = function () {
        console.log('window load...')
      }
    </script>
    <div>test2</div>
  </body>
</html>

//test.js
console.log('domcontentloaded')

输出结果如下：

domcontentloaded
source loaded!
window load...

如果你想直到具体加载事件还可以用 new Date().getTime() 来查看具体的毫秒数。

innerHTML

innerHTML 属性可用来设置 DOM 内容，但不可用来插入并执行 <script>。下面的内联脚本和外部脚本都不会被执行：

document.body.innerHTML = '<script src="foo.js"></script>'
document.body.innerHTML = '<script>console.log("foo")</script>'

在设置 innerHTML 时，浏览器会初始化一个新的 HTML Parser 来解析它。只要与该 Parser 关联的 DOM 启用了 JavaScript（通常是启用的），脚本的 scripting flag 就为真，但是即便如此，HTML 片段的解析过程中，脚本是不会执行的。

Create a new HTML parser, and associate it with the just created Document node. – 12.4 Parsing HTML fragments, WHATWG The scripting flag can be enabled even when the parser was originally created for the HTML fragment parsing algorithm, even though script elements don’t execute in that case. – 12.2.3.5 Other parsing state flags, WHATWG

事实上，设置 innerHTML 和 outerHTML 都不执行脚本，但 document.write() 是会同步执行的。

When inserted using the document.write() method, script elements execute (typically blocking further script execution or HTML parsing), but when inserted using innerHTML and outerHTML attributes, they do not execute at all. – 4.12.1 The script element WHATWG

总结

结合浏览器渲染过程和JS引擎浅析和这篇文章，对于整个浏览器的渲染过程，和我们的代码会在哪个阶段执行，是否会被阻塞应该都能有一个清晰的认识了，虽然扣了很多细节，不过这对于我们写出更好的代码还是有帮助的。

参考文章

搞懂字符编码

Fri, 26 Apr 2019 12:00:00 GMT

前言

我们经常听到 ASCII，UTF-8，UTF-16，这些都是字符的编码格式，它们之间有什么区别，为什么要搞这么多字符的编码格式，在写代码的过程中我们会遇到各种编码格式的字符，所以经常需要 encode，decode，如果不搞清楚字符编码到底是什么，每次遇到编码问题都会很头疼，搜索引擎都很难帮助你解决问题，久而久之对字符编码产生厌恶。所以还是一次性把这个问题搞清楚最好，免除后顾之忧。

给字符编码

我们的计算机只能处理数字，所有的信息无论是在硬盘还是内存里都是二进制字节流，8个二进制位 bit 组成一个字节 byte，每一个二进制位可以表示 0 和 1 两种状态，一个字节就可以表示$2^8$256种状态，从 00000000 到 11111111。但是我们生活中使用的不只有数字，还有各种各样的字符，我们怎么才能在计算机中使用和操作字符呢？所以我们就需要制定一种规则，把我们要使用的字符和计算机能识别的二进制数一一对应起来，这样计算机在解析到字符对应的二进制数就知道要显示哪个字符，再把这个字符渲染到显示器上就可以了。这样我们就把我们使用的字符转化为计算机能识别的数字，最后计算机再把这个数字渲染成我们认识的字符，就实现了我们在计算机中操作字符的需求。

现在还有一个问题是，我们要显示多少种字符，每一个字符对应一个状态，有多少字符我们就有多少种状态，从而知道我们要用多少位二进制数来显示全部字符。由于计算机最早是在美国发明的，上世纪60年代的时候，计算机科学家就根据当时的需求制定了一套字符编码，就是我们现在说的 ASCII 码，这套编码一直到今天还在使用。ASCII 码一共规定了 128 个字符的编码，包含常见的英语字符和一些控制符号，比如空格 SPACE 是 32（二进制 00100000 ），大写的字母 A 是 65（二进制 01000001 ）。这 128 个符号（包括 32 个不能打印出来的控制符号），只占用了一个字节的后面 7 位，最前面的一位统一规定为 0 。

编码扩展

由于当时计算机刚刚开始发展，使用的人还很少，在英语环境中，ASCII 码基本上也够用了。可是这个世界上语言众多，不是所有国家都是用英文的，当欧洲人开始使用计算机发现，我们的字母也需要编码使用呀，比如，在法语中，字母上方有注音符号，它就无法用 ASCII 码表示。不过一个字节表示 ASCII 码不是还空余一位嘛，用上这一位又可以表示 128 个字符了，于是欧洲国家纷纷用这一位闲置的位来表示新的符号，比如，法语中的 é 的编码为 10000010。这样一来，这些欧洲国家使用的编码体系，可以表示最多 256 个符号。

但是世界上的语言实在是太多了，就 128个编码空间实在是不够，于是各个国家用后 128 个二进制数表示自己的语言，比如，10000010 在法语编码中代表了 é，在希伯来语编码中却代表了字母 Gimel (ג)，在俄语编码中又会代表另一个符号。每个国家的字符编码都兼容 ASCII 码，也就是前 128 个编码都是 ASCII，后面的 128 个就根据自己国家的语言来。

而到了东亚这边，情况就更严重了，中文，日文，韩文等等东亚国家的文字都非常多，远不是一个字节能表示的。光是中文就好几千常用字，而且很多人的姓名里面有一些生僻字，总不能连自己的名字也打不出来把。一个字符明显不够，于是我们就加一个字节，设计出了 GB2312 字符集。一个字节功能表示256种状态，两个字节一共是 16 位二进制数，可以表示$2^{16}$共 65546 种状态。不过 GB2312 只收录了一些常用汉字 7445 个。由于这些常用字符还是不太够用，后来有扩展成 21886 个字符的 GKB，也就是现在最常用的中文字符集，windows的中文系统就用的 GBK 编码。

我们的 GBK 和 GB2312 同样是兼容 ASCII 码的。

字符集和字符编码

这两个词容易引起误解，要清楚地解释它们的区别不太容易，特别是因为大家对 ASCII 的概念比较深就容易混淆，因为 ASCII 因为字符较少可以直接把字符集中的元素按自然数排列拿来做编码。因为 ASCII 中每一个字符都在一个字节里面，我们直接就用这种最简单的方式实现就可以了，不会引起计算机的误解。但是中文是两个字节表示，英文是一个字节表示，如果这两种字符混合在一起，计算机该怎么分辨呢？可能你会觉得英文也用两个字节不就可以了，但是这回造成空间的浪费，如果一篇全是英文的文章，用这样的方法大小就会是原来的两倍。那么混合的编码怎么处理呢？在 GB2312 里面，当一个字节的第一位是 0，那么就代表这是一个 ASCII 码，而其他字符都是第一位为 1 的两个字节组成。这样计算机在解码的时候就知道，遇到字节是以 0 开头的，就知道这一个字节就表示了一个字符；遇到字节是以1开头的，就知道要加上下一个字节合起来表示一个字符。这样就在 GB2312 中既把 ASCII 的字符包含了进来，又能将它们区分出来，能达到兼容的效果了。

比如用 GB2312 来写 我叫ABC ，那么二进制编码是 11001110 11010010 10111101 11010000 01000001 01000002 01000003，解码的时候，当遇到 1 开头的字节，就把两个字节合起来解释为一个字符，于是 11001110 11010010 会被解释为我；遇到 0 开头的字节，就只把这个字节解释为一个字符，于是 01000001 就会被解释为 A 了。

我认为可以这么理解，字符集就是我们所有要用的字符的集合，集合的三大特性相信大家都学过 确定性，无序性，互异性 （实际操作不会是无序的，会有一个最简单的映射，比如自然数排列），而字符编码用二进制数对集合中的字符进行一一映射，这种一一映射可以有无数种，比如我有 100 个字符，我可以是从 0～99 的自然数，我也可以是从 0～198 的偶数，甚至如果我高兴，我可以是从 1000～901 的倒序数，对于集合中的元素也是，比如 啊 这个字，我可以把它放在映射的第一个，也可以把它放在最后一个，最重要的是，我们选择的这种映射能够最有效率地利用字节空间同时让计算机能够轻松地识别每一组映射，这因为这个需求我们的 GB2312 字符编码才选择了上述的映射方式，因为这是比较有效率，计算机也能轻松识别的。而 ASCII 选择的映射就是最简单的从 0 开始按自然数排列，因为它的字符少也不需要考虑兼容，这中方式就是最有效率最合适的，但是对于一些字符数量非常多还要考虑兼容其他字符的字符集来说，就需要考虑更好的实现方案。理解这两者的却别对于后面的 Unicode 字符集和它的多种编码方式有帮助。

维基百科上有现代编码模型，整体我的理解还是没问题的。

Unicode

在早期，网路还不是那么发达的时候，大家基本都在自己同语言范围内的网络进行活动，大家的系统以及软件的字符编码方式几乎都是差不多的，所以并不会引起什么大问题。但是随着网络越来越发达，各个国家之间的交流越来越频繁，不同字符编码导致的乱码问题让出现一个同一的编码的需求越来越强烈，这也就是现在大家所知的 Unicode。

Unicode 对世界上大部分的文字系统进行了整理、编码，使得计算机可以用更为简单的方式来呈现和处理文字。Unicode 有两种格式：UCS-2 和 UCS-4。UCS-2 就是用两个字节编码，一共 16 个比特位，这样理论上最多可以表示 65536 个字符，不过要表示全世界所有的字符显示 65536 个数字还远远不过，因为光汉字就有近 10 万个，因此 Unicode4.0规范定义了一组附加的字符编码，UCS-4 就是用4 个字节（实际上只用了 31 位，最高位必须为 0 ）。理论上完全可以涵盖一切语言所用的符号。世界上任何一个字符都可以用一个 Unicode 编码来表示，一旦字符的 Unicode 编码确定下来后，就不会再改变了。

这样的大型字符集在实现的时候就需要解决我们上面说的两个问题：

对于不需要多个字节表示的字符，怎么避免存储空间的浪费。
对于多个字节，比如两个字节，到底是一个两字节字符还是两个单字节字符。

Unicode 字符集有一套自己的字符和编码的映射（即下面说的码点），但是具体到计算机上的实现（即编码方式）需要考虑上述两个问题。如 汉 字的 Unicode 编码是 6C49，我们可以直接按这个编码传输，也可以用 utf-8 编码的3个连续的字节 E6 B1 89 来表示它，Unicode 编码有不同的实现方式，比如：UTF-8、UTF-16 和 UTF-32等等，具体使用哪一种要根据我们的需求和使用场景，有时候也有一些历史因素。

几个重要的概念：

Character：字符，这里可以理解成用户实际看到的实体，比如：A、好 等等；
Code Point：码点/码位，对应 Unicode 字符集中每个 Character 的数字编号，比如 好 的码点是：U+597D；
Code Unit：编码方案对码点进行编码后的结果，比如 好 的 UTF-16编码结果为：Ox597D，UTF-8 编码结果为：E5A5BD；
Normalization：字符标识标准化，有时候，一个字符看起来是多个字符的组成，比如 ö，可以看成一个字符，也可以看成由字符 o 和 ¨ 组合而成，而在 Unicode 通过对每个字符对应一个码点而达到标准化字符标识的目的；
BMP：Basic Multilingual Plane，基本平面，也称零号平面，Unicode Code Point 处于 U+0000 - U+FFFF之间的字符；
SMP：supplementary planes 或 astral planes，辅助平面，Unicode Code Point 处于 U+10000 - U+10FFFF 之间的字符；
UTF 即是 Unicode 转换格式（Unicode (or UCS) Transformation Format）

我们来看看 Unicode 的码点范围，现在 Unicode 标准的表示范围为 U+0000~U+10FFFF，共有 110000 个状态，十进制为 1114112 个码点。其中我们最常用的字符都集中在 U+0000 - U+FFFF 共 $2^{16}$ 65536 个码点，我们称之为基础平面。基础平面的分布看下图。每一个方块中都是 256 个码点，葛优 FF(256) 个方格，不同颜色的方格用来表示不同的类型的字符，比如图中间一大块粉色的区域 CJK characters 就是我们比较熟悉的 Chinese, Japanese, and Korean 中日韩文字的 Unicode 码点区。

以U+0000 - U+FFFF 为一个平面，U+0000~U+10FFFF 的全部码点就可以分为 17 个平面，由于基本平面已经能满足我们的使用的，所以后面的平面成为 辅助平面。基础平面的码点范围在 0 ~ 65535，在计算机中可以用 16 个二进制位表示，也就是两个字节，而所有辅助平面都已经不能只用两个字节来表示了。需要注意的是，Unicode 目前虽然定义了 1114112 个码点，但其实很多是空的，还未填充，目前大概只定义了十多万。这么多的码点只是预先规划的，因为我们生活的世界字符是在不断增加的，目前的看来一百多万是完全够用了。Unicode 自版本 2.0开始保持了向后兼容，即新的版本仅仅增加字符，原有字符不会被删除或更名。从下面的平面分布图可以看出 unicode 还预留了两个私有平面，是用来自定义字符的。

GNU Unifont 制作了一张基本平面的全部字符的图，全图大小 4000 x 4000，点击基本平面字符图查看（由于图片比较大，打开可能有点慢）。

UTF-8

UTF-8 （ Unicode Transformation Format ）作为 Unicode 的一种实现方式，广泛应用于互联网，它是一种变长的字符编码，可以根据具体情况用 1-4个字节来表示一个字符。比如英文字符这些原本就可以用 ASCII 码表示的字符用UTF-8表示时就只需要一个字节的空间，和 ASCII 是一样的。对于多字节（ n 个字节）的字符，第一个字节的前 n 为都设为 1 ，第 n+1位设为 0，后面字节的前两位都设为10。剩下的二进制位全部用该字符的 unicode码填充。

| Unicode符号范围 (十六进制) | UTF-8编码方式（二进制） | 十进制表示 | | -------------------------- | ----------------------------------- | -------------------------- | | U+0000 0000 - U+0000 007F | 0xxxxxxx | 0 - 127 | | U+0000 0080 - U+0000 07FF | 110xxxxx 10xxxxxx | 128 - 2047 | | U+0000 0800 - U+0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx | 2048 - 65535 | | U+0001 0000 - U+0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx | 65536 - 1114111（2097152） |

比如 严 的 Unicode 是 4E25(100111000100101，根据上表，可以发现 4E25 处在第三行的范围内 (0000 0800 - 0000 FFFF)，因此严的 UTF-8 编码需要三个字节，即格式是 1110xxxx 10xxxxxx 10xxxxxx。然后，从严的最后一个二进制位开始，依次从后向前填入格式中的 x，多出的位补 0。这样就得到了，严的 UTF-8 编码是 11100100 10111000 10100101，转换成十六进制就是 E4B8A5。

乱码

由于字符编码多种多样，不同的字符编码之间互相不能兼容就会造成乱码现象。首先要明确的一点是，我们在显示器上看到的字符都是经过计算机用对应的字符编码解码以后渲染给我们的，在计算机存储设备上保存的，以及在网络上传输的，都是字符经过编码后的二进制字节流。打个简单的比方，你在一个网页复制了一段文本到你的 word 或者 txt 里面去，在计算机内部，你也不过是复制了这个字符对应的编码值过去，比如我在 vscode 里面创建了一个 GBK 格式的文本，然后在用 UTF-8 的格式打开，那么就会出现乱码。但是如果我们直接复制文本到其他 utf-8 的文本中去，不会乱码，这应该是软件自动帮你转码过了。

不同的系统，不同的编辑器，不同的程序编译器解释器，默认支持的编码可能都是不同的，我们复制或者从浏览器获取的字符，都只是一段二进制字符编码，如果我们所在的环境的字符编码中没有我们所要显示的这段字符的映射，自然就会出现乱码。比如 windows 的中文系统默认编码是 GBK，那么在 windows 的命令行运行的程序如果输出的是 utf-8 的字符，将会出现乱码。不过现在大部分系统和环境都是支持Unicode的，比如windows系统就能够把Unicode映射到 GBK，映射表见Unicode 12.0 Character Code Charts，那么如果你的环境能够帮你把你的字符编码转换成 Unicode 编码，那么大部分的程序和系统都能够识别了。所以在写代码的过程中如果遇到乱码，检查我们的字符的编码格式和环境的编码格式是否一直，如果不一致可以利用语言提供的转码工具转成 Unicode 来解决乱码问题。比如 python 中的 encode 和 decode。

UTF-8 --> decode 解码 --> Unicode，Unicode --> encode 编码 --> GBK / UTF-8

编程语言中的字符编码

我们经常会看到某某语言默认用的什么编码，这种说法让人很疑惑，因为我们把编程语言的默认编码和我们使用的编辑器支持的编码当成了同一个东西，我们的编辑器可以支持各种编码，但当我们写好程序，要用进行程序的编译或者解释运行的时候，编译器或解释器对变量在内存中的处理使用的字符编码就是程序的默认编码。比如 python2 默认编码就是 ascii，也就是说当我们的程序被 python 解释器装载到内存运行的时候，解释器会把编辑器中保存的编码识别成 ascii，比如我们在编辑器中用了 utf-8，而我们保存了一个字符 严，它的 utf-8 编码是 11100100 10111000 10100101 三个字节，可是 python2 的解释器会把它当作三个 ascii 来处理，这必然会出错，所以要在程序文件的开头声明文档的编码格式，这样解释器才知道怎么转码。不过 python3 已经会自动把我们的编码转成 unicode，Unicode 是能够被各种环境识别的。如果你还想更多地了解，可以看这篇文章：Unicode之痛

UTF-16

UTF-16是一种变长的 2 或 4 字节编码模式。对于BMP内的字符使用 2 字节编码，其它的则使用 4 字节组成所谓的代理对来编码。对于 BMP 内的字符两个字节能够完全表示，很容易理解，关键问题是如何理解 UTF-16 是如何用代理吗来表示辅助平面上的码点的。

在上面基础平面表示的那张方格图上，有一块灰色区域，也就是 D8 - DF，右边的实例图表给出的说明是 UTF-16 surrogates，也就是 UTF-16代理。如果你还打开了上面基本平面字符图你就会发现这块区域是空白的。为什么要留这么一块空白呢，不是造成浪费么。这块空白就是 UTF-16 表示辅助平面字符的关键。

从 D8 - DF 被分成两块，D8 - DB 和 DC - DF，分别叫做搞代理区 High Surrogate Area 和 低代理区 Low Surrogate Area。上面我们说过每一个方格里有 256 个码点，也就是说搞代理区和低代理区分别有 1024 个状态。通过排列组合我们可以知道，两者结合一共可以表示 $2^{10} * 2 ^{10} = 2^ {20}$个状态。而我们的辅助平面一共有多少个码点呢？16 * 65536 也就是$2^4 * 2^{16}=2^{20}$，两者是相等的。这正是 UTF-16 的代理码的原理。

下面这一段落数字全部为十六进制

辅助平面的范围是从 10000 - 10FFFF，去除掉基础平面的 10000 个状态，也就是代理码要表示 0000 - 9FFFF。具体的数学计算就很简单了，用辅助平面的码点先减去基础平面的 10000，然后用除法计算出高代理区的值，用取余得出低代理区的值。

高代理区：(码点值 - 10000) / 400 + D800
低代理区：(码点值 - 10000) % 400 + DC00

以 Unicode Character “𝌆” (U+1D306) 来计算，高代理区为 (1D306 - 10000) / 400 + D800 = D834，低代理区为 (1D306 - 10000) % 400 + DC00 = DF06，关于不同编码模式的值得查询可以参考Unicode编码查询

前端使用 Unicode

字符 unicode 编码查询点击查询链接

CSS 中的使用

比如在伪元素的 content 中使用 unicode，使用方法是 \ 后加上 unicode 编码的 16 进制的表示，比如你 的 unicode 编码的 16 进制的表示是 4F60，我们可以这样使用：

h4::after {
  content: '\4F60';
  font-size: 20px;
  color: red;
}

HTML 中的使用

HTML 中我们经常使用的 HTML entity 实体比如 &，unicode 的使用方法也与这个相同就是在 & 后加上 # 和 unicode 对应的十进制表示或者是 &#x加上十六进制码点值表示，最后要接分号。比如 𝌆 就用如下方法表示：

<h4>𝌆 𝌆  </h4>

JavaScript 中的使用

只使用到 Unicode 基本平面时（\u<码点>）
有使用到 Unicode 辅助平面时（\u{ <码点> }）
只使用到 ASCII 字符时（\x<码点>）

// 使用 2 位的十六进制
console.log('\u{41}\u{42}\u{43}') // 'ABC'

// 使用 4 位的十六进制
console.log('\u{0041}\u{0042}\u{0043}') // ABC

// 使用超过 4 位以上的十六进制
console.log('\u{1F4A9}') // '💩' U+1F4A9
console.log('\u{1F923}') // '🤣' U+1F923
console.log('\u{1F436}') // '🐶' U+1F436

关于 JavaScript 中使用哪种编码有几个不同的方面。

对 JS 文件解码

这个其实跟 “JavaScript” 没什么关系，只是文件传输过来用什么编码来解码文件，类似于上面的乱码章节，编码和解码必须要统一，所以必须要有标记告诉解码方，我是用的哪种模式编码的。大致的优先级规则如下：

如果文件有 BOM 标记，则会使用对应的 Unicode 编码，比如FFFE、FEFF 就会使用 UTF-16，详见字节顺序标记；
由 HTTP(S) 请求的相应头来决定，比如：Content-Type: application/javascript; charset=utf-8；
由 <script> 标签的 charset 属性决定，比如：<script charset="utf-8" src="./main.js"></script>；
由 html 本身的 charset 决定，比如：；

引擎解析执行源码时

ECMAScript source text is represented as a sequence of characters in the Unicode character encoding, version 3.0 or later. ……ECMAScript source text is assumed to be a sequence of 16-bit code units for the purposes of this specification. Such a source text may include sequences of 16-bit code units that are not valid UTF-16 character encodings. If an actual source text is encoded in a form other than 16-bit code units it must be processed as if it was first converted to UTF-16. 上面是 ECMAScript 标准对编码的一些说明，可以看到 Javascipt 源码支持 UTF-16 编码。更实用点的理解是：Javascript 引擎总会尝试把源码转成 UTF-16 编码的文本。

对于标识符，正则表达式，字符串字面量有如下一些规则：

字符串字面量、正则表达式对象字面量、变量名支持使用\u加四位十六进制数值来表示 UTF-16 编码的字符，比如：\u0061表示英文字母小写 a；
在注释中会忽略转义序列；
字符串字面量、正则表达式对象字面量中一个转义序列对应一个字符；
变量名中一个转义序列对应一个字符；

由于 JavaScript 的设计完成是在 1995 年，当时还没有 UTF-16 的标准，也没有辅助平面的概念，所以设计之初就没有考虑到代理码这种模式。这就导致了在 ES6 标准之前的 JS 在处理辅助平面上的 UTF-16 编码会出问题，因为 UTF-16 的代理码都是四字节的，JS 会当做两个字符来处理。比如上面也有提到的 𝌆 字符，他的码点是 0x1D306，UTF-8 编码是 0xF0 0x9D 0x8C 0x86，UTF-16 编码是 0xD834 0xDF06，用 JavaScript 来处理就会出现如下问题。

'𝌆'.length
//2
'𝌆' === '\u1D306'
//false
'𝌆'.charCodeAt(0)
//55348 0xD834
'𝌆'.charCodeAt(1)
//57094 0xDF06
'𝌆'.codePointAt(0)
//119558 0x1D306
'𝌆'.codePointAt(1)
//57094

可以看出字符的长度被解析为 2，因为 JS 无法正确识别代理码，这种现象会出现在几乎所有 JS 的字符处理函数中。不过 String.prototype.codePointAt() 函数还是能正确返回码点值的，当然我们除了用 /u{码点} 的方式可以正确解码以外，还可以将 UTF-16 代理码写在同一个字符串里也是可以解析的，比如 \uD834\uDF06 来表示 𝌆，"𝌆" === "\uD834\uDF06" 的结果为 true。所以即使我们不能使用 ES6 的方法也是能解析代理码的 UTF-16 字符的，方法就是用 String.prototype.charCodeAt() 对字符的编码进行检测，如果发现有编码位于高代理区 D800 ~ DBFF 的字符就手动将他和后面一个字符的编码连结起来解析。

这里说一下几个关于编码的 JS 函数。

String.prototype.codePointAt() 返回一个 Unicode 编码点值的非负整数。如果在指定的位置没有元素则返回 undefined 。如果在索引处开始没有 UTF-16 代理对，将直接返回在那个索引处的编码单元。
String.fromCodePoint() 返回指定码点序列的创建字符串。
String.prototype.charCodeAt() 方法返回 0 到 65535 之间的整数，表示给定索引处的 UTF-16 代码单元 (在 Unicode 编码单元表示一个单一的 UTF-16 编码单元的情况下，UTF-16 编码单元匹配 Unicode 编码单元。但在——例如 Unicode 编码单元 > 0x10000 的这种——不能被一个 UTF-16 编码单元单独表示的情况下，只能匹配 Unicode 代理对的第一个编码单元)
String.fromCharCode() 方法返回由指定的UTF-16代码单元序列创建的字符串，参数范围介于 0 到 65535（0xFFFF）之间。大于 0xFFFF 的数字将被截断。不进行有效性检查。
String.prototype.charAt() 方法根据索引从一个字符串中返回指定的字符。参数为一个介于 0 和字符串长度减 1之间的整数。如果没有提供索引，参数默认为 0。

ECMAScript 6

ES6 基本解决了代理码无法识别的问题。 ES6 可以自动识别4字节的码点。因此，遍历字符串就简单多了。也有方法可以正确返回代理码表示的字符的长度。上面的 JS 码点表示法用大括号表示辅助平面也是 ES6 的新特性。String.prototype.codePointAt() 和 String.fromCodePoint() 也都是 ES6 中新的方法。也对正则表达式添加了四字节码点的支持。

for (let s of string) {
  // ...
}

Array.from('𝌆').length //1

//String.prototype.codePointAt()
'ABC'.codePointAt(1);          // 66
'\uD800\uDC00'.codePointAt(0); // 65536
'XYZ'.codePointAt(42); // undefined

//String.fromCodePoint()
console.log(String.fromCodePoint(9731, 9733, 9842, 0x2F804));
// expected output: "☃★♲你"

//String.prototype.charCodeAt()
const sentence = 'The quick brown fox jumps over the lazy dog.';
const index = 4;
console.log(`The character code ${sentence.charCodeAt(index)} is equal to ${sentence.charAt(index)}`);
//  "The character code 113 is equal to q"

//String.fromCharCode()
console.log(String.fromCharCode(189, 43, 190, 61));
// expected output: "½+¾="

//String.prototype.charAt()
var anyString = "Brave new world";
console.log("The character at index 0   is '" + anyString.charAt(0)   + "'");
console.log("The character at index 999 is '" + anyString.charAt(999) + "'");
//The character at index 0 is 'B'
//The character at index 999 is ''

/^.$/u.test('𝌆')
//true
/^.$/.test('𝌆')
//false

另外一个特别的地方就是有些字符除了字母以外，还有附加符号。比如，汉语拼音的 Ǒ，字母上面的声调就是附加符号。对于许多欧洲语言来说，声调符号是非常重要的。Unicode 提供了两种表示方法。一种是带附加符号的单个字符，即一个码点表示一个字符，比如 Ǒ 的码点是 U+01D1；另一种是将附加符号单独作为一个码点，与主体字符复合显示，即两个码点表示一个字符，比如 Ǒ 可以写成 O（U+004F） + ˇ（U+030C）。这两种表示方法是等价的，但是在 JS 中他们严格相等判断返回的是 false。在 ES6 中提供了一个 normalize 方法对那些等价的 Unicode 序列进行判断。关于 Unicode 的等价性可以参考Unicode等价性

// 方法一
'\u01D1'
// 'Ǒ'

// 方法二
'\u004F\u030C'
// 'Ǒ'

'\u01D1' === '\u004F\u030C'
//false

'\u01D1'.normalize() === '\u004F\u030C'.normalize()
// true

综合上面的内容，现在的 ES6 标准下公有 6 种用字符串字面量表示同一个字符的方法：

'\z' === 'z' // true //一些特殊意义的字符不能这么表示，见下方正则表达式部分
'\172' === 'z' // true //8进制
'\x7A' === 'z' // true //16进制，代理码需要高低代理码合并解析
'\u007A' === 'z' // true //码点
'\u{7A}' === 'z' // true //码点

将 String 转换为 UTF-8 编码

这里写了一个小函数，实现将 String 转换为其对应的 UTF-8 编码，加深自己的理解。

function utf8_encoding1(str) {
  const code = encodeURIComponent(str)
  const byte = []
  for (let i = 0; i < code.length; i++) {
    const c = code.charAt(i)
    if (c === '%') {
      const hex = code.charAt(i + 1) + code.charAt(i + 2)
      const hexVal = parseInt(hex, 16)
      byte.push(hexVal)
      i += 2
    } else byte.push(c.charCodeAt(0))
  }
  return '0x' + byte.map((c) => c.toString(16)).join('')
}
console.log(utf8_encoding1('𝌆')) //0xf09d8c86

function utf8_encoding2(str) {
  const length = str.length
  let arr = []
  for (let i = 0; i < length; i++) {
    let cp = str.codePointAt(i)
    let result = '0x'
    if (cp <= 0x7f) {
      result += cp & 0x7f
    } else if (cp >= 0x80 && cp <= 0x7ff) {
      result += (((cp >> 6) & 0x1f) | 0xc0).toString(16)
      result += ((cp & 0x3f) | 0x80).toString(16)
    } else if (cp >= 0x800 && cp <= 0xffff) {
      result += (((cp >> 12) & 0xf) | 0xe0).toString(16)
      result += (((cp >> 6) & 0x3f) | 0x80).toString(16)
      result += ((cp & 0x3f) | 0x80).toString(16)
    } else if (cp >= 0x10000 && cp <= 0x10ffff) {
      result += (((cp >> 18) & 0x7) | 0xf0).toString(16)
      result += (((cp >> 12) & 0x3f) | 0x80).toString(16)
      result += (((cp >> 6) & 0x3f) | 0x80).toString(16)
      result += ((cp & 0x3f) | 0x80).toString(16)
    }
    arr.push(result)
  }
  return arr
}

console.log(utf8_encoding2('𝌆')) //[ '0xf09d8c86', '0xedbc86' ]

第一个方法是用 encodeURIComponent，最开始我还觉得这个方法行不通，因为 encodeURIComponent 有些字符是不转义的，但后来发现不转义的都是 ASCII 码范围内的字符，也非常好处理。第二个方法则是比较容易理解的用 codePointAt() 方法获取码点然后用位运算转码，需要注意的就是码点超过 0xFFFF 的字符可能长度是 2，返回两个码点。

字符串的正则表达式

winter 给出的 ES5 中的字符串的正则表达式。

const str_reg_sq =
  /"(?:[^"\n\\\r\u2028\u2029]|\\(?:['"\\bfnrtv\n\r\u2028\u2029]|\r\n)|\\x[0-9a-fA-F]{2}|\\u[0-9a-fA-F]{4}\\[^0-9ux'"\\bfnrtv\n\\\r\u2028\u2029])*"/

const str_reg_dq =
  /'(?:[^'\n\\\r\u2028\u2029]|\\(?:['"\\bfnrtv\n\r\u2028\u2029]|\r\n)|\\x[0-9a-fA-F]{2}|\\u[0-9a-fA-F]{4}\\[^0-9ux'"\\bfnrtv\n\\\r\u2028\u2029])*'/

几个特殊的字符都是 ASCII 中的早期计算机中就有存在的，正则表达式中也有对应的元字符。

\b 通常是单词分界位置，但如果在字符类里使用代表退格
\t 制表符，Tab
\r 回车
\v 竖向制表符
\f 换页符
\n 换行符
\u2028 行分隔符
\u2029 段落分隔符

JavaScript字符的转义

除了普通的可打印字符以外，一些有特殊功能的字符可以通过转义字符的形式放入字符串中：

\0：空字符 \'：单引号 \"：双引号 \\：反斜杠 \n：换行 \r：回车 \v：垂直制表符 \t：水平制表符 \b：退格 \f：换页 \uXXXX：unicode 码（基础平面的码点） \u{X} ... \u{XXXXXX}：unicode codepoint（包括辅助平面的码点） \xXX：Latin-1 字符(x小写) （扩展 ASCII 码对应的码点，2 个 16 进制数，共 256 个）

和其他语言不同，javascript 的字符串不区分单引号和双引号，所以不论是单引号还是双引号的字符串，上面的转义字符都能运行。

USVString，DOMString，CSSOMString

在看 MDN 文档的时候我们经常会看到 USVString，DOMString，CSSOMString 和 JavaScript Binary String 等概念。这里补充说明一下这些概念的区别。

USVString

USVString 指的是 Unicode Scalar Value，Unicode 标量值序列，即除了 high-surrogate 和 low-surrogate 的 code points。即从 U+0000 - U+D7FF 和 U+E000 - U+10FFFF 的 Unicode 码点。这里的一个理解关键就是不要理解为 UTF-16，这里指的是 Unicode 码点。

所以一个 USVString 中全是原始 Unicode 码点，不包括给 UTF-16 用的代理区。一般 USVString 一般用在执行文本处理的 API 中。因为 Unicode 是统一的，在任何平台都能识别，所以使用文本处理的 API 使用 Unicode 可以确保兼容性。

在 JavaScript 中使用 USVString 的时候，它会被映射到用 UTF-16 编码的 JavaScript 原始 String 类型。也就是说 USVString 会被编码成 UTF-16。

如果我们在接受 USVString 作为参数的 API 中使用了代理区的编码，这个代理区编码会被替换成 repalcement character 也就是 U+FFFD，对应的字符是 �。

这里有一点容易误解的就是我们不要用 UTF-16 的思维来理解 USVString，虽然我们前面说过 JavaScript 引擎总是尝试把源码转成 UTF-16 编码，但是在处理 USVString 时则不能这么理解。比如 WebSocket.prototype.send 接受的字符串就是 USVString，如果我们传入一个代理平面的 𝌆，应该处理成 U+1D306 的 Unicode code point 而不是 UTF-16 编码。至于引擎之后如何映射处理我们则不用考虑，在 WebSocket 这里应该是先映射到 UTF-16，然后在转 UTF-8 传递。

如果我们使用单个的代理平面的码点，或者错误顺序的代理平面码点都会被替换成 �，比如 ws.send('\uDC00\uD800') 我们会在后端接收到 ��，ws.send('\uDC00') 或者 ws.send('\uD800') 则都会收到 �。

DOMString

DOMString 是 16 位无符号整数序列，通常被解释为 UTF-16 编码单元。这就是 JavaScript 中最常用的 String 类型。有些 API 会把 null 字符串化为空字符串而不是 'null'。根据我的测试，当我们在 DOMString 中使用单个代理区的码点的时候，就会直接返回，比如 '\ud800' 就会直接返回我们输入的这个，也不会报错。

CSSOMString

CSSOMString 就是在 CSSOM 规范中出现的字符串类型，根据浏览器不同，代指 DOMString 或者 USVString。根据 MDN 给出的表格，目前所有的浏览器都是 USVString。

这里我总结一下，其实我并不清楚目前的浏览器引擎将字符串存储到内存中用的是什么形式，可能是 Unicode，也可能是 UTF-16。不过我们认为我们可以简单理解 USVString 就是 Unicode，而 DOMString 就是 UTF-16。字符串编码本质也就是为了用一套标准解析二进制对应的字符，我们在内存中存的可能是一种形式，引擎处理的时候可能是另一种编码格式，到网络上传播的时候可能又是另一种格式，重要的就是我们知道我们当前处理的是什么编码格式。

总结

任何技术的产生都是有历史原因的，也都是为了解决问题的。所以我们学习知识要带着问题去学，知道这个技术是为了解决什么问题而产生的，自然能把知识形成体系，而不容易遗忘，并且运用到合适的地方。如果不知道问题只是背了个答案，那么可能你并没有真的“学会”这个知识。

如果你也和我一样对字符是如何从键盘敲击到渲染到屏幕上的过程很感兴趣，你可以看看知乎答主乌鸦给出的答案：计算机系统是如何显示一个字符的？。

参考文章

浏览器渲染过程

Thu, 25 Apr 2019 12:00:00 GMT

前言

本文由于作者水平有限，肯定有错误之处，如果你看到，希望能够指出，感谢。

相信大家都听过一道经典的面试题：“在浏览器输入 URL 后回车之后发生了什么”，我一直想解答这个问题，不过这个题目涉及的知识面非常广，想要解答需要一定的知识储备。这篇文章我们讨论这个问题中的一部分，当浏览器拿到服务器传回的 html 文档后如何处理文档然后呈现在显示器上呢？

本文主要讲的是浏览器端如何解析渲染文档，如果想看网络方面的内容可以参考我的另外两篇文章：

在进入正题之前我们来想几个问题，然后在跟着问题的脚步来分析： 1. 我们都知道 DOM，CSS 的加载和渲染和 JS 的执行之间存在阻塞，阻塞发生的时候浏览器会加载其他页面资源吗 2. 都说 JS 是单线程的，那么 Event Loop 线程是什么呢，为什么 JS 要设计成单线程呢 3. setTimeout 是如何执行的，为什么 setTimeout 的 delay 和执行时间不同 4. 浏览器的具体渲染流程是什么样的

希望我写完这篇文章和你看完这篇文章之后都能解答这几个问题。

浏览器

在解决问题之前，我们要先了解我们的对象：浏览器。浏览器的功能很简单，就是根据我们给出的 URI，替我们向服务器发出请求，获取服务器上的资源并在展示给我们。这里的资源主要是 HTML 文档也可以是图片，pdf 或其他类型的文件，取决于我们给出的 URI 采取的协议以及请求的文件类型。

浏览器的主要组件

用户界面（ The userinterface ）：包括地址栏、前进/后退按钮、书签菜单等。除了浏览器主窗口显示的您请求的页面外，其他显示的各个部分都属于用户界面。
浏览器引擎（ The browser engine ）：用户页面和渲染引擎的中间层，负责在用户界面和渲染引擎之间传递信息。
渲染引擎（ The rendering engine ）：负责请求并渲染显示内容，这是最核心的一个部分，也就是我们常说的浏览器内核。比如请求的是 HTML 文档，那么渲染引擎负责解析 HTML 和 CSS ，并将解析的结果显示到显示器上。
网络组件：用于网络调用，比如 http 请求，是渲染引擎的一部分
用户界面后端（ UI backend ）：用于绘制一些小部件，是渲染引擎的一部分。
JavaScript 解释器（ JavaScript Interpreter ）：解析并执行 JavaScript 代码，是渲染引擎的一部分
数据存储（ Data Storage ）：浏览器需要保存各种类型的数据到本地，比如 cookies， localStorage, IndexedDB, WebSQL and FileSystem.

这些组件之间是如何配合工作的呢，我们都知道 chrome 是内存杀手，那么我们打开的多个 tab 又是如何分配资源的，不同的 tab 之间会争夺资源吗？

进程与线程

很多前端开发人员都知道 JavaScript 是单线程语言，但具体是什么单线程呢，其实说的是 JS 引擎，也就是上面的 JavaScript 解释器是单线程的，那么这个单线程到底是什么意思呢，我们要来说说线程和进程的概念和关系，以及浏览器中的进程与线程。

进程 process 和线程 thread 在大学的操作系统课程上讲的很多，不过可能很多同学忘记了，那么我们来说说进程和线程的概念。

我们的计算机中的所有计算都是在 cpu 中完成的，cpu 的计算速度非常快，大部分的设备是完全跟不上 cpu的速度的，那么怎么办呢。用金字塔式存储体系来根据信息处理的紧急程度分开存储，它们一般从下到上越来越小，越来越快，越来越贵。如下图：

大部分人都知道计算机有硬盘和内存，而我们的软件一般就安装在硬盘中，在硬盘中的数据是我们最不急需处理的，它们就静静地呆在那里。当我们想要运行一个程序，这些文件就被装载到内存中去了，而对于内存中最急需处理的文件会被传输到 CPU 的高速缓存中，也就是我们买 CPU 的时候会看到三级，二级，一级缓存，而在这些缓存中的文件最后会被依次传到 CPU 的寄存器中让 CPU 执行，只有寄存器的速度勉强能跟上 CPU。

但是我们可以同时开很多软件，同时做很多工作，比如我可以一边听着音乐，一边修改着 Word，同时还在后台开着浏览器后台播放着直播，不仅如此，我们的操作系统还有很多程序需要运行。那么它们是按照什么顺序进 CPU 运行的呢。我们前面已经说过 CPU 非常快，所以当我们的程序进入 CPU 运行的时候，其他资源比如显卡都应该就位了，这些资源就构成了程序执行的上下文。这个程序执行上下文就是我们的进程，也就是操作系统分配系统资源的最小单位，说白了进程就是操作系统用来管理程序和计算机资源之间的分配关系的手段。当我们的程序终于等到能够进入CPU运行的机会，先装载执行上下文，然后执行程序，程序执行完成或系统分配的时间结束，就必须保存执行上下文，让排队的下一个进程进入计算。CPU 就不断重复着装载上下文，执行程序，保存上下文的过程。

那么线程是什么呢，当我们的程序终于获得 CPU 的临幸，我们当然希望我们的程序能尽快执行完成。如果我们的程序只有一个逻辑要执行，那么我们其实只需要一个线程就可以了，但如果有几个并行的任务需要执行，我们可以借助多核 CPU 同时开多个线程，在一个执行上下文中共享系统分配的资源，来协同更快地完成任务。（单核 CPU 也有多线程，操作系统在不同的线程之间快速切换，在进程间交替运行，减少 CPU 闲置的时间）

操作系统对进程的处理和资源的分配会复杂很多，我们只是了解一下大致的概念。阮一峰的博客有一篇更形象一点的比喻，大家可以借助比喻帮助理解：进程与线程的一个简单解释

浏览器的进程

现在大家应该已经对进程和线程有一定的了解了，那么我们来说一说浏览器的进程和线程，首先我们要说，浏览器程序是多进程的，我们的每一个标签页（ tab ）都是一个独立的进程。我们可以打开 Chrome 的 more tools 中的 task manager，就可以看到当前浏览器的进程。

上图是我只打开了一个 tab 显示的进程，我们可以看到有一个 Browser 进程，一个 GPU Process 进程，一个Plugin Broker 进程，一个 Audio Service 进程，一个 Network Service 进程，一个打开的 tab 对应的渲染进程，一个 Spare Renderer 进程和若干个 Extension 进程。

我们结合上面浏览器的主要组件来看（以 Chrome 为例）：

Browser 进程：控制 chrome 应用界面的一些组件，比如地址栏，书签栏，前进后退按钮等。还控制一些浏览器的不可见部分，比如网络请求和文件访问等。
Renderer 进程（浏览器内核）：控制标签页内部网页要显示的一切，也就是我们访问的内容都是有渲染引擎控制，比如页面渲染，脚本执行，事件的处理。在 chrome，每一个 tab 都是一个独立的渲染进程，渲染引擎在其中工作。它会计算出我们的页面最后需要绘制成什么样子，然后交给 GPU 进程进行绘制。
Plugin 进程：控制网站应用的插件，比如 flash。
GPU 进程：独立于其他进程处理 GPU 任务，它被独立出来是因为 GPU 处理来自不同程序的请求。渲染引擎最后渲染出的内容要交给 GPU 进程绘制到显示器上。

第四点翻译的可能有点问题，原文Inside look at modern web browser，这个系列文章非常不错，推荐大家看看。

多进程什么好处呢，最简单的比方，我打开了三个 tab 浏览三个网页，每个页面都有单独的渲染进程，如果其中一个页面的代码非常糟糕崩溃了，那么你的另外两个页面不会受到影响，你依然可以继续浏览。而如果三个页面共享一个进程，那么你的两外两个页面也将崩溃。

不过正因为如此，chrome 简直是内存杀手，相信大家都有体会。

渲染引擎（浏览器内核）

也有一些说法是把渲染引擎和 JS 引擎分开，它们共同组成内核，我是以 How Browsers Work 这篇文章和 Chrome 的结构为准。

对于我们前端来说，最重要的就是渲染引擎以及它工作的渲染进程，这是我们打交道最多的地方，学期其他的浏览器知识能让我们更清楚渲染引擎在浏览器中的定位和工作流程。渲染引擎也就是我们经常说的浏览器内核。目前主要的浏览器内核如下几种：

Trident/EdgeHTML： Trident 是微软的IE浏览器使用的渲染引擎，它是从从早期一款商业性的专利网页浏览器 Spyglass Mosaic 派生出来的。Window 10 发布之后，微软将其内置的浏览器命名为 Edge，而 Edge 浏览器的渲染引擎便是 EdgeHTML。在 2019 年，微软宣布 Edge 浏览器将采用 Chromium 的内核 Blink。
Webkit：WebKit 是苹果公司的 Safari 浏览器使用的渲染引擎，是 KDE（Linux 桌面系统）小组的 KHTML 引擎的一个开源的分支。早期的 Chrome 也是使用的 Webkit 引擎。
Chromium/Blink：Chromium 是谷歌公司的一个开源浏览器项目，每隔一段时间，谷歌会在最新的比较稳定的 Chromium 版本上加入一些其他的功能使之成为新版本的 Chrome 浏览器。而 Chromium 的渲染引擎采用的是 Blink，其前身是 Webkit。Blink 是从早期的 Webkit 项目（而非后来的 Webkit2）复制出来另外维护的一个新的分支项目。
Presto：Presto 是挪威 Opera Software ASA 公司的 Opera 浏览器使用的渲染引擎，后来该公司为了减少研发成本，在 2013 年跟随 Chrome 浏览器将渲染引擎改为 Blink。
Gecko：Gecko 是 Mozilla 公司的 FireFox 浏览器使用的渲染引擎，它是一款开源的跨平台渲染引擎，可以在 Windows、 BSD、Linux 和 Mac OS X 中使用。

现在的浏览器内核可以说是谷歌一家独大，特别是在微软也宣布投向 Chromium。关于浏览器内核的详细可以参考知乎的这个回答浏览器内核真的很复杂吗？- 龙泉寺，我这里只是做一个简单的介绍。

渲染进程是多线程的，那到底有哪些线程，分别做什么工作呢？

GUI 渲染线程
- 负责渲染浏览器界面，解析HTML ，CSS ，构建 DOM 树和 RenderObject 树，布局和绘制等。
- 当界面需要重绘（ Repaint ）或由于某种操作引发回流( reflow )时，该线程就会执行。
- 注意，GUI 渲染线程与 JS 引擎线程是互斥的，当 JS 引擎执行时 GUI 线程会被挂起（相当于被冻结了），GUI 更新会被保存在一个队列中等到 JS 引擎空闲时立即被执行。
JavaScript 引擎
- 负责处理 Javascript 脚本程序，JavaScript 引擎是一个专门处理 JavaScript 脚本的虚拟机，一般会附带在网页浏览器之中，现在有 NodeJS 让我们在服务端也能使用 JavaScript。（例如 V8 引擎），JS 引擎是基于事件驱动单线程执行的， JavaScript 引擎一直等待着任务队列中任务的到来，然后加以处理，浏览器无论什么时候都只有一个 JavaScript 线程在运行 JavaScript 程序。
事件触发线程
- 管理 Event Loop，Event Loop 的标准是在HTML5中，是渲染引擎的一个线程来处理，所以并不和 JS 单线程执行矛盾。
- 当一个事件被触发时，该线程会把事件添加到待处理队列的队尾，等待 JavaScript 引擎的处理。这些事件可来自 JavaScript 引擎当前执行的代码块如 setTimeout 、也可来自浏览器内核的其他线程如鼠标点击、Ajax 异步请求等，但由于 JavaScript 的单线程关系，所有这些事件都得排队等待 JavaScript 引擎处理（当线程中没有执行任何同步代码的前提下才会执行异步代码）。
定时器触发线程
- 浏览器定时计数器并不是由 JavaScript 引擎计数的,（因为 JavaScript 引擎是单线程的, 如果处于阻塞线程状态就会影响记计时的准确），因此通过单独线程来计时并触发定时（计时完毕后，添加到事件队列中，等待 JS 引擎空闲后执行）。W3C 在 HTML 标准中规定，规定要求 setTimeout 中低于 4ms 的时间间隔算为 4ms 。
异步请求线程
- XMLHttpRequest 在连接后是通过浏览器新开一个线程请求
- 检测到状态变更时，如果设置有回调函数，异步线程就产生状态变更事件，将这个回调再放入事件队列中。再由 JavaScript 引擎执行。

其中前三个是常驻线程，是所有浏览器内核必须实现的，后两个线程执行完就会终止。在 Chrome 中，每一个 tab 都是一个独立的渲染进程，都有独立的渲染引擎在工作。

关于JS引擎为什么是单线程的，因为大部分程序控制 UI 的都会是单一单线程，因为 JS 主要使用场景是与用户交互和操作 DOM，如果两个线程同时操作一个 DOM 会很复杂。而H5也提供了多线程方法 web worker，可以创建多个线程，但是子线程完全受控于主线程且不得操作 DOM 。

JavaScript 引擎

渲染引擎中最重要的就是 JavaScript 引擎，JavaScript 作为一门动态弱类型语言，一般来说引擎就是解释器 Interpreter，直接解析并将代码运行结果输出。像 Java、C++、C 这样的静态语言才需要经过编译到机器码或字节码的过程。

编译型语言：程序在执行之前需要一个专门的编译过程，把程序编译成为机器语言的文件（如 exe 文件），运行时不需要重新编译，直接用编译后的文件就行了。优点：执行效率高。缺点：跨平台性差。
解释型语言：程序不需要编译，程序在运行的过程中才用解释器编译成机器语言，边编译边执行。优点：跨平台性好。缺点：执行效率低。

但是现代的 JavaScript 引擎，比如说 V8，它其实为了提高 JS 的运行性能，在运行之前会先将 JS 编译为本地的机器码（native machine code），然后再去执行机器码，也就是 JIT（Just-in-time）。

JavaScript 引擎和渲染引擎之间是可以交互的，浏览器提供了相当丰富的 Web API 让 JavaScript 能操作 DOM，BOM，能够绑定事件，发起请求等等。渲染引擎也可以通过事件循环让 JS 引擎执行代码。

目前主要的 JavaScript 引擎有如下几种：

V8(Google)，用 C++ 编写，开放源代码，Google (丹麦)研发小组在 2006 年开始研发 V8 ，部分的原因是 Google 对既有 JavaScript 引擎的执行速度不满意, 在 2008 年推出 Chrome，也用于 Node.js, 巨大的速度优势，迅速占领市场.。2017 年 Chrome 的市场占有达到 59%。
JavaScriptCore(Apple)，开放源代码，用于 webkit 型浏览器，如 Safari ，2008 年实现了编译器和字节码解释器，升级为了 SquirrelFish。苹果内部代号为 Nitro 的 JavaScript 引擎也是基于 JavaScriptCore 引擎的。
Rhino，由 Mozilla 基金会管理，开放源代码，完全以 Java 编写，用于 HTMLUnit。
SpiderMonkey(Mozilla)，第一款 JavaScript 引擎，早期用于 Netscape Navigator，现时用于 Mozilla Firefox。
Chakra (Microsoft)：JScript 引擎，用于 Internet Explorer。
Chakra (Microsoft)：JavaScript 引擎，用于 Microsoft Edge。目前 Edge 已经使用 Chromium。
KJS，KDE 的 ECMAScript／JavaScript 引擎，最初由哈里·波顿开发，用于 KDE 项目的 Konqueror 网页浏览器中。
Hermes：Facebook 在 ChainReact 2019 大会上正式推出了新一代 JavaScript 执行引擎 Hermes。Hermes 是一款小巧轻便的 JavaScript 引擎，专门针对在 Android 上运行 React Native 进行了优化。对于许多应用程序，只需启用 Hermes 即可缩短启动时间、减少内存使用量并缩小应用程序大小，此外因为它采用 JavaScript 标准实现，所以很容易在 React Native 应用中集成。
QuickJS：QuickJS 是一个小型并且可嵌入的 Javascript 引擎，它支持 ES2020 规范，包括模块，异步生成器和代理器，由 Bellard 开发。

渲染过程

浏览器接收到服务器返回的 HTML 文档后就开始解析并渲染 HTML 文档，主要流程如下： 1. 解析 HTML 文档，将元素按层次转化成一棵 DOM树，根节点为 document。 2. 解析 CSS 样式文件（包括外部 CSS文件和样式元素以及 js 生成的样式），获取样式数据，生成 CSSOM。 3. 结合 CSSOM 和 DOM树计算出节点的样式，生成渲染树（ render tree ），渲染树包含多个带有样式属性的矩形，这些矩形的排列顺讯就是它们在屏幕上显示的顺序。 4. 进入布局阶段，从根节点递归调用，计算每一个元素的大小、位置等，给每个节点所应该出现在屏幕上的精确坐标。 5. 遍历渲染树，每个节点将使用 UI 后端层来绘制。

对于渲染引擎的渲染细节感兴趣的同学可以看看这篇文章，How browsers work，中文翻译的不是很好，推荐大家结合英文看。

Reflow 和 Repaint

Reflow : 元素的盒模型或者布局发生了变化，浏览器需要重新计算其大小和位置。
Repaint : 当一个元素的外观发生改变，但没有改变布局,重新把元素外观绘制出来的过程，叫做重绘。

我们可以发现 Reflow 对应的是渲染过程中的第四步，而 Repaint 对应的是渲染过程的第五步。直白一点说就是当 DOM 被修改后需要重新计算渲染树 render tree 的一部分或者全部的时候，我们就需要 Reflow，而如果元素的修改不影响渲染树，那么只要 Repaint 就可以了。回流必将引起重绘，重绘不一定会引起回流。

显而易见，Reflow 的成本要比 Repaint 高得多，DOM Tree 里的每个结点都会有 reflow方法，一个结点的 reflow 很有可能导致子结点，甚至父点以及同级结点的 reflow。

会导致 Reflow 的操作：

页面首次渲染
浏览器窗口大小发生改变
元素尺寸或位置发生改变
元素内容变化（文字数量或图片大小等等）
元素字体大小变化
添加或者删除可见的 DOM 元素
激活 CSS 伪类（例如：:hover）
查询某些属性或调用某些方法

一些常用且会导致 Reflow 的属性和方法：

clientWidth、clientHeight、clientTop、clientLeft、offsetWidth、offsetHeight、offsetTop、offsetLeft、scrollWidth、scrollHeight、scrollTop、scrollLeft、scrollIntoView()、scrollIntoViewIfNeeded()、getComputedStyle()、getBoundingClientRect()、scrollTo()

当页面中元素样式的改变并不影响它在文档流中的位置时（例如：color、background-color、visibility等），浏览器会将新样式赋予给元素并重新绘制它，这个过程称为重绘。

Reflow 和 Repaint 对性能可能造成很大的影响：有时即使仅仅回流一个单一的元素，它的父元素以及任何跟随它的元素也会产生 Reflow。

现代浏览器会对频繁的回流或重绘操作进行优化：浏览器会维护一个队列，把所有引起回流和重绘的操作放入队列中，如果队列中的任务数量或者时间间隔达到一个阈值的，浏览器就会将队列清空，进行一次批处理，这样可以把多次回流和重绘变成一次。比如下面的代码我们对同一个元素连续进行 transform 的话，浏览器只会执行最后一个。如果我们想看到两段动画效果则要借助 setTimiout。

<div class="cube"></div>
<button>transform</button>
<script>
    let cube = document.querySelector('.cube');
let btn = document.querySelector('button');
btn.addEventListener('click', e => {
    cube.style.transform = 'translateX(30px)';
    setTimeout(() => {
        // cube.style.transform = 'translateX(-30px)';
        console.log('timeout');
    }, 0);
    cube.style.transform = 'translateX(-30px)';
});
</script>

当访问以下属性或方法时，浏览器会立刻清空队列：

clientWidth、clientHeight、clientTop、clientLeft
offsetWidth、offsetHeight、offsetTop、offsetLeft
scrollWidth、scrollHeight、scrollTop、scrollLeft
width、height
getComputedStyle()
getBoundingClientRect()

因为队列中可能会有影响到这些属性或方法返回值的操作，即使你希望获取的信息与队列中操作引发的改变无关，浏览器也会强行清空队列，确保你拿到的值是最精确的。

现在的浏览器已经对渲染的过程尽可能的优化，不过我们还是可以在编码的过程只能够注意一些细节：

CSS
- 避免使用 table 布局。浏览器使用流式布局，对 Render Tree 的计算通常只需要遍历一次就可以完成，但 table 及其内部元素除外，他们可能需要多次计算，通常要花 3 倍于同等元素的时间
- 尽可能在 DOM 树的最末端改变 class。
- 避免设置多层内联样式。
- 将动画效果应用到 position 属性为 absolute 或 fixed 的元素上。
- 避免使用 CSS 表达式（例如：calc()）。
javascript
- 避免频繁操作样式，最好一次性重写 style 属性，或者将样式列表定义为 class 并一次性更改 class 属性。
- 避免频繁操作 DOM，创建一个 documentFragment，在它上面应用所有 DOM 操作，最后再把它添加到文档中。
- 也可以先为元素设置 display: none，操作结束后再把它显示出来。因为在 display 属性为 none 的元素上进行的 DOM 操作不会引发回流和重绘。
- 避免频繁读取会引发回流/重绘的属性，如果确实需要多次使用，就用一个变量缓存起来。
- 对具有复杂动画的元素使用绝对定位，使它脱离文档流，否则会引起父元素及后续元素频繁回流。

DOM, CSS, JS的阻塞

渲染过程并不像上面描述的那么简单，特别是页面的绘制是一件开销非常大的事情，所以浏览器尽量最有效率的绘制，避免那些没必要的重绘和回流。要避免这个问题，DOM 加载和解析，CSS 加载和解析，和 JS 的加载执行之间的顺序和阻塞就非常重要，如果处理不当，页面很可能要重绘。因为渲染树是 DOM 和 CSS 结合生成的，而 JS 可以操作 DOM 和样式，必须处理好三者之间的逻辑。

load 和 DOMContentLoaded

在分析具体情况之前我们先说两个事件 DOMContentLoaded 和 load。

load：当一个资源及其依赖资源已完成加载时，将触发 load 事件，也就是当页面的 html、css、js、图片等资源都已经加载完之后才会触发 load 事件。
DOMContentLoaded ：当初始的 HTML 文档被完全加载和解析完成之后就会被触发，而无需等待样式表、图像和子框架的完成加载。

上面两个说法都是 MDN 给出的，但是其实具体结合加载和解析的阻塞情况会不一样（结合下面的阻塞情况来看这几点）： 1. 因为 js 会阻塞 DOM 的解析，所以当文档解析完成触发 DOMContentLoaded 事件的时候，文档中所有的同步的 js 任务都已经执行完毕。 2. 因为 CSS 会阻塞 JS 而不会阻塞 DOM 解析，并且 JS 的执行会让该 JS 之前的以加载 DOM 和 CSS 渲染，所有在 DOMContentLoaded 事件触发时，所有在 JS 之前的 CSS 已经加载并渲染完成。 3. 当 DOMContentLoaded 事件触发时，文档解析完毕，页面的 DOM 树已经构建完成，所有页面上的 JS 同步任务执行完成，所有在 JS 之前的 CSS 都已经加载并渲染完成。（页面每遇到一个 script 标签都会把当前已经构建的 DOM 树和 CSSOM树结合渲染一次） 4. 当 DOMContentLoaded 事件触发之后，浏览器会继续加载在 JS 之后的 CSS，以及在JS中同步添加的 img，css，js 文件，当这些资源全部加载完成，会进行 load 事件触发之前的最后一次渲染，之后load事件被触发。

这段代码可以验证，同步的 js 代码中的外部资源文件（ js，css，img ）都加载（由异步请求线程完成的异步加载）完毕后才会触发 load 事件，加载速度可以通过设置 network throttling 配置，把加载速度设置非常慢，可以看到资源文件加载完成以后load事件才触发。而异步事件 setTimeout 回调函数中的资源文件则会在 load 事件触发后在执行，不会阻塞 load 的触发。

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script defer src="js/test.js"></script>
  </head>
  <body>
    <div id="test"></div>

    <script>
      let script = document.createElement('link')
      script.setAttribute('rel', 'stylesheet')
      script.setAttribute(
        'href',
        'https://cdn.bootcss.com/bootstrap/4.0.0-alpha.6/css/bootstrap.css'
      )

      var a = document.body.appendChild(script)

      // setTimeout(function() {
      //   let script = document.createElement("link");
      //   script.setAttribute("rel", "stylesheet");
      //   script.setAttribute(
      //     "href",
      //     'https://cdn.bootcss.com/bootstrap/4.0.0-alpha.6/css/bootstrap.css'
      //   );
      //   var a = document.body.appendChild(script);
      //   console.log("setTimeout...");
      // }, 3000);

      window.onload = function () {
        console.log('window load...')
      }
    </script>
  </body>
</html>

下面有提到预加载监视器 preload scanner，浏览器对同一域名下的最大并发连接数不超过 6 个。超过 6 个的话，剩余的将会在队列中等待，这就是为什么我们要将资源放到不同的域名下，也是为了充分利用该机制，最大程度的并发下载所需资源，尽快的完成页面的渲染。下载和加载在浏览器渲染过程中应该是相同的意思。

2020-10-23补充 按照一般的理论来说，DOMContentLoaded 是在文档解析完成，也就是 DOM 树构建完成的时候就会触发，也就是样式表的加载与否不会影响 DOMContentLoaded 事件发生的时间，但是经过实际的测试我发现浏览请的行为并不一致。比如下面的代码，我让服务器延迟 5000ms 返回 css 文件，按理说这个 css 不会影响 DOMContentLoaded 的发生时间，但是在 Chrome 中，只要你将这个 css 放到 body 中就会出现 DOMContentLoaded 知道 CSS 文件加载完成才触发，但是把 link 放到 head 中就不会。在 safari 中则是立即触发 DOMContentLoaded 事件。Opera 的表现跟 chrome 一致。firefox 虽然也是 css 加载完成后触发，但是它先渲染出 div 本来的绿色，css 请求回来后再渲染成 蓝色，其他几个浏览器则是全部只有一次渲染，就是只有 css 回来之后才渲染 div，直接显示蓝色。

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Title</title>
    <style>
      div {
        width: 100px;
        height: 100px;
        background: lightgreen;
      }
    </style>
    <!-- <link rel="stylesheet" href="/css/sleep5000-common.css" /> -->
    <!-- <script defer src="/js/blok.js"></script> -->
  </head>
  <body>
    <!-- <link rel="stylesheet" href="/css/sleep5000-common.css" /> -->
    <button>click</button>
    <script defer src="/js/block.js"></script>
    <link rel="stylesheet" href="/css/sleep5000-common.css" />
    <!-- 服务器延迟返回，设置div为蓝色 -->
    <div></div>
  </body>
</html>

//block.js
console.log('DOMContentLoaded')

所以我进行一个简单的总结就是：放在 body 之前的 link 不会阻塞 DOM 的解析（DOMContentLoaded 不会等待 CSS 加载），但是会阻塞渲染，渲染会在 CSS 请求成功以后再渲染，在之前浏览器将是白屏。而放在 body 中和 body 后的 CSS 则会同时阻止 DOM 的解析和渲染，DOMContentLoaded 会等待 CSS 的加载，link 之前的元素会成功渲染，但是 link 之后的元素会等待 CSS 加载成功后才渲染。从某个角度看，body 中的 link 和 script 的处理逻辑是一致的。当然具体的行为每个浏览器并不完全相同。

为了验证自己的想法我又写了一个例子，我用几个 link 分别将几个 div 隔开，调节 chorme devtools 的 network throttling 为 slow 3g 你也可以设置自己想要的速度。然后看看这些元素的渲染顺序。

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>css-dom-parse</title>
    <script defer src="parse.js"></script>
    <style>
      div {
        height: 100px;
        width: 100px;
      }
      .red {
        background: red;
      }
      .black {
        background: black;
      }
      .green {
        background: green;
      }
    </style>
  </head>
  <body>
    <div>test</div>
    <!-- <script defer src="parse1.js"></script> -->
    <link
      href="https://cdn.bootcss.com/bootstrap/4.0.0-alpha.6/css/bootstrap.css"
      rel="stylesheet"
    />
    <div class="red"></div>
    <link
      href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/4.5.3/css/bootstrap.css"
      rel="stylesheet"
    />
    <div class="green"></div>
    <link
      href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/4.5.3/css/bootstrap-grid.css"
      rel="stylesheet"
    />
    <div class="black"></div>
  </body>
</html>

三个 bootstrap 的 css 文件，加载的顺序是 3 1 2，加载是并行的，而渲染是等到全部加载完才开始，渲染顺序就是从上到下。

阻塞关系

总的原则就是一点 JS 引擎和渲染引擎是互斥的。

外部资源文件的加载不会被阻塞（js，css，image）我们的 HTML 文档一般都会包含外部链接，引入资源文件，包括 js，css，图片等，我们的主线程会一个一个的请求这些链接，不过现代浏览器一般会有一个预加载监视器 preload scanner 来加速这些链接的加载，因为我们的文档解析需要事件，所以提前发送请求获取资源文件会提高效率。这个预加载监视器会找到 <img> 和 <link> 之类的标签，发送给网络线程请求资源。

CSS 不会阻塞 DOM 解析这一点其实很好理解，CSS 不会引起 DOM的变化，它们两个只要尽早解析完成，然后生成渲染树就可以了，并行加载并不影响。我们可以设计一个场景模拟出这个状态，现在 chrome 中把 network throttling 设置一个较小的数值（我设置的 50kb/s ），然后加载一个稍大的 CSS，然后在 css 之前用一个 defer 属性的 js 获取页面上的 DOM（ defer 属性表示这个 js 会在 DOMContentLoaded 事件发生后立即执行），如果能够在 css 加载好之前获取 dom 节点，说明 CSS 是不会阻塞 DOM 解析的。

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>css-dom-parse</title>
    <script defer src="css-dom-parse.js"></script>
    <link
      href="https://cdn.bootcss.com/bootstrap/4.0.0-alpha.6/css/bootstrap.css"
      rel="stylesheet"
    />
  </head>
  <body>
    <div>test</div>
  </body>
</html>

//css-dom-parse.js
const div = document.querySelector('div')
console.log(div)

结果如下图

此时我们的 css 还没加载完成，但是我们可以看到 console 选项卡里面 div 标签已经被打印出来了，说明，此时 DOM 已经解析完成触发 DOMContentLoaded 事件。

2020-10-23 补充 在多个浏览器中测试，如果把 link 标签放到 body 中将会阻塞 DOM 解析（只有 safari 不会），详细的例子可以参考上面的 DOMContentLoaded 章节最后的补充部分。

CSS 会阻塞 DOM 渲染因为 DOM 的渲染需要 DOM 树和 CSSOM 树共同来生成渲染树，所以在 CSS 加载完成之前， DOM 是不会进行渲染的。还是用上面那个例子，我们会发现 CSS 没有加载完成时，页面上是不显示 test 的，而当 CSS 加载完成的瞬间，标签就被渲染到页面上了。
CSS 会阻塞 JS 这一点可能大家有点疑惑，但是仔细想一想，我们的脚本可以在文档解析阶段请求样式信息，如果此时我们的样式还没有加载和解析，那么脚本必然会获得错误的结果，这样会产生很多问题，目前的浏览器做法就是在 CSS加载解析的过程中会阻塞 JS 的加载执行。虽然我们不常遇到这样的情况，但是也要清楚为什么会发生这样的情况。我们还用刚刚的方法，不过这次我们需要快速看到结果，可以把速度设置的快一点，network throttling 设置为 slow 3G，代码如下：

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>css-dom-parse</title>
    <script>
      var starttime = new Date().getTime()
      console.log('page start' + starttime)
    </script>
    <link
      href="https://cdn.bootcss.com/bootstrap/4.0.0-alpha.6/css/bootstrap.css"
      rel="stylesheet"
    />
    <script src="css-dom-parse.js"></script>
  </head>
  <body>
    <div>test</div>
  </body>
</html>

var endtime = new Date().getTime()
console.log('delay:' + (endtime - starttime))

我们在 CSS 加载之前记录时间并保存到全局变量 starttime 中，然后在 CSS 之后加载一个 JS 文件，当这个 JS 文件执行的时候，我们输出执行时间并计算时间差。结果如下图：我们把时间线拖到页面加载的最开始，我们发现 html 和 js都已经加载完毕，但是 css 的请求还没有完成，而我们在看看输出的时间，我们的 js 是在 2487ms 后才执行，正是 css 加载完成后才执行的 js。

JS 会阻塞渲染引擎当解析起遇到 script 标签时，文档会立即停止解析直到脚本执行完毕，如果脚本是外部的，还要加上从服务器下载的时间。这里注意一个比较细节的部分，渲染引擎此时不会继续往下解析和渲染 DOM 了，在下载脚本的过程中，我们还是可以堆页面上已经渲染的 DOM 进行操作，一旦下载完成，JS 引擎开始执行脚本，整个浏览器就处于卡死状态，我们只能等脚本执行完成才能继续和页面交互。

下面的例子中，我在给页面的一个 button 元素绑定了点击事件，点击以后会 console.log(123)，然后在这个 button 下方我引入了一个 script，我在服务器上设置 5000ms 后才返回这个脚本，模拟下载超大脚本或网速很慢的情况。然后这个脚本的执行则是一个非常大的数组操作，也要花费一点时间。这个脚本后面还有一个新的 div 元素。当页面开始加载后 btn 会先加载出来并成功绑定事件，此时我们点击 btn 能够成功输出 123，此时已经开始从服务器下载脚本了，在下载脚本的这段时间内我们依然能够点击按钮。一旦 DOM 成功返回（我在脚本开头执行了一个 console.log），我们点击 DOM 就没有反应了，也就是浏览器卡死了。并且如果我们添加多个 script 标签我们可以发现请求是并行的，现代浏览器也对这种卡死进行了优化，它会在卡死的这段时间查看后面的 DOM 是否有资源要加载，如果有就进行提前加载。

<button>click</button>
<script>
  let btn = document.querySelector('button')
  btn.addEventListener('click', (e) => {
    console.log(123)
  })
</script>
<script src="/js/sleep5000-logDiv.js"></script>
<script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.5.1/jquery.js"></script>
<div></div>

const div = document.querySelector('div')
console.log(div)
const arr = []
for (let i = 0; i < 100000000; i++) {
  arr.push(i)
  arr.splice(i % 3, i % 7, i % 5)
}

服务端代码参考：how js css block Dom，这种现象的因为我们的脚本会操作 DOM，所以在脚本跑完之前浏览器不知道脚本会把 DOM 改成什么样，所以就等脚本执行完再进行解析。还有一个简单测试的例子，我们用一个有 defer 属性的 js 在 DOMContentLoaded 的时候输出内容，然后再写一个一定时常的死循环，看看输出结果。代码如下：

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>css-dom-parse</title>
    <script>
      var starttime = new Date().getTime()
      console.log('starttime' + starttime)
    </script>
    <script defer src="domcontentloaded.js"></script>
    <script src="css-dom-parse.js"></script>
  </head>
  <body>
    <div>test</div>
  </body>
</html>

//domcontentloaded.js
console.log('DOMContentLoaded! ' + (new Date().getTime() - starttime))

//css-dom-parse.js
var now = new Date().getTime()

while (new Date().getTime() - now < 3000) {
  continue
}
console.log('time out' + new Date().getTime())

结果如下图: 可以看出 DOMContentLoaded 事件一直等到 JS 执行完成以后才触发。

浏览器解析到非 defer 和 async 的 script 标签会立即触发一次渲染这个机制可能很多朋友不是很清楚，当我们的浏览器在解析文档的过程中遇到 script 标签（ body 中的，因为 body 之前并没有需要渲染到页面上的元素），他会立即把已经解析的部分渲染了，这当然是个比较极端的情况，一般良好的代码不会遇到。大概是因为解析到一半的时候渲染树还没有，如果此时 JS 要操作的 DOM 的话，浏览器不知道如何处理，只能先把当前内容渲染了。测试代码如下：

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script>
      console.log('page start' + new Date().getTime())
    </script>
    <style>
      div {
        background: lightblue;
        width: 500px;
        height: 500px;
      }
    </style>
  </head>
  <body>
    <div>test3</div>
    <script src="js/test.js"></script>
    <style>
      div {
        background: lightgray;
      }
    </style>
    <script src="js/test1.js"></script>
    <style>
      div {
        background: lightpink;
      }
    </style>
  </body>
</html>

//test.js 和 test1.js相同，都是执行三秒
var now = new Date().getTime()

while (new Date().getTime() - now < 3000) {
  continue
}
console.log('js11 start' + new Date().getTime())

执行后我们会发现 div 先被渲染成 lightblue，三秒后被渲染成 lightgray，再过三秒被渲染成 lightpink。

CSS 虽然不会阻塞 DOM 解析，但是如果在 CSS 后有一个 JS，CSS 会阻塞这个 JS，而这个 JS 会阻塞 DOM，所以有时候会造成 CSS 阻塞 DOM 的错觉。

对这个阻塞分析进行一个总结：

head 中 link 只阻塞 DOM 的渲染而不阻塞 DOM 的解析。
body 中的 link 会同时组织 DOM 的解析和渲染。
link 无论在 body 还是在 head 中都会阻塞 js 的执行。
js 会阻塞 DOM 的解析和渲染，js 在加载过程中不会卡死页面，在执行过程中会卡死页面，无法进行交互。
浏览器解析到非 defer 和 async 的 script 标签会立即触发一次渲染

白屏时间

阻塞的第六种情况说到每次 <script> 的执行渲染引擎都会将当前已经解析的 DOM 和 CSSOM 立即合并成一棵 Render 树进行一次渲染，而第一个 body 中的 <script> 标签引发的渲染就是页面结束白屏的时间点。如果渲染引擎解析到第一个 script 标签时，对应的 js 文件还没有加载到本地，那么会立即进行渲染，如果已经加载好，那么会在 JS 引擎执行完这段脚本之后立即进行渲染。下面的代码可以测试这个机制(依然是把 network throttling 设置慢速，让css的加载时间较长以达到测试的效果：

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script defer src="js/test.js"></script>
  </head>
  <body>
    <div id="test">test1</div>

    <script>
      var start = new Date().getTime()
      while (new Date().getTime() - start < 500) {
        continue
      }
      console.log('time out')
    </script>
    <link
      rel="stylesheet"
      href="https://cdn.bootcss.com/bootstrap/4.0.0-alpha.6/css/bootstrap.css"
    />
    <script>
      console.log(123)
    </script>
  </body>
</html>

//test.js
console.log('domcontentloaded')

当timeout输出时，div正好被渲染出来，此时 bootstrap 的 css 依然在加载中，因为 css 的加载阻塞了下面的 console.log(123) 的执行，当css加载完毕后，console.log(123) 执行，然后触发 DOMContentLoaded 时间，最后 defer 属性的js执行。

window 的 performance 属性可以帮助我们了解页面的加载时间。

关于白屏时间和首屏时间我并没有找到非常严格的定义，一般来说是称为 first paint，也就是说在白屏时间结束之前，页面上没有渲染出任何东西，这个在 chrome devtools 中的 performance 中都能看到，总的规则就是如果第一脚本前的 JS 和 CSS 加载完了，body 中的脚本还未下载完成，那么浏览器就会利用构建好的局部 CSSOM 和 DOM 提前渲染第一脚本前的内容（触发 FP）；如果第一脚本前的 JS 和 CSS 都还没下载完成，body 中的脚本就已经下载完了，那么浏览器就会在所有 JS 脚本都执行完之后才触发 FP。详细的分析可以看这篇文章 Chrome的First Paint触发的时机探究，写的非常细致。

其实特别纠结白屏时间也不必，我们最关注的还是页面从请求到能和用户交互的时间，这中间涉及的内容也很多，后面会单独在研究性能的文章中讨论。

defer和async的区别

上面有几段代码用了 defer 属性，其实还有个属性 async，这里说一下这两个属性。 1. <script src="script.js"></script>：没有 defer 或 async，浏览器会立即加载并执行指定的脚本，“立即”指的是在渲染该 script 标签之下的文档元素之前，也就是说不等待后续载入的文档元素，读到就加载并执行。 2. <script async src="script.js"></script>：有 async，加载和渲染后续文档元素的过程将和 script.js 的加载并行进行（异步），一旦加载成功就中断渲染引擎的渲染，立即执行脚本。 3. <script defer src="myscript.js"></script>：有 defer，加载后续文档元素的过程将和 script.js 的加载并行进行（异步），但是 script.js 的执行要在所有元素解析完成之后，DOMContentLoaded 事件触发之前完成。

把所有脚本都丢到 </body> 之前是最佳实践，因为对于旧浏览器来说这是唯一的优化选择，可以保证非脚本的其他一切元素能够以最快的速度得到加载和解析。

1. defer 和 async 在网络读取（加载）过程中是一样的，都是异步的（相较于 HTML 解析） 2. 两者差别在于脚本加载完之后何时执行，显然 defer 是最接近我们对于应用脚本加载和执行的要求的 3. defer 是按照加载顺序执行脚本的 4. async 则是乱序执行的，对它来说脚本的加载和执行是紧紧挨着的，所以不管你声明的顺序如何，只要它加载完了就会立刻执行 5. async 对于应用脚本的用处不大，因为它完全不考虑依赖（哪怕是最低级的顺序执行），不过它对于那些可以不依赖任何脚本或不被任何脚本依赖的脚本来说却是非常合适的，最典型的例子：Google Analytics

Event Loop 的分析见另一片文章事件循环 Event Loop

总结

本文只是阅读的文章结合自己的一点见解，只是浏览器的渲染过程的一点皮毛，而且在前端技术日新月异的今天，浏览器也在不断地进步和优化，想要更好的掌握其原理还需要不断学习。

Clloz's Blog

Mihomo Mac 配置

前言

创建用户

管理 clash

更新 mihomo 版本

mihomo 配置

自定义 clash 脚本

launchd 配置

Tips to improve concentration

What's fogging up focus?

Strategies to stay focused

Using MDX

Why MDX?

Example

More Links

Markdown Syntax Support

Basic Syntax

Headers

Bold and Italics

Links

Inline Code

Code Blocks

Inline Formula

Formula Blocks

Images

Strikethrough

Lists

Blockquotes

Line Breaks

Separators

Advanced Techniques

Inline HTML Elements

Key Display

Bold Italics

Other HTML Writing

Foldable Blocks

Tables

Footnotes

To-Do Lists

Symbol Escaping

Embedding Astro Components

Markdown 语法支持

基本语法

标题

粗斜体

链接

行内代码

代码块

行内公式

公式块

图片

删除线

列表

引用

换行

分隔符

高级技巧

行内 HTML 元素

键位显示

粗斜体

其他 HTML 写法

折叠块

表格

注释

To-Do 列表

符号转义

内嵌 Astro 组件

实现一个 lazyman

前言

思路

总结

参考文章

拖动时禁止选中文字和元素

前言

Demo

preventDefault

CSS

总结

参考文章

浏览器端的 `WebSocket`

实现 `WebSocket` 服务器

环境记录 Environment Record 和词法环境 Lexical Environment