ash

Git CLI 命令操作手册与详细介绍

2026-04-02T02:00:00.000Z

Git 是目前最主流的分布式版本控制系统。很多人会用 git add、git commit、git push，但一旦进入分支协作、历史整理、冲突处理、误操作恢复，就容易开始混乱。

这篇文章按“从日常到深入”的顺序，把 Git CLI 的核心命令系统化整理出来：先讲最常用的工作流，再讲协作、历史、恢复、排错和高级功能，最后给出一份尽量完整的命令索引。

如果你只想先建立一套稳定工作流，可以重点看这些命令：git init、git clone、git status、git add、git commit、git log、git diff、git branch、git switch、git restore、git fetch、git pull、git push、git merge、git rebase、git stash、git tag、git reset、git revert、git reflog。

1. Git 到底在管理什么
1. Git 配置与帮助系统
1. 新建仓库与获取仓库
1. Git 的四个核心区域
1. 日常高频命令
1. 分支与切换
1. 查看历史与定位问题
1. 远程仓库协作
1. 合并、变基与历史整理
1. 撤销、回退与恢复
1. 标签、暂存、清理与归档
1. 高级协作与维护命令
1. 常见场景速查
1. Git 命令全景索引
1. 学习建议

1. Git 到底在管理什么

先别急着背命令。真正理解 Git，关键是先理解它在管理什么。

Git 管理的不是“文件夹快照”这么简单，而是：

工作区：你当前正在编辑的文件。
暂存区：下一次提交准备带走的内容。
本地仓库：已经提交到当前仓库历史中的内容。
远程仓库：例如 GitHub、GitLab、Gitea 上的仓库副本。

Git 的大部分命令，本质上都是在这几个区域之间移动内容，或者比较它们之间的差异。

你可以把它简单理解成：

1	工作区 --git add--> 暂存区 --git commit--> 本地仓库 --git push--> 远程仓库

反过来也成立：

1 2	远程仓库 --git fetch/pull--> 本地仓库/当前分支本地仓库 --git restore/reset--> 暂存区/工作区

如果这个模型不清楚，后面很多命令都会越用越乱。

2. Git 配置与帮助系统

2.1 查看版本

1	git --version

确认当前机器安装的 Git 版本。

2.2 基础配置

第一次使用 Git，通常先配用户名和邮箱：

1 2	git config --global user.name "Your Name" git config --global user.email "you@example.com"

查看当前生效配置：

1
2
3

git config --list
git config --global --list
git config --local --list

常见配置项：

user.name：提交记录显示的用户名。
user.email：提交记录显示的邮箱。
core.editor：默认编辑器。
init.defaultBranch：默认初始分支名，例如 main。
pull.rebase：git pull 时默认走 rebase 还是 merge。
merge.tool：冲突时使用的合并工具。
alias.xxx：给常用命令设置别名。

例如：

git config --global init.defaultBranch main
git config --global core.editor "vim"
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.lg "log --oneline --graph --decorate --all"

2.3 查看某个配置值

1 2	git config user.name git config --global core.editor

2.4 删除配置

1 2	git config --global --unset alias.co git config --unset user.name

2.5 Git 帮助系统

git help
git help status
git status -h
git help config
git help -a

含义：

git help：查看帮助入口。
git help status：查看 status 的完整手册。
git status -h：查看简短帮助。
git help -a：列出所有可用子命令。

如果你真的想看“全部命令”，最权威的入口不是某篇博客，而是 git help -a 和官方手册。

3. 新建仓库与获取仓库

3.1 初始化仓库：`git init`

1 2	git init git init my-project

作用：

常见场景：

本地新项目开始纳入版本控制。
把已有代码目录变成仓库。

3.2 克隆仓库：`git clone`

1
2
3

git clone https://github.com/user/repo.git
git clone git@github.com:user/repo.git
git clone https://github.com/user/repo.git myrepo

作用：

从远程获取完整仓库历史。
自动创建远程别名 origin。
默认检出远程默认分支。

常见参数：

--depth 1：浅克隆，只拉最近历史。
--branch ：克隆后直接检出指定分支。
--recurse-submodules：同时拉取子模块。

例如：

1	git clone --depth 1 --branch main https://github.com/user/repo.git

3.3 判断当前目录是不是 Git 仓库

1	git rev-parse --is-inside-work-tree

输出 true 代表当前路径在仓库内部。

4. Git 的四个核心区域

理解这四个区域后，很多命令就不难了。

4.1 工作区

就是你当前磁盘上的真实文件。

4.2 暂存区

也叫 index。git add 并不是“提交”，而是把改动放入“下一次提交候选区”。

4.3 本地仓库

git commit 之后，内容进入本地历史。

4.4 远程仓库

git push 才会把本地提交送到远程。

4.5 最容易混淆的三个对比

1
2
3

git diff              比较工作区 和 暂存区
git diff --cached     比较暂存区 和 最近一次提交
git diff HEAD         比较工作区 和 最近一次提交

这是很多人学 Git 时最容易糊的地方。

5. 日常高频命令

这一节是实际工作中最常用的部分。

5.1 查看状态：`git status`

git status
git status -s
git status --short
git status -b

作用：

查看当前分支。
查看哪些文件已修改。
查看哪些内容已暂存。
查看哪些文件未跟踪。

常见输出含义：

M：已修改。
A：已添加。
D：已删除。
R：已重命名。
??：未跟踪文件。

5.2 添加到暂存区：`git add`

git add file.txt
git add src/
git add .
git add -A
git add -p

高频用法说明：

git add file.txt：只暂存一个文件。
git add src/：暂存一个目录。
git add .：暂存当前目录下变更。
git add -A：更明确地把新增、修改、删除都纳入暂存。
git add -p：按代码块交互式暂存，适合拆分提交。

git add -p 非常实用。比如你在一个文件里同时做了“修 bug”和“顺手重构”，这时可以按块选择，只暂存你想提交的那部分。

5.3 提交：`git commit`

git commit -m "fix: handle empty response"
git commit
git commit --amend
git commit -a -m "docs: update README"

高频说明：

git commit -m：直接写提交说明。
git commit：进入编辑器写更完整说明。
git commit --amend：修改上一次提交。
git commit -a -m：把已跟踪文件的修改直接提交，不包含新文件。

提交信息建议：

写清楚“为什么改”。
一次提交只做一类事情。
不要把大量无关改动揉成一个提交。

5.4 查看差异：`git diff`

git diff
git diff --cached
git diff HEAD
git diff branchA..branchB
git diff commit1 commit2
git diff --stat
git diff --name-only

高频场景：

提交前确认到底改了什么。
对比两个提交、两个分支的内容差异。
看哪些文件变了，不看具体行时可以配 --stat 或 --name-only。

5.5 查看文件内容来自哪个提交：`git blame`

1 2	git blame file.txt git blame -L 10,30 file.txt

作用：

看某一行是谁在什么时候改的。
排查历史问题时非常有用。

但别把 blame 只理解成“追责”，它更多是为了找上下文。

5.6 查看对象详情：`git show`

git show
git show HEAD
git show HEAD~1
git show 
git show v1.0.0

作用：

查看某个提交的详细变更。
查看标签、对象、提交说明。

6. 分支与切换

6.1 查看分支：`git branch`

git branch
git branch -a
git branch -r
git branch -vv

说明：

git branch：本地分支。
git branch -a：本地和远程分支。
git branch -r：远程跟踪分支。
git branch -vv：看本地分支跟踪关系和最近提交。

6.2 创建分支

1 2	git branch feature/login git switch -c feature/login

更推荐 git switch -c，语义更清晰：创建并切换。

6.3 切换分支：`git switch`

git switch main
git switch feature/login
git switch -c hotfix/header
git switch -

说明：

git switch -：切回上一个分支。

旧命令里很多人还在用：

1 2	git checkout main git checkout -b feature/login

现在更推荐把“切分支”和“恢复文件”交给 git switch / git restore，比 checkout 更不容易误用。

6.4 重命名分支

1	git branch -m old-name new-name

当前分支重命名：

1	git branch -m new-name

6.5 删除分支

1 2	git branch -d feature/login git branch -D feature/login

区别：

-d：安全删除，只删已经合并过的分支。
-D：强制删除，没合并也删。

6.6 跟踪远程分支

1 2	git switch --track origin/feature/login git checkout --track origin/feature/login

7. 查看历史与定位问题

7.1 历史查看：`git log`

git log
git log --oneline
git log --oneline --graph --decorate --all
git log -p
git log --stat
git log --author="ash"
git log --since="2026-01-01"
git log -- file.txt

高频组合：

1	git log --oneline --graph --decorate --all

这个几乎可以作为默认日志视图。

7.2 精简历史：`git shortlog`

1 2	git shortlog git shortlog -sn

作用：

汇总提交者和提交数量。
适合快速看项目贡献概览。

7.3 查找历史中的某段文本：`git grep`

1
2
3

git grep "useEffect"
git grep "TODO"
git grep -n "function render"

它和系统里的 grep 不同，它是面向 Git 仓库内容的检索工具。

7.4 二分定位引入 bug 的提交：`git bisect`

git bisect start
git bisect bad
git bisect good 
git bisect reset

工作流程：

告诉 Git 当前版本是坏的。
告诉 Git 某个历史提交是好的。
Git 自动在中间挑提交让你验证。
你反复标记 good / bad，最终定位问题提交。

这个命令在“某个 bug 是什么时候引入的”这种场景里非常强。

8. 远程仓库协作

8.1 查看远程：`git remote`

1 2	git remote git remote -v

8.2 添加远程

1 2	git remote add origin https://github.com/user/repo.git git remote add upstream git@github.com:org/repo.git

常见约定：

origin：你自己的默认远程。
upstream：上游仓库，例如 fork 场景里的原始仓库。

8.3 修改远程地址

1	git remote set-url origin git@github.com:user/repo.git

8.4 删除远程

1	git remote remove upstream

8.5 获取远程更新：`git fetch`

git fetch
git fetch origin
git fetch --all
git fetch --prune

作用：

只拉取远程最新提交和引用。
不自动合并到当前分支。

git fetch 很安全，因为它不会直接改你的工作内容。

8.6 拉取并合并：`git pull`

1
2
3

git pull
git pull origin main
git pull --rebase

它本质上等于：

1	git fetch + git merge

或者使用 --rebase 时：

1	git fetch + git rebase

什么时候用 pull --rebase：

希望本地提交接在远程最新提交后面。
想减少无意义的 merge commit。

8.7 推送：`git push`

git push
git push origin main
git push -u origin feature/login
git push --tags

说明：

-u：建立上游跟踪关系，之后可以直接 git push / git pull。
--tags：推送标签。

8.8 强制推送

1	git push --force-with-lease

尽量不要直接用：

1	git push --force

原因：

--force 可能覆盖别人已经推上来的提交。
--force-with-lease 更安全，会先检查远程是否还是你预期的状态。

9. 合并、变基与历史整理

9.1 合并分支：`git merge`

1 2	git switch main git merge feature/login

作用：

把另一个分支的提交合入当前分支。

常见参数：

--no-ff：即使能快进，也创建 merge commit。
--squash：把对方分支压成一个未提交改动，再由你手动提交。

9.2 变基：`git rebase`

1 2	git switch feature/login git rebase main

含义：

把当前分支的提交“重新播放”到 main 最新提交之后。

优点：

历史更线性。
阅读提交链更顺。

代价：

会改写提交历史。
已共享给别人的分支上要谨慎使用。

9.3 交互式变基：`git rebase -i`

1	git rebase -i HEAD~3

常见用途：

合并多个碎提交。
调整提交顺序。
修改提交信息。
删除不需要的提交。

常见动作：

pick：保留提交。
reword：保留提交，修改信息。
edit：中途停下，修改提交内容。
squash：压缩到前一个提交，并合并说明。
fixup：压缩到前一个提交，丢弃当前说明。
drop：移除提交。

9.4 挑选提交：`git cherry-pick`

1 2	git cherry-pick git cherry-pick commit1 commit2

作用：

只拿某一个提交到当前分支。
非常适合 hotfix 回灌、跨分支补丁迁移。

9.5 合并中断与继续

git merge --abort
git rebase --abort
git rebase --continue
git cherry-pick --abort
git cherry-pick --continue

这类命令在冲突处理中非常常见。

10. 撤销、回退与恢复

这是 Git 最容易让人误操作的一部分，要区分清楚。

10.1 恢复工作区文件：`git restore`

1
2
3

git restore file.txt
git restore .
git restore --source=HEAD~1 file.txt

作用：

丢弃工作区未暂存修改。
或把文件恢复成某个提交中的版本。

10.2 取消暂存：`git restore --staged`

1 2	git restore --staged file.txt git restore --staged .

作用：

把文件从暂存区拿回工作区。
文件内容还在，只是不参与下一次提交了。

10.3 老写法：`git checkout -- file`

1	git checkout -- file.txt

历史上常用，但语义不够清晰，现在更推荐 git restore。

10.4 重置分支：`git reset`

1
2
3

git reset --soft HEAD~1
git reset --mixed HEAD~1
git reset --hard HEAD~1

三种模式必须分清：

--soft：回退提交，保留暂存区和工作区。
--mixed：回退提交，清空暂存区，保留工作区。这是默认模式。
--hard：回退提交，同时覆盖暂存区和工作区，危险最大。

高频用途：

刚提交错了，想撤回重新整理：git reset --soft HEAD~1
想把暂存全部撤掉：git reset
确认不再需要改动，强制回到某版本：git reset --hard

10.5 反向提交撤销：`git revert`

1 2	git revert git revert HEAD

作用：

不改写历史。
新建一个“反向提交”来抵消旧提交。

在已经推送到远程、已经共享给团队的提交上，通常优先考虑 git revert，而不是 git reset。

10.6 查看引用移动历史：`git reflog`

1 2	git reflog git reflog show HEAD

这是救命命令。

场景：

你 reset --hard 了。
你误删分支了。
你做了 rebase 后找不到原来的提交了。

只要引用移动过，很多情况下都能从 reflog 找回来。

例如：

1 2	git reflog git reset --hard HEAD@{3}

10.7 删除未跟踪文件：`git clean`

git clean -n
git clean -f
git clean -fd
git clean -fdx

说明：

-n：先预览，不真正删除。
-f：真正删除文件。
-d：连目录一起删。
-x：连 .gitignore 忽略的文件也删。

这是非常危险的命令，最好总是先跑一次 git clean -n。

11. 标签、暂存、清理与归档

11.1 标签：`git tag`

git tag
git tag v1.0.0
git tag -a v1.0.0 -m "release v1.0.0"
git show v1.0.0
git push origin v1.0.0
git push --tags
git tag -d v1.0.0

标签分两类：

轻量标签：只是一个引用。
附注标签：带作者、时间、说明，更适合正式发布。

11.2 临时保存现场：`git stash`

git stash
git stash push -m "wip: header refactor"
git stash list
git stash show
git stash show -p stash@{0}
git stash pop
git stash apply
git stash drop stash@{0}
git stash clear

适用场景：

改到一半，需要先切分支修 bug。
当前改动还不想提交。

区别：

pop：恢复后同时删除 stash。
apply：恢复但保留 stash 记录。

11.3 归档导出：`git archive`

1 2	git archive --format=zip --output=release.zip HEAD git archive --format=tar HEAD \| gzip > release.tar.gz

适合导出某个提交的源代码快照，但不包含 .git 历史。

12. 高级协作与维护命令

12.1 多工作树：`git worktree`

1
2
3

git worktree list
git worktree add ../repo-hotfix hotfix/login
git worktree remove ../repo-hotfix

作用：

一个仓库同时检出多个分支到不同目录。
特别适合“主线开发中，临时开一个目录修线上 bug”。

12.2 子模块：`git submodule`

1
2
3

git submodule status
git submodule update --init --recursive
git submodule add  path/to/submodule

作用：

在一个仓库中引用另一个仓库的特定提交。

但子模块管理复杂度比较高，能不用就尽量别滥用。

12.3 仓库完整性检查：`git fsck`

git fsck

作用：

检查对象完整性和引用有效性。

12.4 垃圾回收与优化：`git gc`

1 2	git gc git gc --prune=now

作用：

压缩对象。
清理不可达对象。
优化仓库存储。

12.5 打包传输对象：`git bundle`

1 2	git bundle create repo.bundle --all git clone repo.bundle repo-copy

适合离线传输仓库。

12.6 查看引用：`git show-ref`

1
2
3

git show-ref
git show-ref --heads
git show-ref --tags

12.7 解析对象名：`git rev-parse`

1
2
3

git rev-parse HEAD
git rev-parse --short HEAD
git rev-parse --abbrev-ref HEAD

这类命令在脚本里非常常见。

13. 常见场景速查

13.1 新项目第一次提交

1
2
3

git init
git add -A
git commit -m "chore: initial commit"

13.2 从远程拉代码开始工作

1 2	git clone git switch -c feature/xxx

13.3 提交前检查

1
2
3

git status
git diff
git diff --cached

13.4 提交到远程新分支

1	git push -u origin feature/xxx

13.5 暂时保存现场去修别的问题

1 2	git stash push -m "wip" git switch main

修完后：

1 2	git switch feature/xxx git stash pop

13.6 本地提交还没推送，想重新整理

1	git reset --soft HEAD~1

13.7 远程已经有别人提交，先同步再推送

1
2
3

git fetch origin
git rebase origin/main
git push

13.8 误删提交，想找回来

1 2	git reflog git reset --hard HEAD@{n}

13.9 回退线上某次错误提交

1 2	git revert git push

13.10 清掉未跟踪垃圾文件

1 2	git clean -n git clean -fd

14. Git 命令全景索引

这一节按类别列出常见和重要命令。严格来说，Git 还包含不少 plumbing 命令和内部维护命令，因此“覆盖所有命令”在实践里更适合理解为：覆盖你日常开发、排错、维护和脚本里最可能接触到的完整命令体系。

如果你想看当前版本 Git 提供的全部子命令，请执行：

1	git help -a

14.1 初始化与获取

git init：初始化仓库。
git clone：克隆仓库。

14.2 配置与帮助

git config：查看和设置配置。
git help：查看帮助。
git bugreport：生成 bug 报告信息。

14.3 工作区与暂存区

git status：查看状态。
git add：加入暂存区。
git restore：恢复工作区或暂存区。
git rm：删除文件并记录到 Git。
git mv：移动或重命名文件。
git clean：删除未跟踪文件。

14.4 提交与历史

git commit：提交。
git log：查看历史。
git show：查看对象详情。
git diff：查看差异。
git blame：查看行级作者信息。
git annotate：blame 的相关形式。
git shortlog：摘要式日志。
git describe：根据最近标签描述提交。

14.5 分支与引用

git branch：管理分支。
git switch：切换分支。
git checkout：旧式切换/恢复命令。
git tag：管理标签。
git show-ref：查看引用。
git update-ref：底层更新引用。

14.6 远程协作

git remote：管理远程。
git fetch：获取远程更新。
git pull：拉取并合并或变基。
git push：推送提交。
git ls-remote：查看远程引用。
git request-pull：生成拉取请求摘要。

14.7 合并与历史整理

git merge：合并分支。
git rebase：变基。
git cherry-pick：挑选提交。
git revert：反向提交撤销。
git reset：移动当前分支并可重置暂存区/工作区。
git range-diff：比较两组提交序列。

14.8 暂存现场与补丁

git stash：暂存现场。
git apply：应用补丁。
git am：应用邮件格式补丁。
git format-patch：导出补丁。

14.9 搜索与排错

git grep：搜索内容。
git bisect：二分定位问题提交。
git reflog：查看引用变动历史。
git fsck：检查仓库完整性。

14.10 子模块、多工作区与归档

git submodule：管理子模块。
git worktree：多工作树。
git archive：导出归档。
git bundle：离线打包仓库。

14.11 对象库与维护

git gc：垃圾回收。
git prune：清理不可达对象。
git repack：重新打包对象。
git pack-refs：压缩引用存储。
git count-objects：统计对象数量。
git maintenance：仓库维护任务。

14.12 常见 plumbing 命令

这些命令平时不一定直接手敲，但在脚本、底层理解和高级排错里很重要：

git cat-file：查看对象内容。
git hash-object：计算对象哈希并可写入对象库。
git ls-files：列出索引和工作树文件。
git ls-tree：查看树对象。
git read-tree：把树对象读入索引。
git write-tree：把索引写成树对象。
git commit-tree：直接基于树对象创建提交。
git mktree：从文本描述创建树对象。
git mktag：创建标签对象。
git rev-parse：解析修订表达式。
git rev-list：列出提交对象。
git name-rev：用可读名称描述提交。
git merge-base：查找分支共同祖先。
git symbolic-ref：读取或修改符号引用。
git for-each-ref：遍历引用。
git update-index：直接操作索引。
git checkout-index：从索引签出文件。
git diff-index：比较树和工作区/索引。
git diff-tree：比较两个树对象。
git diff-files：比较工作区和索引。
git unpack-objects：解包对象。
git pack-objects：打包对象。
git verify-pack：校验 pack 文件。
git unpack-file：解出 blob 内容。
git replace：用替代对象覆盖显示效果。
git notes：附加注释对象。

14.13 邮件工作流相关命令

这类命令在内核社区或部分传统开源项目里比较常见：

git send-email
git imap-send
git mailinfo
git mailsplit
git mailmap
git am
git format-patch
git request-pull

15. 学习建议

如果你不是想研究 Git 内部实现，而是想把工作流先跑稳，建议按下面顺序掌握：

先彻底搞懂 status、add、commit、diff、log。
再掌握 branch、switch、fetch、pull、push。
然后掌握 merge、rebase、stash、tag。
最后重点掌握 restore、reset、revert、reflog，这组命令决定你出问题时能不能救回来。

我自己的建议是：

每次提交前都跑一次 git status。
每次提交前都看一次 git diff --cached。
已经推送到共享分支的历史，优先用 git revert，少用改写历史的方式。
强制推送优先用 git push --force-with-lease。
遇到 Git 混乱时，先停下来，看 status、log、reflog，不要盲目敲命令。

最后给一个非常实用的最小速查表：

git status
git add -A
git diff
git diff --cached
git commit -m "message"
git log --oneline --graph --decorate --all
git switch -c feature/xxx
git fetch --all --prune
git pull --rebase
git push -u origin feature/xxx
git restore --staged .
git restore .
git reset --soft HEAD~1
git revert 
git stash push -m "wip"
git stash pop
git reflog

如果你把上面这一组命令吃透了，已经能覆盖绝大多数日常开发场景。

软考网络工程师备考全攻略：8 周计划、速记表与端口协议清单

2026-03-24T16:00:00.000Z

如果你和我一样，白天上班，真正能拿出来备考的时间只有工作日晚间 2-3 小时，同时又不是网络科班出身，而是有开发经验、懂一些网络但没有系统梳理过，那么软考 Network Engineer 的难点通常不是“完全看不懂”，而是：知识点很散、真题节奏不熟、下午案例题写不出关键词。

这篇文章把三份资料合成了一篇可以直接照着执行的长文：

8 周备考计划
高频知识速记表
端口 + 协议 + 易混点清单

目标不是追求高分，而是尽量在本次考试通过；即使这次没过，也把下一次复习的框架一次搭好。我会保留 English concepts 的组织方式，因为对很多有工程背景的人来说，这种方式更容易形成检索路径。

如果你不是按 3/25 -> 5/23 这个时间窗备考，也没关系，直接把下面的 Week 0 - Week 8 整体平移即可。

一、先讲策略：这场考试怎么准备更像“冲刺”而不是“啃书”

1）目标分数

Morning paper：稳住基础分，目标 52-58
Afternoon paper：不崩盘，目标 48-55
最终目标：两科都过线

2）学习原则

不走“从头到尾啃厚书”的路线
采用 concept -> real questions -> notes -> revisit 的闭环
优先抓 high-frequency topics
从第 2 周开始，必须接触 afternoon case

3）时间预算

按照工作日晚间 2-3h 计算，8 周大约可投入：

2h/night：约 86h
2.5h/night：约 107h
3h/night：约 129h

这个投入量，对于“有多年开发经验、但网络知识没有系统梳理”的人来说，足够完成一次质量不错的冲刺。

4）Morning 和 Afternoon 分别怎么打

Morning

覆盖面广
小知识点很多
很容易在端口、术语、协议差异上丢分
做题速度很重要

Afternoon

题量少，但更偏场景题
高频题型喜欢考：address planning、VLAN、routing、ACL/NAT、fault analysis、design
partial credit 很重要
关键词比长篇大论更重要

下午题一个很实用的答题原则是：

要解决什么问题
采用什么技术或协议
为什么这个方案适合当前场景
最终能达到什么效果

5）如果时间很紧，优先锁定这些内容

IPv4, subnetting, CIDR, VLSM, route summarization
VLAN, Trunk, STP
static routing, RIP, OSPF, BGP basics
ACL, NAT, PAT, firewall, VPN basics
DNS, DHCP, HTTP/HTTPS, SMTP, POP3, IMAP, FTP
network design, redundancy, troubleshooting, cabling/media

如果时间特别紧，不要过度投入这些内容：

很深的 BGP policy
很细的 IPv6 details
SDN / 5G / cloud overview 这类只需要认知级理解的内容

二、资料怎么选：尽量少而有效

1）官方信息

官方网站：https://www.ruankao.org.cn/
考试计划：https://www.ruankao.org.cn/exam/plan.html
官方教材入口：https://www.ruankao.org.cn/book/main.html
报名入口：https://bm.ruankao.org.cn/sign/welcome
机考模拟/下载入口：https://bm.ruankao.org.cn/sign/in?type=query&s=vexam/download/main

2）教材

推荐主教材：网络工程师教程（第6版）
清华大学出版社页面：https://www.tup.com.cn/booksCenter/book_10453401.html

使用方式不要搞反：

把它当 reference book
不要从第一页一路硬读到最后一页
哪些真题章节反复出错，再回书里补对应章节

3）免费视频

晚间时间有限，更适合按专题看，所以优先用 Bilibili。

考试介绍 / 报考指南：https://www.bilibili.com/video/BV1ZAivYsEt3/
搜索关键词 1：希赛软考网络工程师第6版
搜索关键词 2：网络工程师下午真题解析
搜索关键词 3：软考网络工程师机考
搜索关键词 4：子网划分 VLAN STP OSPF ACL NAT 网络工程师

建议只看三类视频：

high-frequency concept videos
afternoon case analysis
机考/答题节奏 视频

4）高频知识点与真题

高频知识点参考：https://www.educity.cn/rk/5374342.html
真题优先做近 5 年
如果纸质真题不全，优先补 2023-2025 的线上真题和解析

三、每晚怎么学：把时间切成可执行模板

Option A：只有 `2 hours`

15 min：回顾昨天错题 / notes
45 min：学习当天主题的核心概念
40 min：做 15-20 道 morning 选择题
20 min：订正 + 记 3-5 条 notes

Option B：有 `2.5-3 hours`

在上面的基础上再增加：

30-60 min：做 1 道 afternoon case，或者看 1 道详细解析

Weekly Output Target

每周至少完成：

80-100 道 morning questions
1-2 道 afternoon case
1 页自己的 topic notes

我额外建议你固定做的 4 张纸

这些不是“可选项”，而是复习越到后面越关键：

protocol comparison
common ports
subnetting cheat sheet
afternoon keywords

四、考点优先级：先打通主线，再补边缘

A-Level：必须拿下

IPv4 addressing
subnetting / VLSM / CIDR
route summarization
VLAN / Trunk
STP
static routing / default route
RIP / OSPF / BGP basics
ACL
NAT / PAT
firewall / VPN basics
DNS / DHCP / HTTP / SMTP
network design / redundancy / troubleshooting

B-Level：必须会做题

SNMP / Syslog
proxy
FTP / POP3 / IMAP
RAID
server basics
wireless LAN
IPv6 basics
cabling / media selection

C-Level：知道就行

SDN
cloud networking overview
5G / new-outline overview topics
其他明显偏概念、偏新大纲的边缘内容

五、8 周冲刺计划：按周推进，不要每天重新想“今天学什么”

Week 0：`3/25 Wed - 3/27 Fri`

Goal

建立考试框架
知道 morning / afternoon 分别怎么考
完成一次 baseline test

Plan

3/25 Wed
- 了解考试结构、题型、时间分配
- 建立笔记文档：wrong questions、topic notes、formula sheet
- 做一套 morning 的前 20-30 题，感受题型
3/26 Thu
- 学 OSI / TCP-IP / encapsulation / decapsulation
- 学 Ethernet / MAC / ARP
- 做 15-20 道对应选择题
3/27 Fri
- 学 IPv4 addressing、subnet mask、CIDR
- 做 15-20 道地址基础题
- 记录第一次暴露出的薄弱点

Optional Weekend Catch-up

用 60-90 min 回顾本周错题
看 1 道 afternoon case 解析，先理解答题风格，不求会做

Week 1：`3/30 Mon - 4/3 Fri`

Goal

拿下 subnetting 这个高频送分点
对 VLAN / Trunk 建立基本理解

Plan

3/30 Mon
- subnetting：网络地址、广播地址、可用主机数
- 做 15 道子网题
3/31 Tue
- VLSM 和 CIDR
- 做 15-20 道地址规划题
4/1 Wed
- route summarization
- 建一张地址计算速记表
- 做 15 道题
4/2 Thu
- VLAN、access port、Trunk
- 做 15-20 道交换基础题
4/3 Fri
- 做一个小复盘
- 1 道 afternoon case：address planning 或 VLAN 基础题

End-of-Week Check

能快速计算网段 / 广播地址 / 主机范围
知道 VLAN 和 Trunk 的作用
能看懂基本地址规划题

Week 2：`4/6 Mon - 4/10 Fri`

Goal

建立 switching + routing basics
开始接触 STP 和动态路由

Plan

4/6 Mon
- STP：why it exists、loop avoidance、root bridge
- 做 15 道题
4/7 Tue
- link aggregation、switch basics
- 做 15 道题
4/8 Wed
- static route、default route
- 做 15-20 道题
4/9 Thu
- RIP：hop count、convergence、suitable scenarios
- 做 15 道题
4/10 Fri
- OSPF basics：link-state、metric、area
- 做 1 道 afternoon case：switch / routing basics

End-of-Week Check

能说明 STP 解决什么问题
能区分 static route、RIP、OSPF
能做基础的交换 / 路由题

Week 3：`4/13 Mon - 4/17 Fri`

Goal

进入网络工程师核心区：OSPF / BGP / ACL / NAT
afternoon 开始真正练习表达

Plan

4/13 Mon
- OSPF：neighbor、metric、convergence、area basics
- 做 15-20 道题
4/14 Tue
- BGP basics：path selection basic ideas、inter-domain scenarios
- 做 10-15 道题
4/15 Wed
- ACL：standard vs extended、matching logic
- 做 15-20 道题
4/16 Thu
- NAT / PAT、firewall basics
- 做 15-20 道题
4/17 Fri
- VPN basics
- 做 1-2 道 afternoon case：ACL / NAT / routing

End-of-Week Check

能说清 OSPF 和 BGP 的最核心差别
知道 ACL 一般按什么匹配
知道 NAT / PAT 的常见题型

Week 4：`4/20 Mon - 4/24 Fri`

Goal

补齐服务类高频考点
建立“服务 + 端口 + 故障”的联动记忆

Plan

4/20 Mon
- DNS：recursion、authoritative、cache、typical issues
- 做 15-20 道题
4/21 Tue
- DHCP：lease、relay、address assignment flow
- 做 15-20 道题
4/22 Wed
- HTTP / HTTPS、proxy、basic web service concepts
- 做 15 道题
4/23 Thu
- SMTP / POP3 / IMAP / FTP
- 整理一张 common ports 速记表
- 做 15-20 道题
4/24 Fri
- SNMP、Syslog、server basics、RAID
- 做 1 道 afternoon case：service / operation / fault diagnosis

End-of-Week Check

常见服务端口能认出来
知道 DNS / DHCP / Mail 常见故障模式
afternoon 答题开始能写出关键词

Week 5：`4/27 Mon - 5/1 Fri`

Goal

切入 design / topology / availability / troubleshooting
让 afternoon 更像“写方案”而不是“猜答案”

Plan

4/27 Mon
- network topology、core / distribution / access
- 做 15 道题
4/28 Tue
- redundancy、high availability、backup links
- 做 15 道题
4/29 Wed
- troubleshooting：fault isolation、layered diagnosis mindset
- 做 15-20 道题
4/30 Thu
- cabling / media selection、wireless LAN basics
- 做 15 道题
5/1 Fri
- IPv6 basics + 新大纲轻量内容扫一遍
- 做 1-2 道 afternoon case：design / troubleshooting

End-of-Week Check

知道典型企业网络分层结构
能解释冗余设计的目的
遇到故障题不会完全没思路

Week 6：`5/4 Mon - 5/8 Fri`

Goal

从“学知识”切换到“拿分”
真题优先级高于新视频

Plan

5/4 Mon
- 做 1 套完整 morning 真题
- 统计错题分布
5/5 Tue
- 复盘错题最多的两个专题
- 补对应概念或视频
5/6 Wed
- 做 1 道 afternoon case
- 按标准答案整理关键词
5/7 Thu
- 再做 20-25 道 morning 高频专题题
- 重点盯 subnetting / routing / services
5/8 Fri
- 做 1 道 afternoon case
- 输出一页 high-frequency notes

End-of-Week Check

知道自己最弱的 3 个专题
开始形成自己的速记表

Week 7：`5/11 Mon - 5/15 Fri`

Goal

稳定做题节奏
压缩知识点到考场可调用状态

Plan

5/11 Mon
- 做第 2 套完整 morning 真题
5/12 Tue
- 做 1 道 afternoon case，限时作答
5/13 Wed
- 回顾 ACL / NAT / OSPF / DNS / DHCP
- 做 20 道专题题
5/14 Thu
- 做 1 套 mini mock：morning 30-40 题 + 1 道 afternoon
5/15 Fri
- 复盘整周错题
- 完成最终版 common ports + protocol comparison 速记表

End-of-Week Check

morning 做题速度明显提升
afternoon 不再只会看答案
高频知识点开始成体系

Week 8：`5/18 Mon - 5/22 Fri`

Goal

只收口，不扩张
把已学内容压成可复述、可作答、可拿分的状态

Plan

5/18 Mon
- 做最后 1 套完整 morning 真题
- 只记高频错点
5/19 Tue
- 做 1 道 afternoon case
- 复盘答案模板
5/20 Wed
- 重点回顾：subnetting / VLAN / STP / OSPF / ACL / NAT
5/21 Thu
- 重点回顾：DNS / DHCP / HTTP / Mail / troubleshooting / design
5/22 Fri
- 只看自己的 wrong questions + notes + formulas + ports
- 不再开新专题
- 提前调整作息

Exam-Eve Rules

不熬夜
不刷偏题、怪题
不再看大段新视频
相信你已经完成的复习闭环

六、把知识串起来：一张紧凑的知识地图

Layer 2 / Layer 3

Ethernet
MAC / ARP
VLAN / Trunk
STP
routing / forwarding

Addressing

IPv4
subnetting
VLSM
CIDR
route summarization
IPv6 basics

Routing

static route
default route
RIP
OSPF
BGP basics

Security

ACL
NAT / PAT
firewall
VPN
常见攻击与基础防护思路

Services

DNS
DHCP
HTTP / HTTPS
SMTP / POP3 / IMAP
FTP
proxy
SNMP / Syslog

Design / Ops

topology
core / distribution / access
redundancy / HA
load balancing
troubleshooting
RAID
cabling / media

这些东西要明确背，不要只靠“理解过”

常见服务端口
RIP / OSPF / BGP 对比
ACL 分类和匹配逻辑
NAT / PAT 区别
VLAN / Trunk / STP 关键词
子网划分计算套路
RAID 级别特点
常见设备 / 介质适用场景

七、高频知识速记表：把最常考的地方先压缩到脑子里

1. IPv4 和 Subnetting

Core Formulas

子网总地址数：2^(32-prefix)
常规可用主机数：2^(32-prefix) - 2
子网步长：找 interesting octet，计算 256 - mask

Fast Memory Table

Prefix	Mask	Total IPs	Usable Hosts
`/24`	`255.255.255.0`	256	254
`/25`	`255.255.255.128`	128	126
`/26`	`255.255.255.192`	64	62
`/27`	`255.255.255.224`	32	30
`/28`	`255.255.255.240`	16	14
`/29`	`255.255.255.248`	8	6
`/30`	`255.255.255.252`	4	2

Workflow for Subnetting Questions

先看每个子网需要多少主机
选能满足需求的最小前缀
VLSM 题先分配大网段，再分配小网段
写清楚 network address、usable range、broadcast address
最后检查是否发生 overlap

High-Frequency Traps

把 network address 和 first usable host 搞混
忘了 broadcast address
VLSM 没有先分配最大的子网
route summarization 既要覆盖所有路由，又要尽量避免多余覆盖

2. VLAN、Trunk、STP

VLAN

逻辑上分割广播域
提升隔离性、可管理性和安全性
不同 VLAN 的主机通信需要 Layer 3 转发

Trunk

用来承载多个 VLAN 的流量
一般依赖 tagging
常见场景是交换机与交换机之间的链路

STP

作用：防止二层环路
核心思路：阻塞冗余路径，但保留备份链路
必记术语：root bridge、root port、designated port、blocking

Common Traps

VLAN 解决的是分段，不会自动解决跨 VLAN 通信
Trunk 不等于 access port
冗余链路如果没有 STP，可能造成广播风暴和 MAC 表震荡

3. Routing Cheat Sheet

Static Route

简单
可预测
开销低
在大网络里可扩展性差

RIP

distance-vector
度量：hop count
收敛慢
只适合小型、简单网络

OSPF

link-state
比 RIP 收敛更快
支持 areas 的分层设计
适合中大型内部网络

BGP

inter-domain routing
偏 policy-oriented
常见于 ISP / multi-AS scenarios
不是普通企业内部路由的默认答案

Fast Comparison Table

Protocol	Type	Metric / Key Idea	Typical Use
`Static`	manual	admin control	small/stable networks
`RIP`	distance-vector	hop count	small LAN/WAN
`OSPF`	link-state	cost	enterprise internal routing
`BGP`	path-vector	policy/path attributes	inter-AS / ISP

High-Frequency Traps

RIP 简单，但不适合大规模网络
OSPF 通常用于内部，BGP 通常用于域间
不要脱离场景写出“BGP 比 OSPF 更好”这种答案

4. ACL、NAT、Firewall、VPN

ACL

做流量过滤和访问控制
标准 ACL：主要按源地址匹配
扩展 ACL：可按源、目的、协议、端口匹配

NAT / PAT

NAT：私网地址和公网地址之间转换
PAT：多个内网主机共用一个公网 IP，通过不同端口复用

Firewall

执行安全策略
按规则允许或拒绝流量
常部署在网络边界或不同安全域之间

VPN

在公共网络之上建立安全隧道
可用于 site-to-site 或 remote access

High-Frequency Traps

ACL 过滤流量，不等于 NAT
多个私网主机共享少量公网 IP 时，PAT 往往才是题目的实际答案
远程管理里 telnet 不安全，SSH 更安全

5. Services and Servers

DNS

域名解析
必记：UDP/TCP 53
高频考法：cache、recursion、authoritative answer、DNS 故障症状

DHCP

自动分配 IP
必记：UDP 67/68
关键概念：lease、pool、gateway、DNS server options、relay

HTTP / HTTPS

Web 服务
必记：80 / 443
HTTPS 在 HTTP 基础上增加了 TLS 加密和身份校验

Mail

SMTP：发信
POP3：收信，偏简单下载模型
IMAP：收信，偏服务器端邮箱同步

SNMP / Syslog

SNMP：监控和管理
Syslog：集中日志传输

RAID Basics

RAID	Key Feature
`RAID 0`	striping，性能好，但无冗余
`RAID 1`	mirroring，有冗余
`RAID 5`	striping + parity，容量和容错平衡
`RAID 10`	性能和冗余兼顾，但成本更高

6. Design and Troubleshooting

Design Keywords

availability
redundancy
scalability
security
manageability
performance

Typical Topology Terms

core layer
distribution layer
access layer

Troubleshooting Method

先定义清楚症状
判断影响范围：单主机、单 VLAN、单子网、单服务还是全网
必要时先看物理连通性
按顺序排查：addressing、gateway、VLAN、ACL、routing、DNS
验证修复前后状态

Common Fault Paths

域名访问不了，但 IP 能访问：大概率是 DNS
本地子网正常，跨子网失败：优先查 gateway / routing / ACL
间歇性环路或广播风暴：优先怀疑二层冗余没有正确跑 STP
内网用户无法出网：优先查 NAT、default route、firewall policy

7. Cabling and Media

不用深挖到物理层细枝末节，但方向要清楚：

双绞线：常见于接入层 LAN
光纤：距离更长、抗干扰更强，常用于骨干或上联
介质选型看：distance、bandwidth、cost、environment、anti-interference

八、端口与协议清单：这一块最适合考前反复默写

1. Must-Memorize Ports

Service	Port / Protocol	Notes
`FTP data`	`20/TCP`	active mode data channel
`FTP control`	`21/TCP`	control channel
`SSH`	`22/TCP`	secure remote login
`Telnet`	`23/TCP`	insecure remote login
`SMTP`	`25/TCP`	mail sending
`DNS`	`53/UDP,TCP`	UDP 用于常规查询，TCP 常见于 zone transfer 或大响应
`DHCP server`	`67/UDP`	server side
`DHCP client`	`68/UDP`	client side
`TFTP`	`69/UDP`	simple file transfer
`HTTP`	`80/TCP`	web
`POP3`	`110/TCP`	receive mail
`NTP`	`123/UDP`	time sync
`IMAP`	`143/TCP`	receive mail, synchronized mailbox
`SNMP`	`161/UDP`	management/query
`SNMP Trap`	`162/UDP`	unsolicited event/alert
`BGP`	`179/TCP`	routing between ASes
`LDAP`	`389/TCP,UDP`	directory service
`HTTPS`	`443/TCP`	encrypted web
`SMTPS`	`465/TCP`	secure SMTP，部分题目或资料中会出现
`Syslog`	`514/UDP`	centralized logs
`RIP`	`520/UDP`	routing update protocol
`RIPng`	`521/UDP`	RIP for IPv6
`DHCPv6 client`	`546/UDP`	IPv6 DHCP client
`DHCPv6 server`	`547/UDP`	IPv6 DHCP server

2. Very Common Exam Traps

DNS

不要只背 53/UDP
DNS 也会用 TCP 53
典型考法包括 zone transfer 和大响应场景

FTP

21 是控制连接
20 是主动模式下的数据连接
如果题目问得比较宽，不要只写一个端口而不加上下文

Mail

SMTP 负责发送
POP3 和 IMAP 负责接收
IMAP 更适合多设备同步邮箱

Remote Management

Telnet 是明文，不安全
SSH 才是更安全的管理方案

3. Protocols Without a Classic Port Number

有些协议不是靠 TCP/UDP 端口来识别，而是靠 IP protocol number。

Protocol	Identifier	Notes
`ICMP`	`IP protocol 1`	error reporting, diagnostics
`TCP`	`IP protocol 6`	connection-oriented transport
`UDP`	`IP protocol 17`	connectionless transport
`GRE`	`IP protocol 47`	tunneling
`ESP`	`IP protocol 50`	IPsec encryption
`AH`	`IP protocol 51`	IPsec authentication
`OSPF`	`IP protocol 89`	link-state routing

这一点很重要，因为题目很喜欢把“端口号”和“IP 协议号”混着考。

4. Transport and Core Internet Protocols

Protocol	Layer / Type	Key Feature	Common Exam Angle
`ARP`	Layer 2/3 boundary	map IP to MAC	local network resolution
`ICMP`	network	control and diagnostics	`ping`、error report
`TCP`	transport	reliable, ordered, connection-oriented	web、mail、SSH
`UDP`	transport	fast, no connection, lower overhead	DNS、DHCP、SNMP、RIP

TCP vs UDP

Item	`TCP`	`UDP`
connection	yes	no
reliability	yes	no built-in reliability
ordering	yes	no
overhead	higher	lower
typical services	HTTP, HTTPS, SSH, SMTP, POP3, IMAP, BGP	DNS, DHCP, SNMP, RIP, TFTP, NTP

高频判断题思路：

当可靠性、顺序性重要时，优先想到 TCP
当低开销、速度更重要，且应用层能容忍或处理丢包时，优先想到 UDP

5. Layer 2 and Switching Protocols

Protocol / Tech	Main Role	What To Say In Answers
`Ethernet`	LAN framing and access	basic LAN data transmission
`VLAN`	logical segmentation	reduce broadcast domain, improve isolation
`Trunk`	carry multiple VLANs	inter-switch multi-VLAN transport
`STP`	loop prevention	avoid Layer 2 loop, keep redundancy
`LACP` / link aggregation	bundle links	increase bandwidth and/or redundancy

Common trap：

VLAN 本身不提供跨 VLAN 通信，跨 VLAN 仍然需要 Layer 3 forwarding

6. Routing Protocol Comparison

Protocol	Category	Transport / Identifier	Key Metric / Idea	Typical Scenario
`RIP`	distance-vector	`UDP 520`	hop count	small/simple network
`OSPF`	link-state	`IP protocol 89`	cost, SPF	enterprise internal routing
`BGP`	path-vector	`TCP 179`	policy/path attributes	inter-AS / ISP

Quick Notes

RIP：简单，但收敛慢、规模受限
OSPF：收敛更快，支持 area 分层
BGP：强调 route policy 和域间控制，不是企业内部路由的默认答案

7. Security Protocols and Concepts

Item	Identifier / Port	Key Point
`SSH`	`22/TCP`	secure remote management
`Telnet`	`23/TCP`	insecure plaintext management
`HTTPS`	`443/TCP`	encrypted web access
`AH`	`IP protocol 51`	IPsec authentication/integrity
`ESP`	`IP protocol 50`	IPsec encryption + protection
`VPN`	varies	secure tunnel over public network
`ACL`	no fixed port	traffic filtering policy
`NAT/PAT`	no fixed port	address translation
`Firewall`	no fixed port	policy enforcement and traffic control

High-frequency trap：

ACL 和 firewall 都能控流，但两者不是同一个概念
NAT 不是安全策略本身，它更多是地址转换，最多只是“隐藏内部地址”

8. Network Services

Service	Protocol / Port	What Questions Often Test
`DNS`	`53/UDP,TCP`	name resolution, cache, zone transfer, DNS faults
`DHCP`	`67/68 UDP`	automatic addressing, lease, relay
`HTTP`	`80/TCP`	web access
`HTTPS`	`443/TCP`	encrypted web access
`SMTP`	`25/TCP`	send mail
`POP3`	`110/TCP`	receive mail
`IMAP`	`143/TCP`	synchronized mailbox access
`SNMP`	`161/162 UDP`	monitoring and management
`Syslog`	`514/UDP`	centralized logging
`NTP`	`123/UDP`	time synchronization
`TFTP`	`69/UDP`	simple file transfer, device configs/images in some contexts

9. Easy Confusion Pairs

`HTTP` vs `HTTPS`

HTTP：明文 Web 传输
HTTPS：基于 TLS 的加密 Web 传输

`POP3` vs `IMAP`

POP3：更偏简单下载模型
IMAP：更适合多设备同步邮箱

`RIP` vs `OSPF`

RIP：hop count，简单，小型网络
OSPF：link-state，收敛更快，适合更大的内部网络

`OSPF` vs `BGP`

OSPF：组织内部 / 网络域内部路由
BGP：自治系统之间路由

`ACL` vs `NAT`

ACL：filter / control
NAT：translate addresses

`Telnet` vs `SSH`

Telnet：明文，不安全
SSH：加密，优先选择

10. What To Recite Before Exam Day

如果考前只剩 10 分钟，把这些快速背一遍：

20/21 FTP、22 SSH、23 Telnet、25 SMTP
53 DNS、67/68 DHCP、69 TFTP、80 HTTP
110 POP3、123 NTP、143 IMAP
161/162 SNMP、179 BGP、443 HTTPS、514 Syslog、520 RIP
OSPF = IP protocol 89
AH = 51、ESP = 50、GRE = 47

九、下午题怎么写：不要写成“我觉得大概是这样”

下午题尽量固定成这个结构：

What is the problem / goal?
Which protocol / technology should be used?
Why is it suitable here?
What result / effect does it achieve?

Example Skeleton

该问题需要解决的是 ______。
可采用 ______ 技术/协议。
原因是：它能够 ______，并且适用于 ______ 场景。
实施后可实现 ______，从而提高 ______。

这个模板可以反复套进这些高频题：

VLAN / Trunk
OSPF
ACL
NAT
DNS / DHCP
redundancy / backup design

Afternoon Keywords You Should Reuse

答题时能复用就复用这些词：

reduce broadcast domain
improve security isolation
provide redundancy
improve availability
speed up convergence
support scalable network design
centralized management
automatic address assignment
secure remote access
control traffic by policy

我的补充建议是：不要追求句子华丽，先保证关键词到位。很多下午题你写不出完整论文没关系，但一定要让阅卷人看到“你知道问题、知道技术、知道原因、知道结果”。

十、最后两三周怎么复习：把知识压到“可调用”状态

这部分最适合搭配上面的速记表使用。

Last-Week Review Checklist

考前一周，确认自己能快速回答这些问题：

你能不能不慌地做 subnetting？
你能不能用自己的话解释 VLAN、Trunk、STP？
你能不能比较 RIP、OSPF、BGP？
你能不能说清 ACL、NAT、PAT、firewall、VPN 的区别？
你能不能快速回忆常见端口和服务职责？
你能不能按 problem -> solution -> reason -> result 写出一段简短下午题答案？

如果这些你都能做到，说明核心过线能力已经基本具备。

If You Fall Behind

如果某一周被工作打乱，不要慌，按照这个优先级保底。

Never Drop

subnetting
VLAN / STP
static / RIP / OSPF / BGP basics
ACL / NAT
DNS / DHCP
afternoon case practice

Can Be Simplified

wireless
IPv6 details
SDN / 5G / cloud overview
比较偏的管理类或边缘新概念

Recovery Strategy

工作日只保留 1h 也没关系，但不要断线
真断线时，至少完成：10 道题 + 10 分钟复盘
追赶进度时优先补 real questions，不要先补长视频

Exam-Eve Rules

不熬夜
不刷偏题、怪题
不再看大段新视频
只看自己的 wrong questions + notes + formulas + ports
相信你已经完成的复习闭环

十一、临门一脚：6 个自测问题

如果你不看笔记就能快速答出下面这些，这份清单就算发挥作用了：

BGP 用什么端口？
为什么 DNS 既可能用 UDP，也可能用 TCP？
设备远程管理更安全的是 Telnet 还是 SSH？
POP3 和 IMAP 的核心区别是什么？
OSPF 是靠 TCP/UDP 端口识别，还是靠 IP 协议号识别？
ACL 和 NAT 的核心区别是什么？

十二、最后的建议

如果你本身就有多年开发经验，理解力通常不是问题，真正的问题往往是考试表达和体系化记忆
不要用“我懂一点网络”替代“我会做真题”
只要把 subnetting + switching + routing + ACL/NAT + DNS/DHCP + afternoon case 这条主线打通，过线概率就不低
即使这次没过，下次也不是从零开始，因为你的复习框架已经搭好了

我再补一句最现实的话：这门考试对在职备考的人来说，最怕的不是难，而是断。哪怕某几天只能学 1 小时，也尽量别让链条断掉。稳定、小步、真题驱动，通常比“周末爆肝一次然后一周不碰”有效得多。

如果你真准备开始动手，今天晚上就做三件事：

建好 wrong questions、topic notes、formula sheet 三份笔记。
先做 20-30 道 morning 题，摸清自己弱点。
开始做第一张 common ports 速记表。

Nano 配置文件编辑指南（附极简 Vim 备忘）

2026-03-18T02:00:00.000Z

这篇文档按一个更实用的思路重新整理：主角是 nano，使用场景是 WSL、Linux、SSH、远程服务器里的配置文件编辑，vim 只保留一个很短的附录，不再放在中间打断阅读。

如果你的真实需求是改 ~/.bashrc、~/.zshrc、~/.gitconfig、/etc/hosts，或者改 ssh、nginx、docker compose、yaml、env 之类的配置，那么 nano 往往比 vim 更适合你。

1. Nano 速查表

先看这个。你平时真正高频会用到的，通常就是下面这些。

打开文件            nano file.txt
跳到指定行          nano +120,8 file.txt
保存                Ctrl+O
退出                Ctrl+X
搜索                Ctrl+W
替换                Ctrl+\
跳行                Ctrl+_
剪切当前行          Ctrl+K
粘贴                Ctrl+U
开始/结束选区       Ctrl+6 或 Alt+A
复制                Alt+6
撤销                Alt+U
重做                Alt+E
帮助                Ctrl+G
只读打开            nano -v file.txt
显示行号            nano -l file.txt
启用鼠标            nano -m file.txt
软换行显示          nano -S file.txt
备份原文件          nano -B file.txt

如果你只想先记住一套最小命令集，记这 8 个就够用了：

Ctrl+O 保存
Ctrl+X 退出
Ctrl+W 搜索
Ctrl+\ 替换
Ctrl+K 剪切当前行
Ctrl+U 粘贴
Ctrl+_ 跳行
Ctrl+G 帮助

2. 为什么 Nano 特别适合改配置文件

如果你不是想把终端编辑器当主力代码编辑器，而只是想高效改配置文件，那 nano 的优势非常明显。

2.1 没有模式切换负担

nano 是无模式编辑器：

打开就能直接输入
不需要先按 i
不需要记 :wq
不容易发生“我到底现在在哪个模式”这种问题

这一点对临时改配置特别重要，因为你追求的是：

快速打开
改掉问题
保存退出

而不是研究一套复杂命令系统。

2.2 底部自带快捷键提示

nano 底部通常会直接显示帮助提示，例如：

^O 写入文件
^X 退出
^W 搜索

这里的：

^ 表示 Ctrl
M- 表示 Alt / Meta

这对配置文件编辑很友好，因为你不需要靠背诵完整命令系统才能开始工作。

2.3 在 Linux / WSL / SSH 环境里几乎随处可用

很多服务器、容器、WSL 环境里，nano 都更容易直接上手。

它特别适合这些场景：

远程机器突然要改一行配置
用 sudo 编辑系统文件
改完就退出，不做复杂跳转
看日志、改 yaml、改 env、改 shell 配置

2.4 你本来就不打算用终端编辑器写大量代码

如果你的真实工作流是：

写代码用专门编辑器，比如 VS Code、JetBrains、Notepad++
终端里只负责改配置、修小问题

那 nano 通常更符合你的目标。

3. Nano 最常用的操作

这一节只讲配置文件场景里最有用的内容。

3.1 打开文件

最常见：

1	nano file.txt

打开常见配置文件：

nano ~/.bashrc
nano ~/.zshrc
nano ~/.gitconfig
nano ~/.ssh/config

编辑系统文件：

1
2
3

sudo nano /etc/hosts
sudo nano /etc/ssh/sshd_config
sudo nano /etc/nginx/nginx.conf

如果文件不存在，nano 会在保存时创建它。

3.2 保存

按：

Ctrl+O

然后回车确认文件名。

3.3 退出

按：

Ctrl+X

如果文件有改动但没保存，nano 会问你：

Y：保存后退出
N：不保存退出
Ctrl+C：取消这次退出

3.4 搜索

按：

Ctrl+W

输入关键词后回车。

这是改配置文件时最高频的操作之一，比如查：

proxy
timeout
host
listen
PATH

3.5 替换

按：

Ctrl+\

然后按提示：

输入要查找的内容
输入替换后的内容
逐个确认，或者全部替换

这个功能非常适合改配置项，比如：

把端口 8080 改成 3000
把旧路径替换成新路径
把某个域名替换成新域名

3.6 跳到指定行

按：

Ctrl+_

然后输入：

120 表示跳到第 120 行
120,8 表示跳到第 120 行第 8 列

适合：

根据报错行定位问题
跳到配置文件中的某一段

3.7 剪切与粘贴

没有选区时：

Ctrl+K：剪切当前整行
Ctrl+U：在当前光标位置粘贴

连续按多次 Ctrl+K：

会把多行连续剪下来
然后一次 Ctrl+U 可以整段贴回去

这在调整配置块顺序时非常有用，比如：

调整 server 段顺序
调整 alias 或 export 的顺序
调整 docker compose 里的某个服务块

3.8 选择与复制

开始选区：

Ctrl+6
或 Alt+A

然后移动光标，经过的内容就会被选中。

复制选区：

Alt+6

剪切选区：

Ctrl+K

3.9 撤销与重做

较新的 nano 版本通常支持：

Alt+U：撤销
Alt+E：重做

如果某些环境下 Alt 键不稳定，可以尝试：

先按 Esc
再按 U 或 E

3.10 帮助

忘了按键时，直接按：

Ctrl+G

这是最稳的保底方案。

4. 配置文件场景里的高频用法

这一节只讲你真正会遇到的配置文件工作流。

4.1 改 shell 配置

1 2	nano ~/.bashrc nano ~/.zshrc

常见动作：

增加 alias
修改 PATH
增加环境变量
调整 prompt

改完后通常别忘了：

1	source ~/.bashrc

或：

1	source ~/.zshrc

4.2 改 Git 配置

1	nano ~/.gitconfig

常见动作：

改用户名和邮箱
配别名
配默认分支行为
配颜色或编辑器

4.3 改 SSH 配置

1	nano ~/.ssh/config

这个文件非常适合用 nano，因为通常只是：

增加一个 Host
改端口
改用户名
改 IdentityFile

4.4 改系统文件

1
2
3

sudo nano /etc/hosts
sudo nano /etc/fstab
sudo nano /etc/ssh/sshd_config

这类文件一般不需要复杂编辑，只需要：

搜索
改几行
保存退出

这正是 nano 最擅长的场景。

4.5 改 YAML / Docker Compose / Nginx 配置

例如：

1
2
3

nano docker-compose.yml
nano compose.yaml
sudo nano /etc/nginx/nginx.conf

这类文件的关键是：

不要改错缩进
快速搜索关键字段
尽量少做复杂文本操作

nano 在这种场景下比 vim 更不容易带来额外心智负担。

4.6 只读查看，避免误改

如果你只是想先看：

1	nano -v file.txt

非常适合：

先确认配置结构
查某个值
查某段内容

4.7 保存前自动留备份

如果你改的是比较关键的配置，建议：

1	nano -B file.txt

保存后会自动生成：

file.txt~

这对系统配置文件尤其有用。

4.8 根据报错直接跳行

1	nano +87,1 nginx.conf

很适合：

nginx 报第几行语法错误
shell 脚本报某一行
yaml 报某一行格式错误

4.9 临时查看命令输出

1	git diff \| nano -

这里的 - 表示从标准输入读取。

这个用法适合：

临时查看输出
复制一段内容
先人工读一下再决定怎么改

5. 常用启动参数

下面这些选项，和配置文件编辑关系最大。

5.1 显示行号

1	nano -l file.txt

5.2 只读打开

1	nano -v file.txt

5.3 启用鼠标

1	nano -m file.txt

5.4 软换行显示超长行

1	nano -S file.txt

它只是显示成多行，不会真的写入换行。

5.5 自动创建备份

1	nano -B file.txt

5.6 自动缩进

1	nano -i file.txt

5.7 Tab 转空格

1	nano -E file.txt

这个对很多配置文件有帮助，但要注意：

对 Makefile 这类严格依赖 Tab 的文件要小心

5.8 记住光标位置

1	nano -P file.txt

5.9 打开时定位到指定行列

1	nano +120,8 file.txt

6. 推荐的 `.nanorc`

如果你主要是用 nano 改配置文件，我建议用一份偏实用、偏稳的配置。

用户配置文件通常是：

~/.nanorc

推荐示例：

set linenumbers
set mouse
set autoindent
set softwrap
set atblanks
set historylog
set positionlog
set indicator
set minibar

include "/usr/share/nano/*.nanorc"

这些配置的含义：

set linenumbers：显示行号
set mouse：启用鼠标
set autoindent：新行自动继承缩进
set softwrap：超长行按屏幕宽度显示
set atblanks：软换行优先在空白处分行
set historylog：记住搜索和替换历史
set positionlog：记住上次光标位置
set indicator：右侧显示滚动指示
set minibar：底栏信息更紧凑
include "/usr/share/nano/*.nanorc"：启用系统语法高亮

6.1 一个更保守的版本

如果你不喜欢软换行，也可以用这个：

set linenumbers
set mouse
set autoindent
set historylog
set positionlog
set indicator

include "/usr/share/nano/*.nanorc"

这更适合：

代码片段
yaml
不想看到长行自动换屏的场景

7. WSL / SSH 里的常见问题

7.1 终端粘贴和 Nano 粘贴不是一回事

这是最常见的坑。

nano 内部的剪切与粘贴是：

Ctrl+K
Ctrl+U

终端自己的系统粘贴通常是：

Ctrl+Shift+V
鼠标右键

不要把这两套逻辑混在一起。

7.2 `Ctrl+C` 在传统 Nano 里不是复制

传统 nano 中：

Ctrl+C 通常是显示当前位置等状态信息
不是复制

所以最稳妥的复制方式仍然是：

选区后按 Alt+6

7.3 Alt 键不工作怎么办

有些终端里 Alt 不会直接传进去。

可以尝试：

按一次 Esc，再按目标键
检查终端是否把 Alt 用作菜单快捷键
在终端里打开“Alt 作为 Meta 发送”之类的选项

7.4 `nano -S` 只是显示换行，不是真的插入换行

这个点很重要。

1	nano -S file.txt

只是为了让超长行看起来更容易读，不会真的改写文件内容结构。

7.5 关键配置建议先留备份

改重要系统配置前，优先考虑：

1	nano -B file.txt

或者你自己先复制一份：

1	cp file.txt file.txt.bak

8. Vim 极简附录

这一节只是为了防止你偶尔遇到 vim，不是为了让你系统学习它。

如果你并不想用 vim，其实只记下面几个就够了：

i        进入输入模式
Esc      回普通模式
:wq      保存并退出
:q!      不保存退出
/text    搜索
dd       删除当前行

一句话理解：

nano 更适合“改配置文件”
vim 更适合“长期高频文本操作”

既然你写代码本来就会用专门编辑器，那这里不用花太多精力。

9. 我的建议

如果你的目标已经很明确：

写代码用专门编辑器
终端里只想快速改配置

那我建议就是：

把 nano 用熟
把上面的速查表记住
把 .nanorc 配起来
遇到 vim 时只会退出就够了

对你这种使用方式来说，最值得练熟的不是一整套 vim，而是这几个 nano 动作：

打开文件
搜索
替换
跳行
保存
退出

这已经足够覆盖大多数配置文件场景。

WezTerm Guide：Windows 和 macOS 的入门、配置与日常工作流

2026-03-16T16:00:00.000Z

WezTerm 这两年基本成了我最愿意推荐给开发者的终端之一：配置文件化、标签页和分屏能力强、跨平台一致性也不错。

但很多教程有两个问题：要么只讲“怎么装”，要么一上来就把配置堆得很满。对大多数人来说，真正需要的不是一份炫技配置，而是一套稳定可落地的起步方案。

这篇文章把 Windows 和 macOS 放在一起写，目标很直接：先让你用起来，再决定要不要继续折腾。

一、先讲清楚：WezTerm 是什么，不是什么

WezTerm 是终端模拟器，不是 shell。

你可以把它理解成两层：

WezTerm：窗口、标签页、分屏、渲染、快捷键、主题
Shell：真正执行命令的环境，比如 Windows 上的 PowerShell，macOS 上的 zsh

所以“我想把 WezTerm 配成 PowerShell / zsh”这句话，更准确地说是：

用 WezTerm 作为终端界面
用 PowerShell 或 zsh 作为默认 shell

这个区分很重要，因为后面很多配置项其实都是围绕这两层展开的。

二、为什么我会推荐 WezTerm

和系统自带终端相比，WezTerm 最实用的优势有 4 个：

配置文件就是 ~/.wezterm.lua，适合版本管理和渐进调整。
默认就有很强的标签页、分屏、搜索和复制粘贴能力。
Windows / macOS / Linux 的整体体验比较统一，换机器成本低。
改完配置可以直接重载，不需要每次去找图形设置界面。

如果你是开发者，尤其经常需要同时跑服务、看日志、连远程机器，它会比“能用就行”的终端更顺手。

三、先用最稳的思路，不要一开始就过度定制

我更建议按这个顺序上手：

第一步：先确定默认 shell
第二步：先选一个稳定深色主题
第三步：先用官方默认快捷键
第四步：一周后再决定要不要改键位、字体和状态栏

原因很简单：

shell 是工作流核心，先稳定
主题影响阅读舒适度，先解决
快捷键属于肌肉记忆，改太早容易把自己弄乱

如果你当前目标只是“日常开发能稳定用”，那这套路径比一上来抄一份 200 行配置更有效。

四、Windows：最适合大多数人的起步方案

1）安装与配置文件位置

Windows 上装好 WezTerm 后，默认配置文件通常放在：

%USERPROFILE%\.wezterm.lua

例如：

C:\Users\<你的用户名>\.wezterm.lua

改完配置后，推荐用 Ctrl+Shift+R 重载；不行再完全重启 WezTerm。

2）Windows 推荐默认组合

如果你不想折腾，最稳的默认组合是：

终端：WezTerm
默认 shell：powershell.exe -NoLogo
主题：Tokyo Night Storm
快捷键：官方默认

之所以先推荐 powershell.exe，不是因为它最强，而是因为它通常最稳定。pwsh.exe 当然更现代，但 profile、模块、环境变量一旦有历史包袱，排错成本会更高。

3）一份够用的 Windows 配置

local wezterm = require("wezterm")

return {
  color_scheme = "Tokyo Night Storm",
  window_background_opacity = 0.92,
  text_background_opacity = 1.0,

  enable_tab_bar = true,
  hide_tab_bar_if_only_one_tab = true,
  use_fancy_tab_bar = false,
  tab_max_width = 32,
  window_padding = { left = 8, right = 8, top = 6, bottom = 6 },

  default_prog = { "powershell.exe", "-NoLogo" },
  exit_behavior = "Close",
  scrollback_lines = 8000,
  adjust_window_size_when_changing_font_size = false,

  launch_menu = {
    { label = "Windows PowerShell", args = { "powershell.exe", "-NoLogo" } },
    { label = "PowerShell 7", args = { "pwsh.exe", "-NoLogo", "-NoProfile" } },
    { label = "Command Prompt", args = { "cmd.exe" } },
  },
}

这份配置的重点不是“炫”，而是稳：

深色主题，提升长期阅读舒适度
轻微透明和边距，界面更松弛
默认用 powershell.exe
保留 launch_menu，需要时再手动切到 pwsh 或 cmd

4）Windows 日常最常用快捷键

新建标签页：Ctrl+Shift+T
关闭当前标签页：Ctrl+Shift+W
新建窗口：Ctrl+Shift+N
复制：Ctrl+Shift+C
粘贴：Ctrl+Shift+V
搜索输出：Ctrl+Shift+F
重载配置：Ctrl+Shift+R

分屏常见默认键位：

水平分屏：Ctrl+Shift+Alt+"
垂直分屏：Ctrl+Shift+Alt+%

如果你的键盘布局和这两个符号位置不一致，不用慌，这在 Windows 上很常见。

5）Windows 常见坑

最典型的三个问题：

配了系统里没有的字体，导致启动时报字体错误
把 pwsh.exe 设成默认后，profile 报错直接退出
改了配置但没重载，误以为配置没生效

我的建议是：

刚开始先不要配字体
默认 shell 先用 powershell.exe
任何修改先按 Ctrl+Shift+R 再判断

五、macOS：更自然的组合是 WezTerm + zsh

1）安装与配置文件位置

macOS 最省事的安装方式是 Homebrew：

1	brew install --cask wezterm

配置文件位置是：

~/.wezterm.lua

例如：

/Users/<你的用户名>/.wezterm.lua

改完配置后，推荐按 Command+Shift+R 重载。

2）macOS 推荐默认组合

Mac 上最自然的起步方案通常是：

终端：WezTerm
默认 shell：/bin/zsh -l
主题：Tokyo Night Storm
快捷键：官方默认

之所以推荐 zsh -l，是因为它更贴近 macOS 的默认行为。很多用户的 PATH、Homebrew 初始化、代理配置、别名和提示符，都是在 shell login 过程里建立起来的。

3）一份够用的 macOS 配置

local wezterm = require("wezterm")

return {
  color_scheme = "Tokyo Night Storm",
  window_background_opacity = 0.95,
  text_background_opacity = 1.0,

  enable_tab_bar = true,
  hide_tab_bar_if_only_one_tab = true,
  use_fancy_tab_bar = false,
  tab_max_width = 32,
  window_padding = { left = 8, right = 8, top = 6, bottom = 6 },

  default_prog = { "/bin/zsh", "-l" },
  exit_behavior = "Close",
  scrollback_lines = 10000,
  adjust_window_size_when_changing_font_size = false,

  launch_menu = {
    { label = "zsh", args = { "/bin/zsh", "-l" } },
    { label = "bash", args = { "/bin/bash", "-l" } },
  },
}

如果你还装了 fish、pwsh 之类的 shell，再把它们补进 launch_menu 就行。需要注意的是，Homebrew 在 Apple Silicon 和 Intel Mac 上的安装路径不同：

Apple Silicon 常见是 /opt/homebrew/bin
Intel Mac 常见是 /usr/local/bin

4）macOS 日常最常用快捷键

macOS 下很多高频操作优先用 Command，也就是 WezTerm 文档里的 SUPER：

新建标签页：Command+T
关闭当前标签页：Command+W
新建窗口：Command+N
复制：Command+C
粘贴：Command+V
搜索输出：Command+F
放大字体：Command+=
缩小字体：Command+-
重置字体：Command+0
重载配置：Command+Shift+R

要特别注意：

Ctrl+C 在终端里通常还是中断当前进程，不是复制
分屏默认键位通常仍是 Ctrl+Shift+Alt+" 和 Ctrl+Shift+Alt+%

5）macOS 常见坑

最常见的不是 WezTerm 本身出问题，而是 shell 路径没配对：

default_prog 指向了不存在的可执行文件
Homebrew shell 的路径写成了另一种架构的目录
你以为在跟随系统默认 shell，其实手动写死了 default_prog

遇到这类问题时，先用下面几个命令确认路径：

echo $SHELL
which zsh
which bash
which fish
which pwsh

六、一个很容易踩的真实问题：Windows 下图片粘贴为什么总是不稳定

如果你在 Windows 上用 WezTerm 跑终端类 AI 工具，比如 opencode，很可能会遇到一个很拧巴的问题：

在 VSCode 插件里，截图后直接粘贴图片基本没问题
但在 PowerShell、WezTerm、Windows Terminal 里运行同一个工具时，Ctrl+V 经常没反应，或者只能粘贴文本
更麻烦的是，它偶尔又会成功，于是问题看起来像“随机故障”

这个现象特别容易让人误判成：模型不支持图片、CLI 不支持图片、或者 PowerShell 有问题。实际上，这几个方向大多都不是根因。

1）先把责任边界分清楚

这里至少有三层：

WezTerm / Windows Terminal：terminal emulator，决定很多按键先由谁处理
PowerShell / cmd：shell，负责命令执行环境
opencode 这类 TUI/CLI 应用：真正实现图片附件能力的前台程序

关键点在于：Ctrl+V 在终端环境里，通常优先表示普通文本粘贴；而图片粘贴往往是应用层收到某个快捷键后，再自己去读取系统剪贴板图片。

所以“文本 paste”和“图片附件”不是同一种能力，它们本来就不在同一层。

2）为什么 VSCode 插件能行，终端里却经常不行

因为两边拿到的根本不是同一种输入语义。

VSCode 这类 GUI 环境拿到的是更高层的 paste event，里面可能直接包含：

文本
HTML
图片
文件

终端前台程序拿到的通常却只是：

某个按键被按下
某段文本被 paste 进来
一些控制序列

这也是为什么 GUI 插件处理图片会显得很自然，而终端里的图片粘贴经常需要额外设计快捷键。

3）WezTerm 里最典型的冲突长什么样

如果你的 WezTerm 配置里写过这种映射：

1	{ key = "v", mods = "CTRL", action = wezterm.action.PasteFrom("Clipboard") }

它的实际含义就是：

Ctrl+V 先由 WezTerm 接管
WezTerm 执行的是普通剪贴板文本粘贴
前台应用未必还能拿到这个按键机会

结果就是：

文本粘贴通常没问题
但依赖“应用自己读图片剪贴板”的那条链路更难触发

这类问题最容易出现在你已经把 Ctrl+V 训练成高频文本粘贴键，同时又希望同一个组合键顺手承担图片附件语义的时候。

4）一个更稳定的做法：把文本和图片拆开

我最后更推荐的分工是：

Ctrl+V：保留给普通文本粘贴
Alt+V：交给应用处理图片粘贴
Ctrl+Alt+V：作为备用图片粘贴键

验证方法也很直接：

用 Win+Shift+S 截图
聚焦到目标 CLI 工具的输入区
按 Alt+V

如果输入区出现类似 [Image 1] 这样的占位，基本就能说明：

模型本身支持图片
应用本身支持图片
真正的问题是 Ctrl+V 在 terminal 和 app 之间的职责冲突

这也是我现在更认同的结论：在终端世界里，文本和图片分不同快捷键，不是 workaround，而是更符合输入模型的工程化方案。

5）把这件事和 WezTerm 的定位联系起来

这件事也顺手说明了一个很重要的使用原则：

WezTerm 很强，但它首先是 terminal，不是 GUI 插件宿主
它能很好地处理文本流、按键和控制序列
它可以帮你透传按键、改键位、做工作流编排
但它不会自动把系统剪贴板图片变成某个 TUI 应用内部的附件对象

所以，如果你的工作流里文本粘贴远高于图片粘贴，最稳的策略通常就是：

不要为了低频图片场景牺牲高频 Ctrl+V
单独给图片粘贴设计一个应用层快捷键
对图片重度依赖时，也接受 GUI 插件在体验上天然更占优势

七、跨平台都适用的配置理解

不管是 Windows 还是 macOS，真正最值得理解的是这几类配置项：

1）外观相关

color_scheme：主题名称
window_background_opacity：窗口背景透明度
text_background_opacity：文本背景透明度
window_padding：内容和边缘的留白

建议：

先固定一个深色主题，不要频繁切换
透明度轻一点就够了，过高会影响阅读

2）标签页相关

enable_tab_bar
hide_tab_bar_if_only_one_tab
use_fancy_tab_bar
tab_max_width

起步阶段我更推荐：

开启标签栏
单标签时自动隐藏
关闭 fancy tab bar，保持简洁

3）启动相关

default_prog：默认启动哪个 shell
default_cwd：默认目录（Windows 更常用）
launch_menu：新建标签或窗口时可选启动项
exit_behavior：最后进程退出时窗口怎么处理

如果你希望配置长期稳定，launch_menu 很值得加。它能让“主力 shell 稳定”和“保留其他入口”同时成立。

4）体验相关

scrollback_lines：历史输出回滚行数
adjust_window_size_when_changing_font_size：调字号时是否改变窗口尺寸

一般来说：

8000-20000 行足够大多数开发场景
关闭字号联动改窗体尺寸，体验更稳定

八、我建议的上手路径：三阶段就够了

阶段 A：先稳定用起来

只保留默认 shell、深色主题、官方快捷键
熟悉标签页、复制粘贴、搜索、分屏

阶段 B：只加少量增强

增加 2-4 个高频键位
增加 launch_menu
根据阅读习惯微调透明度、边距、滚动回溯行数

阶段 C：最后再做重度定制

字体与 fallback
状态栏与 workspace
leader key
启动时自动布局

这一阶段当然很爽，但并不是“好用”的前提。

九、两套我更推荐的模板

如果你只想抄一份能用的配置，可以直接从下面两套开始。

Windows 模板

local wezterm = require("wezterm")

return {
  color_scheme = "Tokyo Night Storm",
  window_background_opacity = 0.92,
  text_background_opacity = 1.0,
  enable_tab_bar = true,
  hide_tab_bar_if_only_one_tab = true,
  use_fancy_tab_bar = false,
  tab_max_width = 32,
  window_padding = { left = 8, right = 8, top = 6, bottom = 6 },
  default_prog = { "powershell.exe", "-NoLogo" },
  exit_behavior = "Close",
  scrollback_lines = 8000,
  adjust_window_size_when_changing_font_size = false,
}

macOS 模板

local wezterm = require("wezterm")

return {
  color_scheme = "Tokyo Night Storm",
  window_background_opacity = 0.95,
  text_background_opacity = 1.0,
  enable_tab_bar = true,
  hide_tab_bar_if_only_one_tab = true,
  use_fancy_tab_bar = false,
  tab_max_width = 32,
  window_padding = { left = 8, right = 8, top = 6, bottom = 6 },
  default_prog = { "/bin/zsh", "-l" },
  exit_behavior = "Close",
  scrollback_lines = 10000,
  adjust_window_size_when_changing_font_size = false,
}

十、最后给一个很实际的建议

很多人喜欢问：“WezTerm 最强配置是什么？”

我现在更认同另一种问法：你每天最常做的 3 件终端操作是什么？

如果你的答案是：

开项目
跑服务
看日志

那你真正需要的往往只有这些：

稳定的默认 shell
好读的主题
够用的标签页和分屏
不打架的快捷键

先把这 4 件事配好，WezTerm 就已经足够成为主力终端了。剩下的高级玩法，等你真的需要时再加，完全不晚。

OpenCode 实战指南（2026）：从能用到好用

2026-03-14T16:00:00.000Z

最近我把 OpenCode 当成主力 coding agent 在用。网上已经有不少“功能总览”文章，但很多内容像产品说明书：信息全，落地弱。

这篇我按“真实开发流程”重写一版，重点是：你今天装好后，怎么在项目里稳定产出，而不是只会敲 /help。

图源：OpenCode 官方文档 Intro 页

一、先讲结论：OpenCode 适合什么人

如果你符合下面 3 条中的 2 条，OpenCode 会比“IDE 内嵌 AI 聊天框”更好用：

你愿意在终端里工作，接受命令行思维。
你希望 agent 不止回答问题，还能“读写文件 + 跑命令 + 调外部工具”。
你在意可控性（权限、规则、可审计、可自动化），而不是“一键魔法”。

简单理解：

Cursor/Copilot 更像“编辑器里增强写代码”。
OpenCode 更像“可编排的工程代理平台”。

二、安装与启动：3 分钟跑起来

官方安装方式很多，这里只保留常用命令。

# 一键安装
curl -fsSL https://opencode.ai/install | bash

# 或者 npm 全局安装
npm install -g opencode-ai

启动方式：

# 在当前目录启动 TUI
opencode

# 指定项目目录
opencode /path/to/project

# 非交互执行（脚本/CI 常用）
opencode run "Explain this repository architecture"

第一次进入建议按这个顺序：

/connect 配 provider。
/models 选模型。
/init 让它生成项目 AGENTS.md。

/init 非常关键，它决定 agent 在你的仓库里是不是“懂规矩”。

三、你每天最常用的 6 个能力（带场景）

1) `@文件`：把上下文喂准

1	解释一下 @src/api/auth.ts 的刷新 token 流程

它会把文件内容注入上下文，避免 agent 在大仓库里“猜”。

2) `!命令`：把终端输出直接回填

1 2	!git status !npm run build

适合把“报错现场”直接给 agent，不需要复制粘贴。

3) `/undo` + `/redo`：可逆编辑

OpenCode 的撤销/重做依赖 Git（仓库必须是 git repo）。

/undo：撤回最后一次消息及其文件修改。
/redo：恢复撤销的内容。

这个是我敢让 agent 改代码的底气之一。

4) `/compact`：上下文太长时续命

长会话一定会碰到 token 压力。/compact 可以保留关键状态，压掉无关历史。

5) `/details`：审计工具调用

你怀疑 agent 为什么做出某个修改时，打开 /details 看它调了哪些工具、传了什么参数。

6) `/editor`：写长 prompt 时救命

复杂任务建议进外部编辑器写需求（尤其是带验收标准时）。

1	export EDITOR="code --wait"

四、从“会用”到“好用”的关键：Plan -> Build

很多人一上来就让 agent 直接改，结果是：能改，但经常改偏。

更稳的流程：

用 plan 模式先产方案（默认对 edit/bash 更谨慎）。
人工确认边界、风险点。
切回 build 模式执行。

你可以把它想成：

plan = 资深同事做方案评审。
build = 开工落地并提交可运行结果。

一个实用 prompt：

先不要改代码。先给我：
1) 受影响文件清单
2) 迁移步骤
3) 风险点和回滚策略
4) 最小验证命令

五、CLI 子命令怎么选（不是每次都开 TUI）

适合人机协作：TUI

opencode

适合自动化脚本：`run`

1	opencode run "review latest changes and suggest improvements"

适合服务化：`serve` / `web`

1 2	opencode serve opencode web

适合远程附着：`attach`

1	opencode attach http://127.0.0.1:4096

适合 MCP 管理：`opencode mcp ...`

opencode mcp add
opencode mcp list
opencode mcp auth 
opencode mcp debug

适合会话与成本复盘

1 2	opencode session list opencode stats --days 7 --models 10

六、权限系统：让 agent “能干活但不乱来”

权限只有三种动作：

allow：直接执行
ask：执行前确认
deny：拒绝

推荐起步策略：高风险工具 ask，低风险默认 allow。

{
  "$schema": "https://opencode.ai/config.json",
  "permission": {
    "*": "ask",
    "read": "allow",
    "bash": {
      "*": "ask",
      "git status*": "allow",
      "git diff*": "allow",
      "npm run build*": "allow",
      "rm *": "deny"
    },
    "edit": "ask",
    "webfetch": "allow"
  }
}

两个容易被忽略的点：

规则是“最后匹配生效”（last match wins）。
external_directory 和 doom_loop 是额外安全阀，默认建议保留 ask。

七、MCP 才是 OpenCode 的上限（结合你的组合）

你现在这组 context7 + gh_grep + exa 很实用，我建议按“信息可靠性分层”用：

官方定义先走 context7。
真实代码范式走 gh_grep。
时效信息补充走 exa。

一个可直接用的 MCP 配置示例

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp"
    },
    "gh_grep": {
      "type": "remote",
      "url": "https://mcp.grep.app"
    }
  },
  "permission": {
    "context7_*": "allow",
    "gh_grep_*": "allow",
    "websearch": "allow"
  }
}

如果你要启用 Exa Web Search（按官方说明）：

1	OPENCODE_ENABLE_EXA=1 opencode

八、把“低幻觉”流程写进提示词

你原文里这个思路非常对，我给你扩展成可复用模板。

请按以下顺序回答：
1) 先用 context7 给官方文档结论，并附文档链接。
2) 再用 gh_grep 给 2-3 个真实仓库代码示例（附仓库路径）。
3) 若涉及时效性信息，再用 exa 补充，并标注检索时间。
4) 最后给出“我在当前项目该怎么做”的最小落地步骤。

这样做的好处是：

你能看见“依据链”，不是只看结论。
讨论能落到“可执行步骤”，不是空话。

九、Rules：为什么 `AGENTS.md` 值得认真写

OpenCode 会读项目规则文件。你把规则写清楚，等于在降低返工率。

建议 AGENTS.md 至少包含：

构建/测试命令（尤其单测命令）。
目录边界（哪些文件夹可改，哪些只读）。
代码风格和命名规范。
提交与验证标准。

在团队里，AGENTS.md 其实就是“给 agent 的 CONTRIBUTING.md”。

十、分享与安全：能分享，但默认要克制

/share 很方便做协作复盘，但要注意链接是公开可访问。

建议默认：

1
2
3

{
  "share": "manual"
}

涉敏项目直接：

1
2
3

{
  "share": "disabled"
}

另外，跑 serve / web 时建议加基本鉴权：

1 2	export OPENCODE_SERVER_PASSWORD="your-strong-password" export OPENCODE_SERVER_USERNAME="opencode"

十一、一个我自己更推荐的 `opencode.json` 起步模板

下面这份配置偏“日常开发安全默认 + MCP 增强”。

{
  "$schema": "https://opencode.ai/config.json",
  "model": "heiyucode/gpt-5.3-codex",
  "small_model": "heiyucode/gpt-5.4",
  "share": "manual",
  "permission": {
    "read": "allow",
    "webfetch": "allow",
    "websearch": "allow",
    "edit": "ask",
    "bash": {
      "*": "ask",
      "git status*": "allow",
      "git diff*": "allow",
      "npm run build*": "allow",
      "rm *": "deny",
      "git push *": "ask"
    }
  },
  "agent": {
    "plan": {
      "permission": {
        "edit": "ask",
        "bash": "ask"
      }
    }
  },
  "instructions": [
    "AGENTS.md"
  ]
}

你可以再按项目微调，比如把 npm test* 放开，或者把某些目录的 edit 设为 deny。

十二、一个完整任务示例（端到端）

目标：给博客项目加“文章字数统计”并验证部署。

建议流程：

plan 模式描述需求和约束。
明确“只改 source/ 与 root config，不改主题子模块”。
build 模式执行修改。
跑 npm run build 验证。
人工抽查页面。
最后再 npm run deploy。

对应 prompt（可直接改后复用）：

先进入 plan 模式，不要改代码。
目标：给 Hexo 博客增加文章字数与阅读时长展示。
约束：优先改 root config 或内容，不修改 themes/stellar 子模块。
请先输出：
1) 变更文件清单
2) 风险点
3) 验证步骤
确认后我再让你切 build 执行。

十三、常见坑（我自己踩过）

没写规则就开干：结果是 agent 改了你不想改的目录。
权限全 allow：短期爽，长期会有不可控风险。
MCP 开太多：上下文被工具说明吃掉，反而变慢变贵。
不做会话压缩：长会话后期质量明显下降。
只要答案，不要依据：最后很难判断对错，只能“凭感觉相信”。

十四、最后的使用建议（针对你这种重度用户）

如果你已经在稳定使用 OpenCode，我建议把目标从“会用命令”升级到“可复制的工作流”：

固化 AGENTS.md（项目规则）。
固化 opencode.json（权限与模型策略）。
固化提问模板（context7 -> gh_grep -> exa）。
固化验收步骤（build/test/lint/手工检查）。

当这 4 件事稳定后，OpenCode 就不只是“AI 助手”，而是你工程流程的一部分。

参考资料（官方）

Intro: https://opencode.ai/docs/
TUI: https://opencode.ai/docs/tui/
CLI: https://opencode.ai/docs/cli/
Config: https://opencode.ai/docs/config/
Tools: https://opencode.ai/docs/tools/
Permissions: https://opencode.ai/docs/permissions/
Agents: https://opencode.ai/docs/agents/
Commands: https://opencode.ai/docs/commands/
MCP Servers: https://opencode.ai/docs/mcp-servers/

OneApp 性能与架构优化方案（内存与模块化）

2026-01-28T16:00:00.000Z

本方案包含三部分：性能与内存优化理论、架构改造（模块化完善）与内存优化实战，并补充性能监控方案、成本与风险评估。

理论基础：内存模型、排查方法与治理策略

1) 内存构成（跨端共识）

Flutter/Dart：Dart Heap、Native Heap、GPU 纹理、ImageCache、Skia 资源
Android：Java Heap、Native
Heap、Graphics/GL、Ashmem/匿名共享、文件映射
iOS：Heap、VM、Metal/纹理、ImageIO 解码缓存

2) 常见内存问题类型

泄漏：对象生命周期失控，无法被 GC/ARC 回收
峰值过高：大图、视频、批量解析造成瞬时激增
缓存失控：图片/列表/业务缓存无上限或无 TTL
碎片与抖动：高频创建大对象导致频繁 GC/ARC

3) 使用 DevTools 排查内存问题（流程化）

基线建立：进入核心场景（首页、车控、地图/媒体、个人中心）分别记录内存曲线与峰值
事件复现：复现场景触发后，观察内存是否回落到基线附近
快照对比：多次快照对比，锁定增长中的对象类型与数量
引用链分析：定位“谁在持有对象”，找出未释放的根因
GC 验证：触发 GC 后仍不回落，优先排查泄漏与缓存失控
输出结论：标注对象类型、持有链路、场景、复现步骤与修复建议

3.1) 内存自动化回归（AirtestIDE）

目标
- 替代人工点击，稳定复现核心场景并采集内存曲线
- 形成可重复的回归路径与对比基线
脚本覆盖
- 首页 → 车控 → 地图/媒体 → 个人中心 → 返回首页
- 前后台切换、列表滚动、资源密集操作路径
采集策略
- 启动前清理缓存，保证基线一致
- 场景进入与退出分别记录峰值与回落
- 与内存告警联动，定位异常场景
产出物
- Airtest 脚本与用例集
- 自动化内存基线报告与回归对比报告

4) 僵尸对象与内存不释放的判断方法

僵尸对象特征：页面退出后对象仍在内存中、数量持续上升、被全局单例或静态集合持有
常见来源：未取消订阅、缓存未清理、生命周期未对齐、异步任务回调未释放
判断方式：同场景多次进入退出，观察对象数量是否线性增长
处理策略：明确生命周期边界、集中释放入口、限制缓存上限、引入弱引用或定时清理

5) 解决思路的优先级

限制缓存上限与生命周期（优先）
下采样与降规格加载（优先）
资源释放与生命周期治理（优先）
计算迁移与异步分批处理（中）
架构层优化与模块拆分（长期）

6) 性能监控方案（内存与卡顿）

指标体系
- 内存：PSS、Dart Heap、Native Heap、峰值与稳定值、低内存告警次数
- 卡顿：FPS、Jank 帧占比、平均/90 分位帧耗时、UI/渲染线程耗时、GC 频次
- 体验：页面首帧时间、路由切换耗时、列表滑动掉帧率
- 稳定性：OOM、Crash、页面白屏/卡死
采集策略
- 核心场景高频采样，非核心场景抽样采集
- 前后台切换、页面进出、资源密集操作、帧耗时异常触发关键事件
上报链路
- 本地缓存 + 批量上报 + 失败重试
- 与现有内存告警联动，形成“告警—定位—修复—验证”闭环
产出物
- 基线报告、卡顿场景榜单、专项优化清单、回归对比报告

7) 代码层面的漏洞与泄漏高发点（排查清单）

生命周期与订阅
- StreamSubscription/RxDart/EventBus 未取消订阅
- Timer/Isolate/Compute 任务未停止或回收
- MethodChannel/EventChannel 监听未释放
控制器与资源
- AnimationController/ScrollController/TextEditingController/FocusNode
  未 dispose
- 视频/地图/纹理资源未 stop/destroy
缓存与引用
- 单例/静态集合持有 BuildContext/Widget/State
- 图片/业务缓存无上限或无 TTL，列表 keepAlive 过度使用
主线程阻塞
- 大 JSON 解析/排序/解码在主线程执行
- 同步磁盘 IO 或大量 setState/重建导致帧耗时激增

排查要点

同场景多次进入退出，对象数量应稳定或回落
退出页面后仍增长的对象，优先回溯持有链与订阅源
发生卡顿时定位长帧对应的函数与调用链，先移出主线程

8) 常见内存问题与解决方案（摘要）

图片与纹理占用过大 → 统一下采样、限制缓存上限、资源按需加载
列表长期驻留 → 分页与复用、减少 keepAlive、页面退出清理
业务缓存失控 → TTL 与容量上限、冷热分层、统一清理入口
异步任务未释放 → 统一取消订阅与回调清理
资源引擎未释放 → 提供 destroy/stop 入口并强制调用

9) 验收标准（以基线报告为准）

内存指标
- 核心场景峰值下降、退场后回落至基线区间
- 低内存告警次数显著下降
卡顿指标
- 核心场景 Jank 帧占比下降、长帧数量显著降低
- 滑动与路由切换场景的帧耗时回落至基线区间
稳定性指标
- OOM 与相关 Crash 明显下降
过程指标
- 形成可复用的排查流程与问题归因闭环
- 代码层泄漏清单闭环，关键模块释放入口覆盖率提升

架构改造：模块化完善（高内聚低耦合）

1) 模块分层与依赖方向

basic_*：基础设施层，只依赖基础能力，不依赖业务
kit_*：通用工具与能力，允许被 app_*/clr_* 依赖
ui_*：UI 组件层，不依赖 app_*，仅依赖 basic_*/kit_*
clr_*：服务 SDK 层，对外暴露 Facade，内部可依赖 basic_*/kit_*
app_*：业务模块层，只依赖
basic_*/kit_*/ui_*/clr_*，禁止互相强依赖

现有模块依赖关系图（基于 pubspec.yaml 扫描）

应用入口与本地模块归属

graph TB
    subgraph 应用入口层
        MAIN[oneapp_main]
    end

    subgraph 业务模块
        ACC[app_account]
        SET[app_setting]
        COM[oneapp_community]
        MEM[oneapp_membership]
        AFTER[oneapp_after_sales]
        CAR_SALES[oneapp_car_sales]
        TP[oneapp_touch_point]
    end

    subgraph 服务组件
        CONF[app_configuration]
        COMP[oneapp_companion]
        POPUP[oneapp_popup]
        SHARE[share_to_friends]
    end

    subgraph 车辆相关
        CAR[app_car]
        CHARGE[app_charging]
        WALLBOX[app_wallbox]
        WATCH[app_carwatcher]
        AVATAR[app_avatar]
        ORDER[app_order]
        TOUCHGO[app_touchgo]
        VUR[app_vur]
        MAINT[app_maintenance]
        RPA[app_rpa]
        COMPOSER[app_composer]
    end

    MAIN --> ACC
    MAIN --> SET
    MAIN --> COM
    MAIN --> MEM
    MAIN --> AFTER
    MAIN --> CAR_SALES
    MAIN --> TP
    MAIN --> CONF
    MAIN --> COMP
    MAIN --> POPUP
    MAIN --> SHARE
    MAIN --> CAR
    MAIN --> CHARGE
    MAIN --> WALLBOX
    MAIN --> WATCH
    MAIN --> AVATAR
    MAIN --> ORDER
    MAIN --> TOUCHGO
    MAIN --> VUR
    MAIN --> MAINT
    MAIN --> RPA
    MAIN --> COMPOSER

业务模块内部依赖

graph TB
    COM[oneapp_community] --> MEM[oneapp_membership]
    COM --> CAR_SALES[oneapp_car_sales]
    COM --> TP[oneapp_touch_point]
    COM --> AFTER[oneapp_after_sales]
    COM --> SHARE[share_to_friends]

    MEM --> COM
    MEM --> AFTER
    MEM --> ACC[app_account]

    CAR_SALES --> CONF[app_configuration]
    CAR_SALES --> AFTER
    CAR_SALES --> TP

    CONF --> CAR_SALES

    SET[app_setting] --> MEM

业务模块与 CLR 依赖

graph TB
    subgraph 业务模块
        ACC[app_account]
        SET[app_setting]
        AFTER[oneapp_after_sales]
        CONF[app_configuration]
        COMP[oneapp_companion]
    end

    subgraph CLR
        MNO_C[clr_mno]
        SET_C[clr_setting]
        MEDIA_C[clr_media]
        GEO_C[clr_geo]
        CONF_C[clr_configuration]
        COMP_C[clr_companion]
    end

    ACC --> MNO_C
    SET --> SET_C
    SET --> MEDIA_C
    AFTER --> GEO_C
    CONF --> CONF_C
    COMP --> COMP_C

车辆模块与 CLR 依赖

graph TB
    subgraph 车辆模块
        CAR[app_car]
        CHARGE[app_charging]
        MAINT[app_maintenance]
        WATCH[app_carwatcher]
        AVATAR[app_avatar]
        ORDER[app_order]
        TOUCHGO[app_touchgo]
    end

    subgraph CLR
        GEO_C[clr_geo]
        CHARGE_C[clr_charging]
        MAINT_C[clr_maintenance]
        WATCH_C[clr_carwatcher]
        TOUCHGO_C[clr_touchgo]
        ORDER_C[clr_order]
        PAY_C[clr_payment]
        ACC_C[clr_account]
        MNO_C[clr_mno]
        VOICE_C[clr_voiceclone]
    end

    CAR --> GEO_C
    CAR --> CHARGE_C
    CAR --> MNO_C

    CHARGE --> CHARGE_C
    CHARGE --> GEO_C
    CHARGE --> PAY_C

    MAINT --> MAINT_C
    MAINT --> GEO_C

    WATCH --> WATCH_C
    WATCH --> GEO_C

    AVATAR --> ORDER_C
    AVATAR --> PAY_C
    AVATAR --> VOICE_C

    ORDER --> ORDER_C
    ORDER --> PAY_C
    ORDER --> ACC_C

    TOUCHGO --> GEO_C
    TOUCHGO --> TOUCHGO_C

UI 模块与 CLR 依赖

graph TB
    subgraph UI
        UI_BASIC[ui_basic]
        UI_BUSINESS[ui_business]
    end

    subgraph CLR
        GEO_C[clr_geo]
        MSG_C[clr_message]
    end

    UI_BUSINESS --> GEO_C
    UI_BUSINESS --> MSG_C

2) 当前存在的问题

版本治理
- 大量使用 dependency_overrides，反映依赖版本冲突与治理缺失
- 本地路径依赖多，模块版本同步与冲突解决成本高
构建效率
- 模块数量多且粒度偏小，构建时间长，增量构建收益不足
依赖关系
- 部分模块间存在潜在循环依赖风险
- 业务模块彼此直接引用内部实现，边界不清晰

3) 改善目标

版本治理统一化：逐步消灭 dependency_overrides，统一基础依赖版本
边界与解耦强化：业务模块只经由 Facade/Service
接口交互，禁止跨层直接依赖
模块粒度优化：合并过小、强相关模块，提升构建与维护效率
构建效率提升：缩短全量构建时间，引入更明确的增量构建策略
依赖安全：杜绝循环依赖，建立依赖白名单/黑名单与审计机制

4) 模块边界与接口约束

每个模块必须提供唯一对外入口（如 lib/.dart）
模块内部代码禁止被外部直接 import（通过导出文件统一暴露）
业务模块之间通过接口或事件解耦，禁止直接访问彼此内部实现

5) 模块自闭环能力要求

模块内部完成“接口 + 实现 + 测试”闭环
公共能力上收至 basic_*/kit_*，避免横向复制
业务模块内禁止重复定义通用模型与工具类

6) 依赖治理与版本策略

统一基础依赖版本，逐步减少 dependency_overrides
建立模块依赖白名单与黑名单规则
每个模块提供版本变更说明与兼容策略

7) 模块化完善具体方案（落地步骤）

依赖梳理：输出模块依赖关系图与循环依赖清单
依赖拆解：识别横向耦合点，抽取到 basic_*/kit_*
接口对齐：模块外只通过 Facade/Service 访问
路由收敛：模块内自注册路由，外部只调用入口
回归验证：每次迁移只影响单模块，确保低风险落地

8) 模块化完善的验收清单

app_* 之间无直接依赖
ui_* 不依赖任何业务模块
clr_* 仅暴露 Facade API
basic_*/kit_* 不依赖业务模块
模块版本与依赖版本统一可追溯
构建指标达标：全量构建时间下降、增量构建命中率提升
依赖指标达标：dependency_overrides 清零或极少量、循环依赖为零

1. 内存优化（基于现有代码）

入口内存告警联动（应用主入口使用 MemoryWatcher）
- 代码位置：[app_widget.dart:L312-L337]

Widget _createApp() => MemoryWatcher(
  memoryWarningLine: minWarningFreeMemory,
  onMemoryWarning: () {
    pushFacade.postEvent(topic: memoryPressureTopic);
    OneAppConfigHandler.instance.clearMemory();
  },
  child: MaterialApp.router(
    builder: FlutterSmartDialog.init(),
    key: ContextProvider.globalKey,
    onGenerateTitle: (context) => AppIntlDelegate.of(context).appTitle,
    title: 'ID. UX',
    theme: themeFacade.theme.ofStandard().themeData,
    routeInformationParser: Modular.routeInformationParser,
    routerDelegate: Modular.routerDelegate,
    scrollBehavior: _NoGlowingBehavior(),
  ).routerIntlConfig(
    _supportLocale,
    _localizationsDelegates,
  ),
);

系统内存压力回调与全局缓存清理
- 代码位置：[app_config_handler.dart:L57-L78]

@override
void didHaveMemoryPressure() {
  Logger.w("app_config: didHaveMemoryPressure", LogTag_App);
  if (currentAppState != AppLifecycleState.resumed) {
    Logger.d("app_config: in background, not clear");
    return;
  }
  if (!OneDeviceInfoUtil.isLowMemoryIOSDevice()) {
    Logger.d("app_config: not need clear");
    return;
  }
  clearMemory();
  super.didHaveMemoryPressure();
}

void clearMemory() {
  PaintingBinding.instance.imageCache.clear();
  DefaultCacheManager manager = DefaultCacheManager();
  manager.store.emptyMemoryCache(); //clears all data in cache.
}

设置模块缓存清理
- 代码位置：[clear_cache_util.dart]

static Future<bool> clear() async {
  final Directory tempDir = await getTemporaryDirectory();
  await _delete(tempDir);
  String locale = Intl.getCurrentLocale();
  String environment = AppEnvironmentConfig.getCurEnvironment().toString().split('.').last;
  String componetJsonCacheKey1 = 'Component_${ComponentPageCode.DISCOVER}_${locale}_${environment}';
  String componetJsonCacheKey2 = 'Component_${ComponentPageCode.COMMUNITY}_${locale}_${environment}';
  await clearSpCahceByKeys([componetJsonCacheKey1, componetJsonCacheKey2]);
  return true;
}

账号模块内存缓存清理
- 代码位置：[garage_facade_impl.dart:L395-L401]

@override
Future<void> clearCache() async {
  Logger.i('$_tagPrefix#clearCache: calling', clrAccountTag);
  await encryptedModuleBox.delete(vehicleCacheKey);
  _memoryCache.clear();
  _defaultVehicle = null;
}

原生资源释放（AvatarX 模块）
- 代码位置：[AvatarxManager.swift:L685-L696]

func destroy() {
    FUAvatarHelper.destroy()
    FURenderKit.destroy()
    FUAIKit.destroy()
    FUAIKit.unloadAllAIMode()
    removeDisplayView()
    initResource = false
    isLoadDefaultBundle = false
}

1.1 现状缺口（基于仓库检索）

未找到全局 ImageCache 上限的真实配置代码
未找到统一的图片下采样封装入口
未找到 Isolate 大计算通用封装入口
Android/iOS 侧缺少统一的缓存限额策略代码

1.2 直接可做的补齐任务（基于现有框架）

在应用入口补齐 ImageCache 上限配置，挂载在已有 MemoryWatcher
初始化流程中
基于现有 DefaultCacheManager 清理逻辑，补齐业务级缓存 TTL
与最大内存占用
增加图片加载统一封装（业务模块只用封装入口，不直接 Image.network）
对耗时解析/批量处理提供统一异步处理入口

2. Android 内存优化（现状与补齐）

2.1 现状

当前仓库中未检索到 Android 侧的 onTrimMemory/onLowMemory、Bitmap
下采样、LruCache 等内存治理实现代码。现阶段内存清理主要集中在 Flutter
层与业务缓存逻辑。

2.2 补齐方向（基于现有架构可落地）

在 Android Application 级别接入内存回调并驱动缓存清理
为高频图片/视频模块补齐下采样与缓存限额策略
统一原生缓存上限与回收入口，供 Flutter 侧触发

3. iOS 内存优化（现状与补齐）

3.1 现状

iOS 低内存设备识别已在基础能力中实现，用于清理策略判断
- 代码位置：[one_device_info_util.dart:L27-L49]

static bool isLowMemoryIOSDevice() {
  switch (oneDeviceType) {
    case OneDeviceType.iPhone_7:
    case OneDeviceType.iPhone_7_Plus:
    case OneDeviceType.iPhone_8:
    case OneDeviceType.iPhone_8_Plus:
    case OneDeviceType.iPhone_X:
    case OneDeviceType.iPhone_XS:
    case OneDeviceType.iPhone_XS_MAX:
    case OneDeviceType.iPhone_XR:
    case OneDeviceType.iPhone_11:
    case OneDeviceType.iPhone_11_Pro:
    case OneDeviceType.iPhone_11_Pro_Max:
    case OneDeviceType.iPhone_SE_2:
    case OneDeviceType.iPhone_12_mini:
    case OneDeviceType.iPhone_12:
    case OneDeviceType.iPhone_13_mini:
    case OneDeviceType.iPhone_13:
    case OneDeviceType.iPhone_SE_3:
      return true;
    default:
      return false;
  }
}

3.2 补齐方向

统一 iOS 侧图片/模型资源下采样入口
统一 NSCache/LRU 上限并与 Flutter 清理逻辑联动

4. 统一缓存治理（跨端，基于现状的改造点）

现状清理入口：OneAppConfigHandler.clearMemory() 已在内存告警触发时执行
- 代码位置：[app_config_handler.dart:L73-L77]
业务缓存清理入口：设置模块提供清理临时目录与组件缓存逻辑
- 代码位置：[clear_cache_util.dart]

5. 落地改造优先级（基于现有代码的下一步）

在应用入口补齐 ImageCache 上限配置，接入现有 MemoryWatcher
业务缓存统一 TTL 与内存上限，复用 DefaultCacheManager 清理入口
引入统一图片加载封装，替换业务模块直接 Image.network 使用
对批量解析/重计算提供统一异步处理入口
Android/iOS 侧补齐统一的内存回调与缓存上限策略

6. 成本与风险评估（结合当前项目）

低成本/低风险
- 缓存清理入口统一、内存告警联动优化、生命周期释放规范化
中成本/中风险
- 图片加载统一封装、缓存策略统一、模块依赖治理
高成本/高风险
- 核心业务模块重构、原生侧深度改造、三端基础库大版本升级

7. 结合当前项目的建议行动

先做基线：以核心场景建立内存基线与峰值对照表
先修高收益：围绕内存告警链路与缓存清理入口做闭环
再做结构性优化：模块边界治理、依赖统一、缓存策略统一

OneApp 鸿蒙（HarmonyOS）工作步骤文档

2026-01-28T16:00:00.000Z

Step 0：前置约束与目标确认（必做）

目标
- 在不破坏 Android/iOS 现有架构的前提下新增 HarmonyOS 支持
- 首版功能可裁剪、可降级
约束
- 不重写 Flutter 业务代码
- 业务模块不得直接依赖平台插件
- 鸿蒙首版不要求功能全量对齐
产出
- 《鸿蒙首版功能白名单》
- 《不支持/延后支持模块清单》

Step 1：插件与平台能力盘点（P0）

1.1 插件全量清点
- 对现有 Flutter 插件形成“插件→使用模块→平台支持矩阵”
- 核心关注：地图/定位、推送、支付、存储、设备信息、媒体、车控
- 产出：《插件→模块→平台支持矩阵表》
1.2 插件分级（强制）
- L0：纯 Dart（直接复用）
- L1：轻平台（需补鸿蒙实现）
- L2：重平台（能力抽象 + 原生实现）
- L3：强绑定（首版可能不支持）
- 产出：《插件分级治理表》

Step 2：平台能力抽象（架构改造核心，P0）

新增 Platform Capability Layer（统一能力抽象包）
- 目录建议：
  - packages/platform_capability/{geo,push,payment,car_control,media,device,storage}
- 定义跨端接口（示例）
  - GeoCapability.getLocation(), PushCapability.subscribe(),
    PaymentCapability.pay()
- 强制规则
  - 业务模块不依赖任何平台插件
  - CLR 不直接引用 Android/iOS/HarmonyOS SDK
  - 所有平台能力通过 Capability 接口访问
  - Capability Interface 禁止暴露 Platform
    类型（Context/Ability/Activity）
- 产出：Capability 接口定义、依赖调整方案

Step 2A：模块化适配约束（Harmony 优先）

基础设施层（basic_*）
- 原则：尽量纯 Dart 实现，避免依赖任何原生平台能力
- 目的：降低平台适配成本，保障 Harmony 接入可持续
工具与组件层（kit_*/ui_*）
- 原则：不直接依赖平台插件；如需平台能力，必须经 Capability
- 目的：保持 UI/工具层跨端一致性
服务连接层（clr_*）
- 原则：仅通过 Capability 访问平台能力，不直接引用 Android/iOS/Harmony
  SDK
- 目的：统一平台差异收敛点，避免平台污染
业务模块层（app_*）
- 原则：只依赖 basic_*/kit_*/ui_*/clr_*，禁止互相强依赖
- 目的：保证模块边界清晰、可裁剪、可灰度

验收要点

basic_* 不含原生依赖
kit_*/ui_* 不出现 Platform 类型（Context/Ability/Activity）
clr_* 仅调用 Capability 接口
app_* 无跨层直接依赖

Step 3：CLR 模块改造（P0–P1）

去插件化
- 将 clr_* 模块中的“直接插件/Native SDK 调用”替换为 Capability 调用
- 适配模块：clr_geo、clr_account、clr_message、clr_charging、clr_touchgo、clr_wallbox、clr_carwatcher
- Before：CLR → Plugin → Native
- After：CLR → Capability → Platform Impl
- 产出：CLR 重构完成，Android/iOS Capability 实现保持不变

Step 4：HarmonyOS 宿主工程与 Flutter 引擎接入（P0）

4.1 宿主工程结构（建议）
- Flutter 业务代码保持唯一真源
- HarmonyOS 宿主与 Android/iOS 宿主同级或并列目录即可
- 示例结构
  - oneapp/
    - flutter/
      - lib/
      - packages/
      - pubspec.yaml
    - host_android/
    - host_ios/
    - host_harmony/
- 产出：《鸿蒙宿主工程结构与路径规范》
4.2 HarmonyOS 启动流程与参数策略
- Harmony 宿主决定“给 Flutter 什么参数”
- 启动流程
  - Harmony Ability
  - 初始化 Flutter Engine
  - 注入启动参数（appMode/featureFlags）
  - runApp(main.dart)
- 最小启动策略（首版）
  - 只做三件事：启动 Engine、注册最小插件集合、指定初始路由
  - 启动参数语义
    - appMode：应用形态（如 harmonyLite）
    - featureFlags：模块开关（如 map/pay/carControl）
  - Harmony 宿主在 Engine 初始化阶段向 Flutter 注入启动参数
  - Flutter 启动后通过统一入口获取启动参数
  - Flutter 层保持完整 App，只是能力不可用或返回 not supported
  - iOS/Android 不改动，默认无 args
- 产出：《Harmony 启动参数规范》《最小插件集合清单》

Step 5：HarmonyOS 原生能力实现（P1）

Capability 的鸿蒙实现
- Geo → Map Kit
- Push → Push Kit
- Payment → IAP
- Storage → Preferences
- Device/Media/CarControl → 系统/厂商 API
- 通过 MethodChannel 暴露给 Flutter
- 产出：鸿蒙 Capability 实现代码（Flutter 侧透明）

Step 6：模块级功能适配与裁剪（P1–P2）

首版必保模块（建议）
- oneapp_main、app_home、oneapp_account
- clr_account / clr_geo / clr_message
- app_car / app_charging（基础能力）
可延后模块
- app_avatar、app_rpa、app_vur、3D/AI/音视频增强模块
策略
- 模块级 feature flag
- UI 隐藏 / 功能降级
- 产出：鸿蒙首版功能闭环

Step 7：分阶段落地顺序（强执行）

阶段 1（POC）
- 新建 host_harmony
- Flutter 首页跑通
- 只接入：网络、存储、账号
- 产出：鸿蒙最小可运行包
阶段 2（核心可用）
- 跑通：app_home、app_discover、clr_account、clr_message
- UI 完整，部分按钮 disabled 或降级
- 产出：核心场景闭环
阶段 3（逐模块放开）
- 每新增模块：宿主补插件、Flutter 放 feature flag、打通 clr → app
- 启动参数示例
  - appMode: “harmonyLite”
  - featureFlags: { map: false, pay: false, carControl: false }
- 产出：模块级逐步放量清单

Step 8：多宿主构建与 CI 约束（P1）

约束
- flutter/ 目录为唯一真源
- host_harmony 仅负责 Engine 初始化与插件注册
- Flutter 代码不得 import host_harmony 相关实现
- Capability 必须有 Android/iOS 默认实现
产出
- Flutter lint / 构建校验规则

Step 9：测试与稳定性验证（P2）

测试重点
- Flutter 启动稳定性
- MethodChannel 调用一致性
- 权限 / 生命周期
- 弱网 / 异常兜底
真机测试（必须）
- 至少 2–3 款鸿蒙设备
- 不以 Emulator 结论替代真机结果
- 产出：测试报告与问题清单

Step 10：上架与合规检查（P2）

审核重点
- 权限最小化
- 无动态代码下载
- SDK 合规（华为生态）
发布
- 华为应用市场
- 首版灰度发布
- 产出：合规材料与发布记录

附录：可视化补充（可直接插入评审材料）

附录 A：多宿主 + Flutter 架构示意

            ┌───────────────┐
            │   Flutter UI  │
            │   lib/*       │
            └───────┬───────┘
                    │ Capability 接口
    ┌───────────────┴─────────────────┐
    │                                 │
┌───▼─────────┐                   ┌───▼─────────┐
│  Android    │                   │   iOS       │
│ Platform Impl│                  │ Platform Impl│
└─────────────┘                   └─────────────┘
                    │
                    │
            ┌───────▼───────────┐
            │ HarmonyOS Platform│
            │ Impl (ArkTS/Java) │
            └───────────────────┘

Flutter 层唯一真源，业务模块不依赖平台
Capability 层统一接口访问原生能力
HarmonyOS / Android / iOS 只提供实现

附录 B：HarmonyOS 启动流程图

┌─────────────────┐
│ Harmony Ability  │
└─────────┬───────┘
          │ 初始化 Flutter Engine
          ▼
┌─────────────────────────┐
│ 注入启动参数 initialArgs │
│ appMode / featureFlags   │
└─────────┬───────────────┘
          │ 注册最小插件集合
          ▼
┌───────────────────┐
│ runApp(main.dart) │
│ Flutter 层启动     │
└───────────────────┘

初版策略：只启动 Engine、注册最小插件、指定初始路由
Flutter 层保持完整 App，可根据 featureFlags 降级模块

附录 C：Feature Flags 可视化表

模块	首版状态	功能降级 / UI 隐藏
map	false	隐藏地图按钮
pay	false	禁用支付入口
carControl	false	禁止操作车辆
oneapp_main	true	-
app_home	true	-
oneapp_account	true	-
clr_account	true	-
clr_geo	true	-

启动参数示例：

{
  "appMode": "harmonyLite",
  "featureFlags": {
      "map": false,
      "pay": false,
      "carControl": false
  }
}

附录 D：分阶段落地甘特/流程示意

阶段 1：POC (新建 host_harmony)
 ├─ Flutter 首页跑通
 ├─ 最小插件集合
 └─ 网络 / 存储 / 账号模块可用

阶段 2：核心可用
 ├─ app_home、app_discover
 ├─ clr_account / clr_message
 └─ UI 完整，部分按钮 disabled

阶段 3：逐模块放开
 ├─ 每新增模块宿主补插件
 ├─ Flutter 放 feature flag
 └─ 打通 clr → app

阶段对应产出：

POC → 鸿蒙最小可运行包
核心可用 → 核心场景闭环
模块放开 → 模块级逐步放量清单

参考资料（官方）

HarmonyOS
开发者官网：https://developer.harmonyos.com
OpenHarmony
文档中心：https://docs.openharmony.cn
DevEco
Studio（IDE）：https://developer.huawei.com/consumer/cn/deveco-studio
华为应用市场审核规范：https://developer.huawei.com/consumer/cn/doc/app

React 学习参考

2024-12-24T05:52:28.479Z

以下是一些推荐的文字资源，可以帮助你深入学习 React 的原理和应用：

1. 官方文档

React 官方文档: 尽管你觉得内容较浅，但它仍然是学习 React 的基础，尤其是对核心概念的理解。
- React 官方文档

2. 书籍

《React - Up & Running》 - Stoyan Stefanov 著，适合想要快速上手和理解 React 的开发者。
《Learning React》 - Alex Banks 和 Eve Porcello 著，涵盖了 React 的基本概念和一些高级特性。
《Fullstack React: The Complete Guide to ReactJS, Redux, and Friends》 - 详细介绍了 React 的各个方面，包括 Redux 和其他相关技术。
《React Design Patterns and Best Practices》 - Michele Bertoli 著，深入探讨了 React 的设计模式和最佳实践。

3. 博客和文章

Overreacted: Dan Abramov 的博客，涵盖了许多 React 的深层次概念和最佳实践。
- Overreacted Blog
CSS-Tricks: 提供了许多关于 React 的实用文章和示例。
- CSS-Tricks React Articles
Smashing Magazine: 提供了一些深入的技术文章，涵盖 React 和前端开发的各种主题。
- Smashing Magazine React Articles

4. GitHub 和开源项目

React GitHub 仓库: 查看 React 的源代码，理解其实现原理。
- React GitHub
Awesome React: 一个 GitHub 上的资源集合，包含许多学习资源和开源项目。
- Awesome React

5. 在线教程

FreeCodeCamp: 提供了免费的文本教程，涵盖 React 和其他前端技术。
- FreeCodeCamp React Tutorial
MDN Web Docs: Mozilla 的开发者网络提供了关于 JavaScript 和前端开发的全面文档。
- MDN Web Docs

6. 论坛和社区

Dev.to: 一个开发者社区，许多开发者在这里分享他们的经验和教程。
- Dev.to React
Stack Overflow: 通过提问和回答问题，深入理解具体的技术难题。

7. 实践项目

构建项目: 实际动手构建项目是学习的最好方式。可以尝试构建一个简单的应用（如待办事项列表、博客等），并逐步加入更复杂的功能。

总结

通过结合以上文字资源，你可以更深入地理解 React 的原理和应用场景。建议从基础开始，逐渐深入到高级主题，并通过实践来巩固所学知识。如果你有特定的主题或问题需要深入了解，请随时告诉我！

React原理的简单介绍

当然可以！以下是对 React 原理的简要介绍，帮助你理解其背后的核心概念。

1. 组件化

组件是 React 的基本构建块。每个组件都是一个独立的、可复用的 UI 单元。
组件可以是类组件或函数组件，函数组件更为常用，尤其是结合 Hooks 使用时。

2. 虚拟 DOM

React 使用 虚拟 DOM 来提高性能。虚拟 DOM 是 React 在内存中维护的一个轻量级的 DOM 表示。
当组件的状态发生变化时，React 会首先在虚拟 DOM 中进行更新，然后通过比较算法（称为 Diffing）找出需要更新的部分，最后只将这些更改应用到实际的 DOM 中。

3. 单向数据流

React 遵循 单向数据流 的原则，数据从父组件流向子组件。这种方式使得数据流动更加可预测，便于管理和调试。
父组件通过 props 将数据传递给子组件，子组件不能直接修改父组件的数据。

4. 状态管理

组件的 状态（state） 是组件内部管理的数据。状态的变化会触发组件的重新渲染。
React 提供了 useState 和 useReducer Hooks 来管理状态，类组件则使用 this.state 和 this.setState()。

5. 生命周期

组件的生命周期分为挂载、更新和卸载三个阶段。React 提供了一些生命周期方法（如 componentDidMount、componentDidUpdate 和 componentWillUnmount）来处理这些阶段。
在函数组件中，可以使用 useEffect Hook 来处理副作用，类似于类组件的生命周期方法。

6. Hooks

Hooks 是 React 16.8 引入的特性，允许在函数组件中使用状态和其他 React 特性。
常用的 Hooks 包括：
- useState: 管理组件状态。
- useEffect: 处理副作用（如数据获取、订阅等）。
- useContext: 访问上下文数据。

7. 上下文 API

上下文 API 提供了一种在组件树中共享数据的方法，而不必通过每层组件传递 props。
使用 React.createContext 创建上下文，Provider 组件提供数据，Consumer 组件或 useContext Hook 访问数据。

8. 性能优化

React 提供了一些性能优化的手段，例如：
- React.memo: 用于优化函数组件的渲染，避免不必要的更新。
- shouldComponentUpdate: 在类组件中控制组件的更新。
- useMemo 和 useCallback: 用于优化计算和函数引用的性能。

总结

React 的原理围绕组件化、虚拟 DOM、单向数据流和状态管理等核心概念展开。理解这些原理将帮助你更有效地使用 React，并在实际开发中解决各种问题。如果你有更具体的方面需要深入了解，请告诉我！

广州马拉松

2024-12-12T09:12:20.000Z

马拉松中签

今年挺幸运的，第二轮的补录，中签了广州马拉松。作为全国的大满贯赛事，我还是很希望广州马拉松能够中签的，毕竟武汉马拉松连续4年没有中。

时间过得挺快的，不知不觉上一篇已经是3年前了。

今年跑步一点都不积极，月跑量可能只有20KM左右。

本来中签了孝感马拉松，但是那天我身体状态不好直接放弃了。

然后在广州马拉松开赛前的三周，我每周的跑量都是40左右，这个已经是我能够做到的极限了。

跑步是一个时间成本很高的运动，需要大量的时间。

起点

顺利完赛

作为我的第一次马拉松（全马），我很认真准备了三周，最后一周的周日跑了一个21公里。

三周的训练时间，每个周末都会拉一个长距离，15KM -> 18KM -> 21KM，逐渐加长。

所以我对35KM是有信心完成的，后面的就不知道了，跑之前的计划是，35公里之后走一半跑一半，5小时内完赛就是胜利✌🏻

比赛当日的广州天气很好，温度很合适，而且有风，风也不大。

但是最后的8公里确实让人绝望，35KM之后的每一公里都是痛苦面具。

不过最后的成绩跟我预料的相差不大。

成绩

完赛前的视频

Your browser does not support the video tag.

夜游广州

多年后来到广州，重新去了珠江边，上了珠江边的那个发着光的大桥。

当然首先是吃了一个晚饭，或者说中饭。因为我拿到赛事大礼包的时候已经3点多了，将近4点。

米粒和夕夕

大桥可以联通到珠江中间的二沙岛，二沙岛旁边就是马拉松的终点 - 海心沙

远远看去，那座桥像鹊桥一样，勾勒出一个很好看的弧形一直延伸到珠江中间的岛上。

因为桥的轮廓是发着光的，很有未来科技的感觉，反而是珠江中间的海心沙，融入黑暗中，让人感觉这座发光的鹊桥横跨了黑暗，一路延伸。

米粒

长隆野生动物园

第二天约好了一起去长隆野生动物园，不过因为要补课要12点才能下课，我们只能中午吃完饭之后出发，到达长隆的时候已经是2点多了。

我好像从没去过长隆，以前在广州的时候没有机会体验这些。

长隆有一点类似迪士尼的样子，不过长隆把几个乐园分开了，欢乐世界、水上乐园、野生动物园。同样的，门票也分开了，相比于迪士尼的599，还是相对便宜的，也只是相对便宜而已！

长隆野生动物园还是非常适合小孩子的，坐着小火车穿越丛林、草原，非洲的、美洲的，还有亚洲的动物都可以看见。

那些狮子老虎居然躺在山上看着我们，我们可以在小火车上跟狮子遥相对望。不过狮子们好像对我们没有兴趣，它们是我们的风景，我们也是他们的风景。

每每去动物园看这些，我都会想起一个电影《楚门的世界》。这个世界好像一个巨大的楚门的世界，每个人都在表演，表演活着，表演高兴、悲伤、痛苦，以及生离死别。

非洲大草原

做完火车之后就可以自由选择路线了，有的孩子愿意去青龙山看蛇和恐龙，由于之前有一个小朋友被恐龙吓哭了，我们就不去看恐龙了。

另外一条路线可以看花车游行，还可以看见大熊猫，看完大熊猫可以坐缆车回去。

花车游行的时候我抱着小米粒，所以没办法拍视频，只有米粒和八戒的合照🙂🙂🙂

米粒和八戒

后面游行完之后还有看大熊猫，三胞胎的大兄弟，全国也只有这一对。

但是这个时候我已经是困得不行了，加上看熊猫的人太热情了，人巨多，最后我累倒在一个小游乐场的餐桌前。

我只记得我趴着睡着了，睡醒的时候已经天黑了。小朋友们还很有激情，看着转转的飞天座椅，兴冲冲的排队。

结果在关门前的最后一轮，被挡在了前面，没有成功上去。

小朋友吃完了零食和冰淇淋，只能很失望的下山了。

返程

返程日的天气真好，阳光明媚的。

完赛之后大概是12点半，阳台晒在身上懒洋洋的，像一个调皮的孩子在你的皮肤上打滚，或者开心的在上面跳舞。

从海心沙走到地铁站真的好远啊，我跑完了42公里，还要走半个小时才能到地铁站。

从广州塔出来，阳光更舒服了，基本上可以穿着短袖短裤享受阳光。

米粒和广州塔

在广州塔玩耍了几个小时，到了吃饭的点，吃完饭就该去赶火车了。

这个时候身体已经冷下来了，右腿一脚不能弯曲了，一弯曲就疼的不行，基本上只能一瘸一拐的走路。

综合我的训练量，这个结果是必然的，最后的8公里已经超出了我的能力极限。

广马是什么？

是无数颗心不舍昼夜

是无数颗心不舍昼夜共同书写的一场

关于热爱和信念的伟大篇章

是讲述不完的一个个故事

是分享不完的一串串感动

----是

“我们的力量”

乡土中国

2021-09-14T16:00:00.000Z

《乡土中国》是社会学的经典书，可以说是经典中的经典，也是所有研究中国的人必读的一本书。

这本书讲的是中国人的社会操作系统，是研究中国人复杂思维非常重要的一块基石，

一、乡土本色

中国基层社会是“乡土性的”。“乡土性”对应着自古以来人们对土地的依附和“不流动”。
从历史的角度：“我们的民族确是和泥土分不开的了。
从土里长出过光荣的历史，自然也会受到土的束缚…”
从地理的角度：“农业和游牧或工业不同，它是直接取资于土地的。游牧的人可以逐水草而居，飘忽无定；做工业的人可以择地而居，迁移无碍；而种地的人却搬不动地，长在土里的庄稼行动不得，侍候庄稼的老农也因之像是半身插入了土里，土气是因为不流动而发生的。”
“不流动”是指中国农村以村落为单位彼此孤立隔绝。
“不流动是从人和空间的关系上说的，从人和人在空间的排列关系上说就是孤立和隔膜。孤立和隔膜并不是以个人为单位的，而是以住在一处的集团为单位的。”
中国农村聚村而居大致由于4个原因：小农经营下屋舍与农田较近、共用水力设施的需要、安全的需要、土地不断继承积累。
在缺乏流动性的乡土社会，每个人从出生便被嵌入了熟人社会的网络。
“乡土社会在地方性的限制下成了生于斯、死于斯的社会。常态的生活是终老是乡。…这是一个“熟悉”的社会，没有陌生人的社会。”
传统熟人社会依靠习俗和人与人之间的了解维系，与现代社会所讲的规则和契约精神产生了冲突。
“在一个熟悉的社会中，我们会得到从心所欲而不逾规矩的自由。这和法律所保障的自由不同。规矩不是法律，规矩是“习”出来的礼俗。从俗即是从心。换一句话说，社会和个人在这里通了家。”
“乡土社会的信用并不是对契约的重视，而是发生于对一种行为的规矩熟悉到不假思索时的可靠性。”

“这种办法在一个陌生人面前是无法应用的。在我们社会的急速变迁中，从乡土社会进入现代社会的过程中，我们在乡土社会中所养成的生活方式处处产生了流弊。陌生人所组成的现代社会是无法用乡土社会的习俗来应付的。”

二、文字下乡（空间尺度上文字在乡村的价值）

乡下人与城里人知识结构不尽相同，易产生乡下人“愚”的误解。
“乡下多文盲”与熟人社会下运用“特殊语言”比文字间接表意更有效有关。面对面能解决的事不必诉诸文字。
“特殊语言”不过是亲密社群中所使用的象征体系的一部分，用声音来作象征的那一部分。在亲密社群中可用来作象征体系的原料比较多。表情、动作，在面对面的情境中，有时比声音更容易传情达意。
“特殊语言”常是特别有效，因为它可以摆脱字句的固定意义。语言像是个社会定下的筛子，如果我们有一种情意和这筛子的格子不同也就漏不过去。
“在乡土社会中，不但文字是多余的，连语言都并不是传达情意的唯一象征体系。”
文字下乡需要结合现实情况。
“我决不是说我们不必推行文字下乡，在现代化的过程中，我们已经开始抛离乡土社会，文字是现代化的工具。我要辨明的是乡土社会中的文盲，并非出于乡下人的“愚”，而是由于乡土社会的本质。

而且我还愿意进一步说，单从文字和语言的角度中去批判一个社会中人和人的了解程度是不够的，因为文字和语言，只是传情达意的一种工具，并非唯一的工具；而且这工具本身也是有缺陷的，能传的情、能达的意是有限的。

所以提倡文字下乡的人，必须先考虑到文字和语言的基础。”

三、再论文字下乡（时间尺度上文字在乡村的价值）

人靠一套象征体系来存储记忆，因为人凭借记忆积累的过去的经验对现在的生活有益。而对集体而言，共同的记忆就是文化。
“文化是依赖象征体系和个人的记忆而维护着的社会共同经验。”
这套象征体系中最重要的就是“词”，但“词”不等于“文”，前者是文化存续的前提而后者不是。
“我们不断地在学习时说着话，把具体的情境抽象成一套能普遍应用的概念，概念必然是用词来表现的，于是我们靠着词，使我们从特殊走上普遍，在个别情境中搭下了桥梁；又使我们从当前走到今后，在片刻情境中搭下了桥梁。”
“没有象征体系也就没有概念，人的经验也就不能或不易在时间里累积”
“但是词却不一定要文。文是用眼睛可以看得到的符号，就是字。词不一定是刻出来或写出来的符号，也可以是用声音说出来的符号，语言。一切文化中不能没有“词”，可是不一定有“文字”。”
乡土社会的人日出而作日落而息生活定型，乡土社会的历史轨迹也是一条直线，语言足以传递代际经验，不需要文字了。而文字既不产生于基层也不属于基层乡土社会。所以只有在乡土性的基层发生了变化后，文字才能下乡。
“当一个人碰着生活上的问题时，他必然能在一个比他年长的人那里问得到解决这问题的有效办法，因为大家在同一环境里，走同一道路，他先走，你后走；后走的所踏的是先走的人的脚印，口口相传，不会有遗漏。哪里用得着文字？时间里没有阻隔，拉得十分紧，全部文化可以在亲子之间传授无缺。”

四、差序格局（划重点）

在中国，由“私”引起的社会问题很普遍，“私”与“差序格局”密切相关。
“一说是公家的，差不多就是说大家可以占一点便宜的意思，有权利而没有义务了。”
“于是像格兰亨姆的公律，坏钱驱逐好钱一般，公德心就在这里被自私心驱走。”（外在激励与自我利益最大化）
“所谓贪污无能，并不是每个人绝对的能力问题，而是相对的，是从个人对公家的服务和责任上说的。”
与西方社会界限分明的“团体格局”不同，中国的“差序格局”下，团体的界限并不清晰，无论是在亲属关系还是地缘关系中，团体以个人为中心，其覆盖范围是任意的，正如投石入水激起的涟漪。
“这个网络像个蜘蛛的网，有一个中心，就是自己。我们每个人都有这么一个以亲属关系布出去的网，但是没有一个网所罩住的人是相同的。在一个社会里的人可以用同一个体系来记认他们的亲属，所同的只是这体系罢了。体系是抽象的格局”
“中国人也特别对世态炎凉有感触，正因为这富于伸缩的社会圈子会因中心势力的变化而大小。”
正是因为团体界限不清晰，我们乡土社会讲交情而不是权利。
“在孩子成年了住在家里都得给父母膳食费的西洋社会里，大家承认团体的界限。在团体里的有一定的资格。资格取消了就得走出这个团体。在他们不是人情冷热的问题，而是权利问题。在西洋社会里争的是权利，而在我们却是攀关系、讲交情。”
正是因为以“己”为中心，乡土社会利己的自我主义突出。
“在个人主义下，一方面是平等观念，指在同一团体中各分子的地位相等，个人不能侵犯大家的权利；一方面是宪法观念，指团体不能抹煞个人，只能在个人们所愿意交出的一分权利上控制个人。

这些观念必须先假定了团体的存在。在我们中国传统思想里是没有这一套的，因为我们所有的是自我主义，一切价值是以“己”作为中心的主义。”
与西方不同，乡土社会的“公”与“私”是相对的，不利于现代国家观念的形成。
“国是皇帝之家，界线从来就是不清不楚的，不过是从自己这个中心里推出去的社会势力里的一圈而已。

所以可以着手的，具体的只有己，克己也就成了社会生活中最重要的德行，他们不会去克群，使群不致侵略个人的权利。

在这种差序格局中，是不会发生这问题的。”

五、系维着私人的道德

社会结构或者说社会格局决定社会的道德观念。
“道德观念是在社会里生活的人自觉应当遵守社会行为规范的信念。它包括着行为规范、行为者的信念和社会的制裁。它的内容是人和人关系的行为规范，是依着该社会的格局而决定的。

从社会观点说，道德是社会对个人行为的制裁力，使他们合于规定下的形式行事，用以维持该社会的生存和绵续。”
西方“团体格局”在宗教的影响下形成，“神”象征着团体，人在神前平等，在团体（如国家）中平等享有权利履行义务，没有人可以凌驾于神或团体之上。
“宗教的虔诚和信赖不但是他们道德观念的来源，而且是支持行为规范的力量，是团体的象征。在象征着团体的神的观念下，有着两个重要的派生观念：一是每个个人在神前的平等；一是神对每个个人的公道。”
“可是上帝是在冥冥之中，正象征团体无形的实在；但是在执行团体的意志时，还得有人来代理。“代理者”Minister是团体格局的社会中一个基本的概念。

执行上帝意志的牧师是Minister，执行团体权力的官吏也是Minister，都是“代理者”，而不是神或团体的本身”
中国没有平等爱人的宗教文化，只有以自我为中心的有等级差序的爱，难有统一的公共道德标准，道德依附在私人关系上。
“不但在我们传统道德系统中没有一个像基督教里那种“爱”的观念—不分差序的兼爱；而且我们也很不容易找到个人对于团体的道德要素。

在西洋团体格局的社会中，公务，履行义务，是一个清楚明白的行为规范。而这在中国传统中是没有的。”
“而忠君并不是个人与团体的道德要素，而依旧是对君私之间的关系。

团体道德的缺乏，在公私的冲突里更看得清楚。”
“传统的道德里不另找出一个笼统性的道德观念来，所有的价值标准也不能超脱于差序的人伦而存在了。

中国的道德和法律，都因之得看所施的对象和“自己”的关系而加以程度上的伸缩。”

六、家族

理清本书说述“差序格局”不是指中国没有诸如家庭和氏族等“团体”，而是指“从主要的格局说，在中国乡土社会中，差序格局和社会圈子的组织是比较的重要。”
家庭不仅有生育合作功能，还有组织经济等功能，可以按需要任意伸缩范围，扩大路线一般只按父系，其性质近似与氏族。
“家庭这概念在人类学上有明确的界说：这是个亲子所构成的生育社群。”
“依人类学上的说法，氏族是一个事业组织，再扩大就可以成为一个部落”
“我的假设是中国乡土社会采取了差序格局，利用亲属的伦常去组合社群，经营各种事业，使这基本的家，变成氏族性了。

家的结构不能限于亲子的小组合，必须加以扩大。而且凡是政治、经济、宗教等事物都需要长期绵续性的，这个基本社群决不能像西洋的家庭一般是临时的。

家必须是绵续的，不因个人的长成而分裂，不因个人的死亡而结束，于是家的性质变成了族。氏族本是长期的，和我们的家一般。

我称我们这种社群作小家族，也表示了这种长期性在内，和家庭的临时性相对照。”
“中国的家是一个事业组织，家的大小是依着事业的大小而决定。”
家庭包含了太多生育之外的功能，导致“中国人在感情上，尤其是在两性间的矜持和保留。”

七、男女有别

中国传统感情定向是接受秩序的安排。
“在上篇我说家族在中国的乡土社会里是一个事业社群，凡是做事业的社群，纪律是必须维持的，纪律排斥了私情。”
乡土社会的社会关系生而定型，不需创造新的社会关系，它追求的是稳定，因此“男女间的关系必须有一种安排，使他们之间不发生激动性的感情。那就是男女有别的原则。”
“社会秩序范围着个性，为了秩序的维持，一切足以引起破坏秩序的要素都被遏制着。男女之间的鸿沟从此筑下。乡土社会是个男女有别的社会，也是个安稳的社会。”

八、礼治秩序

“人治”与“法治”的区别不在于有没有法律可依据，而在于“维持秩序时所用的力量，和所根据的规范的性质。”
但无“法”并不会使乡土社会混乱不堪，因为有“礼治”的维系。
“礼是社会公认的行为规范，它本和法律无异，不同之处在于法律是靠国家的权力来推行的，而礼却不需要这样有形的权力机构来维持，维持礼这种规范的是传统。”
“法”由外而内约束人，“礼”由内而外控制人。
“礼并不是靠一个外在的权力来推行的，而是从教化中养成了个人的敬畏感，使人服膺，人服礼是主动的”

九、无讼

传统生活是礼治社会，违背规矩是道德问题，需要的是教育和教化。而现代法治社会讲个人权利，权利不可侵犯，以刑法保护个人的权利和社会的安全。
“但是在乡土社会的礼治秩序中做人，如果不知道“礼”，就成了撒野，没有规矩，简直是个道德问题，不是个好人。一个负责地方秩序的父母官，维持礼治秩序的理想手段是教化，而不是折狱。”
“一个法官并不考虑道德问题、伦理观念，他并不在教化人。刑罚的用意已经不复“以儆效尤”，而是在保护个人的权利和社会的安全。尤其在民法范围里，他并不是在分辨是非，而是在厘定权利。”
法治秩序的建立不能单靠制定若干法律条文和设立若干法庭，还得看人民怎么去应用这些设备。社会结构和思想理念还得先有一番改革。

十、无为政治

权力有两种用途，一是在阶级斗争中平衡冲突的工具，二是支配社会分工。即横暴权力和同意权力。
“冲突的性质并没有消弭，但是武力的阶段过去了，被支配的一方面已认了输，屈服了。但是他们并没有甘心接受胜利者所规定下的条件，非心服也。于是两方面的关系中发生了权力。

权力是维持这关系所必需的手段，它是压迫性质的，是上下之别”

“这种权力的基础是社会契约，是同意。社会分工愈复杂，这权力也愈扩大。”
权力的诱人之处在于它可能带来经济利益，但农业社会被权力征服的团体生产力不高，吸引力不强，但易于被征服。
权力滋长靠内部农业生产力的提高，而和平有利于人口增长和农业社会力量的积聚，所以需要“养民”。
“皇权力求无为，所谓养民。养到一个时候，皇权逐渐累积了一些力量，这力量又刺激皇帝的雄图大略，这种循环也因而复始。
为了皇权自身的维持，在历史的经验中，找到了“无为”的生存价值，确立了无为政治的理想。”

十一、长老统治

中国社会基层存在一种长老式的权力
“既不是横暴性质，也不是同意性质；既不是发生于社会冲突，也不是发生于社会合作；它是发生于社会继替的过程，是教化性的权力，或是说爸爸式的，英文里是Paternalism。”
教化权力没有政治权力的强制性，但由于人人都认可，也形成了一种每个成员都被迫接受的规范。
“所谓社会契约必先假定个人的意志。个人对于这种契约虽则并没有自由解脱的权利，但是这种契约性的规律在形成的过程中，必须尊重各个人的自由意志，民主政治的形式就是综合个人意志和社会强制的结果。

在教化过程中并不发生这个问题，被教化者并没有选择的机会。”
“凡是文化性的，不是政治性的强制都包含这种权力。

文化和政治的区别就在这里：凡是被社会不成问题地加以接受的规范，是文化性的；当一个社会还没有共同接受一套规范，各种意见纷呈，求取临时解决办法的活动是政治。

文化的基础必须是同意的，但文化对于社会的新分子是强制的，是一种教化过程。”
文化性规范不如成文的政治性规范稳定，因此在社会变迁中需要年长者的维系。

十二、血缘和地缘

长幼权力差别形成了血缘社会个人权利义务不同的基础，这种基础与生俱来不可选择。
“缺乏变动的文化里，长幼之间发生了社会的差次，年长的对年幼的具有强制和权力。这是血缘社会的基础。”
“血缘的意思是人和人的权利和义务根据亲属关系来决定。”
血缘与地缘存在联系与冲突。
“血缘是稳定的力量。在稳定的社会中，地缘不过是血缘的投影，不分离的。”
“籍贯只是“血缘的空间投影。”
“地缘是从商业里发展出来的社会关系。血缘是身份社会的基础，而地缘却是契约社会的基础。”
现代社会讲求契约关系，是乡土社会所欠缺的，需要从血缘关系到地缘关系的转变。
“契约的完成是权利义务的清算，须要精密的计算、确当的单位、可靠的媒介。在这里是冷静的考虑，不是感情，于是理性支配着人们的活动—这一切是现代社会的特性，也正是乡土社会所缺的。
从血缘结合转变到地缘结合是社会性质的转变，也是社会史上的一个大转变。”

十三、名实的分离

社会变动分为“社会继替”和“社会变迁”，二者同时存在，但前者更明显，后者由于需求作用不显著。
“社会继替是指人物在固定的社会结构中的流动；社会变迁却是指社会结构本身的变动。这两种过程并不是冲突的，而是同时存在的。”
乡土社会并非绝对静止，在其缓慢的变化中，长老权力在社会继替中壮大在“社会继替”中产生长老权力，如果社会变动得慢，长老权力也就更有势力。
“社会结构的变动是人要它变的，要它变的原因是在它已不能答复人的需要。”
“社会变迁可以吸收在社会继替之中的时候，我们可以称这社会是安定的。”
长老权力在乡土社会生命力极强。
“儒家所注重的“孝”道，其实是维持社会安定的手段，孝的解释是“无违”，那就是承认长老权力。

长老代表传统，遵守传统也就可以无违于父之教。”
“长老权力是建立在教化作用之上的，教化是有知对无知，如果所传递的文化是有效的，被教的自没有反对的必要；如果所传递的文化已经失效，根本也就失去了教化的意义。“反对”在这种关系里是不发生的。”
长老依靠“加入注释”维系权力，而注释的变动可以引起名实之间发生极大的分离。
“长老权力下，传统的形式是不准反对的，但是只要表面上承认这形式，内容却可以经注释而改变。结果不免是口是心非。

在中国旧式家庭中生长的人都明白家长的意志怎样在表面的无违下，事实上被歪曲的。

虚伪在这种情境中不但是无可避免而且是必需的。”

十四、从欲望到需要

乡土社会靠欲望行事能自洽。
“在十九世纪发生了一种理论说，每个人只要能“自私”，那就是充分地满足我们本性里带来的欲望，社会就会形成一个最好、最融洽的秩序。”
“在乡土社会中，这种理论多少可以说是正确的，正确的原因并不是真是有个“冥冥中”的那只手，而是在乡土社会中个人的欲望常是合于人类生存条件的。”
于是乡土社会靠欲望，不像现代社会靠理性和计划。
“在乡土社会中人可以靠欲望去行事，但在现代社会中欲望并不能作为人们行为的指导，于是产生“需要”，因之有了“计划”。从欲望到需要是社会变迁中一个很重要的里程碑。”
乡土社会依赖经验，现代社会依赖知识。
“乡土社会是个传统社会，传统就是经验的累积，能累积就是说经得起自然选择的，各种“错误”—不合于生存条件的行为—被淘汰之后留下的那一套生活方式。不论行为者对于这套方式怎样说法，它们必然是有助于生存的。”
“在现代社会里知识即是权力，因为在这种社会里生活的人要依他们的需要去做计划。从知识里得来的权力是我在上文中所称的时势权力。”

套路真多

2021-08-19T16:00:00.000Z

小说的那些套路

1.落魄大叔爱喝酒，以前肯定是高手。
2.高手厌倦俗世纷争，避世隐居。但往往无论什么杂鱼都知道他隐居到哪儿去了。
3.几拨人同时上山去请一个高手，谁先上去谁倒霉。高手都是跟着最后上去的那拨人走的。
4.大家族里从来不学文化课，整天研究怎么打架，年轻一代天天就盘算着出去强抢民女。就这点出息，见笑了。
5.叶、萧、林、易，四大修真家族，长期为修真界输送着各种优秀人才。
6.统领一方地界的强者，见到少年高手从来不想着笼络，只想着灭口。难怪手下只剩下些弱智。
7.超级废柴划入外门，走上人生巅峰。顶级天才被收为入室弟子，从此暗淡无光。
8.顶级高手的孩子自带GPS，不管小时候扔多远，最后总能找回来。
9.圣女选出来就是为了让人拐跑的。
10.名医给病人治完病往往会顺带把自家闺女搭出去。
11.一个普通人活了几十年学会写字绘画，修身养性。一个修真者修炼数百年满脑子是女人和钱。
12.但凡大家族都有一套特别邪门的武功，用了会短命的那种。
13.著名学院附近多半有树林，树林里必定蹲着一些特别危险的上古魔兽。
14.顶级高手不是二十岁以下的就是几百岁以上的，中间好几代人都在打酱油。
15.高手出招如电如风，但一定会很礼貌地等敌人摆完姿势喊完招式名才动手。
16.无论什么高级毒药都是可以化解的，唯独泻药无解。不管是什么等级的高手，服了泻药没有几个能解掉的。
17.正道长期向魔道输送高级人才魔道长期向正道提供绝世神兵。
18.他是众口相传的绝顶高手，令后辈敬仰的不朽传奇重新出山不到三天,就被新人按在地上暴打。
19.看管门派重地的人都很喜欢私自放人进去。
20.名门大派的后山或者断崖往往藏着一些不得了的东西。
21.有些感觉敏锐的掌门可能会发现，自从某个弟子加入之后，什么寻仇的，叛变的，踢馆的就都找上门了，各种上古魔兽、神级高手排着队来搞事，传说中的丧门星可能真的是存在的。

后续持续更新。。。

乌合之众

2021-07-28T16:00:00.000Z

1.人一到群体中，智商就严重降低，为了获得认同，个体愿意抛弃是非，用智商去换取那份让人备感安全的归属感。

2.我们始终有一种错觉，以为我们的感情源自于我们自己的内心。

3.群体只会干两种事——锦上添花或落井下石。

4.个人一旦成为群体的一员，他所作所为就不会再承担责任，这时每个人都会暴露出自己不受到的约束的一面。群体追求和相信的从来不是什么真相和理性，而是盲从、残忍、偏执和狂热，只知道简单而极端的感情。

5.我们以为自己是理性的，我们以为自己的一举一动都是有其道理的。但事实上，我们的绝大多数日常行为，都是一些我们自己根本无法了解的隐蔽动机的结果。

6.所谓的信仰，它能让一个人变得完全受自己的梦想奴役。

7.在与理性永恒的冲突中，感情从未失过手。

8.有时不真实的东西比真实的东西包含更多的真理。

9.群众没有真正渴求过真理，面对那些不合口味的证据，他们会充耳不闻…凡是能向他们提供幻觉的，都可以很容易地成为他们的主人；凡是让他们幻灭的，都会成为他们的牺牲品。

10.数量，即是正义。

11.掌握了影响群众想象力的艺术，也就掌握了统治他们的艺术。

12.没有传统，就没有文明；没有对传统的缓慢淘汰，就没有进步。

13.孤立的个人很清楚，在孤身一人时，他不能焚烧宫殿或洗劫商店，即使受到这样做的诱惑，他也很容易抵制这种诱惑。但是在成为群体的一员时，他就会意识到人数赋予他的力量，这足以让他生出杀人劫掠的念头，并且会立刻屈从于这种诱惑。出乎预料的障碍会被狂暴地摧毁。人类的机体的确能够产生大量狂热的激情，因此可以说，愿望受阻的群体所形成的正常状态，也就是这种激愤状态。

14.一个国家为其年轻人所提供的教育，可以让我们看到这个国家未来的样子。

15.能够感觉到的现象可以比作波浪，是海洋深处我们一无所知的那些乱象在洋面上的表象。

16.昨天受群众拥戴的英雄一旦失败，今天就会受到侮辱。当然名望越高，反应就会越强烈。在这种情况下，群众就会把末路英雄视为自己的同类，为自己曾向一个已不复存在的权威低头哈腰而进行报复。

17.群体在智力上总是低于孤立的个人，但是从感情及其激发的行动这个角度看，群体可以比个人表现得更好或更差，这全看环境如何。一切取决于群体所接受的暗示具有什么性质。

18.群体因为夸大自己的感情，因此它只会被极端感情所打动。希望感动群体的演说家，必须出言不逊，信誓旦旦。夸大其辞、言之凿凿、不断重复、绝对不以说理的方式证明任何事情——这些都是公众集会上的演说家惯用的论说技巧。

19.令人难忘的历史事件，只是人类思想无形的变化造成的有形的后果而已。

20.孤立的个体具有控制自身反应行为的能力，而群体则不具备。

21.专横和偏执是一切类型的群体的共性。

22.影响民众想象力的，并不是事实本身，而是它们发生和引起注意的方式。

23.群体总是对强权俯首帖耳，却很少为仁慈善行感动！在他们看来，仁慈善良只不过是软弱可欺的代名词。

24.大众没有辨别能力，因而无法判断事情的真伪，许多经不起推敲的观点，都能轻而易举的得到普遍赞同!

25.群体盲从意识会淹没个体的理性，个体一旦将自己归入该群体，其原本独立的理性就会被群体的无知疯狂所淹没。

26.从长远看，不断重复的说法会进入我们无意识的自我的深层区域，而我们的行为动机正是在这里形成的。到了一定的时候，我们会忘记谁是那个不断被重复的主张的作者，我们最终会对它深信不移。

27.群体中的个人是沙中之沙，风可以随意搅动他们。

28.群体表现出来的感情不管是好是坏，其突出的特点就是极为简单而夸张。

29.但凡能够成就大业的领袖人物，他重要的品质不是博学多识，而是必须具备强大而持久的意志力，这是一种极为罕见，极为强大的品质，它足以征服一切。

30.文明向来只由少数知识贵族阶级而非群体来创造。

31.身为一位领袖，如果想要让自己创立的宗教或政治信条站住脚，就必须成功地激起群众想入非非的感情。

32.结群后，由于人多势众，个人会产生一种幻觉，感到自己力大无穷，不可战胜，好像没有什么事情是办不到的。

33.当一个人融入社会之中时，他便失去了自我。

34.在迫不得已的情况下，我们也许还是会愿意接受传统教育当中所有的弊端，因为尽管它只会培养一些被社会所抛弃的人、心怀不满的人，但起码，对冗繁知识的肤浅掌握，对成堆教科书的完美背诵，或许可以提高智力水平。但事实上它真的能提高智力吗？不可能！在生活中，判断力、经验、进取心和个性，这些才是取得成功的条件，这些都不是书本所能够给予的。书本是可供查询的有用字典，但倘若把这些冗长的词条都装在脑子里，那可是一点用都没有。

35.文明赖以形成的道德力量失去效力时，它的最终瓦解总是由无意识且野蛮的群体来完成的。

36.一切政治、神学或社会信条，要想在群众中扎根，都必须采取宗教的形式——能够把危险的讨论排除在外的形式。

37.群体精神最需要的不是自由而是服从。他们如此甘愿听从别人的意志，以至于只要有人自称是它们的主人，他们就会本能地听命于他。

38.尽管在那一天的那两个小时里他们做到了或者几乎做到了，到一个月以后他们却不再具备这种能力。他们无法再次通过考试。他们脑中不断丢失大量过于沉重的知识，而且没有新的知识来填充。他们的思想活力开始衰退，促进成长的才能渐渐干涸，这时一个得到充分发展的人诞生了，但此时的他早已疲惫不堪。结婚过上安定的生活，陷入某种循环，并永无止境地重复下去；他将自己封闭在狭隘的工作中，尽职尽责，仅此而已。他们最终变为了平庸之辈。

39.个人一旦融入群体，他的个性便会被湮没，群体的思想便会占据绝对的统治地位，而与此同时，群体的行为也会表现出排斥异议，极端化、情绪化及低智商化等特点。进而对社会产生破坏性的影响。

40.所有时代和所有国家的伟大政客，包括最专横的暴君，也都把群众的想象力视为他们权力的基础，他们从来没有设想过通过与它作对而进行统治。要想掌握这种本领，万万不可求助于智力或推理，也就是说，绝对不可以采用论证的方式。

41.群体的叠加只是愚蠢的叠加，而真正的智慧被愚蠢的洪流淹没。

42.人们经常说起那家大众剧院，它只演令人压抑的戏剧，散场后，必须保护扮演叛徒的演员，免得他遭到观众的暴打。他所犯的罪行，当然是想象出来的，引起了群众的巨大愤怒。我觉得这是群体精神状态最显著的表现之一，这清楚地说明，要给他们什么暗示是一件多么容易的事情。对他们来说，假与真几乎同样奏效。他们明显地表现出真假不分的倾向。

43.各种制度并没有固定的优点，就它们本身而言，它们无所谓好坏。因为在特定的时刻对一个民族有益的制度，对另一个民族也许是极为有害的。

44.群体也许永远是无意识的，但这种无意识本身，可能就是它力量强大的秘密之一。在自然界，绝对服从本能的生物，其行为会复杂得让我们不敢相信。理智是人类新近才有的东西，太不完美了，不能向我们揭示无意识的规律，更不能替代它。在我们的行为举止中，无意识部分占的比重很大，理智所占的比例却很小。无意识现在仍作为未知的力量在起作用。

45.到了一定的时候我们不会记得那个不断被重复的主张的人是谁，我们最终会对它深信不疑，广告能有令人吃惊的威力，这就是原因。

46.教育既不会让人更道德，同样不会使他更幸福，它既不能将他的本能改变，也不能将他天生的热情改变，而且有在进行不良引导后，它的害处远大于好处。

47.单独一个人必须要为他的行为承担责任——法律上或者道德上。但是，群体则不然，群体不需要承担任何责任，群体就是责任，群体就是道德，群体就是法律，群体就是道德，群体的行为自然是合理的。

48.名望的产生与若干因素有关，而成功永远是其中最重要的一个。

49.学习课程，把一种语法或一篇纲要牢记在心，重复得好，模仿也出色——这实在是一种十分可笑的教育方式，它的每项工作都是一种信仰行为，即默认教师不可能犯错误。这种教育的唯一结果，就是贬低自我，让我们变得无能。

50.民众的想象力是政客的权力基础。

51.在决定人们历史地位上起着更大作用的，不是他们的“真实”面目，而是后人对他们的认识和感受。

52.群体会让每个人在其中的错误缩小，同时让每个人的恶意被无限放大。

54.束缚个人行为的责任感一消失，人便会随心所欲，肆意妄为。

55.群体的无意识行为取代了个体有意识的行为，这是现时代最显著的特征之一。

56.偶像崇拜的五大标识：

第一，偶像总是凌驾于信徒，处于高高在上的地位，这一点有着决定性地作用。
第二，信徒总是盲目服从偶像的命令。
第三，信徒没有能力，也不愿意对偶像规定的信条进行讨论。
第四，信徒有着狂热的愿望，希望把偶像的信条广加传播。
第五，信徒倾向于把不接受它们的任何人视为仇敌。

当群体符合第一条，其形式就等同于宗教，而这种情感就变成了宗教信仰。

对群体来说，也许最不合理的才是最合理的选择

57.群众日益被大众文化所湮没，这种文化把平庸低俗当作最有价值的东西。

58.所以不要轻易地成为集体的一份子，这样很容易被别有用心的人利用，即使你以为自己只不过是随声附和了一下而已，实际上你已经成了帮凶。

59.群体的夸张倾向只作用于感情，对智力不起任何作用。

60.群体不善推理，却又急于行动。

React 技术栈（一）

2021-06-18T16:00:00.000Z

ECMAScript 6 简介

除开JavaScript的基础内容，React 必备的知识肯定非 ES6，其实前面的文章已经讲了一部分的ES6的内容，这边只记录，我觉得比较重要的ES6的内容
ECMAScript 6.0（以下简称 ES6）是 JavaScript 语言的下一代标准，已经在 2015 年 6 月正式发布了。它的目标，是使得 JavaScript 语言可以用来编写复杂的大型应用程序，成为企业级开发语言。

let 和 const 命令

let var这个很简单，不需要解释了，跟现在新的语言的用法一致，const 就是类似 C 里面修饰指针，则指针不变，修饰常量则常量不可变化，没什么可说的。
JavaScript 以前的var就挺曹丹的，现在的用法起码像个人了。

箭头函数

箭头函数有几个使用注意点。

（1）箭头函数没有自己的this对象（详见下文）。
（2）不可以当作构造函数，也就是说，不可以对箭头函数使用new命令，否则会抛出一个错误。
（3）不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
（4）不可以使用yield命令，因此箭头函数不能用作 Generator 函数。

上面四点中，最重要的是第一点。对于普通函数来说，内部的this指向函数运行时所在的对象，但是这一点对箭头函数不成立。它没有自己的this对象，内部的this就是定义时上层作用域中的this。
也就是说，箭头函数内部的this指向是固定的，相比之下，普通函数的this指向是可变的。

function foo() {
  setTimeout(() => {
    console.log('id:', this.id);
  }, 100);
}

var id = 21;

foo.call({ id: 42 });
// id: 42

上面代码中，setTimeout()的参数是一个箭头函数，这个箭头函数的定义生效是在foo函数生成时，而它的真正执行要等到 100 毫秒后。
如果是普通函数，执行时this应该指向全局对象window，这时应该输出21。但是，箭头函数导致this总是指向函数定义生效时所在的对象（本例是{id: 42}），所以打印出来的是42。

箭头函数的什么教程一大堆，在我看来都是为了之前的设计买单而已，如果真的是像写Java 一样写，this的指向不会出现任何问题，普通函数的this 是不确定的，那么使用普通函数的时候bind一个this就完全可以解决了。

JavaScript 是一个很让人头疼的语言，有些人总是摸着规则的边缘写代码，然后减少了几行代码，以为有多厉害。我只想说，并不是人家看不懂就厉害的，那些白痴们。
如果只学习JavaScript一种语言，那他的代码肯定是乱七八糟的。所以我每年基本上都会复习一下C的知识，还是很有用的，了解程序运行的底层逻辑，才能更好地写代码。

对象的扩展

对象（object）是 JavaScript 最重要的数据结构。ES6 对它进行了重大升级，本章介绍数据结构本身的改变，下一章介绍Object对象的新增方法。

属性的赋值器（setter）和取值器（getter）

const cart = {
  _wheels: 4,

  get wheels () {
    return this._wheels;
  },

  set wheels (value) {
    if (value < this._wheels) {
      throw new Error('数值太小了！');
    }
    this._wheels = value;
  }
}

super 关键字

我们知道，this关键字总是指向函数所在的当前对象，ES6 又新增了另一个类似的关键字super，指向当前对象的原型对象。

const proto = {
  foo: 'hello'
};

const obj = {
  foo: 'world',
  find() {
    return super.foo;
  }
};

Object.setPrototypeOf(obj, proto);
obj.find() // "hello"

上面代码中，对象obj.find()方法之中，通过super.foo引用了原型对象proto的foo属性。

注意，super关键字表示原型对象时，只能用在对象的方法之中，用在其他地方都会报错。

// 报错
const obj = {
  foo: super.foo
}

// 报错
const obj = {
  foo: () => super.foo
}

// 报错
const obj = {
  foo: function () {
    return super.foo
  }
}

上面三种super的用法都会报错，因为对于 JavaScript 引擎来说，这里的super都没有用在对象的方法之中。第一种写法是super用在属性里面，第二种和第三种写法是super用在一个函数里面，然后赋值给foo属性。目前，只有对象方法的简写法可以让 JavaScript 引擎确认，定义的是对象的方法。

JavaScript 引擎内部，super.foo等同于Object.getPrototypeOf(this).foo（属性）或Object.getPrototypeOf(this).foo.call(this)（方法）。

const proto = {
  x: 'hello',
  foo() {
    console.log(this.x);
  },
};

const obj = {
  x: 'world',
  foo() {
    super.foo();
  }
}

Object.setPrototypeOf(obj, proto);

obj.foo() // "world"

上面代码中，super.foo指向原型对象proto的foo方法，但是绑定的this却还是当前对象obj，因此输出的就是world。

JavaScript 温习记录（二）

2020-11-01T16:00:00.000Z

写在前面的话

JavaScript 语言的内容，前面基本上也记录的差不多了。这里就聊一些JavaScript语言更深入的问题，加深对这个语言的理解。
C 和 Java 始终是 JavaScript 的基础，很多概念都是直接继承过来的，所以学习 C 是很重要的。我基本上每年都会对 C 有一个回顾，然后把数据结构的书再看一遍。
扯远了，这边只是记录 JavaScript 一些知识点，让我以后更好地上手 JavaScript，也是学习React的一个必要的过程。虽然我已经有一个上线的 React 项目，但是React的很多原理我基本上是抓瞎的。
作为一个移动端，在现在大前端的趋势下，多一个React的能力也挺好的。好几年前已经用Vue上线过一个项目了，但是那个项目比较简单，所以几年过去，我基本上忘的差不多了。

继承与原型链

对于使用过基于类的语言 (如 Java 或 C++) 的开发人员来说，JavaScript 有点令人困惑，因为它是动态的，并且本身不提供一个 class 实现。（在 ES2015/ES6 中引入了 class 关键字，但那只是语法糖，JavaScript 仍然是基于原型的）。

当谈到继承时，JavaScript 只有一种结构：对象。每个实例对象（ object ）都有一个私有属性（称之为 proto ）指向它的构造函数的原型对象（prototype）。该原型对象也有一个自己的原型对象( proto ) ，层层向上直到一个对象的原型对象为 null。根据定义，null 没有原型，并作为这个原型链中的最后一个环节。

几乎所有 JavaScript 中的对象都是位于原型链顶端的 Object 的实例。

尽管这种原型继承通常被认为是 JavaScript 的弱点之一，但是原型继承模型本身实际上比经典模型更强大。例如，在原型模型的基础上构建经典模型相当简单。

基于原型链的继承

JavaScript 对象是动态的属性“包”（指其自己的属性）。JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性时，它不仅仅在该对象上搜寻，还会搜寻该对象的原型，以及该对象的原型的原型，依次层层向上搜索，直到找到一个名字匹配的属性或到达原型链的末尾。

遵循ECMAScript标准，someObject.[[Prototype]] 符号是用于指向 someObject 的原型。从 ECMAScript 6 开始，[[Prototype]] 可以通过 Object.getPrototypeOf() 和 Object.setPrototypeOf() 访问器来访问。这个等同于 JavaScript 的非标准但许多浏览器实现的属性 proto。
但它不应该与构造函数 func 的 prototype 属性相混淆。被构造函数创建的实例对象的 [[Prototype]] 指向 func 的 prototype 属性。Object.prototype 属性表示 Object 的原型对象。

// 让我们从一个函数里创建一个对象o，它自身拥有属性a和b的：
let f = function () {
   this.a = 1;
   this.b = 2;
}
/* 这么写也一样
function f() {
  this.a = 1;
  this.b = 2;
}
*/

let o = new f(); // {a: 1, b: 2}

// 在f函数的原型上定义属性
f.prototype.b = 3;
f.prototype.c = 4;

// 不要在 f 函数的原型上直接定义 f.prototype = {b:3,c:4};这样会直接打破原型链
// o.[[Prototype]] 有属性 b 和 c
//  (其实就是 o.__proto__ 或者 o.constructor.prototype)
// o.[[Prototype]].[[Prototype]] 是 Object.prototype.
// 最后o.[[Prototype]].[[Prototype]].[[Prototype]]是null
// 这就是原型链的末尾，即 null，
// 根据定义，null 就是没有 [[Prototype]]。

// 综上，整个原型链如下:
// {a:1, b:2} ---> {b:3, c:4} ---> Object.prototype---> null

console.log(o.a); // 1
// a是o的自身属性吗？是的，该属性的值为 1

console.log(o.b); // 2
// b是o的自身属性吗？是的，该属性的值为 2
// 原型上也有一个'b'属性，但是它不会被访问到。
// 这种情况被称为"属性遮蔽 (property shadowing)"

console.log(o.c); // 4
// c是o的自身属性吗？不是，那看看它的原型上有没有
// c是o.[[Prototype]]的属性吗？是的，该属性的值为 4

console.log(o.d); // undefined
// d 是 o 的自身属性吗？不是，那看看它的原型上有没有
// d 是 o.[[Prototype]] 的属性吗？不是，那看看它的原型上有没有
// o.[[Prototype]].[[Prototype]] 为 null，停止搜索
// 找不到 d 属性，返回 undefined

在 JavaScript 中使用原型

接下去，来仔细分析一下这些应用场景下， JavaScript 在背后做了哪些事情。
正如之前提到的，在 JavaScript 中，函数（function）是允许拥有属性的。所有的函数会有一个特别的属性 —— prototype 。请注意，以下的代码是独立的（出于严谨，假定页面没有其他的JavaScript代码）。为了最佳的学习体验，我们强烈建议阁下打开浏览器的控制台（在Chrome和火狐浏览器中，按Ctrl+Shift+I即可），进入“console”选项卡，然后把如下的JavaScript代码复制粘贴到窗口中，最后通过按下回车键运行代码。

function doSomething(){}
console.log( doSomething.prototype );
// 和声明函数的方式无关，
// JavaScript 中的函数永远有一个默认原型属性。
var doSomething = function(){};
console.log( doSomething.prototype );

在控制台显示的JavaScript代码块中，我们可以看到doSomething函数的一个默认属性prototype。而这段代码运行之后，控制台应该显示类似如下的结果：

{
    constructor: ƒ doSomething(),
    __proto__: {
        constructor: ƒ Object(),
        hasOwnProperty: ƒ hasOwnProperty(),
        isPrototypeOf: ƒ isPrototypeOf(),
        propertyIsEnumerable: ƒ propertyIsEnumerable(),
        toLocaleString: ƒ toLocaleString(),
        toString: ƒ toString(),
        valueOf: ƒ valueOf()
    }
}

// 我们可以给doSomething函数的原型对象添加新属性
function doSomething(){}
doSomething.prototype.foo = "bar";
console.log( doSomething.prototype );

// 可以看到运行后的结果

{
    foo: "bar",
    constructor: ƒ doSomething(),
    __proto__: {
        constructor: ƒ Object(),
        hasOwnProperty: ƒ hasOwnProperty(),
        isPrototypeOf: ƒ isPrototypeOf(),
        propertyIsEnumerable: ƒ propertyIsEnumerable(),
        toLocaleString: ƒ toLocaleString(),
        toString: ƒ toString(),
        valueOf: ƒ valueOf()
    }
}

现在我们可以通过new操作符来创建基于这个原型对象的doSomething实例。使用new操作符，只需在调用doSomething函数语句之前添加new。这样，便可以获得这个函数的一个实例对象。一些属性就可以添加到该原型对象中。

function doSomething(){}
doSomething.prototype.foo = "bar"; // add a property onto the prototype
var doSomeInstancing = new doSomething();
doSomeInstancing.prop = "some value"; // add a property onto the object
console.log( doSomeInstancing );

{
    prop: "some value",
    __proto__: {
        foo: "bar",
        constructor: ƒ doSomething(),
        __proto__: {
            constructor: ƒ Object(),
            hasOwnProperty: ƒ hasOwnProperty(),
            isPrototypeOf: ƒ isPrototypeOf(),
            propertyIsEnumerable: ƒ propertyIsEnumerable(),
            toLocaleString: ƒ toLocaleString(),
            toString: ƒ toString(),
            valueOf: ƒ valueOf()
        }
    }
}

如上所示, doSomeInstancing 中的__proto__是 doSomething.prototype. 但这是做什么的呢？当你访问doSomeInstancing 中的一个属性，浏览器首先会查看doSomeInstancing 中是否存在这个属性。

如果 doSomeInstancing 不包含属性信息, 那么浏览器会在 doSomeInstancing 的 __proto__ 中进行查找(同 doSomething.prototype). 如属性在 doSomeInstancing 的 __proto__ 中查找到，则使用 doSomeInstancing 中 __proto__ 的属性。

否则，如果 doSomeInstancing 中 __proto__ 不具有该属性，则检查doSomeInstancing 的 __proto__ 的 __proto__ 是否具有该属性。默认情况下，任何函数的原型属性 __proto__ 都是 window.Object.prototype. 因此, 通过doSomeInstancing 的 __proto__ 的 __proto__ ( 同 doSomething.prototype 的 __proto__ (同 Object.prototype)) 来查找要搜索的属性。

如果属性不存在 doSomeInstancing 的 __proto__ 的 __proto__ 中，那么就会在 doSomeInstancing 的 __proto__ 的 __proto__ 的 __proto__ 中查找。然而, 这里存在个问题：doSomeInstancing 的 __proto__ 的 __proto__ 的 __proto__ 其实不存在。因此，只有这样，在 __proto__ 的整个原型链被查看之后，这里没有更多的 __proto__ ，浏览器断言该属性不存在，并给出属性值为 undefined 的结论。

使用不同的方法来创建对象和生成原型链

使用语法结构创建的对象

var o = {a: 1};

// o 这个对象继承了 Object.prototype 上面的所有属性
// o 自身没有名为 hasOwnProperty 的属性
// hasOwnProperty 是 Object.prototype 的属性
// 因此 o 继承了 Object.prototype 的 hasOwnProperty
// Object.prototype 的原型为 null
// 原型链如下:
// o ---> Object.prototype ---> null

var a = ["yo", "whadup", "?"];

// 数组都继承于 Array.prototype
// (Array.prototype 中包含 indexOf, forEach 等方法)
// 原型链如下:
// a ---> Array.prototype ---> Object.prototype ---> null
function f(){
  return 2;
}

使用构造器创建的对象

function Graph() {
  this.vertices = [];
  this.edges = [];
}

Graph.prototype = {
  addVertex: function(v){
    this.vertices.push(v);
  }
};

var g = new Graph();
// g 是生成的对象，他的自身属性有 'vertices' 和 'edges'。
// 在 g 被实例化时，g.[[Prototype]] 指向了 Graph.prototype。

使用 Object.create 创建的对象

ECMAScript 5 中引入了一个新方法：Object.create()。可以调用这个方法来创建一个新对象。新对象的原型就是调用 create 方法时传入的第一个参数：

var a = {a: 1};
// a ---> Object.prototype ---> null

var b = Object.create(a);
// b ---> a ---> Object.prototype ---> null
console.log(b.a); // 1 (继承而来)

var c = Object.create(b);
// c ---> b ---> a ---> Object.prototype ---> null

var d = Object.create(null);
// d ---> null
console.log(d.hasOwnProperty); // undefined, 因为d没有继承Object.prototype

使用 class 关键字创建的对象

ECMAScript6 引入了一套新的关键字用来实现 class。使用基于类语言的开发人员会对这些结构感到熟悉，但它们是不同的。JavaScript 仍然基于原型。这些新的关键字包括 class, constructor，static，extends 和 super。

"use strict";

class Polygon {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
}

class Square extends Polygon {
  constructor(sideLength) {
    super(sideLength, sideLength);
  }
  get area() {
    return this.height * this.width;
  }
  set sideLength(newLength) {
    this.height = newLength;
    this.width = newLength;
  }
}

var square = new Square(2);

内存管理

像C语言这样的底层语言一般都有底层的内存管理接口，比如 malloc()和free()。相反，JavaScript是在创建变量（对象，字符串等）时自动进行了分配内存，并且在不使用它们时“自动”释放。释放的过程称为垃圾回收。这个“自动”是混乱的根源，并让JavaScript（和其他高级语言）开发者错误的感觉他们可以不关心内存管理。

内存生命周期

不管什么程序语言，内存生命周期基本是一致的：

分配你所需要的内存
使用分配到的内存（读、写）
不需要时将其释放\归还

所有语言第二部分都是明确的。第一和第三部分在底层语言中是明确的，但在像JavaScript这些高级语言中，大部分都是隐含的。

JavaScript 的内存分配

为了不让程序员费心分配内存，JavaScript 在定义变量时就完成了内存分配。

var n = 123; // 给数值变量分配内存
var s = "azerty"; // 给字符串分配内存

var o = {
  a: 1,
  b: null
}; // 给对象及其包含的值分配内存

// 给数组及其包含的值分配内存（就像对象一样）
var a = [1, null, "abra"];

function f(a){
  return a + 2;
} // 给函数（可调用的对象）分配内存

// 函数表达式也能分配一个对象
someElement.addEventListener('click', function(){
  someElement.style.backgroundColor = 'blue';
}, false);

通过函数调用分配内存

var d = new Date(); // 分配一个 Date 对象

var e = document.createElement('div'); // 分配一个 DOM 元素

// 有些方法分配新变量或者新对象：
var s = "azerty";
var s2 = s.substr(0, 3); // s2 是一个新的字符串
// 因为字符串是不变量，
// JavaScript 可能决定不分配内存，
// 只是存储了 [0-3] 的范围。

var a = ["ouais ouais", "nan nan"];
var a2 = ["generation", "nan nan"];
var a3 = a.concat(a2);
// 新数组有四个元素，是 a 连接 a2 的结果

使用值的过程实际上是对分配内存进行读取与写入的操作。读取与写入可能是写入一个变量或者一个对象的属性值，甚至传递函数的参数。

当内存不再需要使用时释放

大多数内存管理的问题都在这个阶段。在这里最艰难的任务是找到“哪些被分配的内存确实已经不再需要了”。它往往要求开发人员来确定在程序中哪一块内存不再需要并且释放它。

高级语言解释器嵌入了“垃圾回收器”，它的主要工作是跟踪内存的分配和使用，以便当分配的内存不再使用时，自动释放它。这只能是一个近似的过程，因为要知道是否仍然需要某块内存是无法判定的（无法通过某种算法解决）。

垃圾回收

如上文所述自动寻找是否一些内存“不再需要”的问题是无法判定的。因此，垃圾回收实现只能有限制的解决一般问题。

垃圾回收算法主要依赖于引用的概念。在内存管理的环境中，一个对象如果有访问另一个对象的权限（隐式或者显式），叫做一个对象引用另一个对象。例如，一个Javascript对象具有对它原型的引用（隐式引用）和对它属性的引用（显式引用）。

在这里，“对象”的概念不仅特指 JavaScript 对象，还包括函数作用域（或者全局词法作用域）。

这是最初级的垃圾收集算法。此算法把“对象是否不再需要”简化定义为“对象有没有其他对象引用到它”。如果没有引用指向该对象（零引用），对象将被垃圾回收机制回收。

var o = {
  a: {
    b:2
  }
};
// 两个对象被创建，一个作为另一个的属性被引用，另一个被分配给变量o
// 很显然，没有一个可以被垃圾收集

var o2 = o; // o2变量是第二个对“这个对象”的引用

o = 1;      // 现在，“这个对象”只有一个o2变量的引用了，“这个对象”的原始引用o已经没有

var oa = o2.a; // 引用“这个对象”的a属性
// 现在，“这个对象”有两个引用了，一个是o2，一个是oa

o2 = "yo"; // 虽然最初的对象现在已经是零引用了，可以被垃圾回收了
// 但是它的属性a的对象还在被oa引用，所以还不能回收

oa = null; // a属性的那个对象现在也是零引用了
// 它可以被垃圾回收了

该算法有个限制：无法处理循环引用的事例。在下面的例子中，两个对象被创建，并互相引用，形成了一个循环。它们被调用之后会离开函数作用域，所以它们已经没有用了，可以被回收了。然而，引用计数算法考虑到它们互相都有至少一次引用，所以它们不会被回收。

function f(){
  var o = {};
  var o2 = {};
  o.a = o2; // o 引用 o2
  o2.a = o; // o2 引用 o

  return "azerty";
}

f();

这里的内存管理讲的很一般，如果要详细的了解，还是要去看 C 的指针部分的内容。不过 C 的指针内容很复杂，需要慢慢斟酌，慢慢理解

函数

函数算是 js 里面花样最多的了，其他语言也有闭包，函数式编程，但是花样这么多，用法这么乱的挺少的。起码Swift的函数真的很好用，然后对于引用对象的拷贝也是正常的 C 的逻辑，js的我现在很难理解，也看不到底层的内存分布是怎么个逻辑。

还是先看看函数的教程吧

箭头函数

箭头函数表达式的语法比函数表达式更简洁，并且没有自己的this，arguments，super或new.target。箭头函数表达式更适用于那些本来需要匿名函数的地方，并且它不能用作构造函数。

语法

基础语法

(param1, param2, …, paramN) => { statements }
(param1, param2, …, paramN) => expression
//相当于：(param1, param2, …, paramN) =>{ return expression; }

// 当只有一个参数时，圆括号是可选的：
(singleParam) => { statements }
singleParam => { statements }

// 没有参数的函数应该写成一对圆括号。
() => { statements }

高级语法

//加括号的函数体返回对象字面量表达式：
params => ({foo: bar})

//支持剩余参数和默认参数
(param1, param2, ...rest) => { statements }
(param1 = defaultValue1, param2, …, paramN = defaultValueN) => {
  statements
}

//同样支持参数列表解构
let f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
f();  // 6

描述

引入箭头函数有两个方面的作用：更简短的函数并且不绑定this。

更短的函数

var elements = [
  'Hydrogen',
  'Helium',
  'Lithium',
  'Beryllium'
];

elements.map(function(element) {
  return element.length;
}); // 返回数组：[8, 6, 7, 9]

// 上面的普通函数可以改写成如下的箭头函数
elements.map((element) => {
  return element.length;
}); // [8, 6, 7, 9]

// 当箭头函数只有一个参数时，可以省略参数的圆括号
elements.map(element => {
 return element.length;
}); // [8, 6, 7, 9]

// 当箭头函数的函数体只有一个 `return` 语句时，可以省略 `return` 关键字和方法体的花括号
elements.map(element => element.length); // [8, 6, 7, 9]

// 在这个例子中，因为我们只需要 `length` 属性，所以可以使用参数解构
// 需要注意的是字符串 `"length"` 是我们想要获得的属性的名称，而 `lengthFooBArX` 则只是个变量名，
// 可以替换成任意合法的变量名
elements.map(({ "length": lengthFooBArX }) => lengthFooBArX); // [8, 6, 7, 9]

没有单独的this

在箭头函数出现之前，每一个新函数根据它是被如何调用的来定义这个函数的this值：

如果是该函数是一个构造函数，this指针指向一个新的对象
在严格模式下的函数调用下，this指向undefined
如果是该函数是一个对象的方法，则它的this指针指向这个对象
等等

This被证明是令人厌烦的面向对象风格的编程。

function Person() {
  // Person() 构造函数定义 `this`作为它自己的实例.
  this.age = 0;

  setInterval(function growUp() {
    // 在非严格模式, growUp()函数定义 `this`作为全局对象,
    // 与在 Person()构造函数中定义的 `this`并不相同.
    this.age++;
  }, 1000);
}

var p = new Person();

// 在ECMAScript 3/5中，通过将this值分配给封闭的变量，可以解决this问题。

function Person() {
  var that = this;
  that.age = 0;

  setInterval(function growUp() {
    // 回调引用的是`that`变量, 其值是预期的对象.
    that.age++;
  }, 1000);
}

箭头函数不会创建自己的this,它只会从自己的作用域链的上一层继承this。因此，在下面的代码中，传递给setInterval的函数内的this与封闭函数中的this值相同.
严格模式的其他规则依然不变.

function Person(){
  this.age = 0;

  setInterval(() => {
    this.age++; // |this| 正确地指向 p 实例
  }, 1000);
}

var p = new Person();

通过 call 或 apply 调用
由于箭头函数没有自己的this指针，通过 call() 或 apply() 方法调用一个函数时，只能传递参数（不能绑定this—译者注），他们的第一个参数会被忽略。（这种现象对于bind方法同样成立—译者注）

var adder = {
  base : 1,
  
  add : function(a) {
    var f = v => v + this.base;
    return f(a);
  },

  addThruCall: function(a) {
    var f = v => v + this.base;
    var b = {
      base : 2
    };
    
    return f.call(b, a);
  }
};

console.log(adder.add(1));         // 输出 2
console.log(adder.addThruCall(1)); // 仍然输出 2

箭头函数不绑定Arguments 对象。因此，在本示例中，arguments只是引用了封闭作用域内的arguments：

var arguments = [1, 2, 3];
var arr = () => arguments[0];

arr(); // 1

function foo(n) {
  var f = () => arguments[0] + n; // 隐式绑定 foo 函数的 arguments 对象. arguments[0] 是 n,即传给foo函数的第一个参数
  return f();
}

foo(1); // 2
foo(2); // 4
foo(3); // 6
foo(3,2);//6
foo(4);//8

// 在大多数情况下，使用剩余参数是相较使用arguments对象的更好选择。

function foo(arg) {
  var f = (...args) => args[0];
  return f(arg);
}
foo(1); // 1

function foo(arg1,arg2) {
    var f = (...args) => args[1];
    return f(arg1,arg2);
}
foo(1,2);  //2

最后

就到这里吧，js的内容看得我头疼，又很困。

参考文档

JavaScript

JavaScript 温习记录（一）

2020-10-29T16:00:00.000Z

写在前面的话

最近用react-native 完成了一个公司的项目，JavaScript 其实已经看过很多遍了，上个月就看了一遍全部的教程，但是没有系统的记录，以及一些比较麻烦的地方。
有一些三方的源码还是看的不太懂，而且js的坑不算少，我希望能够记录一下，下次能够快速定位问题。
（起码我可以看得懂三方的源代码o(╯□╰)o）

让我们愉快的开始吧

JavaScript ( JS ) 是一种具有函数优先的轻量级，解释型或即时编译型的编程语言。虽然它是作为开发Web 页面的脚本语言而出名的，但是它也被用到了很多非浏览器环境中，例如 Node.js、 Apache CouchDB 和 Adobe Acrobat。JavaScript 是一种基于原型编程、多范式的动态脚本语言，并且支持面向对象、命令式和声明式（如函数式编程）风格。了解更多 JavaScript。

一些基础的知识这里就不说了，主要是一些值得注意的。

Promises

从 ECMAScript 6 开始，JavaScript 增加了对 Promise 对象的支持，它允许你对延时和异步操作流进行控制。
Promise 对象有以下几种状态：

pending：初始的状态，即正在执行，不处于 fulfilled 或 rejected 状态。
fulfilled：成功的完成了操作。
rejected：失败，没有完成操作。
settled：Promise 处于 fulfilled 或 rejected 二者中的任意一个状态, 不会是 pending。

通过 XHR 加载图片
你可以在 MDN GitHub promise-test 中找到这个简单的例子，它使用了 Promise 和 XMLHttpRequest 来加载一张图片，你也可以直接在这个页面查看他的效果。同时为了让你更清楚的了解 Promise 和 XHR 的结构，代码中每一个步骤后都附带了注释。

这里有一个未注释的版本，展现了 Promise 的工作流，希望可以对你的理解有所帮助。

function imgLoad(url) {
  return new Promise(function(resolve, reject) {
    var request = new XMLHttpRequest();
    request.open('GET', url);
    request.responseType = 'blob';
    request.onload = function() {
      if (request.status === 200) {
        resolve(request.response);
      } else {
        reject(Error('Image didn\'t load successfully; error code:' 
                     + request.statusText));
      }
    };
    request.onerror = function() {
      reject(Error('There was a network error.'));
    };
    request.send();
  });
}

Promise 这里只是简单介绍，后面会用单独的部分来讲解的

函数

函数是 JavaScript 中的基本组件之一。一个函数是 JavaScript 过程 — 一组执行任务或计算值的语句。要使用一个函数，你必须将其定义在你希望调用它的作用域内。

一个JavaScript 函数用function关键字定义，后面跟着函数名和圆括号。

函数很重要，函数作用域很重要，最关键的是js的作用域有很多奇葩的地方

在函数内定义的变量不能在函数之外的任何地方访问，因为变量仅仅在该函数的域的内部有定义。相对应的，一个函数可以访问定义在其范围内的任何变量和函数。换言之，定义在全局域中的函数可以访问所有定义在全局域中的变量。在另一个函数中定义的函数也可以访问在其父函数中定义的所有变量和父函数有权访问的任何其他变量。

// 下面的变量定义在全局作用域(global scope)中
var num1 = 20,
    num2 = 3,
    name = "Chamahk";

// 本函数定义在全局作用域
function multiply() {
    return num1 * num3;
}

function change() {
    num1 = 40;
    num2 = 3;
}

function multiplyWithNumber(num1: number, num2: number) {
    const num = num1 * num2;
    return num;
}

multiply(); // 返回 60

multiplyWithNumber(num1, num2)

change();

multiply(); // 返回 ??? 120

var c = {
  num: 10
}

var d = {}

var a = {
  init(num, obj) {
    this.num = num
    this.obj = obj
  }
}

a.init(c.num, d)
c.num = 20
d = { aaaa: 1 }

var b = {
  num: a.num,

  change: function() {
    num = 20
  }
}

b.change()

a.num
b.num

嵌套函数和闭包

你可以在一个函数里面嵌套另外一个函数。嵌套（内部）函数对其容器（外部）函数是私有的。它自身也形成了一个闭包。一个闭包是一个可以自己拥有独立的环境与变量的表达式（通常是函数）。

既然嵌套函数是一个闭包，就意味着一个嵌套函数可以”继承“容器函数的参数和变量。换句话说，内部函数包含外部函数的作用域。

function outside(x) {
  function inside(y) {
    return x + y;
  }
  return inside;
}
fn_inside = outside(3); // 可以这样想：给一个函数，使它的值加3
result = fn_inside(5); // returns 8

result1 = outside(3)(5); // returns 8

闭包是 JavaScript 中最强大的特性之一。JavaScript 允许函数嵌套，并且内部函数可以访问定义在外部函数中的所有变量和函数，以及外部函数能访问的所有变量和函数。
但是，外部函数却不能够访问定义在内部函数中的变量和函数。这给内部函数的变量提供了一定的安全性。

此外，由于内部函数可以访问外部函数的作用域，因此当内部函数生存周期大于外部函数时，外部函数中定义的变量和函数的生存周期将比内部函数执行时间长。当内部函数以某一种方式被任何一个外部函数作用域访问时，一个闭包就产生了。

函数参数

从ECMAScript 6开始，有两个新的类型的参数：默认参数，剩余参数。
在JavaScript中，函数参数的默认值是undefined。然而，在某些情况下设置不同的默认值是有用的。这时默认参数可以提供帮助。

剩余参数语法允许将不确定数量的参数表示为数组。在下面的例子中，使用剩余参数收集从第二个到最后参数。然后，我们将这个数组的每一个数与第一个参数相乘。这个例子是使用了一个箭头函数，这将在下面介绍。

function multiply(multiplier, ...theArgs) {
  return theArgs.map(x => multiplier * x);
}

var arr = multiply(2, 1, 2, 3);
console.log(arr); // [2, 4, 6]

箭头函数

箭头函数表达式（也称胖箭头函数）相比函数表达式具有较短的语法并以词法的方式绑定 this。箭头函数总是匿名的。另见 hacks.mozilla.org 的博文：“深度了解ES6：箭头函数”。

有两个因素会影响引入箭头函数：更简洁的函数和 this。

数字和日期

数字

在 JavaScript 里面，数字均为双精度浮点类型（double-precision 64-bit binary format IEEE 754），即一个介于±2−1023和±2+1024之间的数字，或约为±10−308到±10+308，数字精度为53位。整数数值仅在±(253 - 1)的范围内可以表示准确。

JavaScript最近添加了 BigInt 的支持，能够用于表示极大的数字。使用 BigInt 的时候有一些注意事项，例如，你不能让 BigInt 和 Number 直接进行运算，你也不能用 Math 对象去操作 BigInt 数字。

请参见Javascript指南中的 JavaScript 数据类型和数据结构，了解其他更多的基本类型。

日期对象

JavaScript没有日期数据类型。但是你可以在你的程序里使用 Date 对象和其方法来处理日期和时间。Date对象有大量的设置、获取和操作日期的方法。它并不含有任何属性。
JavaScript 处理日期数据类似于Java。这两种语言有许多一样的处理日期的方法，也都是以1970年1月1日00:00:00以来的毫秒数来储存数据类型的。

处理日期时间的Date对象方法可分为以下几类：

“set” 方法, 用于设置Date对象的日期和时间的值。
“get” 方法,用于获取Date对象的日期和时间的值。
“to” 方法,用于返回Date对象的字符串格式的值。
parse 和UTC 方法, 用于解析Date字符串。

正则表达式

正则表达式是用于匹配字符串中字符组合的模式。在 JavaScript中，正则表达式也是对象。这些模式被用于 RegExp 的 exec 和 test 方法, 以及 String 的 match、matchAll、replace、search 和 split 方法。本章介绍 JavaScript 正则表达式。

字符	含义
\	依照下列规则匹配：在非特殊字符之前的反斜杠表示下一个字符是特殊字符，不能按照字面理解。例如，前面没有 “" 的 “b” 通常匹配小写字母 “b”，即字符会被作为字面理解，无论它出现在哪里。但如果前面加了 “"，它将不再匹配任何字符，而是表示一个字符边界。在特殊字符之前的反斜杠表示下一个字符不是特殊字符，应该按照字面理解。详情请参阅下文中的 “转义（Escaping）” 部分。如果你想将字符串传递给 RegExp 构造函数，不要忘记在字符串字面量中反斜杠是转义字符。所以为了在模式中添加一个反斜杠，你需要在字符串字面量中转义它。/[a-z]\s/i 和 new RegExp(“[a-z]\s”, “i”) 创建了相同的正则表达式：一个用于搜索后面紧跟着空白字符（\s 可看后文）并且在 a-z 范围内的任意字符的表达式。为了通过字符串字面量给 RegExp 构造函数创建包含反斜杠的表达式，你需要在字符串级别和正则表达式级别都对它进行转义。例如 /[a-z]:\/i 和 new RegExp(“[a-z]:\\“,”i”) 会创建相同的表达式，即匹配类似 “C:" 字符串。
^	匹配输入的开始
$	匹配输入的结束
*	匹配前一个表达式 0 次或多次。等价于 {0,}
+	匹配前面一个表达式 1 次或者多次。等价于 {1,}
?	匹配前面一个表达式 0 次或者 1 次。等价于 {0,1}。
.	（小数点）默认匹配除换行符之外的任何单个字符。
x\|y	匹配‘x’或者‘y’。例如, /a{2,}/ 匹配 “aa”, “aaaa” 和 “aaaaa” 但是不匹配 “a”。
(x)	像下面的例子展示的那样，它会匹配 ‘x’ 并且记住匹配项。其中括号被称为捕获括号。
(?:x)	匹配 ‘x’ 但是不记住匹配项。这种括号叫作非捕获括号，使得你能够定义与正则表达式运算符一起使用的子表达式。
x(?=y)	匹配’x’仅仅当’x’后面跟着’y’.这种叫做先行断言。
(?<=y)x	匹配’x’仅当’x’前面是’y’.这种叫做后行断言。
x(?!y)	仅仅当’x’后面不跟着’y’时匹配’x’，这被称为正向否定查找。
(?	仅仅当’x’前面不是’y’时匹配’x’，这被称为反向否定查找。
{n}	n 是一个正整数，匹配了前面一个字符刚好出现了 n 次。比如， /a{2}/ 不会匹配“candy”中的’a’,但是会匹配“caandy”中所有的 a，以及“caaandy”中的前两个’a’。
{n,}	n是一个正整数，匹配前一个字符至少出现了n次。例如, /a{2,}/ 匹配 “aa”, “aaaa” 和 “aaaaa” 但是不匹配 “a”。
{n,m}	n 和 m 都是整数。匹配前面的字符至少n次，最多m次。如果 n 或者 m 的值是0，这个值被忽略。例如，/a{1, 3}/ 并不匹配“cndy”中的任意字符，匹配“candy”中的a，匹配“caandy”中的前两个a，也匹配“caaaaaaandy”中的前三个a。注意，当匹配”caaaaaaandy“时，匹配的值是“aaa”，即使原始的字符串中有更多的a。
[xyz]	一个字符集合。匹配方括号中的任意字符，包括转义序列。你可以使用破折号（-）来指定一个字符范围。对于点（.）和星号（*）这样的特殊符号在一个字符集中没有特殊的意义。他们不必进行转义，不过转义也是起作用的。例如，[abcd] 和[a-d]是一样的。他们都匹配”brisket”中的‘b’,也都匹配“city”中的‘c’。/[a-z.]+/ 和/[\w.]+/与字符串“test.i.ng”匹配。
[^xyz]	一个反向字符集。也就是说，它匹配任何没有包含在方括号中的字符。你可以使用破折号（-）来指定一个字符范围。任何普通字符在这里都是起作用的。
[\b]	匹配一个退格(U+0008)。（不要和\b混淆了。）
\b	匹配一个词的边界。一个词的边界就是一个词不被另外一个“字”字符跟随的位置或者前面跟其他“字”字符的位置，例如在字母和空格之间。注意，匹配中不包括匹配的字边界。换句话说，一个匹配的词的边界的内容的长度是0。（不要和[\b]混淆了）使用”moon”举例： /\bm/匹配“moon”中的‘m’； /oo\b/并不匹配”moon”中的’oo’，因为’oo’被一个“字”字符’n’紧跟着。 /oon\b/匹配”moon”中的’oon’，因为’oon’是这个字符串的结束部分。这样他没有被一个“字”字符紧跟着。
\B	匹配一个非单词边界。
\d	匹配一个数字。等价于[0-9]。例如， /\d/ 或者 /[0-9]/ 匹配”B2 is the suite number.”中的’2’。
\D	匹配一个非数字字符。等价于[^0-9]。
\f	匹配一个换页符 (U+000C)。
\n	匹配一个换行符 (U+000A)。
\r	匹配一个回车符 (U+000D)。
\s	匹配一个空白字符，包括空格、制表符、换页符和换行符。
\S	匹配一个非空白字符。
\t	匹配一个水平制表符 (U+0009)。
\v	匹配一个垂直制表符 (U+000B)。
\w	匹配一个单字字符（字母、数字或者下划线）。等价于 [A-Za-z0-9_]。例如, /\w/ 匹配 “apple,” 中的 ‘a’，”$5.28,”中的 ‘5’ 和 “3D.” 中的 ‘3’。
\W	匹配一个非单字字符。等价于 [^A-Za-z0-9_]。例如, /\W/ 或者 /[^A-Za-z0-9_]/ 匹配 “50%.” 中的 ‘%’。
\n	在正则表达式中，它返回最后的第n个子捕获匹配的子字符串(捕获的数目以左括号计数)。比如 /apple(,)\sorange\1/ 匹配”apple, orange, cherry, peach.”中的’apple, orange,’ 。
\0	匹配 NULL（U+0000）字符，不要在这后面跟其它小数，因为 \0 是一个八进制转义序列。
\xhh	匹配一个两位十六进制数（\x00-\xFF）表示的字符。
\uhhhh	匹配一个四位十六进制数表示的 UTF-16 代码单元。
\u{hhhh}或\u{hhhhh}	（仅当设置了u标志时）匹配一个十六进制数表示的 Unicode 字符。

数组对象(Array object)

数组(array)是一个有序的数据集合，我们可以通过数组名称(name)和索引(index)进行访问。例如，我们定义了一个数组emp，数组中的每个元素包含了一个雇员的名字以及其作为索引的员工号。那么emp[1]将会代表1号员工，emp[2]将会代表2号员工，以此类推。

JavaScript中没有明确的数组数据类型。但是，我们可以通过使用内置Array对象和它的方法对数组进行操作。Array对象有很多操作数组的方法，比如合并、反转、排序等。数组对象有一个决定数组长度和使用正则表达式操作其他属性的属性。

var arr = new Array(element0, element1, ..., elementN);
var arr = Array(element0, element1, ..., elementN);
var arr = [element0, element1, ..., elementN];

// 译者注: var arr=[4] 和 var arr=new Array(4)是不等效的，
// 后者4指数组长度，所以使用字面值(literal)的方式应该不仅仅是便捷，同时也不易踩坑

var arr = new Array(arrayLength);
var arr = Array(arrayLength);

// 这样有同样的效果
var arr = [];
arr.length = arrayLength;

数组的方法(array methods)

Array 对象具有下列方法：
concat() 连接两个数组并返回一个新的数组。

1
2
3

var myArray = new Array("1", "2", "3");
myArray = myArray.concat("a", "b", "c"); 
// myArray is now ["1", "2", "3", "a", "b", "c"]

join(deliminator = ‘,’) 将数组的所有元素连接成一个字符串。

1 2	var myArray = new Array("Wind", "Rain", "Fire"); var list = myArray.join(" - "); // list is "Wind - Rain - Fire"

push() 在数组末尾添加一个或多个元素，并返回数组操作后的长度。

1 2	var myArray = new Array("1", "2"); myArray.push("3"); // myArray is now ["1", "2", "3"]

pop() 从数组移出最后一个元素，并返回该元素。

1
2
3

var myArray = new Array("1", "2", "3");
var last = myArray.pop();
// myArray is now ["1", "2"], last = "3"

shift() 从数组移出第一个元素，并返回该元素。

1
2
3

var myArray = new Array ("1", "2", "3");
var first = myArray.shift(); 
// myArray is now ["2", "3"], first is "1"

unshift() 在数组开头添加一个或多个元素，并返回数组的新长度。

1
2
3

var myArray = new Array ("1", "2", "3");
myArray.unshift("4", "5"); 
// myArray becomes ["4", "5", "1", "2", "3"]

其他的就不一一介绍了

类型化数组(Typed Arrays )

JavaScript typed arrays 是类数组对象（array-like object），其提供访问原始二进制数据的机制。就像你知道的那样, Array 对象动态增长和收缩，可以有任何JavaScript值。但对于类型化数组，JavaScript引擎执行优化使得这些数组访问速度快速。随着Web应用程序变得越来越强大，添加音频和视频处理等功能、可以使用 WebSockets 、使用原始数据，这都需要访问原始的二进制数据，所以专门的优化将有助于JavaScript代码能够快速和容易地操纵原始二进制数据类型的数组。

映射

Map对象

ECMAScript 2015 引入了一个新的数据结构来将一个值映射到另一个值。一个Map对象就是一个简单的键值对映射集合，可以按照数据插入时的顺序遍历所有的元素。

Object和Map的比较

一般地，objects会被用于将字符串类型映射到数值。Object允许设置键值对、根据键获取值、删除键、检测某个键是否存在。而Map具有更多的优势。

Object的键均为Strings类型，在Map里键可以是任意类型。
必须手动计算Object的尺寸，但是可以很容易地获取使用Map的尺寸。
Map的遍历遵循元素的插入顺序。
Object有原型，所以映射中有一些缺省的键。（可以用 map = Object.create(null) 回避）。

这三条提示可以帮你决定用Map还是Object：

如果键在运行时才能知道，或者所有的键类型相同，所有的值类型相同，那就使用Map。
如果需要将原始值存储为键，则使用Map，因为Object将每个键视为字符串，不管它是一个数字值、布尔值还是任何其他原始值。
如果需要对个别元素进行操作，使用Object。

WeakMap对象

WeakMap对象也是键值对的集合。它的键必须是对象类型，值可以是任意类型。它的键被弱保持，也就是说，当其键所指对象没有其他地方引用的时候，它会被GC回收掉。WeakMap提供的接口与Map相同。

与Map对象不同的是，WeakMap的键是不可枚举的。不提供列出其键的方法。列表是否存在取决于垃圾回收器的状态，是不可预知的。

对象（Object）

javascript 中的对象(物体)，和其它编程语言中的对象一样，可以比照现实生活中的对象(物体)来理解它。 javascript 中对象(物体)的概念可以比照着现实生活中实实在在的物体来理解。

在javascript中，一个对象可以是一个单独的拥有属性和类型的实体。我们拿它和一个杯子做下类比。一个杯子是一个对象(物体)，拥有属性。杯子有颜色，图案，重量，由什么材质构成等等。同样，javascript对象也有属性来定义它的特征。

创建新对象

JavaScript 拥有一系列预定义的对象。另外，你可以创建你自己的对象。从 JavaScript 1.2 之后，你可以通过对象初始化器（Object Initializer）创建对象。或者你可以创建一个构造函数并使用该函数和 new 操作符初始化对象。

Promise

Promise 是一个对象，它代表了一个异步操作的最终完成或者失败。因为大多数人仅仅是使用已创建的 Promise 实例对象，所以本教程将首先说明怎样使用 Promise，再说明如何创建 Promise。

本质上 Promise 是一个函数返回的对象，我们可以在它上面绑定回调函数，这样我们就不需要在一开始把回调函数作为参数传入这个函数了。

假设现在有一个名为 createAudioFileAsync() 的函数，它接收一些配置和两个回调函数，然后异步地生成音频文件。一个回调函数在文件成功创建时被调用，另一个则在出现异常时被调用。

链式调用

连续执行两个或者多个异步操作是一个常见的需求，在上一个操作执行成功之后，开始下一个的操作，并带着上一步操作所返回的结果。我们可以通过创造一个 Promise 链来实现这种需求。

doSomething().then(function(result) {
  return doSomethingElse(result);
})
.then(function(newResult) {
  return doThirdThing(newResult);
})
.then(function(finalResult) {
  console.log('Got the final result: ' + finalResult);
})
.catch(failureCallback);

// 我们也可以用箭头函数来表示
doSomething()
.then(result => doSomethingElse(result))
.then(newResult => doThirdThing(newResult))
.then(finalResult => {
  console.log(`Got the final result: ${finalResult}`);
})
.catch(failureCallback);

错误传递

在之前的回调地狱示例中，你可能记得有 3 次 failureCallback 的调用，而在 Promise 链中只有尾部的一次调用。
通常，一遇到异常抛出，浏览器就会顺着 Promise 链寻找下一个 onRejected 失败回调函数或者由 .catch() 指定的回调函数。这和以下同步代码的工作原理（执行过程）非常相似。

try {
  let result = syncDoSomething();
  let newResult = syncDoSomethingElse(result);
  let finalResult = syncDoThirdThing(newResult);
  console.log(`Got the final result: ${finalResult}`);
} catch(error) {
  failureCallback(error);
}

// 在 ECMAScript 2017 标准的 async/await 语法糖中，这种异步代码的对称性得到了极致的体现：

async function foo() {
  try {
    const result = await doSomething();
    const newResult = await doSomethingElse(result);
    const finalResult = await doThirdThing(newResult);
    console.log(`Got the final result: ${finalResult}`);
  } catch(error) {
    failureCallback(error);
  }
}

Promise 拒绝事件

当 Promise 被拒绝时，会有下文所述的两个事件之一被派发到全局作用域（通常而言，就是window；如果是在 web worker 中使用的话，就是 Worker 或者其他 worker-based 接口）。这两个事件如下所示：

rejectionhandled
当 Promise 被拒绝、并且在 reject 函数处理该 rejection 之后会派发此事件。
unhandledrejection
当 Promise 被拒绝，但没有提供 reject 函数来处理该 rejection 时，会派发此事件。

以上两种情况中，PromiseRejectionEvent 事件都有两个属性，一个是 promise 属性，该属性指向被驳回的 Promise，另一个是 reason 属性，该属性用来说明 Promise 被驳回的原因。

元编程

从ECMAScript 2015 开始，JavaScript 获得了 Proxy 和 Reflect 对象的支持，允许你拦截并定义基本语言操作的自定义行为（例如，属性查找，赋值，枚举，函数调用等）。借助这两个对象，你可以在 JavaScript 元级别进行编程。

代理

在 ECMAScript 6 中引入的 Proxy 对象可以拦截某些操作并实现自定义行为。

let handler = {
  get: function(target, name){
    return name in target ? target[name] : 42;
  }
};

let p = new Proxy({}, handler);
p.a = 1;

console.log(p.a, p.b); // 1, 42

Proxy 对象定义了一个目标（这里是一个空对象）和一个实现了 get 陷阱的 handler 对象。这里，代理的对象在获取未定义的属性时不会返回 undefined，而是返回 42。

反射

Reflect 是一个内置对象，它提供了可拦截 JavaScript 操作的方法。该方法和代理句柄类似，但 Reflect 方法并不是一个函数对象。

客户端 Web API

当你给网页或者网页应用编写客户端的JavaScript时，你很快会遇上应用程序接口（API ）—— 这些编程特性可用来操控网站所基于的浏览器与操作系统的不同方面，或是操控由其他网站或服务端传来的数据。在这个单元里，我们将一同探索什么是API，以及如何使用一些在你开发中将经常遇见的API。

Web API简介
首先, 我们将从一个更高的角度来看这些API —它们是什么，它们怎么起作用的，你该怎么在自己的代码中使用它们以及他们是怎么构成的？我们依旧会再来看一看这些API有哪些主要的种类和他们会有哪些用处。
操作文档
当你在制作WEB页面和APP时,一个你最经常想要做的事就是通过一些方法来操作WEB文档。这其中最常见的方法就是使用文档对象模型Document Object Model (DOM)，它是一系列大量使用了 Document object的API来控制HTML和样式信息。通过这篇文章，我们来看看使用DOM方面的一些细节，以及其他一些有趣的API能够通过一些有趣的方式改变你的环境。
从服务器获取数据
在现代网页及其APP中另外一个很常见的任务就是与服务器进行数据交互时不再刷新整个页面，这看起来微不足道，但却对一个网页的展现和交互上起到了很大的作用，在这篇文章里，我们将阐述这个概念，然后来了解实现这个功能的技术，例如 XMLHttpRequest 和 Fetch API.（抓取API）。
第三方 API
到目前为止我们所涉及的API都是浏览器内置的，但并不代表所有。许多大网站如Google Maps, Twitter, Facebook, PayPal等，都提供他们的API给开发者们去使用他们的数据（比如在你的博客里展示你分享的推特内容）或者服务（如在你的网页里展示定制的谷歌地图或接入Facebook登录功能）。这篇文章介绍了浏览器API和第三方API 的差别以及一些最新的典型应用。
绘制图形
浏览器包含多种强大的图形编程工具，从可缩放矢量图形语言Scalable Vector Graphics (SVG) language，到HTML绘制元素元素(The Canvas API and WebGL). 这篇文章提供了部分canvas的简介，以及让你更深入学习的资源。
视频和音频 API
HTML5能够通过元素标签嵌入富媒体—— and ——而将有自己的API来控制回放，搜索等功能。本文向您展示了如何创建自定义播放控制等常见的任务。
客户端存储
现代web浏览器拥有很多不同的技术，能够让你存储与网站相关的数据，并在需要时调用它们，能够让你长期保存数据、保存离线网站及其他实现其他功能。本文解释了这些功能的基本原理。

详细的内容以后在慢慢补充吧，这种 api 对于我来说没多大作用，我还是主要在语言方面多了解一些。

重新介绍 JavaScript（JS 教程）

为什么会有这一篇“重新介绍”呢？因为 JavaScript 堪称世界上被人误解最深的编程语言。虽然常被嘲为“玩具语言”，但在它看似简洁的外衣下，还隐藏着强大的语言特性。 JavaScript 目前广泛应用于众多知名应用中，对于网页和移动开发者来说，深入理解 JavaScript 就尤为必要。

我们有必要先从这门语言的历史谈起。在1995 年 Netscape 一位名为 Brendan Eich 的工程师创造了 JavaScript，随后在 1996 年初，JavaScript 首先被应用于 Netscape 2 浏览器上。最初的 JavaScript 名为 LiveScript，但是因为一个糟糕的营销策略而被重新命名，该策略企图利用Sun Microsystem的Java语言的流行性，将它的名字从最初的 LiveScript 更改为 JavaScript——尽管两者之间并没有什么共同点。这便是之后混淆产生的根源。

几个月后，Microsoft 随 IE 3 发布推出了一个与之基本兼容的语言 JScript。又过了几个月，Netscape 将 JavaScript 提交至 Ecma International（一个欧洲标准化组织）， ECMAScript 标准第一版便在 1997 年诞生了，随后在 1999 年以 ECMAScript 第三版的形式进行了更新，从那之后这个标准没有发生过大的改动。由于委员会在语言特性的讨论上发生分歧，ECMAScript 第四版尚未推出便被废除，但随后于 2009 年 12 月发布的 ECMAScript 第五版引入了第四版草案加入的许多特性。第六版标准已经于 2015 年 6 月发布。

与大多数编程语言不同，JavaScript 没有输入或输出的概念。它是一个在宿主环境（host environment）下运行的脚本语言，任何与外界沟通的机制都是由宿主环境提供的。浏览器是最常见的宿主环境，但在非常多的其他程序中也包含 JavaScript 解释器，如 Adobe Acrobat、Adobe Photoshop、SVG 图像、Yahoo! 的 Widget 引擎，Node.js 之类的服务器端环境，NoSQL 数据库（如开源的 Apache CouchDB）、嵌入式计算机，以及包括 GNOME （注：GNU/Linux 上最流行的 GUI 之一）在内的桌面环境等等。

概览

JavaScript 是一种多范式的动态语言，它包含类型、运算符、标准内置（ built-in）对象和方法。它的语法来源于 Java 和 C，所以这两种语言的许多语法特性同样适用于 JavaScript。JavaScript 通过原型链而不是类来支持面向对象编程（有关 ES6 类的内容参考这里Classes，有关对象原型参考见此继承与原型链）。JavaScript同样支持函数式编程——因为它们也是对象，函数也可以被保存在变量中，并且像其他对象一样被传递。

先从任何编程语言都不可缺少的组成部分——“类型”开始。JavaScript 程序可以修改值（value），这些值都有各自的类型。JavaScript 中的类型包括：

Number（数字）
String（字符串）
Boolean（布尔）
Function（函数）
Object（对象）
Symbol（ES2015 新增）

还有看上去有些…奇怪的 undefined（未定义）类型和 null（空）类型。此外还有Array（数组）类型，以及分别用于表示日期和正则表达式的 Date（日期）和 RegExp（正则表达式），这三种类型都是特殊的对象。严格意义上说，Function（函数）也是一种特殊的对象。所以准确来说，JavaScript 中的类型应该包括这些：

Number（数字）
String（字符串）
Boolean（布尔）
Symbol（符号）（ES2015 新增）
Object（对象）
- Function（函数）
- Array（数组）
- Date（日期）
- RegExp（正则表达式）
null（空）
undefined（未定义）

JavaScript 还有一种内置的 Error（错误）类型。但是，如果我们继续使用上面的分类，事情便容易得多；所以，现在，我们先讨论上面这些类型。

数字

根据语言规范，JavaScript 采用“遵循 IEEE 754 标准的双精度 64 位格式”（”double-precision 64-bit format IEEE 754 values”）表示数字。——在JavaScript（除了BigInt）当中，并不存在整数/整型(Integer)。

console.log(3 / 2);             // 1.5,not 1
console.log(Math.floor(3 / 2)); // 1

// 你可以使用内置函数 parseInt() 将字符串转换为整型。

parseInt("123", 10); // 123
parseInt("010", 10); // 10

// 一些老版本的浏览器会将首字符为“0”的字符串当做八进制数字，2013 年以前的 JavaScript 实现

parseInt("010");  //  8
parseInt("0x10"); // 16

// 这是因为字符串以数字 0 开头，parseInt()函数会把这样的字符串视作八进制数字；
// 同理，0x开头的字符串则视为十六进制数字。

JavaScript 还有两个特殊值：Infinity（正无穷）和 -Infinity（负无穷）：
可以使用内置函数 isFinite() 来判断一个变量是否是一个有穷数，如果类型为Infinity, -Infinity 或 NaN则返回false：

1 / 0; //  Infinity
-1 / 0; // -Infinity

isFinite(1/0); // false
isFinite(Infinity); // false
isFinite(-Infinity); // false
isFinite(NaN); // false

isFinite(0); // true
isFinite(2e64); // true

isFinite("0"); // true
// 如果是纯数值类型的检测，则返回 false：
Number.isFinite("0"); // false

字符串

JavaScript 中的字符串是一串Unicode 字符序列。这对于那些需要和多语种网页打交道的开发者来说是个好消息。更准确地说，它们是一串UTF-16编码单元的序列，每一个编码单元由一个 16 位二进制数表示。每一个Unicode字符由一个或两个编码单元来表示。

其他类型

与其他类型不同，JavaScript 中的 null 表示一个空值（non-value），必须使用 null 关键字才能访问，undefined 是一个“undefined（未定义）”类型的对象，表示一个未初始化的值，也就是还没有被分配的值。我们之后再具体讨论变量，但有一点可以先简单说明一下，JavaScript 允许声明变量但不对其赋值，一个未被赋值的变量就是 undefined 类型。还有一点需要说明的是，undefined 实际上是一个不允许修改的常量。

JavaScript 包含布尔类型，这个类型的变量有两个可能的值，分别是 true 和 false（两者都是关键字）。根据具体需要，JavaScript 按照如下规则将变量转换成布尔类型：

false、0、空字符串（””）、NaN、null 和 undefined 被转换为 false
所有其他值被转换为 true

变量

在 JavaScript 中声明一个新变量的方法是使用关键字 let 、const 和 var：

let 语句声明一个块级作用域的本地变量，并且可选的将其初始化为一个值。
const 允许声明一个不可变的常量。这个常量在定义域内总是可见的。
var 是最常见的声明变量的关键字。它没有其他两个关键字的种种限制。这是因为它是传统上在 JavaScript 声明变量的唯一方法。
使用 var 声明的变量在它所声明的整个函数都是可见的。

剩下的对象，函数就不一一记录了，其实跟上面的没多大区别，只是强化一下记忆。有语言基础的人应该会很好理解这些内容。

最后

JavaScript还有很多的内容，继承和原型链是特别重要的内容，下一篇文章会详细聊一聊。

参考文档

JavaScript

macbook-键盘连击问题

2020-09-10T16:00:00.000Z

最近一段时间，我的笔记本（17年款 macbook pro 13寸）经常出现键盘连击问题。

最大的表现是 e/n/i 这几个按键，按下的时候，会有概率的出现两个或三个。

这不是个案

搜索了一下，有不少人都反馈了相同的问题，比如

2018 款 MacBook Pro 键盘连击问题。。。
MacBook Pro 键盘又连击了~😤🤪

而且苹果官方确实也承认了，这一代的键盘确实存在设计问题。

临时解决方案

根据大家的经验，找到了一款软件 Unshaky ，号称可以通过软件识别连击问题。

论坛中也有人说通过这个软件解决了。

Unshaky tries to address an issue on the butterfly keyboard (Macbook, Macbook Air 2018 & MacBook Pro 2016 and later): Double Key Press (See “User complaints“ below).

Apple made it difficult to replace only the keyboard and it costs hundreds of dollars. Unshaky might save your keyboard by dismissing such “second key hits” (any key presses that occur no later than x milliseconds after the previous effective one). I fixed my “w” key with Unshaky, and if it does not work for you, open an issue here. The image below illustrates how Unshaky works.

[May 2019] Apple extends the service program to cover all MacBook (Air & Pro) with 3rd gen butterfly keyboards.

我也暂时用这个方案解决了三个按键连击的问题。

终极解决方案

之所以存在连击问题，大概率是因为这一代的键盘中进灰了，影响了按压时候的判断。

苹果官方给出的解决方案，简单的说就是用压缩空气喷键盘。

这么好的东西，哪里买呢

压缩空气罐淘宝上很多，20多块钱，不用买很多，一罐就够用了。除了解决键盘，还可以清理相机之类的设备。

记得不要买成别的气罐了（比如带WD-40，那是用于润滑去锈的，不要买），要纯净空气那种。

为什么不用吸尘器或者电吹风呢

理论上来说，吸尘器和电吹风效果是类似的，但是不能保证你身边的空气足够干净，万一把新的灰尘吹进去了岂不是…

使用方法

如果您的 MacBook（2015 年及更新机型）或 MacBook Pro（2016 年及更新机型）上的某个按键无反应，或某个按键按下时的触感与其他按键不同，请按照以下步骤用压缩空气来清洁键盘。

当您按照这些步骤进行操作时，应务必使用压缩空气自带的喷管来控制气流，在喷气时保持喷管末端距离键盘半英寸远。还要注意，喷气时不要颠倒瓶体。

以 75 度角握持 Mac 笔记本电脑，这样电脑不会完全垂直。
按从左到右的方式将压缩空气喷向键盘，或仅喷向受影响的按键。
将 Mac 笔记本电脑向右侧旋转，然后再次按从左到右的方式喷向键盘。
这一次将 Mac 笔记本电脑向左侧旋转，然后重复以上操作。

具体方法还是就要查看苹果的官方帮助文档。

更新后续的使用情况

总的来说还是Unshaky还是很好用的，可以解决大部分的键盘连击问题，但是有时候键盘会有3次或者以上的连击，Unshaky没法很完美的解决这个问题。

Python-Flask基础篇(二)

2020-03-21T11:12:10.000Z

前言

前面介绍了Flask和HTTP的基础知识，下面会介绍Flask的基础用法

第4章表单

在Web程序中，表单是和用户交互最常见的方式之一。用户注册、登录、撰写文章、编辑设置，无一不用到表单。不过，表单的处理却并不简单。
你不仅要创建表单，验证用户输入的内容，向用户显示错误提示，还要获取并保存数据。幸运的是，强大的WTForms可以帮我们解决这些问题。
WTForms是一个使用Python编写的表单库，它使得表单的定义、验证（服务器端）和处理变得非常轻松。这一章我们会介绍在Web 程序中处理表单的方法和技巧。

使用Flask-WTF处理表单

扩展Flask-WTF集成了WTForms，使用它可以在Flask中更方便地使用WTForms。Flask-WTF将表单数据解析、CSRF保护、文件上传等功能与Flask集成，另外还附加了reCAPTCHA支持。

Flask-WTF默认为每个表单启用CSRF保护，它会为我们自动生成和验证CSRF令牌。默认情况下，Flask-WTF使用程序密钥来对CSRF令牌进行签名，所以我们需要为程序设置密钥：

1	app.secret_key = 'secret string'

定义WTForms表单类

当使用WTForms创建表单时，表单由Python类表示，这个类继承从 WTForms导入的Form基类。一个表单由若干个输入字段组成，这些字段分别用表单类的类属性来表示（字段即Field，你可以简单理解为表单内的输入框、按钮等部件）。下面定义了一个LoginForm类，最终会生成我们在前面定义的HTML表单：

from wtforms import Form, StringField, PasswordField, BooleanField, SubmitField
from wtforms.validators import DataRequired, Length


# 4.2.1 basic form example
class LoginForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired()])
    password = PasswordField('Password', validators=[DataRequired(), Length(8, 128)])
    remember = BooleanField('Remember me')
    submit = SubmitField('Log in')

每个字段属性通过实例化WTForms提供的字段类表示。字段属性的名称将作为对应HTML元素的name属性及id属性值。

当使用Flask-WTF定义表单时，我们仍然使用WTForms提供的字段类和验证器，创建的方式也完全相同，只不过表单类要继承Flask-WTF提供的FlaskForm类。FlaskForm类继承自Form类，进行了一些设置，并附加了一些辅助方法，以便与Flask集成。

输出HTML代码

以我们使用WTForms创建的LoginForm为例，实例化表单类，然后将实例属性转换成字符串或直接调用就可以获取表单字段对应的HTML代码：

>>> form = LoginForm() >>> form.username()
u''
>>> form.submit()
u''

在创建HTML表单时，我们经常会需要使用HTML元素的其他属性来对字段进行设置。比如，添加class属性设置对应的CSS类为字段添加样式；添加placeholder属性设置占位文本。默认情况下，WTForms输出的字段HTML代码只会包含id和name属性，属性值均为表单类中对应的字段属性名称。如果要添加额外的属性，通常有两种方法。

使用render_kw属性

1	username = StringField('Username', render_kw={'placeholder': 'Your Username'})

1	<input type="text" id="username" name="username" placeholder="Your Username">

在调用字段时传入

1 2	>>> form.username(style='width: 200px;', class_='bar') u''

在模板中渲染表单

为了能够在模板中渲染表单，我们需要把表单类实例传入模板。首先在视图函数里实例化表单类LoginForm，然后在render_template()函数中使用关键字参数form将表单实例传入模板。

from flask import Flask, render_template, redirect, url_for, flash
from forms import LoginForm


@app.route('/basic')
def basic():
    form = LoginForm()
    return render_template('login.html', form=form)

<form method="post"> {{ form.csrf_token }}
    
    {{ form.username.label }}{{ form.username }}<br>
    {{ form.password.label }}{{ form.password }}<br>
    {{ form.remember }}{{ form.remember.label }}<br>
    {{ form.submit }}<br>
form>

需要注意的是，在上面的代码中，除了渲染各个字段的标签和字段本身，我们还调用了form.csrf_token属性渲染Flask-WTF为表单类自动创建的CSRF令牌字段。form.csrf_token字段包含了自动生成的CSRF令牌值，在提交表单后会自动被验证，为了确保表单通过验证，我们必须在表单中手动渲染这个字段。

处理表单数据

表单数据的处理涉及很多内容，除去表单提交不说，从获取数据到保存数据大致会经历以下步骤：

解析请求，获取表单数据。
对数据进行必要的转换，比如将勾选框的值转换成Python的布尔值。
验证数据是否符合要求，同时验证CSRF令牌。
如果验证未通过则需要生成错误消息，并在模板中显示错误消息。
如果通过验证，就把数据保存到数据库或做进一步处理。

除非是简单的程序，否则手动处理不太现实，使用Flask-WTF和 WTForms可以极大地简化这些步骤。

提交表单

在HTML中，当

标签声明的表单中类型为submit的提交字段被单击时，就会创建一个提交表单的HTTP请求，请求中包含表单各个字段的数据。
表单的提交行为主要由三个属性控制，如下图所示。

form标签的action属性用来指定表单被提交的目标URL，默认为当前URL，也就是渲染该模板的路由所在的URL。如果你要把表单数据发送到其他URL，可以自定义这个属性值。

验证表单数据

表单数据的验证是Web表单中最重要的主题之一，这一节我们会学习如何使用Flask-WTF验证并获取表单数据。

客户端验证和服务器端验证
表单的验证通常分为以下两种形式：
- 客户端验证
  客户端验证（client side validation）是指在客户端（比如Web浏览器）对用户的输入值进行验证。比如，使用HTML5内置的验证属性即可实现基本的客户端验证（type、required、min、max、accept等）。比如，下面的username字段添加了required标志：
1
<input type="text" name="username" required>
- 服务器端验证
服务器端验证（server side validation）是指用户把输入的数据提交到服务器端，在服务器端对数据进行验证。如果验证出错，就在返回的响应中加入错误信息。用户修改后再次提交表单，直到通过验证。我们在Flask程序中使用WTForms实现的就是服务器端验证。
WTForms验证机制
WTForms验证表单字段的方式是在实例化表单类时传入表单数据，然后对表单实例调用validate()方法。这会逐个对字段调用字段实例化时定义的验证器，返回表示验证结果的布尔值。如果验证失败，就把错误消息存储到表单实例的errors属性对应的字典中，验证的过程如下所示：

>>> from wtforms import Form, StringField, PasswordField, BooleanField
>>> from wtforms.validators import DataRequired, Length
>>> class LoginForm(Form):
... username = StringField('Username', validators=[DataRequired()])
... password = PasswordField('Password', validators=[DataRequired() , Length(8, 128)])
>>> form = LoginForm(username='', password='123')
>>> form.data
# 表单数据字典
{'username': '', 'password': '123'}
>>> form.validate()
False >>> form.errors
# 错误消息字典
{'username': [u'This field is required.'], 'password': [u'Field must be at least 6 characters long.']}
>>> form2 = LoginForm(username='greyli', password='123456')
>>> form2.data
{'username': 'greyli', 'password': '123456'}
>>> form2.validate()
True
>>> form2.errors {}

在视图函数中验证表单
因为现在的basic_form视图同时接收两种类型的请求：GET请求和POST请求。所以我们要根据请求方法的不同执行不同的代码。具体来说：首先是实例化表单，如果是GET请求，那么就渲染模板；如果是 POST请求，就调用validate()方法验证表单数据。

@app.route('/basic', methods=['GET', 'POST'])
def basic():
    form = LoginForm()
    if form.validate_on_submit():
        username = form.username.data
        flash('Welcome home, %s!' % username)
        return redirect(url_for('index'))
    return render_template('login.html', form=form)

在模板中渲染错误消息

如果form.validate_on_submit()返回False，那么说明验证没有通过。对于验证未通过的字段，WTForms会把错误消息添加到表单类的 errors属性中，这是一个匹配作为表单字段的类属性到对应的错误消息列表的字典。我们一般会直接通过字段名来获取对应字段的错误消息列表，即"form.字段名.errors"。比如，form.name.errors返回name字段的错误消息列表。

<form method="post">
    {{ form.csrf_token }}
    {{ form.username.label }}<br>
    {{ form.username() }}<br>
    {% for message in form.username.errors %}
    <small class="error">{{ message }}small><br>
    {% endfor %} {{ form.password.label }}<br>
    {{ form.password }}<br>
    {% for message in form.password.errors %}
    <small class="error">{{ message }}small><br>
    {% endfor %}
    {{ form.remember }}{{ form.remember.label }}<br>
    {{ form.submit }}<br>
form>

第5章数据库(重点)

数据库是大多数动态Web程序的基础设施，只要你想把数据存储下来，就离不开数据库。我们这里提及的数据库（Database）指的是由存储数据的单个或多个文件组成的集合，它是一种容器，可以类比为文件柜。而人们通常使用数据库来表示操作数据库的软件，这类管理数据库的软件被称为数据库管理系统（DBMS，Database Management System），常见的DBMS有MySQL、PostgreSQL、SQLite、MongoDB等。为了便于理解，我们可以把数据库看作一个大仓库，仓库里有一些负责搬运货物（数据）的机器人，而DBMS就是操控机器人搬运货物的程序。

数据库的分类

数据库一般分为两种，SQL（Structured Query Language，结构化查询语言）数据库和NoSQL（Not Only SQL，泛指非关系型）数据库。

SQL

SQL数据库指关系型数据库，常用的SQL DBMS主要包括SQL Server、Oracle、MySQL、PostgreSQL、SQLite等。关系型数据库使用表来定义数据对象，不同的表之间使用关系连接。

在SQL数据库中，每一行代表一条记录（record），每条记录又由不同的列（column）组成。在存储数据前，需要预先定义表模式（schema），以定义表的结构并限定列的输入数据类型。
为了避免在措辞上引起误解，我们先了解几个基本概念：

表（table）：存储数据的特定结构。
模式（schema）：定义表的结构信息。
列/字段（column/field）：表中的列，存储一系列特定的数据，列组成表。
行/记录（row/record）：表中的行，代表一条记录。
标量（scalar）：指的是单一数据，与之相对的是集合（collection）。

NoSQL

NoSQL最初指No SQL或No Relational，现在NoSQL社区一般会解释为Not Only SQL。NoSQL数据库泛指不使用传统关系型数据库中的表格形式的数据库。近年来，NoSQL数据库越来越流行，被大量应用在实时（real-time）Web程序和大型程序中。与传统的SQL数据库相比，它在速度和可扩展性方面有很大的优势，除此之外还拥有无模式（schema- free）、分布式、水平伸缩（horizontally scalable）等特点。

最常用的两种NoSQL数据库如下所示：

文档存储（document store）
文档存储是NoSQL数据库中最流行的种类，它可以作为主数据库使用。文档存储使用的文档类似SQL数据库中的记录，文档使用类JSON格式来表示数据。常见的文档存储DBMS有MongoDB、CouchDB等。
键值对存储（key-value store）
键值对存储在形态上类似Python中的字典，通过键来存取数据，在读取上非常快，通常用来存储临时内容，作为缓存使用。常见的键值对 DBMS有Redis、Riak等，其中Redis不仅可以管理键值对数据库，还可以作为缓存后端（cache backend）和消息代理（message broker）。
另外，还有列存储（column store，又被称为宽列式存储）、图存储（graph store）等类型的NoSQL数据库，这里不再展开介绍。

ORM魔法

在Web应用里使用原生SQL语句操作数据库主要存在下面两类问题：

手动编写SQL语句比较乏味，而且视图函数中加入太多SQL语句会降低代码的易读性。另外还会容易出现安全问题，比如SQL注入。
常见的开发模式是在开发时使用简单的SQLite，而在部署时切换到MySQL等更健壮的DBMS。但是对于不同的DBMS，我们需要使用不同的Python接口库，这让DBMS的切换变得不太容易。

尽管使用ORM可以避免SQL注入问题，但你仍然需要对传入的查询参数进行验证。
另外，在执行原生SQL语句时也要注意避免使用字符串拼接或字符串格式化的方式传入参数。
使用ORM可以很大程度上解决这些问题。它会自动帮你处理查询参数的转义，尽可能地避免SQL注入的发生。
另外，它为不同的DBMS提供统一的接口，让切换工作变得非常简单。
ORM扮演翻译的角色，能够将我们的Python语言转换为DBMS能够读懂的SQL指令，让我们能够使用Python来操控数据库。

尽管ORM非常方便，但如果你对SQL相当熟悉，那么自己编写SQL代码可以获得更大的灵活性和性能优势。
就像是使用IDE一样，ORM对初学者来说非常方便，但进阶以后你也许会想要自己掌控一切。
ORM把底层的SQL数据实体转化成高层的Python对象，这样一来，你甚至不需要了解SQL，只需要通过Python代码即可完成数据库操作，ORM主要实现了三层映射关系：

表→Python类。
字段（列）→类属性。
记录（行）→类实例。

比如，我们要创建一个contacts表来存储留言，其中包含用户名称和电话号码两个字段。
在SQL中，下面的代码用来创建这个表，要向表中插入一条记录，需要使用下面的SQL语句：

CREATE TABLE contacts(
    name varchar(100) NOT NULL,
    phone_number varchar(32),
);
-- 插入一条记录
INSERT INTO contacts(name, phone_number) VALUES('Grey Li', '12345678');

如果使用ORM，我们可以使用类似下面的Python类来定义这个表：
使用ORM则只需要创建一个Contact类的实例，传入对应的参数表示各个列的数据即可。
下面的代码和使用上面的SQL语句效果相同：

from foo_orm import Model, Column, String


class Contact(Model):
    __tablename__ = 'contacts'
    name = Column(String(100), nullable=False)
    phone_number = Column(String(32))

# 插入一条记录
contact = Contact(name='Grey Li', phone_number='12345678')

除了便于使用，ORM还有下面这些优点：

灵活性好。你既能使用高层对象来操作数据库，又支持执行原生 SQL语句。
提升效率。从高层对象转换成原生SQL会牺牲一些性能，但这微不足道的性能牺牲换取的是巨大的效率提升。
可移植性好。ORM通常支持多种DBMS，包括MySQL、PostgreSQL、Oracle、SQLite等。你可以随意更换DBMS，只需要稍微改动少量配置。

使用Python实现的ORM有SQLAlchemy、Peewee、PonyORM等。其中SQLAlchemy是Python社区使用最广泛的ORM之一，我们将介绍如何在Flask程序中使用它。SQL-Alchemy，直译过来就是SQL炼金术，下一节我们会见识到SQLAlchemy的神奇力量。

使用Flask-SQLAlchemy管理数据库

扩展Flask-SQLAlchemy集成了SQLAlchemy，它简化了连接数据库服务器、管理数据库操作会话等各类工作，让Flask中的数据处理体验变得更加轻松。
下面在示例程序中实例化Flask-SQLAlchemy提供的SQLAlchemy类，传入程序实例app，以完成扩展的初始化。

import os
from flask_sqlalchemy import SQLAlchemy


app = Flask(__name__)
app.jinja_env.trim_blocks = True
app.jinja_env.lstrip_blocks = True

app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', 'secret string')

app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv(
    'DATABASE_URL', 'sqlite:///' + os.path.join(app.root_path, 'data.db'))
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app=app)

连接数据库服务器

DBMS通常会提供数据库服务器运行在操作系统中。要连接数据库服务器，首先要为我们的程序指定数据库URI（Uniform Resource
Identifier，统一资源标识符）。数据库URI是一串包含各种属性的字符串，其中包含了各种用于连接数据库的信息。

在Flask-SQLAlchemy中，数据库的URI通过配置变量SQLALCHEMY_DATABASE_URI设置，默认为SQLite内存型数据库(sqlite:///:memory:)。SQLite是基于文件的DBMS，不需要设置数据库服务器，只需要指定数据库文件的绝对路径。

在生产环境下更换到其他类型的DBMS时，数据库URL会包含敏感信息，所以这里优先从环境变量DATABASE_URL获取(注意这里为了便于理解使用了URL，而不是URI)。

安装并初始化Flask-SQLAlchemy后，启动程序时会看到命令行下有一行警告信息。这是因为Flask-SQLAlchemy建议你设置 SQLALCHEMY_TRACK_MODIFICATIONS配置变量，这个配置变量决定是否追踪对象的修改，这用于Flask-SQLAlchemy的事件通知系统。这个配置键的默认值为None，如果没有特殊需要，我们可以把它设为False来关闭警告信息。

1	app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

定义数据库模型

用来映射到数据库表的Python类通常被称为数据库模型
(model)，一个数据库模型类对应数据库中的一个表。定义模型即使用Python类定义表模式，并声明映射关系。所有的模型类都需要继承Flask-SQLAlchemy提供的db.Model基类。本章的示例程序是一个笔记程序，笔记保存到数据库中，你可以通过程序查询、添加、更新和删除笔记。

class Note(db.Model):
    """
    创建一个数据库Model
    """
    id = db.Column(db.Integer, primary_key=True)
    body = db.Column(db.Text)

在上面的模型类中，表的字段（列）由db.Column类的实例表示，字段的类型通过Column类构造方法的第一个参数传入。在这个模型中，我们创建了一个类型为db.Integer的id字段和类型为db.Text的body列，分别存储整型和文本。

字段类型一般直接声明即可，如果需要传入参数，你也可以添加括号。对于类似String的字符串列，有些数据库会要求限定长度，因此最好为其指定长度。虽然使用Text类型可以存储相对灵活的变长文本，但从性能上考虑，我们仅在必须的情况下使用Text类型，比如用户发表的文章和评论等不限长度的内容。

一般情况下，字段的长度是由程序设计者自定的。尽管如此，也有一些既定的约束标准，比如姓名（英语）的长度一般不超过70个字符，中文名一般不超过20个字符，电子邮件地址的长度不超过254个字符，虽然各主流浏览器支持长达2048个字符的URL，但在网站中用户资料设置的限度一般为255。尽管如此，对于超过一定长度的Email和URL，比如20个字符，会在显示时添加省略号的形式。显示的用户名（username）允许重复，通常要短一些，以不超过36个字符为佳。当然，在程序中，你可以根据需要来自由设定这些限制值。

创建数据库和表

如果把数据库（文件）看作一个仓库，为了方便取用，我们需要把货物按照类型分别放置在不同货架上，这些货架就是数据库中的表。创建模型类后，我们需要手动创建数据库和对应的表，也就是我们常说的建库和建表。这通过对我们的db对象调用create_all()方法实现。

数据库操作

现在我们创建了模型，也生成了数据库和表，是时候来学习常用的数据库操作了。数据库操作主要是CRUD，即Create（创建）、Read（读取/查询）、Update（更新）和Delete（删除）。
SQLAlchemy使用数据库会话来管理数据库操作，这里的数据库会话也称为事务(transaction)。Flask-SQLAlchemy自动帮我们创建会话，可以通过db.session属性获取。
数据库中的会话代表一个临时存储区，你对数据库做出的改动都会存放在这里。你可以调用add()方法将新创建的对象添加到数据库会话中，或是对会话中的对象进行更新。只有当你对数据库会话对象调用commit()方法时，改动才被提交到数据库，这确保了数据提交的一致性。另外，数据库会话也支持回滚操作。当你对会话调用rollback()方法时，添加到会话中且未提交的改动都将被撤销。

CRUD

这一节我们会在Python Shell中演示CRUD操作。默认情况下，Flask-SQLAlchemy(>=2.3.0版本)会自动为模型类生成一个__repr__()方法。当在Python Shell中调用模型的对象时，__repr__()方法会返回一条类似“<模型类名主键值>”的字符串，比如。

Create
添加一条新记录到数据库主要分为三步：
- 创建Python对象（实例化模型类）作为一条记录。
- 添加新创建的记录到数据库会话。
- 提交数据库会话。
Read
我们已经知道了如何向数据库里添加记录，那么如何从数据库里取回数据呢？使用模型类提供的query属性附加调用各种过滤方法及查询方法可以完成这个任务。

1	<模型类>.query.<过滤方法>.<查询方法>

从某个模型类出发，通过在query属性对应的Query对象上附加的过滤方法和查询函数对模型类对应的表中的记录进行各种筛选和调整，最终返回包含对应数据库记录数据的模型类实例，对返回的实例调用属性即可获取对应的字段数据。

精确的查询，比如获取指定字段值的记录。对模型类的query属性存储的Query对象调用过滤方法将返回一个更精确的Query对象(后面我们简称为查询对象)。因为每个过滤方法都会返回新的查询对象，所以过滤器可以叠加使用。在查询对象上调用前面介绍的查询方法，即可获得一个包含过滤后的记录的列表。

Update
更新一条记录非常简单，直接赋值给模型类的字段属性就可以改变字段值，然后调用commit()方法提交会话即可。
只有要插入新的记录或要将现有的记录添加到会话中时才需要使用 add()方法，单纯要更新现有的记录时只需要直接为属性赋新值，然后提交会话。
Delete
删除记录和添加记录很相似，不过要把add()方法换成delete() 方法，最后都需要调用commit()方法提交修改。

在视图函数里操作数据库

在视图函数里操作数据库的方式和我们在Python Shell中的练习大致相同，只不过需要一些额外的工作。比如把查询结果作为参数传入模板渲染出来，或是获取表单的字段值作为提交到数据库的数据。在这一节，我们将把上一节学习的所有数据库操作知识运用到一个简单的笔记程序中。这个程序可以让你创建、编辑和删除笔记，并在主页列出所有保存后的笔记。

Create

@app.route('/new', methods=['GET', 'POST'])
def new_note():
    form = NewNoteForm()
    if form.validate_on_submit():
        body = form.body.data
        note = Note(body=body)
        db.session.add(note)
        db.session.commit()
        flash('Your note is saved.')
        return redirect(url_for('index'))
    return render_template('new_note.html', form=form)

Read

@app.route('/note/all')
@app.route('/')
def index():
    form = DeleteNoteForm()
    notes = Note.query.all()
    return render_template('index.html', notes=notes, form=form)

Update

@app.route('/edit/', methods=['GET', 'POST'])
def edit_note(note_id):
    form = EditNoteForm()
    note = Note.query.get(note_id)
    if form.validate_on_submit():
        note.body = form.body.data
        db.session.commit()
        flash('Your note is updated.')
        return redirect(url_for('index'))
    form.body.data = note.body  # preset form input's value
    return render_template('edit_note.html', form=form)

Delete

@app.route('/delete/', methods=['POST'])
def delete_note(note_id):
    form = DeleteNoteForm()
    if form.validate_on_submit():
        note = Note.query.get(note_id)
        db.session.delete(note)
        db.session.commit()
        flash('Your note is deleted.')
    else:
        abort(400)
    return redirect(url_for('index'))

定义关系

在关系型数据库中，我们可以通过关系让不同表之间的字段建立联系。一般来说，定义关系需要两步，分别是创建外键和定义关系属性。在更复杂的多对多关系中，我们还需要定义关联表来管理关系。这一节我们会学习如何使用SQLAlchemy在模型之间建立几种基础的关系模式。

配置Python Shell上下文

在上面的许多操作中，每一次使用flask shell命令启动Python Shell后都要从app模块里导入db对象和相应的模型类。为什么不把它们自动集成到Python Shell上下文里呢？就像Flask内置的app对象一样。这当然可以实现！我们可以使用app.shell_context_processor装饰器注册一个shell上下文处理函数。

# handlers
@app.shell_context_processor
def make_shell_context():
    return dict(db=db, Note=Note)

一对多

我们将以作者和文章来演示一对多关系：一个作者可以写作多篇文章。

Author类用来表示作者，Article类用来表示文章

class Author(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(70), unique=True)
    phone = db.Column(db.String(20))
    articles = db.relationship('Article')  # collection


class Article(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(50), index=True)
    body = db.Column(db.Text)
    author_id = db.Column(db.Integer, db.ForeignKey('author.id'))

我们将在这两个模型之间建立一个简单的一对多关系，建立这个一对多关系的目的是在表示作者的Author类中添加一个关系属性articles，
作为集合（collection）属性，当我们对特定的Author对象调用articles属性会返回所有相关的Article对象。我们会在下面介绍如何一步步定义这个一对多关系。

定义外键
定义关系的第一步是创建外键。外键是（foreign key）用来在A表存储B表的主键值以便和B表建立联系的关系字段。因为外键只能存储单一数据（标量），所以外键总是在“多”这一侧定义，多篇文章属于同一个作者，所以我们需要为每篇文章添加外键存储作者的主键值以指向对应的作者。在Article模型中，我们定义一个author_id字段作为外键.
定义关系属性
定义关系的第二步是使用关系函数定义关系属性。关系属性在关系的出发侧定义，即一对多关系的“一”这一侧。一个作者拥有多篇文章，在Author模型中，我们定义了一个articles属性来表示对应的多篇文章
建立关系
建立关系有两种方式，第一种方式是为外键字段赋值，另一种方式是通过操作关系属性，将关系属性赋给实际的对象即可建立关系。

# 1.外键字段赋值
spam.author_id = 1
db.session.commit()

# 2.关系属性赋给实际的对象
foo.articles.append(spam)
foo.articles.append(ham)
db.session.commit()

建立双向关系
我们在Author类中定义了集合关系属性articles，用来获取某个作者拥有的多篇文章记录。在某些情况下，你也许希望能在Article类中定义一个类似的author关系属性，当被调用时返回对应的作者记录，这类返回单个值的关系属性被称为标量关系属性。而这种两侧都添加关系属性获取对方记录的关系我们称之为双向关系（bidirectional relationship）。

双向关系并不是必须的，但在某些情况下会非常方便。双向关系的建立很简单，通过在关系的另一侧也创建一个relationship()函数，我们就可以在两个表之间建立双向关系。

# one to many + bidirectional relationship
class Writer(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)
    books = db.relationship('Book', back_populates='writer')


class Book(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50), index=True)
    writer_id = db.Column(db.Integer, db.ForeignKey('writer.id'))
    writer = db.relationship('Writer', back_populates='books')

使用backref简化关系定义
在介绍关系函数的参数时，我们曾提到过，使用关系函数中的 backref参数可以简化双向关系的定义。以一对多关系为例，backref参数
用来自动为关系另一侧添加关系属性，作为反向引用（back reference），赋予的值会作为关系另一侧的关系属性名称。比如，我们在Author一侧的关系函数中将backref参数设为author，SQLAlchemy会自动为Article类添加一个author属性。

# 尽管使用backref非常方便，但通常来说“显式好过隐式”，所以我们 应该尽量使用back_populates定义双向关系。
# 为了便于理解，将使用back_populates来建立双向关系。
# one to many + bidirectional relationship + use backref to declare bidirectional relationship
class Singer(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(70), unique=True)
    songs = db.relationship('Song', backref='singer')


class Song(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50), index=True)
    singer_id = db.Column(db.Integer, db.ForeignKey('singer.id'))

在定义集合属性songs的关系函数中，我们将backref参数设为 singer，这会同时在Song类中添加了一个singer标量属性。这时我们仅需要定义一个关系函数，虽然singer是一个“看不见的关系属性”，但在使用上和定义两个关系函数并使用back_populates参数的效果完全相同。需要注意的是，使用backref允许我们仅在关系一侧定义另一侧的关系属性，但是在某些情况下，我们希望可以对在关系另一侧的关系属性进行设置，这时就需要使用backref()函数。backref()函数接收第一个参数作为在关系另一侧添加的关系属性名，其他关键字参数会作为关系另一侧关系函数的参数传入。比如，我们要在关系另一侧“看不见的 relationship()函数”中将uselist参数设为False。

多对一

一对多关系反过来就是多对一关系，这两种关系模式分别从不同的视角出发。一个作者拥有多篇文章，反过来就是多篇文章属于同一个作者。为了便于区分，我们使用居民和城市来演示多对一关系：多个居民居住在同一个城市。

# many to one
class Citizen(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(70), unique=True)
    city_id = db.Column(db.Integer, db.ForeignKey('city.id'))
    city = db.relationship('City')


class City(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(30), unique=True)

这时定义的city关系属性是一个标量属性（返回单一数据）。当Citizen.city被调用时，SQLAlchemy会根据外键字段city_id存储的值查找对应的City对象并返回，即居民记录对应的城市记录。
当建立双向关系时，如果不使用backref，那么一对多和多对一关系模式在定义上完全相同，这时可以将一对多和多对一视为同一种关系模式。在后面我们通常都会为一对多或多对一建立双向关系，这时将弱化这两种关系的区别，一律称为一对多关系。

一对一

我们将使用国家和首都来演示一对一关系：每个国家只有一个首都；反过来说，一个城市也只能作为一个国家的首都。

Country类表示国家，Capital类表示首都。建立一对一关系后，我们将在Country类中创建一个标量关系属性capital，调用它会获取单个Capital对象；我们还将在Capital类中创建一个标量关系属性country，调用它会获取单个的Country对象。

一对一关系实际上是通过建立双向关系的一对多关系的基础上转化而来。我们要确保关系两侧的关系属性都是标量属性，都只返回单个值，所以要在定义集合属性的关系函数中将uselist参数设为False，这时一对多关系将被转换为一对一关系。

# one to one
class Country(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(30), unique=True)
    capital = db.relationship('Capital', uselist=False)  # collection -> scalar


class Capital(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(30), unique=True)
    country_id = db.Column(db.Integer, db.ForeignKey('country.id'))
    country = db.relationship('Country')  # scalar

多对多

我们将使用学生和老师来演示多对多关系：每个学生有多个老师，而每个老师有多个学生。

Student类表示学生，Teacher类表示老师。在这两个模型之间建立多对多关系后，我们需要在Student类中添加一个集合关系属性teachers，调用它可以获取某个学生的多个老师，而不同的学生可以和同一个老师建立关系。

在一对多关系中，我们可以在“多”这一侧添加外键指向“一”这一侧，外键只能存储一个记录，但是在多对多关系中，每一个记录都可以与关系另一侧的多个记录建立关系，关系两侧的模型都需要存储一组外键。在SQLAlchemy中，要想表示多对多关系，除了关系两侧的模型外，我们还需要创建一个关联表（association table）。关联表不存储数据，只用来存储关系两侧模型的外键对应关系。

class Student(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(70), unique=True)
    grade = db.Column(db.String(20))
    teachers = db.relationship('Teacher',
                               secondary=association_table,
                               back_populates='students')  # collection


class Teacher(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(70), unique=True)
    office = db.Column(db.String(20))
    students = db.relationship('Student',
                               secondary=association_table,
                               back_populates='teachers')  # collection

关联表使用db.Table类定义，传入的第一个参数是关联表的名称。我们在关联表中定义了两个外键字段：teacher_id字段存储Teacher类的主键，student_id存储Student类的主键。借助关联表这个中间人存储的外键对，我们可以把多对多关系分化成两个一对多关系，如图所示。

更新数据库表

模型类（表）不是一成不变的，当你添加了新的模型类，或是在模型类中添加了新的字段，甚至是修改了字段的名称或类型，都需要更新表。在前面我们把数据库表类比成盛放货物的货架，这些货架是固定生成的。当我们在操控程序（DBMS/ORM）上变更了货架的结构时，仓库的货架也要根据变化相应进行调整。而且，当货架的结构产生变动时，我们还需要考虑如何处理货架上的货物（数据）。

重新生成表

重新调用create_all()方法并不会起到更新表或重新创建表的作用。如果你并不在意表中的数据，最简单的方法是使用drop_all()方法删除表以及其中的数据，然后再使用create_all()方法重新创建

使用Flask-Migrate迁移数据库

在开发时，以删除表再重建的方式更新数据库简单直接，但明显的缺陷是会丢掉数据库中的所有数据。在生产环境下，你绝对不会想让数据库里的数据都被删除掉，这时你需要使用数据库迁移工具来完成这个工作。
SQLAlchemy的开发者Michael Bayer写了一个数据库迁移工具 ——Alembic来帮助我们实现数据库的迁移，数据库迁移工具可以在不破坏数据的情况下更新数据库表的结构。蒸馏器（Alembic）是炼金术士最重要的工具，要学习SQL炼金术（SQLAlchemy），我们当然要掌握蒸馏器的使用。

我们实例化Flask-Migrate提供的Migrate类，进行初始化操作
实例化Migrate类时，除了传入程序实例app，还需要传入实例化 Flask-SQLAlchemy提供的SQLAlchemy类创建的db对象作为第二个参数。

from flask import Flask from flask_sqlalchemy
import SQLAlchemy from flask_migrate
import Migrate


app = Flask(__name__)
...
db = SQLAlchemy(app)
migrate = Migrate(app, db)
# 在db对象创建后调用

创建迁移环境
在开始迁移数据之前，需要先使用下面的命令创建一个迁移环境
迁移环境只需要创建一次。这会在你的项目根目录下创建一个migrations文件夹，其中包含了自动生成的配置文件和迁移版本文件夹。

1	flask db init

生成迁移脚本

使用migrate子命令可以自动生成迁移脚本：

$ flask db migrate -m "add note timestamp"
...
INFO [alembic.autogenerate.compare] Detected added column 'message.timestamp Generating /Path/to/your/database/migrations/versions/c52a02014635_add note_timestamp.py
...
done

这条命令可以简单理解为在flask里对数据库（db）进行迁移（migrate）。-m选项用来添加迁移备注信息。从上面的输出信息我们可以看到，Alembic检测出了模型的变化：表note新添加了一个timestamp列，并且相应生成了一个迁移脚本 c52a02014635_add_note_timestamp.py，

更新数据库

生成了迁移脚本后，使用upgrade子命令即可更新数据库

1
2
3

$ flask db upgrade
...
INFO [alembic.runtime.migration] Running upgrade -> c52a02014635, add note timestamp

如果还没有创建数据库和表，这个命令会自动创建；如果已经创建，则会在不损坏数据的前提下执行更新。

开发时是否需要迁移

在生产环境下，当对数据库结构进行修改后，进行数据库迁移是必要的。因为你不想损坏任何数据，毕竟数据是无价的。在生成自动迁移脚本后，执行更新之前，对迁移脚本进行检查，甚至是使用备份的数据库进行迁移测试，都是有必要的。

而在开发环境中，你可以按需要选择是否进行数据迁移。对于大多数程序来说，我们可以在开发时使用虚拟数据生成工具来生成虚拟数据，从而避免手动创建记录进行测试。这样每次更改表结构时，可以直接清除后重新生成，然后生成测试数据，这要比执行一次迁移简单很多（在后面我们甚至会学习通过一条命令完成所有工作），除非生成虚拟数据耗费的时间过长。

另外，在本地开发时通常使用SQLite作为数据库引擎。SQLite不支持ALTER语句，而这正是迁移工具依赖的工作机制。也就是说，当SQLite数据库表的字段删除或修改后，我们没法直接使用迁移工具进行更新，你需要手动添加迁移代码来进行迁移。在开发中，修改和删除列是很常见的行为，手动操作迁移会花费太多的时间。

总结

本来还有一章讲邮件的，但是邮件这部分太简单就不放在这里了。
基础篇（二）主要是讲数据库的知识，简单了解在Flask应用中使用数据库的方法，但数据库的内容还有很多，这里只是一个简单的介绍。
如果你想了解更多具体细节，SQLAlchemy提供的入门教程是个起步的好地方。
另外，如果还不熟悉SQL，那么有必要去学习一下，掌握SQL可以让你更高效地使用ORM。

这里也没有介绍在Flask中使用文档型NoSQL数据库的过程。
以流行的MongoDB为例，通过使用ODM（Object Document Mapper，对象文档映射），比如MongoEngine，或是对应的扩展Flask- MongoEngine，其操作数据库的方式和使用本章要介绍的SQLAlchemy基本相同。

Python-Flask基础篇(一)

2020-03-16T13:20:00.000Z

第1章初识Flask

Flask介绍

搭建开发环境，编写一个最小的Flask程序并运行它，了解 Flask基本知识

这一切开始于2010年4月1日，Armin Ronacher在网上发布了一篇关于“下一代Python微框架”的介绍文章，文章里称这个Denied框架不依赖 Python标准库，只需要复制一份deny.py放到你的项目文件夹就可以开始编程。伴随着一本正经的介绍、名人推荐语、示例代码和演示视频，这个“虚假”的项目让不少人都信以为真。

5天后， Flask就从这么一个愚人节玩笑诞生了。

Flask是使用Python编写的Web微框架。Web框架可以让我们不用关心底层的请求响应处理，更方便高效地编写Web程序。因为Flask核心简单且易于扩展，所以被称作微框架（micro framework）。Flask有两个主要依赖，一个是WSGI（Web Server Gateway Interface，Web服务器网关接口）工具集——Werkzeug，另一个是 Jinja2模板引擎。Flask只保留了Web开发的核心功能，其他的功能都由外部扩展来实现，比如数据库集成、表单认证、文件上传等。如果没有合适的扩展，你甚至可以自己动手开发。 Flask不会替你做决定，也不会限制你的选择。总之，Flask可以变成任何你想要的东西，一切都由你做主。

Flask（瓶子，烧瓶）的命名据说是对另一个Python Web框架—— Bottle的双关语/调侃，即另一种容器（另一个Python Web框架）。 Werkzeug是德语单词“工具（tool）”，而Jinja指日本神社，因为神社（庙）的英文temple与template（模板）相近而得名。

WSGI（Web Server Gateway Interface）是Python中用来规定Web服务器如何与Python Web程序进行沟通的标准，在本书的第三部分将进行详细介绍。

Flask与MVC架构

你也许会困惑为什么用来处理请求并生成响应的函数被称为“视图函数（view function）”，其实这个命名并不合理。在Flask中，这个命名的约定来自Werkzeug，而Werkzeug中URL匹配的实现主要参考了 Routes（一个URL匹配库），再往前追溯，Routes的实现又参考了Ruby on Rails。在Ruby on Rails中，术语views用来表示MVC（Model-View-Controller，模型-视图-控制器）架构中的 View。

MVC架构最初是用来设计桌面程序的，后来也被用于Web程序，应用了这种架构的Web框架有Django、Ruby on Rails等。在MVC架构中，程序被分为三个组件：数据处理（Model）、用户界面（View）、交互逻辑（Controller）。如果套用MVC架构的内容，那么Flask中视图函数的名称其实并不严谨，使用控制器函数（Controller Function）似乎更合适些，虽然它也附带处理用户界面。严格来说，Flask并不是MVC架构的框架，因为它没有内置数据模型支持。为了方便表述，在本书中，使用了app.route()装饰器的函数仍被称为视图函数，同时会使用“<函数名>视图”（比如index视图）的形式来代指某个视图函数。

粗略归类，如果想要使用Flask来编写一个MVC架构的程序，那么视图函数可以作为控制器（Controller），视图（View）则是我们将要介绍的使用Jinja2渲染的HTML模板，而模型（Model）可以使用其他库来实现，在后面我们会介绍使用SQLAlchemy来创建数据库模型。

本章小结

Flask 基础其实很简单，这次主要是复习之前的知识，基础就不过多介绍了。
本章我们学习了Flask程序的运作方式和一些基本概念，这为我们进一步学习打下了基础。
下面，我们会了解隐藏在Flask背后的重要角色 ——HTTP，并学习Flask是如何与之进行交互的。

第2章 Flask与HTTP

HTTP（Hypertext Transfer Protocol，超文本传输协议）定义了服务器和客户端之间信息交流的格式和传递方式，它是万维网（World Wide Web）中数据交换的基础。

请求响应循环

为了更贴近现实，我们以一个真实的URL为例：

http://helloflask.com/hello

当我们在浏览器中的地址栏中输入这个URL，然后按下Enter时，稍等片刻，浏览器会显示一个问候页面。
这背后到底发生了什么？你一定可以猜想到，这背后也有一个web程序运行着。
它负责接收用户的请求，并把对应的内容返回给客户端，显示在用户的浏览器上。
事实上，每一个Web应用都包含这种处理模式，即“请求-响应循环（Request-Response Cycle）”：
客户端发出请求，服务器端处理请求并返回响应，如图所示。

这是每一个Web程序的基本工作模式，如果再进一步，这个模式又包含着更多的工作单元，下图展示了一个Flask程序工作的实际流程。
从下图中可以看出，HTTP在整个流程中起到了至关重要的作用，它是客户端和服务器端之间沟通的桥梁。

当用户访问一个URL，浏览器便生成对应的HTTP请求，经由互联网发送到对应的Web服务器。
Web服务器接收请求，通过WSGI将HTTP 格式的请求数据转换成我们的Flask程序能够使用的Python数据。
在程序中，Flask根据请求的URL执行对应的视图函数，获取返回值生成响应。
响应依次经过WSGI转换生成HTTP响应，再经由Web服务器传递，最终被发出请求的客户端接收。
浏览器渲染响应中包含的HTML和CSS代码，并执行JavaScript代码，最终把解析后的页面呈现在用户浏览器的窗口中。

HTTP请求

URL是一个请求的起源。不论服务器是运行在美国洛杉矶，还是运行在我们自己的电脑上，当我们输入指向服务器所在地址的URL，都会向服务器发送一个HTTP请求。一个标准的URL由很多部分组成，以下面这个URL为例：

http://helloflask.com/hello?name=Grey

当我们在浏览器中访问这个URL时，随之产生的是一个发向http://helloflask.com所在服务器的请求。
请求的实质是发送到服务器上的一些数据，这种浏览器与服务器之间交互的数据被称为报文(message)，请求时浏览器发送的数据被称为请求报文(request message)，而服务器返回的数据被称为响应报文(response message)。

请求报文

请求报文由请求的方法、URL、协议版本、首部字段（header）以及内容实体组成。
报文由报文首部和报文主体组成，两者由空行分隔，请求报文的主体一般为空。
如果URL中包含查询字符串，或是提交了表单，那么报文主体将会是查询字符串和表单数据。
报文首部包含了请求的各种信息和设置，比如客户端的类型、是否设置缓存、语言偏好等。

Request对象

现在该让Flask的请求对象request出场了，这个请求对象封装了从客户端发来的请求报文，我们能从它获取请求报文中的所有数据。

请求解析和响应封装实际上大部分是由Werkzeug完成的，Flask子类化Werkzeug的请求（Request）和响应（Response）对象并添加了和程序相关的特定功能。

当Flask接收到请求后，请求对象会提供多个属性来获取URL的各个部分，常用的属性如下表所示。

除了URL，请求报文中的其他信息都可以通过request对象提供的属性和方法获取。

在Flask中处理请求

URL是指向网络上资源的地址。在Flask中，我们需要让请求的URL 匹配对应的视图函数，视图函数返回值就是URL对应的资源。

路由匹配
为了便于将请求分发到对应的视图函数，程序实例中存储了一个路由表（app.url_map），其中定义了URL规则和视图函数的映射关系。
当请求发来后，Flask会根据请求报文中的URL（path部分）来尝试与这个表中的所有URL规则进行匹配，调用匹配成功的视图函数。
如果没有找到匹配的URL规则，说明程序中没有处理这个URL的视图函数，Flask会自动返回404错误响应（Not Found，表示资源未找到）。
你可以尝试在浏览器中访问http://localhost:5000/nothing ，因为我们的程序中没有视图函数负责处理这个URL，所以你会得到404响应。
设置监听的HTTP方法
通过flask routes命令打印出的路由列表可以看到，每一个路由除了包含URL规则外，还设置了监听的HTTP方法。
GET是最常用的HTTP方法，所以视图函数默认监听的方法类型就是GET，HEAD、 OPTIONS方法的请求由Flask处理，而像DELETE、PUT等方法一般不会在程序中实现，在后面我们构建Web API时才会用到这些方法。

我们可以在app.route()装饰器中使用methods参数传入一个包含监听的HTTP方法的可迭代对象。
比如，下面的视图函数同时监听GET请求和POST请求：

1
2
3

@app.route('/hello', methods=['GET', 'POST'])
def hello():
    return 'Hello, Flask!
'

当某个请求的方法不符合要求时，请求将无法被正常处理。比如，在提交表单时通常使用POST方法，而如果提交的目标URL对应的视图函数只允许GET方法，这时Flask会自动返回一个405错误响应（Method Not Allowed，表示请求方法不允许）。
3. URL处理
从前面的路由列表中可以看到，除了/hello，这个程序还包含许多 URL规则，比如和go_back端点对应的/goback/。现在请尝试访问http://localhost:5000/goback/34 ，在URL中加入一个数字作为时光倒流的年数，你会发现加载后的页面中有通过传入的年数计算出的年份：“Welcome to 1984！”。仔细观察一下，你会发现URL规则中的变量部分有一些特别，表示为year变量添加了一个int转换器， Flask在解析这个URL变量时会将其转换为整型。

1
2
3

@app.route('goback/')
def go_back(year):
    return 'Welcome to %d!
' % (2018 - year)

请求钩子

有时我们需要对请求进行预处理（preprocessing）和后处理（postprocessing），这时可以使用Flask提供的一些请求钩子（Hook），它们可以用来注册在请求处理的不同阶段执行的处理函数（或称为回调函数，即Callback）。这些请求钩子使用装饰器实现，通过程序实例app调用，用法很简单：以before_request钩子（请求之前）为例，当你对一个函数附加了app.before_request装饰器后，就会将这个函数注册为before_request处理函数，每次执行请求前都会触发所有 before_request处理函数。

这些钩子使用起来和app.route()装饰器基本相同，每个钩子可以注册任意多个处理函数，函数名并不是必须和钩子名称相同，下面是一个基本示例：

假如我们创建了三个视图函数A、B、C，其中视图C使用了 after_this_request钩子，那么当请求A进入后，整个请求处理周期的请求处理函数调用流程如图2-7所示。下面是请求钩子的一些常见应用场景：

before_first_request：
在玩具程序中，运行程序前我们需要进行一些程序的初始化操作，比如创建数据库表，添加管理员用户。这些工作可以放到使用before_first_request装饰器注册的函数中。
before_request：
比如网站上要记录用户最后在线的时间，可以通过用户最后发送的请求时间来实现。为了避免在每个视图函数都添加更新在线时间的代码，我们可以仅在使用before_request钩子注册的函数中调用这段代码。
after_request：
我们经常在视图函数中进行数据库操作，比如更新、插入等，之后需要将更改提交到数据库中。提交更改的代码就可以放到after_request钩子注册的函数中。

另一种常见的应用是建立数据库连接，通常会有多个视图函数需要建立和关闭数据库连接，这些操作基本相同。一个理想的解决方法是在请求之前（before_request）建立连接，在请求之后（teardown_request）关闭连接。通过在使用相应的请求钩子注册的函数中添加代码就可以实现。这很像单元测试中的setUp()方法和tearDown()方法。

HTTP响应

在Flask程序中，客户端发出的请求触发相应的视图函数，获取返回值会作为响应的主体，最后生成完整的响应，即响应报文。

响应报文

响应报文主要由协议版本、状态码（status code）、原因短语（reason phrase）、响应首部和响应主体组成。
以发向localhost:5000/hello的请求为例，服务器生成的响应报文示意如下表所示。

响应报文的首部包含一些关于响应和服务器的信息，这些内容由 Flask生成，而我们在视图函数中返回的内容即为响应报文中的主体内容。
浏览器接收到响应后，会把返回的响应主体解析并显示在浏览器窗口上。
HTTP状态码用来表示请求处理的结果，表2-9是常见的几种状态码和相应的原因短语。

在Flask中生成响应

响应在Flask中使用Response对象表示，响应报文中的大部分内容由服务器处理，大多数情况下，我们只负责返回主体内容。
根据我们在上一节介绍的内容，Flask会先判断是否可以找到与请求 URL相匹配的路由，如果没有则返回404响应。
如果找到，则调用对应的视图函数，视图函数的返回值构成了响应报文的主体内容，正确返回时状态码默认为200。
Flask会调用make_response()方法将视图函数返回值转换为响应对象。
完整地说，视图函数可以返回最多由三个元素组成的元组：响应主体、状态码、首部字段。其中首部字段可以为字典，或是两元素元组组成的列表。

比如，普通的响应可以只包含主体内容：

@app.route('/hello')
def hello():
    ...
    return 'Hello, Flask!
'

默认的状态码为200，下面指定了不同的状态码：

@app.route('/hello')
def hello():
    ...
    return 'Hello, Flask!
', 201

有时你会想附加或修改某个首部字段。比如，要生成状态码为3XX 的重定向响应，需要将首部中的Location字段设置为重定向的目标 URL：

1
2
3

@app.route('/hello')
def hello():
    return '', 302, {'Location', 'http://www.example.com'}

现在访问http://localhost:5000/hello ，会重定向到http://www.example.com 。在多数情况下，除了响应主体，其他部分我们通常只需要使用默认值即可。

重定向
在Web程序中，我们经常需要进行重定向。比如，当某个用户在没有经过认证的情况下访问需要登录后才能访问的资源，程序通常会重定向到登录页面。
对于重定向这一类特殊响应，Flask提供了一些辅助函数。
除了像前面那样手动生成302响应，我们可以使用Flask提供的redirect（）函数来生成重定向响应，重定向的目标URL作为第一个参数。
前面的例子可以简化为：

from flask import Flask, redirect

@app.route('/hello')
def hello():
    return redirect('http://www.example.com')

使用redirect()函数时，默认的状态码为302，即临时重定向。如果你想修改状态码，可以在redirect()函数中作为第二个参数或使用code关键字传入。

如果要在程序内重定向到其他视图，那么只需在redirect()函数中
使用url_for()函数生成目标URL即可

from flask import Flask, redirect, url_for
...
@app.route('/hi')
def hi():
    ...
    return redierct(url_for('hello'))
# 重定向到/hello

错误响应
大多数情况下，Flask会自动处理常见的错误响应。HTTP错误对应的异常类在Werkzeug的werkzeug.exceptions模块中定义，抛出这些异常即可返回对应的错误响应。
如果你想手动返回错误响应，更方便的方法是使用Flask提供的abort()函数。在abort()函数中传入状态码即可返回对应的错误响应

from flask import Flask, abort
...
@app.route('/404')
def not_found():
    abort(404)

响应格式

在HTTP响应中，数据可以通过多种格式传输。大多数情况下，我们会使用HTML格式，这也是Flask中的默认设置。在特定的情况下，我们也会使用其他格式。
MIME类型（又称为media type或content type）是一种用来标识文件类型的机制，它与文件扩展名相对应，可以让客户端区分不同的内容类型，并执行不同的操作。一般的格式为“类型名/子类型名”，其中的子类型名一般为文件扩展名。
比如，HTML的MIME类型为“text/html”，png图片的MIME类型为“image/png”。完整的标准MIME类型列表可以在这里看到：https://www.iana.org/assignments/media-types/media-types.xhtml。

如果你想使用其他MIME类型，可以通过Flask提供的 make_response（）方法生成响应对象，传入响应的主体作为参数，然后使用响应对象的mimetype属性设置MIME类型

from flask import make_response
@app.route('/foo')
def foo():
    response = make_response('Hello, World!')
    response.mimetype = 'text/plain'
    return response

你也可以直接设置首部字段，比如response.headers['Content-Type']='text/xml；charset=utf-8'。但操作mimetype属性更加方便，而且不用设置字符集（charset）选项。

常用的数据格式有纯文本、HTML、XML和JSON，下面我们分别对这几种数据进行简单的介绍和分析。

纯文本
MIME类型：text/plain
事实上，其他几种格式本质上都是纯文本。比如同样是一行包含 HTML标签的文本Hello，Flask！，当MIME类型设置为纯文本时，浏览器会以文本形式显示Hello，Flask！；当 MIME类型声明为text/html时，浏览器则会将其作为标题1样式的HTML 代码渲染。
HTML
MIME类型：text/html
HTML指Hypertext Markup Language（超文本标记语言），是最常用的数据格式，也是Flask返回响应的默认数据类型。从我们在本书一开始的最小程序中的视图函数返回的字符串，到我们后面会学习的HTML模板，都是HTML。当数据类型为HTML时，浏览器会自动根据HTML标签以及样式类定义渲染对应的样式。
因为HTML常常包含丰富的信息，我们可以直接将HTML嵌入页面中，处理起来比较方便。因此，在普通的HTTP请求中我们使用HTTP作为响应的内容，这也是默认的数据类型。
XML
MIME类型：application/xml
XML指Extensible Markup Language（可扩展标记语言），它是一种简单灵活的文本格式，被设计用来存储和交换数据。XML的出现主要就是为了弥补HTML的不足：对于仅仅需要数据的请求来说，HTML提供的信息太过丰富了，而且不易于重用。XML和HTML一样都是标记性语言，使用标签来定义文本，但 HTML中的标签用于显示内容，而XML中的标签只用于定义数据。 XML一般作为AJAX请求的响应格式，或是Web API的响应格式。
JSON
MIME类型：application/json
JSON指JavaScript Object Notation（JavaScript对象表示法），是一种流行的、轻量的数据交换格式。它的出现又弥补了 XML的诸多不足：XML有较高的重用性，但XML相对于其他文档格式来说体积稍大，处理和解析的速度较慢。JSON轻量，简洁，容易阅读和解析，而且能和Web默认的客户端语言JavaScript更好地兼容。JSON 的结构基于“键值对的集合”和“有序的值列表”，这两种数据结构类似 Python中的字典（dictionary）和列表（list）。正是因为这种通用的数据结构，使得JSON在同样基于这些结构的编程语言之间交换成为可能。

来一块Cookie

HTTP是无状态（stateless）协议。也就是说，在一次请求响应结束后，服务器不会留下任何关于对方状态的信息。
但是对于某些Web程序来说，客户端的某些信息又必须被记住，比如用户的登录状态，这样才可以根据用户的状态来返回不同的响应。
为了解决这类问题，就有了Cookie技术。Cookie技术通过在请求和响应报文中添加Cookie数据来保存客户端的状态信息。

在Flask中，如果想要在响应中添加一个cookie，最方便的方法是使用Response类提供的set_cookie()方法。要使用这个方法，我们需要先使用make_response()方法手动生成一个响应对象，传入响应主体作为参数。这个响应对象默认实例化内置的Response类。

set_cookie视图用来设置cookie，它会将URL中的name变量的值设置到名为name的cookie里

from flask import Flask, make_response, url_for
...
@app.route('/set/')
def set_cookie(name):
    response = make_response(redirect(url_for('hello')))
    response.set_cookie('name', name)
    return response

当浏览器保存了服务器端设置的Cookie后，浏览器再次发送到该服务器的请求会自动携带设置的Cookie信息，Cookie的内容存储在请求首部的Cookie字段中，整个交互过程由上到下如下图所示。

在Flask中，Cookie可以通过请求对象的cookies属性读取。在修改后的hello视图中，如果没有从查询参数中获取到name的值，就从Cookie中寻找：

from flask import Flask, request
@app.route('/')
@app.route('/hello')
def hello():
    name = request.args.get('name')
    if name is None: name = request.cookies.get('name', 'Human')
    # 从Cookie中获取name值
    return 'Hello, %s
' % name

session：安全的Cookie

Cookie在Web程序中发挥了很大的作用，其中最重要的功能是存储用户的认证信息。我们先来看看基于浏览器的用户认证是如何实现的。
当我们使用浏览器登录某个社交网站时，会在登录表单中填写用户名和密码，单击登录按钮后，这会向服务器发送一个包含认证数据的请求。
服务器接收请求后会查找对应的账户，然后验证密码是否匹配，如果匹配，就在返回的响应中设置一个cookie，比如，login_user：greyli。
响应被浏览器接收后，cookie会被保存在浏览器中。当用户再次向这个服务器发送请求时，根据请求附带的Cookie字段中的内容，服务器上的程序就可以判断用户的认证状态，并识别出用户。
但是这会带来一个问题，在浏览器中手动添加和修改Cookie是很容易的事，仅仅通过浏览器插件就可以实现。
所以，如果直接把认证信息以明文的方式存储在Cookie里，那么恶意用户就可以通过伪造cookie的内容来获得对网站的权限，冒用别人的账户。
为了避免这个问题，我们需要对敏感的Cookie内容进行加密。方便的是，Flask提供了session对象用来将Cookie数据加密储存。

设置程序密钥
session通过密钥对数据进行签名以加密数据，因此，我们得先设置一个密钥。这里的密钥就是一个具有一定复杂度和随机性的字符串，比如“Drmhze6EPcv0fN_81Bj-nA”。
程序的密钥可以通过Flask.secret_key属性或配置变量SECRET_KEY 设置，比如：
更安全的做法是把密钥写进系统环境变量（在命令行中使用export 或set命令），或是保存在.env文件中：

app.secret_key = 'secret string'

SECRET_KEY=secret string
app.secret_key = SECRET_KEY

然后在程序脚本中使用os模块提供的getenv（）方法获取：

1
2
3

import os
# ...
app.secret_key = os.getenv('SECRET_KEY', 'secret string')

模拟用户认证
下面我们会使用session模拟用户的认证功能。代码清单2-5是用来登入用户的login视图。

from flask import redirect, session, url_for
@app.route('/login')
def login():
    session['logged_in'] = True
    # 写入session
    return redirect(url_for('hello'))

这个登录视图只是简化的示例，在实际的登录中，我们需要在页面上提供登录表单，供用户填写账户和密码，然后在登录视图里验证账户和密码的有效性。
session对象可以像字典一样操作，我们向session中添加一个logged-in cookie，将它的值设为True，表示用户已认证。
当我们使用session对象添加cookie时，数据会使用程序的密钥对其进行签名，加密后的数据存储在一块名为session的cookie里。

Flask上下文

我们可以把编程中的上下文理解为当前环境（environment）的快照（snapshot）。如果把一个Flask程序比作一条可怜的生活在鱼缸里的鱼的话，那么它当然离不开身边的环境。

上下文全局变量

每一个视图函数都需要上下文信息，在前面我们学习过Flask将请求报文封装在request对象中。按照一般的思路，如果我们要在视图函数中使用它，就得把它作为参数传入视图函数，就像我们接收URL变量一样。但是这样一来就会导致大量的重复，而且增加了视图函数的复杂度。

在前面的示例中，我们并没有传递这个参数，而是直接从Flask导入一个全局的request对象，然后在视图函数里直接调用request的属性获取数据。你一定好奇，我们在全局导入时request只是一个普通的Python对象，为什么在处理请求时，视图函数里的request就会自动包含对应请求的数据？这是因为Flask会在每个请求产生后自动激活当前请求的上下文，激活请求上下文后，request被临时设为全局可访问。而当每个请求结束后，Flask就销毁对应的请求上下文。

我们在前面说request是全局对象，但这里的“全局”并不是实际意义上的全局。我们可以把这些变量理解为动态的全局变量。
在多线程服务器中，在同一时间可能会有多个请求在处理。假设有三个客户端同时向服务器发送请求，这时每个请求都有各自不同的请求报文，所以请求对象也必然是不同的。
因此，请求对象只在各自的线程内是全局的。Flask通过本地线程（thread local）技术将请求对象在特定的线程和请求中全局可访问。具体内容和应用我们会在后面进行详细介绍。

我们在前面对session和request都了解得差不多了，这里简单介绍一下current_app和g。
你在这里也许会疑惑，既然有了程序实例app对象，为什么还需要 current_app变量。在不同的视图函数中，request对象都表示和视图函数对应的请求，也就是当前请求（current request）。而程序也会有多个程序实例的情况，为了能获取对应的程序实例，而不是固定的某一个程序实例，我们就需要使用current_app变量，后面会详细介绍。

因为g存储在程序上下文中，而程序上下文会随着每一个请求的进入而激活，随着每一个请求的处理完毕而销毁，所以每次请求都会重设这个值。我们通常会使用它结合请求钩子来保存每个请求处理前所需要的全局变量，比如当前登入的用户对象，数据库连接等。
在前面的示例中，我们在hello视图中从查询字符串获取name的值，如果每一个视图都需要这个值，那么就要在每个视图重复这行代码。借助g我们可以将这个操作移动到before_request处理函数中执行，然后保存到g的任意属性上：

from flask import g

@app.before_request
def get_name():
    g.name = request.args.get('name')

设置这个函数后，在其他视图中可以直接使用g.name获取对应的值。另外，g也支持使用类似字典的get()、pop()以及setdefault()方法进行操作。

激活上下文

阳光柔和，鱼儿在水里欢快地游动，这一切都是上下文存在后的美好景象。如果没有上下文，我们的程序只能直挺挺地躺在鱼缸里。
在下面这些情况下，Flask会自动帮我们激活程序上下文：

当我们使用flask run命令启动程序时。
使用旧的app.run()方法启动程序时。
执行使用@app.cli.command()装饰器注册的flask命令时。
使用flask shell命令启动Python Shell时。

当请求进入时，Flask会自动激活请求上下文，这时我们可以使用request和session变量。
另外，当请求上下文被激活时，程序上下文也被自动激活。当请求处理完毕后，请求上下文和程序上下文也会自动销毁。
也就是说，在请求处理时这两者拥有相同的生命周期。
结合Python的代码执行机制理解，这也就意味着，我们可以在视图函数中或在视图函数内调用的函数/方法中使用所有上下文全局变量。
在使用flask shell命令打开的Python Shell中，或是自定义的flask命令函数中，我们可以使用current_app和g变量，也可以手动激活请求上下文来使用request和session。
如果我们在没有激活相关上下文时使用这些变量，Flask就会抛出 RuntimeError异常：RuntimeError：Working outside of application context.或是RuntimeError：Working outside of request context.。

上下文钩子

在前面我们学习了请求生命周期中可以使用的几种钩子，Flask也为上下文提供了一个teardown_appcontext钩子，使用它注册的回调函数会在程序上下文被销毁时调用，而且通常也会在请求上下文被销毁时调用。
比如，你需要在每个请求处理结束后销毁数据库连接：

@app.teardown_appcontext
def teardown_db(exception):
    ...
    db.close()

使用app.teardown_appcontext装饰器注册的回调函数需要接收异常对象作为参数，当请求被正常处理时这个参数值将是None，这个函数的返回值将被忽略。
上下文是Flask的重要话题，在这里我们也只是简单了解一下，后面我们会详细了解上下文的实现原理。

HTTP进阶实践

重定向回上一个页面

在前面的示例程序中，我们使用redirect()函数生成重定向响应。比如，在login视图中，登入用户后我们将用户重定向到/hello页面。在复杂的应用场景下，我们需要在用户访问某个URL后重定向到上一个页面。最常见的情况是，用户单击某个需要登录才能访问的链接，这时程序会重定向到登录页面，当用户登录后合理的行为是重定向到用户登录前浏览的页面，以便用户执行未完成的操作，而不是直接重定向到主页。在示例程序中，我们创建了两个视图函数foo和bar，分别显示一个 Foo页面和一个Bar页面。

@app.route('/foo')
def foo():
    return 'Foo page
Do something' % url_for('do_something')


app.route('/bar')
def bar():
    return 'Bar page
Do something ' % url_for('do_something')


@app.route('/do_something')
def do_something():
    # do something
    return redirect(url_for('hello'))

获取上一个页面的URL

要重定向回上一个页面，最关键的是获取上一个页面的URL。上一个页面的URL一般可以通过两种方式获取：

（1）HTTP referer
HTTP referer（起源为referrer在HTTP规范中的错误拼写）是一个用来记录请求发源地址的HTTP首部字段（HTTP_REFERER），即访问来源。
当用户在某个站点单击链接，浏览器向新链接所在的服务器发起请求，请求的数据中包含的HTTP_REFERER字段记录了用户所在的原站点URL。
这个值通常会用来追踪用户，比如记录用户进入程序的外部站点，以此来更有针对性地进行营销。在Flask中，referer的值可以通过请求对象的referrer属性获取，即request.referrer（正确拼写形式）。

1
2
3

return redirect(request.referrer)

return redirect(request.referrer or url_for('hello'))

（2）查询参数
除了自动从referrer获取，另一种更常见的方式是在URL中手动加入包含当前页面URL的查询参数，这个查询参数一般命名为next。比如，下面在foo和bar视图的返回值中的URL后添加next参数

from flask import request

@app.route('/foo')
def foo():
    return 'Foo page
Do something and redirect' % url_for('do_something', next=request.full_path)


@app.route('/bar')
def bar():
    return 'Bar page
Do something and redirect' % url_for('do_something', next=request.full_path)


return redirect(request.args.get('next'))
return redirect(request.args.get('next', url_for('hello')))

对URL进行安全验证
虽然我们已经实现了重定向回上一个页面的功能，但安全问题不容小觑，鉴于referer和next容易被篡改的特性，如果我们不对这些值进行验证，则会形成开放重定向（Open Redirect）漏洞。

以URL中的next参数为例，next变量以查询字符串的方式写在URL里，因此任何人都可以发给某个用户一个包含next变量指向任何站点的链接。举个简单的例子，如果你访问下面的URL：

1	http://localhost:5000/do-something?next=http://helloflask.com

程序会被重定向到http://helloflask.com 。也就是说，如果我们不验证next变量指向的URL地址是否属于我们的应用内，那么程序很容易就会被重定向到外部地址。

假设我们的应用是一个银行业务系统（下面简称网站A），某个攻击者模仿我们的网站外观做了一个几乎一模一样的网站（下面简称网站 B）。
接着，攻击者伪造了一封电子邮件，告诉用户网站A账户信息需要更新，然后向用户提供一个指向网站A登录页面的链接，但链接中包含一个重定向到网站B的next变量，比如：http://exampleA.com/login?next=http://maliciousB.com。
当用户在A网站登录后，如果A网站重定向到next对应的URL，那么就会导致重定向到攻击者编写的B网站。因为B网站完全模仿A网站的外观，攻击者就可以在重定向后的B网站诱导用户输入敏感信息，比如银行卡号及密码。
确保URL安全的关键就是判断URL是否属于程序内部，我们创建了一个URL验证函数is_safe_url()，用来验证next变量值是否属于程序内部URL。

from urlparse import urlparse, urljoin
# Python3需要从urllib.parse导入
from flask import request

def is_safe_url(target):
    ref_url = urlparse(request.host_url)
    test_url = urlparse(urljoin(request.host_url, target))
    return test_url.scheme in ('http', 'https') and ref_url.netloc == test_url.netloc

使用AJAX技术发送异步请求

在传统的Web应用中，程序的操作都是基于请求响应循环来实现的。每当页面状态需要变动，或是需要更新数据时，都伴随着一个发向服务器的请求。
当服务器返回响应时，整个页面会重载，并渲染新页面。
这种模式会带来一些问题。首先，频繁更新页面会牺牲性能，浪费服务器资源，同时降低用户体验。
另外，对于一些操作性很强的程序来说，重载页面会显得很不合理。比如我们做了一个Web计算器程序，所有的按钮和显示屏幕都很逼真，但当我们单击“等于”按钮时，要等到页面重新加载后才在显示屏幕上看到结果，这显然会严重影响用户体验。
我们这一节要学习的AJAX技术可以完美地解决这些问题。

HTTP服务器端推送

不论是传统的HTTP请求-响应式的通信模式，还是异步的AJAX式请求，服务器端始终处于被动的应答状态，只有在客户端发出请求的情况下，服务器端才会返回响应。这种通信模式被称为客户端拉取（client pull）。在这种模式下，用户只能通过刷新页面或主动单击加载按钮来拉取新数据。

然而，在某些场景下，我们需要的通信模式是服务器端的主动推送（server push）。比如，一个聊天室有很多个用户，当某个用户发送消息后，服务器接收到这个请求，然后把消息推送给聊天室的所有用户。类似这种关注实时性的情况还有很多，比如社交网站在导航栏实时显示新提醒和私信的数量，用户的在线状态更新，股价行情监控、显示商品库存信息、多人游戏、文档协作等。

Web安全防范

无论是简单的博客，还是大型的社交网站，Web安全都应该放在首位。Web安全问题涉及广泛，我们在这里介绍其中常见的几种攻击（attack）和其他常见的漏洞（vulnerability）。

对于Web程序的安全问题，一个首要的原则是：永远不要相信你的用户。大部分Web安全问题都是因为没有对用户输入的内容进行“消毒”造成的。

注入攻击
在OWASP（Open Web Application Security Project，开放式Web程序安全项目）发布的最危险的Web程序安全风险Top 10中，无论是最新的2017年的排名，2013年的排名还是最早的2010年，注入攻击（Injection）都位列第一。
注入攻击包括系统命令（OS Command）注入、SQL（Structured Query Language，结构化查询语言）注入（SQL Injection）、NoSQL注入、ORM（Object Relational Mapper，对象关系映射）注入等。我们这里重点介绍的是SQL注入。
XSS攻击
XSS（Cross-Site Scripting，跨站脚本）攻击历史悠久，最远可以追溯到90年代，但至今仍然是危害范围非常广的攻击方式。在OWASP TOP 10中排名第7。
CSRF攻击
CSRF（Cross Site Request Forgery，跨站请求伪造）是一种近年来才逐渐被大众了解的网络攻击方式，又被称为One-Click Attack或Session Riding。在OWASP上一次（2013）的TOP 10 Web程序安全风险中，它位列第8。随着大部分程序的完善，各种框架都内置了对CSRF保护的支持，但目前仍有5%的程序受到威胁。

本章小结

HTTP是各种Web程序的基础，本章只是简要介绍了和Flask相关的部分，没有涉及HTTP底层的TCP/IP或DNS协议。
建议你通过阅读相关书籍来了解完整的Web原理，这将有助于编写更完善和安全的Web程序。

在下一章，我们会学习使用Flask的模板引擎——Jinja2，通过学习运用模板和静态文件，我们可以让程序变得更加丰富和完善。
现在前后端分离的架构下，Jinja2我们就简单的介绍一下。

Jinja模板

在动态Web程序中，视图函数返回的HTML数据往往需要根据相应的变量（比如查询参数）动态生成。
当HTML代码保存到单独的文件中时，我们没法再使用字符串格式化或拼接字符串的方式来在HTML代码中插入变量，这时我们需要使用模板引擎（template engine）。
借助模板引擎，我们可以在HTML文件中使用特殊的语法来标记出变量，这类包含固定内容和动态部分的可重用文件称为模板（template）。
模板引擎的作用就是读取并执行模板中的特殊语法标记，并根据传入的数据将变量替换为实际值，输出最终的HTML页面，这个过程被称为渲染（rendering）。
Flask默认使用的模板引擎是Jinja2，它是一个功能齐全的Python模板引擎，除了设置变量，还允许我们在模板中添加if判断，执行for迭代，调用函数等，以各种方式控制模板的输出。
对于Jinja2来说，模板可以是任何格式的纯文本文件，比如HTML、XML、 CSV、LaTeX等。

模板基本用法

user = {
    'username': 'Grey Li',
    'bio': 'A boy who loves movies and music.',
}
movies = [
    {'name': 'My Neighbor Totoro', 'year': '1988'},
    {'name': 'Three Colours trilogy', 'year': '1993'},
    {'name': 'Forrest Gump', 'year': '1994'},
    {'name': 'Perfect Blue', 'year': '1997'},
    {'name': 'The Matrix', 'year': '1999'},
    {'name': 'Memento', 'year': '2000'},
    {'name': 'The Bucket list', 'year': '2007'},
    {'name': 'Black Swan', 'year': '2010'},
    {'name': 'Gone Girl', 'year': '2014'},
    {'name': 'CoCo', 'year': '2017'},
]

我们在templates目录下创建一个watchlist.html作为模板文件，然后使用Jinja2支持的语法在模板中操作这些变量

html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>{{ user.username }}'s Watchlisttitle>
head>
<body>
    <a href="{{ url_for('index') }}">← Returna>
    <h2>{{ user.username }}h2>
{% if user.bio %}
    <i>{{ user.bio }}i>
{% else %}
    <i>This user has not provided a bio.i>
{% endif %}
    {# 下面是电影清单（这是注释） #}
    <h5>{{ user.username }}'s Watchlist ({{ movies|length }}):h5>
    <ul>{% for movie in movies %}
    <li>{{ movie.name }} - {{ movie.year }}li>
    {% endfor %}
    ul>
body>
html>

Jinja2 的用法很多，其实和Java的那个jsp用法差不多，具体的用法可以查询文档

Jinja2文档

Jinja2 其实跟jsp的优缺点也很像，在复杂的页面并不太好用，还是用Web API和Vue比较适合我。

总结

上面的3章介绍的都是Flask的基础知识，比较简单也比较枯燥，主要的篇幅放在了HTTP上面，其他两章在官方的文档中介绍的很详细。
基础篇还剩一部分，将会在后面介绍，剩下的基础篇会结合基础知识和实际的用途，以及代码来介绍。

Python-100天(三)-数据库基础和进阶

2020-03-12T12:14:23.000Z

关系数据库入门

关系数据库概述

数据持久化 - 将数据保存到能够长久保存数据的存储介质中，在掉电的情况下数据也不会丢失。
数据库发展史 - 网状数据库、层次数据库、关系数据库、NoSQL数据库。
1970年，IBM的研究员E.F.Codd在Communication of the ACM上发表了名为A Relational Model of Data for Large Shared Data Banks的论文，提出了关系模型的概念，奠定了关系模型的理论基础。后来Codd又陆续发表多篇文章，论述了范式理论和衡量关系系统的12条标准，用数学理论奠定了关系数据库的基础。
关系数据库特点。
- 理论基础：集合论和关系代数。
- 具体表象：用二维表（有行和列）组织数据。
- 编程语言：结构化查询语言（SQL）。
ER模型（实体关系模型）和概念模型图。
ER模型，全称为实体关系模型（Entity-Relationship Model），由美籍华裔计算机科学家陈品山先生提出，是概念数据模型的高层描述方式.
- 实体 - 矩形框
- 属性 - 椭圆框
- 关系 - 菱形框
- 重数 - 1:1（一对一） / 1:N（一对多） / M:N（多对多）
实际项目开发中，我们可以利用数据库建模工具（如：PowerDesigner）来绘制概念数据模型（其本质就是ER模型），然后再设置好目标数据库系统，将概念模型转换成物理模型，最终生成创建二维表的SQL（很多工具都可以根据我们设计的物理模型图以及设定的目标数据库来导出SQL或直接生成数据表）。
关系数据库产品。
- Oracle - 目前世界上使用最为广泛的数据库管理系统，作为一个通用的数据库系统，它具有完整的数据管理功能；作为一个关系数据库，它是一个完备关系的产品；作为分布式数据库，它实现了分布式处理的功能。在Oracle最新的12c版本中，还引入了多承租方架构，使用该架构可轻松部署和管理数据库云。
- DB2 - IBM公司开发的、主要运行于Unix（包括IBM自家的AIX）、Linux、以及Windows服务器版等系统的关系数据库产品。DB2历史悠久且被认为是最早使用SQL的数据库产品，它拥有较为强大的商业智能功能。
- SQL Server - 由Microsoft开发和推广的关系型数据库产品，最初适用于中小企业的数据管理，但是近年来它的应用范围有所扩展，部分大企业甚至是跨国公司也开始基于它来构建自己的数据管理系统。
- MySQL - MySQL是开放源代码的，任何人都可以在GPL（General Public License）的许可下下载并根据个性化的需要对其进行修改。MySQL因为其速度、可靠性和适应性而备受关注。
- PostgreSQL - 在BSD许可证下发行的开放源代码的关系数据库产品。

MySQL简介

MySQL最早是由瑞典的MySQL AB公司开发的一个开放源码的关系数据库管理系统，该公司于2008年被昇阳微系统公司（Sun Microsystems）收购。在2009年，甲骨文公司（Oracle）收购昇阳微系统公司，因此在这之后MySQL成为了Oracle旗下产品。

MySQL在过去由于性能高、成本低、可靠性好，已经成为最流行的开源数据库，因此被广泛地应用于中小型网站开发。随着MySQL的不断成熟，它也逐渐被应用于更多大规模网站和应用，比如维基百科、谷歌（Google）、脸书（Facebook）、淘宝网等网站都使用了MySQL来提供数据持久化服务。

甲骨文公司收购后昇阳微系统公司，大幅调涨MySQL商业版的售价，且甲骨文公司不再支持另一个自由软件项目OpenSolaris的发展，因此导致自由软件社区对于Oracle是否还会持续支持MySQL社区版（MySQL的各个发行版本中唯一免费的版本）有所担忧，MySQL的创始人麦克尔·维德纽斯以MySQL为基础，成立分支计划MariaDB（以他女儿的名字命名的数据库）。有许多原来使用MySQL数据库的公司（例如：维基百科）已经陆续完成了从MySQL数据库到MariaDB数据库的迁移。

安装和配置

说明：下面的安装和配置都是以CentOS Linux环境为例，如果需要在其他系统下安装MySQL，读者可以自行在网络上查找对应的安装教程）。

刚才说过，MySQL有一个分支版本名叫MariaDB，该数据库旨在继续保持MySQL数据库在GNU GPL下开源。如果要使用MariaDB作为MySQL的替代品，可以使用下面的命令进行安装。
1
yum install mariadb mariadb-server

如果要安装官方版本的MySQL，可以在MySQL官方网站下载安装文件。首先在下载页面中选择平台和版本，然后找到对应的下载链接。下面以MySQL 5.7.26版本和Red Hat Enterprise Linux为例，直接下载包含所有安装文件的归档文件，解归档之后通过包管理工具进行安装。

1 2	wget https://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.26-1.el7.x86_64.rpm-bundle.tar tar -xvf mysql-5.7.26-1.el7.x86_64.rpm-bundle.tar

如果系统上有MariaDB相关的文件，需要先移除MariaDB相关的文件。

1	yum list installed \| grep mariadb \| awk '{print $1}' \| xargs yum erase -y

接下来可以按照如下所示的顺序用RPM（Redhat Package Manager）工具安装MySQL。

rpm -ivh mysql-community-common-5.7.26-1.el7.x86_64.rpm
rpm -ivh mysql-community-libs-5.7.26-1.el7.x86_64.rpm
rpm -ivh mysql-community-client-5.7.26-1.el7.x86_64.rpm
rpm -ivh mysql-community-server-5.7.26-1.el7.x86_64.rpm

可以使用下面的命令查看已经安装的MySQL相关的包。

1	rpm -qa \| grep mysql

配置MySQL。

MySQL的配置文件在/etc目录下，名为my.cnf，默认的配置文件内容如下所示。如果对这个文件不理解并没有关系，什么时候用到这个配置文件什么时候再了解它就行了。

1	cat /etc/my.cnf

# For advice on how to change settings please see
# http://dev.mysql.com/doc/refman/5.7/en/server-configuration-defaults.html

[mysqld]
#
# Remove leading # and set to the amount of RAM for the most important data
# cache in MySQL. Start at 70% of total RAM for dedicated server, else 10%.
# innodb_buffer_pool_size = 128M
#
# Remove leading # to turn on a very important data integrity option: logging
# changes to the binary log between backups.
# log_bin
#
# Remove leading # to set options mainly useful for reporting servers.
# The server defaults are faster for transactions and fast SELECTs.
# Adjust sizes as needed, experiment to find the optimal values.
# join_buffer_size = 128M
# sort_buffer_size = 2M
# read_rnd_buffer_size = 2M
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock

# Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0

log-error=/var/log/mysqld.log
pid-file=/var/run/mysqld/mysqld.pid

启动MySQL服务。
可以使用下面的命令来启动MySQL。
1
service mysqld start
在CentOS 7中，更推荐使用下面的命令来启动MySQL。
1
systemctl start mysqld
启动MySQL成功后，可以通过下面的命令来检查网络端口使用情况，MySQL默认使用3306端口。
1
netstat -ntlp | grep mysql
也可以使用下面的命令查找是否有名为mysqld的进程。
1
pgrep mysqld
使用MySQL客户端工具连接服务器。
命令行工具：
1
mysql -u root -p
说明：启动客户端时，-u参数用来指定用户名，MySQL默认的超级管理账号为root；-p表示要输入密码（用户口令）；如果连接的是其他主机而非本机，可以用-h来指定连接主机的主机名或IP地址。
如果是首次安装MySQL，可以使用下面的命令来找到默认的初始密码。
1
cat /var/log/mysqld.log | grep password
上面的命令会查看MySQL的日志带有password的行，在显示的结果中root@localhost:后面的部分就是默认设置的初始密码。
修改超级管理员（root）的访问口令为123456。
1
2
3
set global validate_password_policy=0;
set global validate_password_length=6;
alter user 'root'@'localhost' identified by '123456';
说明：MySQL较新的版本默认不允许使用弱口令作为用户口令，所以我们通过上面的前两条命令修改了验证用户口令的策略和口令的长度。事实上我们不应该使用弱口令，因为存在用户口令被暴力破解的风险。近年来，攻击数据库窃取数据和劫持数据库勒索比特币的事件屡见不鲜，要避免这些潜在的风险，最为重要的一点是不要让数据库服务器暴露在公网上（最好的做法是将数据库置于内网，至少要做到不向公网开放数据库服务器的访问端口），另外要保管好root账号的口令，应用系统需要访问数据库时，通常不使用root账号进行访问，而是创建其他拥有适当权限的账号来访问。
再次使用客户端工具连接MySQL服务器时，就可以使用新设置的口令了。在实际开发中，为了方便用户操作，可以选择图形化的客户端工具来连接MySQL服务器，包括：
- MySQL Workbench（官方提供的工具）
- Navicat for MySQL（界面简单优雅，功能直观强大）
- SQLyog for MySQL（强大的MySQL数据库管理员工具）

常用命令。

查看服务器版本。
1
select version();
查看所有数据库。
1
show databases;
切换到指定数据库。
1
use mysql;
查看数据库下所有表。
1
show tables;

获取帮助。

? contents;
? functions;
? numeric functions;
? round;

? data types;
? longblob;

SQL详解

基本操作

我们通常可以将SQL分为三类：DDL（数据定义语言）、DML（数据操作语言）和DCL（数据控制语言）。DDL主要用于创建（create）、删除（drop）、修改（alter）数据库中的对象，比如创建、删除和修改二维表；DML主要负责插入数据（insert）、删除数据（delete）、更新数据（update）和查询（select）；DCL通常用于授予权限（grant）和召回权限（revoke）。

说明：SQL是不区分大小写的语言，为了书写方便，下面的SQL都使用了小写字母来书写。

DDL（数据定义语言）

-- 如果存在名为school的数据库就删除它
drop database if exists school;

-- 创建名为school的数据库并设置默认的字符集和排序方式
create database school default charset utf8;

-- 切换到school数据库上下文环境
use school;

-- 创建学院表
create table tb_college
(
collid int auto_increment comment '编号',
collname varchar(50) not null comment '名称',
collintro varchar(500) default '' comment '介绍',
primary key (collid)
);

-- 创建学生表
create table tb_student
(
stuid int not null comment '学号',
stuname varchar(20) not null comment '姓名',
stusex boolean default 1 comment '性别',
stubirth date not null comment '出生日期',
stuaddr varchar(255) default '' comment '籍贯',
collid int not null comment '所属学院',
primary key (stuid),
foreign key (collid) references tb_college (collid)
);

-- 创建教师表
create table tb_teacher
(
teaid int not null comment '工号',
teaname varchar(20) not null comment '姓名',
teatitle varchar(10) default '助教' comment '职称',
collid int not null comment '所属学院',
primary key (teaid),
foreign key (collid) references tb_college (collid)
);

-- 创建课程表
create table tb_course
(
couid int not null comment '编号',
couname varchar(50) not null comment '名称',
coucredit int not null comment '学分',
teaid int not null comment '授课老师',
primary key (couid),
foreign key (teaid) references tb_teacher (teaid)
);

-- 创建选课记录表
create table tb_record
(
recid int auto_increment comment '选课记录编号',
sid int not null comment '选课学生',
cid int not null comment '所选课程',
seldate datetime default now() comment '选课时间日期',
score decimal(4,1) comment '考试成绩',
primary key (recid),
foreign key (sid) references tb_student (stuid),
foreign key (cid) references tb_course (couid),
unique (sid, cid)
);

上面的DDL有几个地方需要强调一下：

创建数据库时，我们通过default charset utf8指定了数据库默认使用的字符集，我们推荐使用该字符集，因为utf8能够支持国际化编码。如果将来数据库中用到的字符可能包括类似于Emoji这样的图片字符，也可以将默认字符集设定为utf8mb4（最大4字节的utf-8编码）。查看MySQL支持的字符集可以执行下面的语句。

1	show character set;

+----------+---------------------------------+---------------------+--------+
| Charset  | Description                     | Default collation   | Maxlen |
+----------+---------------------------------+---------------------+--------+
| big5     | Big5 Traditional Chinese        | big5_chinese_ci     |      2 |
| dec8     | DEC West European               | dec8_swedish_ci     |      1 |
| cp850    | DOS West European               | cp850_general_ci    |      1 |
| hp8      | HP West European                | hp8_english_ci      |      1 |
| koi8r    | KOI8-R Relcom Russian           | koi8r_general_ci    |      1 |
| latin1   | cp1252 West European            | latin1_swedish_ci   |      1 |
| latin2   | ISO 8859-2 Central European     | latin2_general_ci   |      1 |
| swe7     | 7bit Swedish                    | swe7_swedish_ci     |      1 |
| ascii    | US ASCII                        | ascii_general_ci    |      1 |
| ujis     | EUC-JP Japanese                 | ujis_japanese_ci    |      3 |
| sjis     | Shift-JIS Japanese              | sjis_japanese_ci    |      2 |
| hebrew   | ISO 8859-8 Hebrew               | hebrew_general_ci   |      1 |
| tis620   | TIS620 Thai                     | tis620_thai_ci      |      1 |
| euckr    | EUC-KR Korean                   | euckr_korean_ci     |      2 |
| koi8u    | KOI8-U Ukrainian                | koi8u_general_ci    |      1 |
| gb2312   | GB2312 Simplified Chinese       | gb2312_chinese_ci   |      2 |
| greek    | ISO 8859-7 Greek                | greek_general_ci    |      1 |
| cp1250   | Windows Central European        | cp1250_general_ci   |      1 |
| gbk      | GBK Simplified Chinese          | gbk_chinese_ci      |      2 |
| latin5   | ISO 8859-9 Turkish              | latin5_turkish_ci   |      1 |
| armscii8 | ARMSCII-8 Armenian              | armscii8_general_ci |      1 |
| utf8     | UTF-8 Unicode                   | utf8_general_ci     |      3 |
| ucs2     | UCS-2 Unicode                   | ucs2_general_ci     |      2 |
| cp866    | DOS Russian                     | cp866_general_ci    |      1 |
| keybcs2  | DOS Kamenicky Czech-Slovak      | keybcs2_general_ci  |      1 |
| macce    | Mac Central European            | macce_general_ci    |      1 |
| macroman | Mac West European               | macroman_general_ci |      1 |
| cp852    | DOS Central European            | cp852_general_ci    |      1 |
| latin7   | ISO 8859-13 Baltic              | latin7_general_ci   |      1 |
| utf8mb4  | UTF-8 Unicode                   | utf8mb4_general_ci  |      4 |
| cp1251   | Windows Cyrillic                | cp1251_general_ci   |      1 |
| utf16    | UTF-16 Unicode                  | utf16_general_ci    |      4 |
| utf16le  | UTF-16LE Unicode                | utf16le_general_ci  |      4 |
| cp1256   | Windows Arabic                  | cp1256_general_ci   |      1 |
| cp1257   | Windows Baltic                  | cp1257_general_ci   |      1 |
| utf32    | UTF-32 Unicode                  | utf32_general_ci    |      4 |
| binary   | Binary pseudo charset           | binary              |      1 |
| geostd8  | GEOSTD8 Georgian                | geostd8_general_ci  |      1 |
| cp932    | SJIS for Windows Japanese       | cp932_japanese_ci   |      2 |
| eucjpms  | UJIS for Windows Japanese       | eucjpms_japanese_ci |      3 |
| gb18030  | China National Standard GB18030 | gb18030_chinese_ci  |      4 |
+----------+---------------------------------+---------------------+--------+
41 rows in set (0.00 sec)

如果要设置MySQL服务启动时默认使用的字符集，可以修改MySQL的配置并添加以下内容

1 2	[mysqld] character-set-server=utf8

在创建表的时候，我们可以在右圆括号的后面通过engine=XXX来指定表的存储引擎，MySQL支持多种存储引擎，可以通过show engines命令进行查看。MySQL 5.5以后的版本默认使用的存储引擎是InnoDB，它正好也就是我们推荐大家使用的存储引擎（因为InnoDB更适合互联网应用对高并发、性能以及事务支持等方面的需求）。

1	show engines\G

*************************** 1. row ***************************
      Engine: InnoDB
     Support: DEFAULT
     Comment: Supports transactions, row-level locking, and foreign keys
Transactions: YES
          XA: YES
  Savepoints: YES
*************************** 2. row ***************************
      Engine: MRG_MYISAM
     Support: YES
     Comment: Collection of identical MyISAM tables
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 3. row ***************************
      Engine: MEMORY
     Support: YES
     Comment: Hash based, stored in memory, useful for temporary tables
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 4. row ***************************
      Engine: BLACKHOLE
     Support: YES
     Comment: /dev/null storage engine (anything you write to it disappears)
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 5. row ***************************
      Engine: MyISAM
     Support: YES
     Comment: MyISAM storage engine
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 6. row ***************************
      Engine: CSV
     Support: YES
     Comment: CSV storage engine
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 7. row ***************************
      Engine: ARCHIVE
     Support: YES
     Comment: Archive storage engine
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 8. row ***************************
      Engine: PERFORMANCE_SCHEMA
     Support: YES
     Comment: Performance Schema
Transactions: NO
          XA: NO
  Savepoints: NO
*************************** 9. row ***************************
      Engine: FEDERATED
     Support: NO
     Comment: Federated MySQL storage engine
Transactions: NULL
          XA: NULL
  Savepoints: NULL
9 rows in set (0.00 sec)

下面的表格对MySQL几种常用的数据引擎进行了简单的对比。

特性	InnoDB	MRG_MYISAM	MEMORY	MyISAM
存储限制	有	没有	有	有
事务	支持
锁机制	行锁	表锁	表锁	表锁
B树索引	支持	支持	支持	支持
哈希索引			支持
全文检索	支持（5.6+）			支持
集群索引	支持
数据缓存	支持		支持
索引缓存	支持	支持	支持	支持
数据可压缩				支持
内存使用	高	低	中	低
存储空间使用	高	低		低
批量插入性能	低	高	高	高
是否支持外键	支持

通过上面的比较我们可以了解到，InnoDB是唯一能够支持外键、事务以及行锁的存储引擎，所以我们之前说它更适合互联网应用，而且它也是较新的MySQL版本中默认使用的存储引擎。

在定义表结构为每个字段选择数据类型时，如果不清楚哪个数据类型更合适，可以通过MySQL的帮助系统来了解每种数据类型的特性、数据的长度和精度等相关信息。

1	? data types

You asked for help about help category: "Data Types"
For more information, type 'help ', where  is one of the following
topics:
   AUTO_INCREMENT
   BIGINT
   BINARY
   BIT
   BLOB
   BLOB DATA TYPE
   BOOLEAN
   CHAR
   CHAR BYTE
   DATE
   DATETIME
   DEC
   DECIMAL
   DOUBLE
   DOUBLE PRECISION
   ENUM
   FLOAT
   INT
   INTEGER
   LONGBLOB
   LONGTEXT
   MEDIUMBLOB
   MEDIUMINT
   MEDIUMTEXT
   SET DATA TYPE
   SMALLINT
   TEXT
   TIME
   TIMESTAMP
   TINYBLOB
   TINYINT
   TINYTEXT
   VARBINARY
   VARCHAR
   YEAR DATA TYPE

? varchar

Name: 'VARCHAR'
Description:
[NATIONAL] VARCHAR(M) [CHARACTER SET charset_name] [COLLATE
collation_name]

A variable-length string. M represents the maximum column length in
characters. The range of M is 0 to 65,535. The effective maximum length
of a VARCHAR is subject to the maximum row size (65,535 bytes, which is
shared among all columns) and the character set used. For example, utf8
characters can require up to three bytes per character, so a VARCHAR
column that uses the utf8 character set can be declared to be a maximum
of 21,844 characters. See
http://dev.mysql.com/doc/refman/5.7/en/column-count-limit.html.

MySQL stores VARCHAR values as a 1-byte or 2-byte length prefix plus
data. The length prefix indicates the number of bytes in the value. A
VARCHAR column uses one length byte if values require no more than 255
bytes, two length bytes if values may require more than 255 bytes.

*Note*:

MySQL follows the standard SQL specification, and does not remove
trailing spaces from VARCHAR values.

VARCHAR is shorthand for CHARACTER VARYING. NATIONAL VARCHAR is the
standard SQL way to define that a VARCHAR column should use some
predefined character set. MySQL uses utf8 as this predefined character
set. http://dev.mysql.com/doc/refman/5.7/en/charset-national.html.
NVARCHAR is shorthand for NATIONAL VARCHAR.

URL: http://dev.mysql.com/doc/refman/5.7/en/string-type-overview.html

在数据类型的选择上，保存字符串数据通常都使用VARCHAR和CHAR两种类型，前者通常称为变长字符串，而后者通常称为定长字符串；对于InnoDB存储引擎，行存储格式没有区分固定长度和可变长度列，因此VARCHAR类型好CHAR类型没有本质区别，后者不一定比前者性能更好。如果要保存的很大字符串，可以使用TEXT类型；如果要保存很大的字节串，可以使用BLOB（二进制大对象）类型。在MySQL中，TEXT和BLOB又分别包括TEXT、MEDIUMTEXT、LONGTEXT和BLOB、MEDIUMBLOB、LONGBLOB三种不同的类型，它们主要的区别在于存储数据的最大大小不同。保存浮点数可以用FLOAT或DOUBLE类型，而保存定点数应该使用DECIMAL类型。如果要保存时间日期，DATETIME类型优于TIMESTAMP类型，因为前者能表示的时间日期范围更大。

DML

-- 插入学院数据
insert into tb_college (collname, collintro) values 
('计算机学院', '创建于1956年是我国首批建立计算机专业。学院现有计算机科学与技术一级学科和网络空间安全一级学科博士学位授予权，其中计算机科学与技术一级学科具有博士后流动站。计算机科学与技术一级学科在2017年全国第四轮学科评估中评为A；2019 U.S.News全球计算机学科排名26名；ESI学科排名0.945‰，进入全球前1‰，位列第43位。'),
('外国语学院', '1998年浙江大学、杭州大学、浙江农业大学、浙江医科大学四校合并，成立新的浙江大学。1999年原浙江大学外语系、原杭州大学外国语学院、原杭州大学大外部、原浙江农业大学公外部、原浙江医科大学外语教学部合并，成立浙江大学外国语学院。2003年学院更名为浙江大学外国语言文化与国际交流学院。'),
('经济管理学院', '四川大学经济学院历史悠久、传承厚重，其前身是创办于1905年的四川大学经济科,距今已有100多年的历史。已故著名经济学家彭迪先、张与九、蒋学模、胡寄窗、陶大镛、胡代光，以及当代著名学者刘诗白等曾先后在此任教或学习。在长期的办学过程中，学院坚持以马克思主义的立场、观点、方法为指导，围绕建设世界一流经济学院的奋斗目标，做实“两个伟大”深度融合，不断提高党的建设质量与科学推进一流事业深度融合。');

-- 插入学生数据
insert into tb_student (stuid, stuname, stusex, stubirth, stuaddr, collid) values
(1001, '杨逍', 1, '1990-3-4', '四川成都', 1),
(1002, '任我行', 1, '1992-2-2', '湖南长沙', 1),
(1033, '王语嫣', 0, '1989-12-3', '四川成都', 1),
(1572, '岳不群', 1, '1993-7-19', '陕西咸阳', 1),
(1378, '纪嫣然', 0, '1995-8-12', '四川绵阳', 1),
(1954, '林平之', 1, '1994-9-20', '福建莆田', 1),
(2035, '东方不败', 1, '1988-6-30', null, 2),
(3011, '林震南', 1, '1985-12-12', '福建莆田', 3),
(3755, '项少龙', 1, '1993-1-25', null, 3),
(3923, '杨不悔', 0, '1985-4-17', '四川成都', 3),
(4040, '隔壁老王', 1, '1989-1-1', '四川成都', 2);

-- 删除学生数据
delete from tb_student where stuid=4040;

-- 更新学生数据
update tb_student set stuname='杨过', stuaddr='湖南长沙' where stuid=1001;

-- 插入老师数据
insert into tb_teacher (teaid, teaname, teatitle, collid) values 
(1122, '张三丰', '教授', 1),
(1133, '宋远桥', '副教授', 1),
(1144, '杨逍', '副教授', 1),
(2255, '范遥', '副教授', 2),
(3366, '韦一笑', '讲师', 3);

-- 插入课程数据
insert into tb_course (couid, couname, coucredit, teaid) values 
(1111, 'Python程序设计', 3, 1122),
(2222, 'Web前端开发', 2, 1122),
(3333, '操作系统', 4, 1122),
(4444, '计算机网络', 2, 1133),
(5555, '编译原理', 4, 1144),
(6666, '算法和数据结构', 3, 1144),
(7777, '经贸法语', 3, 2255),
(8888, '成本会计', 2, 3366),
(9999, '审计学', 3, 3366);

-- 插入选课数据
insert into tb_record (sid, cid, seldate, score) values 
(1001, 1111, '2017-09-01', 95),
(1001, 2222, '2017-09-01', 87.5),
(1001, 3333, '2017-09-01', 100),
(1001, 4444, '2018-09-03', null),
(1001, 6666, '2017-09-02', 100),
(1002, 1111, '2017-09-03', 65),
(1002, 5555, '2017-09-01', 42),
(1033, 1111, '2017-09-03', 92.5),
(1033, 4444, '2017-09-01', 78),
(1033, 5555, '2017-09-01', 82.5),
(1572, 1111, '2017-09-02', 78),
(1378, 1111, '2017-09-05', 82),
(1378, 7777, '2017-09-02', 65.5),
(2035, 7777, '2018-09-03', 88),
(2035, 9999, default, null),
(3755, 1111, default, null),
(3755, 8888, default, null),
(3755, 9999, '2017-09-01', 92);

-- 查询所有学生信息
select * from tb_student;

-- 查询所有课程名称及学分(投影和别名)
select couname, coucredit from tb_course;
select couname as 课程名称, coucredit as 学分 from tb_course;

-- 查询所有学生的姓名和性别(条件运算)
select stuname as 姓名, case stusex when 1 then '男' else '女' end as 性别 from tb_student;
select stuname as 姓名, if(stusex, '男', '女') as 性别 from tb_student;

-- 查询所有女学生的姓名和出生日期(筛选)
select stuname, stubirth from tb_student where stusex=0;

-- 查询所有80后学生的姓名、性别和出生日期(筛选)
select stuname, stusex, stubirth from tb_student where stubirth>='1980-1-1' and stubirth<='1989-12-31';
select stuname, stusex, stubirth from tb_student where stubirth between '1980-1-1' and '1989-12-31';

-- 查询姓"杨"的学生姓名和性别(模糊)
select stuname, stusex from tb_student where stuname like '杨%';

-- 查询姓"杨"名字两个字的学生姓名和性别(模糊)
select stuname, stusex from tb_student where stuname like '杨_';

-- 查询姓"杨"名字三个字的学生姓名和性别(模糊)
select stuname, stusex from tb_student where stuname like '杨__';

-- 查询名字中有"不"字或"嫣"字的学生的姓名(模糊)
select stuname, stusex from tb_student where stuname like '%不%' or stuname like '%嫣%';

-- 查询没有录入家庭住址的学生姓名(空值)
select stuname from tb_student where stuaddr is null;

-- 查询录入了家庭住址的学生姓名(空值)
select stuname from tb_student where stuaddr is not null;

-- 查询学生选课的所有日期(去重)
select distinct seldate from tb_record;

-- 查询学生的家庭住址(去重)
select distinct stuaddr from tb_student where stuaddr is not null;

-- 查询男学生的姓名和生日按年龄从大到小排列(排序)
select stuname as 姓名, datediff(curdate(), stubirth) div 365 as 年龄 from tb_student where stusex=1 order by 年龄 desc;

-- 查询年龄最大的学生的出生日期(聚合函数)
select min(stubirth) from tb_student;

-- 查询年龄最小的学生的出生日期(聚合函数)
select max(stubirth) from tb_student;

-- 查询男女学生的人数(分组和聚合函数)
select stusex, count(*) from tb_student group by stusex;

-- 查询课程编号为1111的课程的平均成绩(筛选和聚合函数)
select avg(score) from tb_record where cid=1111;

-- 查询学号为1001的学生所有课程的平均分(筛选和聚合函数)
select avg(score) from tb_record where sid=1001;

-- 查询每个学生的学号和平均成绩(分组和聚合函数)
select sid as 学号, avg(score) as 平均分 from tb_record group by sid;

-- 查询平均成绩大于等于90分的学生的学号和平均成绩
-- 分组以前的筛选使用where子句 / 分组以后的筛选使用having子句
select sid as 学号, avg(score) as 平均分 from tb_record group by sid having 平均分>=90;

-- 查询年龄最大的学生的姓名(子查询/嵌套的查询)
select stuname from tb_student where stubirth=( select min(stubirth) from tb_student );

-- 查询年龄最大的学生姓名和年龄(子查询+运算)
select stuname as 姓名, datediff(curdate(), stubirth) div 365 as 年龄 from tb_student where stubirth=( select min(stubirth) from tb_student );

-- 查询选了两门以上的课程的学生姓名(子查询/分组条件/集合运算)
select stuname from tb_student where stuid in ( select stuid from tb_record group by stuid having count(stuid)>2 );

-- 查询学生姓名、课程名称以及成绩(连接查询)
select stuname, couname, score from tb_student t1, tb_course t2, tb_record t3 where stuid=sid and couid=cid and score is not null;

-- 查询学生姓名、课程名称以及成绩按成绩从高到低查询第11-15条记录(内连接+分页)
select stuname, couname, score from tb_student inner join tb_record on stuid=sid inner join tb_course on couid=cid where score is not null order by score desc limit 5 offset 10;

select stuname, couname, score from tb_student inner join tb_record on stuid=sid inner join tb_course on couid=cid where score is not null order by score desc limit 10, 5;

-- 查询选课学生的姓名和平均成绩(子查询和连接查询)
select stuname, avgmark from tb_student, ( select sid, avg(score) as avgmark from tb_record group by sid ) temp where stuid=sid;

select stuname, avgmark from tb_student inner join ( select sid, avg(score) as avgmark from tb_record group by sid ) temp on stuid=sid;

-- 查询每个学生的姓名和选课数量(左外连接和子查询)
select stuname, ifnull(total, 0) from tb_student left outer join ( select sid, count(sid) as total from tb_record group by sid ) temp on stuid=sid;

上面的DML有几个地方需要加以说明：

MySQL中支持多种类型的运算符，包括：算术运算符（+、-、*、/、%）、比较运算符（=、<>、<=>、<、<=、>、>=、BETWEEN…AND…、IN、IS NULL、IS NOT NULL、LIKE、RLIKE、REGEXP）、逻辑运算符（NOT、AND、OR、XOR）和位运算符（&、|、^、~、>>、<<），我们可以在DML中使用这些运算符处理数据。

在查询数据时，可以在SELECT语句及其子句（如WHERE子句、ORDER BY子句、HAVING子句等）中使用函数，这些函数包括字符串函数、数值函数、时间日期函数、流程函数等，如下面的表格所示。

常用字符串函数。

函数	功能
CONCAT	将多个字符串连接成一个字符串
FORMAT	将数值格式化成字符串并指定保留几位小数
FROM_BASE64 / TO_BASE64	BASE64解码/编码
BIN / OCT / HEX	将数值转换成二进制/八进制/十六进制字符串
LOCATE	在字符串中查找一个子串的位置
LEFT / RIGHT	返回一个字符串左边/右边指定长度的字符
LENGTH / CHAR_LENGTH	返回字符串的长度以字节/字符为单位
LOWER / UPPER	返回字符串的小写/大写形式
LPAD / RPAD	如果字符串的长度不足，在字符串左边/右边填充指定的字符
LTRIM / RTRIM	去掉字符串前面/后面的空格
ORD / CHAR	返回字符对应的编码/返回编码对应的字符
STRCMP	比较字符串，返回-1、0、1分别表示小于、等于、大于
SUBSTRING	返回字符串指定范围的子串

常用数值函数。

函数	功能
ABS	返回一个数的绝度值
CEILING / FLOOR	返回一个数上取整/下取整的结果
CONV	将一个数从一种进制转换成另一种进制
CRC32	计算循环冗余校验码
EXP / LOG / LOG2 / LOG10	计算指数/对数
POW	求幂
RAND	返回[0,1)范围的随机数
ROUND	返回一个数四舍五入后的结果
SQRT	返回一个数的平方根
TRUNCATE	截断一个数到指定的精度
SIN / COS / TAN / COT / ASIN / ACOS / ATAN	三角函数

常用时间日期函数。

函数	功能
CURDATE / CURTIME / NOW	获取当前日期/时间/日期和时间
ADDDATE / SUBDATE	将两个日期表达式相加/相减并返回结果
DATE / TIME	从字符串中获取日期/时间
YEAR / MONTH / DAY	从日期中获取年/月/日
HOUR / MINUTE / SECOND	从时间中获取时/分/秒
DATEDIFF / TIMEDIFF	返回两个时间日期表达式相差多少天/小时
MAKEDATE / MAKETIME	制造一个日期/时间

常用流程函数。

函数	功能
IF	根据条件是否成立返回不同的值
IFNULL	如果为NULL则返回指定的值否则就返回本身
NULLIF	两个表达式相等就返回NULL否则返回第一个表达式的值

其他常用函数。

函数	功能
MD5 / SHA1 / SHA2	返回字符串对应的哈希摘要
CHARSET / COLLATION	返回字符集/校对规则
USER / CURRENT_USER	返回当前用户
DATABASE	返回当前数据库名
VERSION	返回当前数据库版本
FOUND_ROWS / ROW_COUNT	返回查询到的行数/受影响的行数
LAST_INSERT_ID	返回最后一个自增主键的值
UUID / UUID_SHORT	返回全局唯一标识符

DCL

-- 创建可以远程登录的root账号并为其指定口令
create user 'root'@'%' identified by '123456';

-- 为远程登录的root账号授权操作所有数据库所有对象的所有权限并允许其将权限再次赋予其他用户
grant all privileges on *.* to 'root'@'%' with grant option;

-- 创建名为hellokitty的用户并为其指定口令
create user 'hellokitty'@'%' identified by '123123';

-- 将对school数据库所有对象的所有操作权限授予hellokitty
grant all privileges on school.* to 'hellokitty'@'%';

-- 召回hellokitty对school数据库所有对象的insert/delete/update权限
revoke insert, delete, update on school.* from 'hellokitty'@'%';

说明：创建一个可以允许任意主机登录并且具有超级管理员权限的用户在现实中并不是一个明智的决定，因为一旦该账号的口令泄露或者被破解，数据库将会面临灾难级的风险。

索引

索引是关系型数据库中用来提升查询性能最为重要的手段。关系型数据库中的索引就像一本书的目录，我们可以想象一下，如果要从一本书中找出某个知识点，但是这本书没有目录，这将是意见多么可怕的事情（我们估计得一篇一篇的翻下去，才能确定这个知识点到底在什么位置）。创建索引虽然会带来存储空间上的开销，就像一本书的目录会占用一部分的篇幅一样，但是在牺牲空间后换来的查询时间的减少也是非常显著的。

MySQL中，所有数据类型的列都可以被索引，常用的存储引擎InnoDB和MyISAM能支持每个表创建16个索引。InnoDB和MyISAM使用的索引其底层算法是B-tree（B树），B-tree是一种自平衡的树，类似于平衡二叉排序树，能够保持数据有序。这种数据结构能够让查找数据、顺序访问、插入数据及删除的操作都在对数时间内完成。

接下来我们通过一个简单的例子来说明索引的意义，比如我们要根据学生的姓名来查找学生，这个场景在实际开发中应该经常遇到，就跟通过商品名称查找商品道理是一样的。我们可以使用MySQL的explain关键字来查看SQL的执行计划。

1	explain select * from tb_student where stuname='林震南'\G

*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_student
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 11
     filtered: 10.00
        Extra: Using where
1 row in set, 1 warning (0.00 sec)

在上面的SQL执行计划中，有几项值得我们关注：

type：MySQL在表中找到满足条件的行的方式，也称为访问类型，包括：ALL（全表扫描）、index（索引全扫描）、range（索引范围扫描）、ref（非唯一索引扫描）、eq_ref（唯一索引扫描）、const/system、NULL。在所有的访问类型中，很显然ALL是性能最差的，它代表了全表扫描是指要扫描表中的每一行才能找到匹配的行。
possible_keys：MySQL可以选择的索引，但是有可能不会使用。
key：MySQL真正使用的索引。
rows：执行查询需要扫描的行数，这是一个预估值。

从上面的执行计划可以看出，当我们通过学生名字查询学生时实际上是进行了全表扫描，不言而喻这个查询性能肯定是非常糟糕的，尤其是在表中的行很多的时候。如果我们需要经常通过学生姓名来查询学生，那么就应该在学生姓名对应的列上创建索引，通过索引来加速查询。

1	create index idx_student_name on tb_student(stuname);

再次查看刚才的SQL对应的执行计划。

1	explain select * from tb_student where stuname='林震南'\G

*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_student
   partitions: NULL
         type: ref
possible_keys: idx_student_name
          key: idx_student_name
      key_len: 62
          ref: const
         rows: 1
     filtered: 100.00
        Extra: NULL
1 row in set, 1 warning (0.00 sec)

可以注意到，在对学生姓名创建索引后，刚才的查询已经不是全表扫描而是基于索引的查询，而且扫描的行只有唯一的一行，这显然大大的提升了查询的性能。MySQL中还允许创建前缀索引，即对索引字段的前N个字符创建索引，这样的话可以减少索引占用的空间（但节省了空间很有可能会浪费时间，时间和空间是不可调和的矛盾），如下所示。

1	create index idx_student_name_1 on tb_student(stuname(1));

上面的索引相当于是根据学生姓名的第一个字来创建的索引，我们再看看SQL执行计划。

1	explain select * from tb_student where stuname='林震南'\G

*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_student
   partitions: NULL
         type: ref
possible_keys: idx_student_name
          key: idx_student_name
      key_len: 5
          ref: const
         rows: 2
     filtered: 100.00
        Extra: Using where
1 row in set, 1 warning (0.00 sec)

不知道大家是否注意到，这一次扫描的行变成了2行，因为学生表中有两个姓“林”的学生，我们只用姓名的第一个字作为索引的话，在查询时通过索引就会找到这两行。

如果要删除索引，可以使用下面的SQL。

1	alter table tb_student drop index idx_student_name;

或者

1	drop index idx_student_name on tb_student;

我们简单的为大家总结一下索引的设计原则：

最适合索引的列是出现在WHERE子句和连接子句中的列。
索引列的基数越大（取值多重复值少），索引的效果就越好。
使用前缀索引可以减少索引占用的空间，内存中可以缓存更多的索引。
索引不是越多越好，虽然索引加速了读操作（查询），但是写操作（增、删、改）都会变得更慢，因为数据的变化会导致索引的更新，就如同书籍章节的增删需要更新目录一样。
使用InnoDB存储引擎时，表的普通索引都会保存主键的值，所以主键要尽可能选择较短的数据类型，这样可以有效的减少索引占用的空间，利用提升索引的缓存效果。

最后，还有一点需要说明，InnoDB使用的B-tree索引，数值类型的列除了等值判断时索引会生效之外，使用>、<、>=、<=、BETWEEN…AND… 、<>时，索引仍然生效；对于字符串类型的列，如果使用不以通配符开头的模糊查询，索引也是起作用的，但是其他的情况会导致索引失效，这就意味着很有可能会做全表查询。

视图

视图是关系型数据库中将一组查询指令构成的结果集组合成可查询的数据表的对象。简单的说，视图就是虚拟的表，但与数据表不同的是，数据表是一种实体结构，而视图是一种虚拟结构，你也可以将视图理解为保存在数据库中被赋予名字的SQL语句。

使用视图可以获得以下好处：

可以将实体数据表隐藏起来，让外部程序无法得知实际的数据结构，让访问者可以使用表的组成部分而不是整个表，降低数据库被攻击的风险。
在大多数的情况下视图是只读的（更新视图的操作通常都有诸多的限制），外部程序无法直接透过视图修改数据。
重用SQL语句，将高度复杂的查询包装在视图表中，直接访问该视图即可取出需要的数据；也可以将视图视为数据表进行连接查询。
视图可以返回与实体数据表不同格式的数据，

创建视图。

create view vw_avg_score 
as 
    select sid, round(avg(score), 1) as avgscore 
    from tb_record group by sid;

create view vw_student_score 
as 
    select stuname, avgscore 
    from tb_student, vw_avg_score 
    where stuid=sid;

提示：因为视图不包含数据，所以每次使用视图时，都必须执行查询以获得数据，如果你使用了连接查询、嵌套查询创建了较为复杂的视图，你可能会发现查询性能下降得很厉害。因此，在使用复杂的视图前，应该进行测试以确保其性能能够满足应用的需求。

使用视图。

1	select stuname, avgscore from vw_student_score order by avgscore desc;

+--------------+----------+
| stuname      | avgscore |
+--------------+----------+
| 杨过         |     95.6 |
| 任我行       |     53.5 |
| 王语嫣       |     84.3 |
| 纪嫣然       |     73.8 |
| 岳不群       |     78.0 |
| 东方不败     |     88.0 |
| 项少龙       |     92.0 |
+--------------+----------+

既然视图是一张虚拟的表，那么视图的中的数据可以更新吗？视图的可更新性要视具体情况而定，以下类型的视图是不能更新的：

使用了聚合函数（SUM、MIN、MAX、AVG、COUNT等）、DISTINCT、GROUP BY、HAVING、UNION或者UNION ALL的视图。
SELECT中包含了子查询的视图。
FROM子句中包含了一个不能更新的视图的视图。
WHERE子句的子查询引用了FROM子句中的表的视图。

删除视图。

1	drop view vw_student_score;

说明：如果希望更新视图，可以先用上面的命令删除视图，也可以通过create or replace view来更新视图。

视图的规则和限制。

视图可以嵌套，可以利用从其他视图中检索的数据来构造一个新的视图。视图也可以和表一起使用。
创建视图时可以使用order by子句，但如果从视图中检索数据时也使用了order by，那么该视图中原先的order by会被覆盖。
视图无法使用索引，也不会激发触发器（实际开发中因为性能等各方面的考虑，通常不建议使用触发器，所以我们也不对这个概念进行介绍）的执行。

存储过程

存储过程是事先编译好存储在数据库中的一组SQL的集合，调用存储过程可以简化应用程序开发人员的工作，减少与数据库服务器之间的通信，对于提升数据操作的性能也是有帮助的。其实迄今为止，我们使用的SQL语句都是针对一个或多个表的单条语句，但在实际开发中经常会遇到某个操作需要多条SQL语句才能完成的情况。例如，电商网站在受理用户订单时，需要做以下一系列的处理。

通过查询来核对库存中是否有对应的物品以及库存是否充足。
如果库存有物品，需要锁定库存以确保这些物品不再卖给别人，并且要减少可用的物品数量以反映正确的库存量。
如果库存不足，可能需要进一步与供应商进行交互或者至少产生一条系统提示消息。
不管受理订单是否成功，都需要产生流水记录，而且需要给对应的用户产生一条通知信息。

我们可以通过存储过程将复杂的操作封装起来，这样不仅有助于保证数据的一致性，而且将来如果业务发生了变动，只需要调整和修改存储过程即可。对于调用存储过程的用户来说，存储过程并没有暴露数据表的细节，而且执行存储过程比一条条的执行一组SQL要快得多。

下面的存储过程实现了查询某门课程的最高分、最低分和平均分。

drop procedure if exists sp_score_by_cid;

delimiter $$

create procedure sp_score_by_cid(
courseId int, 
out maxScore decimal(4,1), 
out minScore decimal(4,1),
out avgScore decimal(4,1)
)
begin
select max(score) into maxScore from tb_record 
where cid=courseId;
select min(score) into minScore from tb_record 
where cid=courseId;
select avg(score) into avgScore from tb_record 
where cid=courseId;
end $$

delimiter ;

call sp_score_by_cid(1111, @a, @b, @c);
select @a, @b, @c;

说明：在定义存储过程时，因为可能需要书写多条SQL，而分隔这些SQL需要使用分号作为分隔符，如果这个时候，仍然用分号表示整段代码结束，那么定义存储过程的SQL就会出现错误，所以上面我们用delimiter $$将整段代码结束的标记定义为$$，那么代码中的分号将不再表示整段代码的结束，需要马上执行，整段代码在遇到end $$时才输入完成并执行。在定义完存储过程后，通过delimiter ;将结束符重新改回成分号。

上面定义的存储过程有四个参数，其中第一个参数是输入参数，代表课程的编号，后面的参数都是输出参数，因为存储过程不能定义返回值，只能通过输出参数将执行结果带出，定义输出参数的关键字是out，默认情况下参数都是输入参数。

调用存储过程。

1	call sp_score_by_cid(1111, @a, @b, @c);

获取输出参数的值。

1	select @a as 最高分, @b as 最低分, @c as 平均分;

删除存储过程。

1	drop procedure sp_score_by_cid;

在存储过程中，我们可以定义变量、条件，可以使用分支和循环语句，可以通过游标操作查询结果，还可以使用事件调度器，这些内容我们暂时不在此处进行介绍。虽然我们说了很多存储过程的好处，但是在实际开发中，如果过度的使用存储过程，将大量复杂的运算放到存储过程中，也会导致占用数据库服务器的CPU资源，造成数据库服务器承受巨大的压力。为此，我们一般会将复杂的运算和处理交给应用服务器，因为很容易部署多台应用服务器来分摊这些压力。

几个重要的概念

范式理论 - 设计二维表的指导思想

第一范式：数据表的每个列的值域都是由原子值组成的，不能够再分割。
第二范式：数据表里的所有数据都要和该数据表的键（主键与候选键）有完全依赖关系。
第三范式：所有非键属性都只和候选键有相关性，也就是说非键属性之间应该是独立无关的。

数据完整性

实体完整性 - 每个实体都是独一无二的
- 主键（primary key） / 唯一约束 / 唯一索引（unique）
引用完整性（参照完整性）- 关系中不允许引用不存在的实体
- 外键（foreign key）
域完整性 - 数据是有效的
- 数据类型及长度
- 非空约束（not null）
- 默认值约束（default）
- 检查约束（check）
  说明：在MySQL数据库中，检查约束并不起作用。

数据一致性

事务：一系列对数据库进行读/写的操作，这些操作要么全都成功，要么全都失败。
事务的ACID特性
- 原子性：事务作为一个整体被执行，包含在其中的对数据库的操作要么全部被执行，要么都不执行
- 一致性：事务应确保数据库的状态从一个一致状态转变为另一个一致状态
- 隔离性：多个事务并发执行时，一个事务的执行不应影响其他事务的执行
- 持久性：已被提交的事务对数据库的修改应该永久保存在数据库中
MySQL中的事务操作
- 开启事务环境
  1
  start transaction
  或
  1
  begin
- 提交事务
  1
  commit
- 回滚事务
  1
  rollback

其他内容

大家应该能够想到，关于MySQL的知识肯定远远不止上面列出的这些，比如MySQL的性能优化、管理和维护MySQL的相关工具、MySQL数据的备份和恢复、监控MySQL、部署高可用架构等问题我们在这里都没有进行讨论。当然，这些内容也都是跟项目开发密切相关的，我们就留到后续的章节中再续点进行讲解。

Python数据库编程

我们用如下所示的数据库来演示在Python中如何访问MySQL数据库。

drop database if exists hrs;
create database hrs default charset utf8;

use hrs;

drop table if exists tb_emp;
drop table if exists tb_dept;

create table tb_dept
(
dno   int not null comment '编号',
dname varchar(10) not null comment '名称',
dloc  varchar(20) not null comment '所在地',
primary key (dno)
);

insert into tb_dept values 
(10, '会计部', '北京'),
(20, '研发部', '成都'),
(30, '销售部', '重庆'),
(40, '运维部', '深圳');

create table tb_emp
(
eno   int not null comment '员工编号',
ename varchar(20) not null comment '员工姓名',
job   varchar(20) not null comment '员工职位',
mgr   int comment '主管编号',
sal   int not null comment '员工月薪',
comm  int comment '每月补贴',
dno   int comment '所在部门编号',
primary key (eno)
);

alter table tb_emp add constraint fk_emp_dno foreign key (dno) references tb_dept (dno);

insert into tb_emp values 
(7800, '张三丰', '总裁', null, 9000, 1200, 20),
(2056, '乔峰', '分析师', 7800, 5000, 1500, 20),
(3088, '李莫愁', '设计师', 2056, 3500, 800, 20),
(3211, '张无忌', '程序员', 2056, 3200, null, 20),
(3233, '丘处机', '程序员', 2056, 3400, null, 20),
(3251, '张翠山', '程序员', 2056, 4000, null, 20),
(5566, '宋远桥', '会计师', 7800, 4000, 1000, 10),
(5234, '郭靖', '出纳', 5566, 2000, null, 10),
(3344, '黄蓉', '销售主管', 7800, 3000, 800, 30),
(1359, '胡一刀', '销售员', 3344, 1800, 200, 30),
(4466, '苗人凤', '销售员', 3344, 2500, null, 30),
(3244, '欧阳锋', '程序员', 3088, 3200, null, 20),
(3577, '杨过', '会计', 5566, 2200, null, 10),
(3588, '朱九真', '会计', 5566, 2500, null, 10);

在Python 3中，我们通常使用纯Python的三方库PyMySQL来访问MySQL数据库，它应该是目前Python操作MySQL数据库最好的选择。

安装PyMySQL。
1
pip install pymysql

添加一个部门。

import pymysql


def main():
    no = int(input('编号: '))
    name = input('名字: ')
    loc = input('所在地: ')
    # 1. 创建数据库连接对象
    con = pymysql.connect(host='localhost', port=3306,
                          database='hrs', charset='utf8',
                          user='yourname', password='yourpass')
    try:
        # 2. 通过连接对象获取游标
        with con.cursor() as cursor:
            # 3. 通过游标执行SQL并获得执行结果
            result = cursor.execute(
                'insert into tb_dept values (%s, %s, %s)',
                (no, name, loc)
            )
        if result == 1:
            print('添加成功!')
        # 4. 操作成功提交事务
        con.commit()
    finally:
        # 5. 关闭连接释放资源
        con.close()


if __name__ == '__main__':
    main()

删除一个部门。

import pymysql


def main():
    no = int(input('编号: '))
    con = pymysql.connect(host='localhost', port=3306,
                          database='hrs', charset='utf8',
                          user='yourname', password='yourpass',
                          autocommit=True)
    try:
        with con.cursor() as cursor:
            result = cursor.execute(
                'delete from tb_dept where dno=%s',
                (no, )
            )
        if result == 1:
            print('删除成功!')
    finally:
        con.close()


if __name__ == '__main__':
    main()

说明：如果不希望每次SQL操作之后手动提交或回滚事务，可以像上面的代码那样，在创建连接的时候多加一个名为autocommit的参数并将它的值设置为True，表示每次执行SQL之后自动提交。如果程序中不需要使用事务环境也不希望手动的提交或回滚就可以这么做。

更新一个部门。

import pymysql


def main():
    no = int(input('编号: '))
    name = input('名字: ')
    loc = input('所在地: ')
    con = pymysql.connect(host='localhost', port=3306,
                          database='hrs', charset='utf8',
                          user='yourname', password='yourpass',
                          autocommit=True)
    try:
        with con.cursor() as cursor:
            result = cursor.execute(
                'update tb_dept set dname=%s, dloc=%s where dno=%s',
                (name, loc, no)
            )
        if result == 1:
            print('更新成功!')
    finally:
        con.close()


if __name__ == '__main__':
    main()

查询所有部门。

import pymysql
from pymysql.cursors import DictCursor


def main():
    con = pymysql.connect(host='localhost', port=3306,
                          database='hrs', charset='utf8',
                          user='yourname', password='yourpass')
    try:
        with con.cursor(cursor=DictCursor) as cursor:
            cursor.execute('select dno as no, dname as name, dloc as loc from tb_dept')
            results = cursor.fetchall()
            print(results)
            print('编号\t名称\t\t所在地')
            for dept in results:
                print(dept['no'], end='\t')
                print(dept['name'], end='\t')
                print(dept['loc'])
    finally:
        con.close()

if __name__ == '__main__':
    main()

分页查询员工信息。

import pymysql
from pymysql.cursors import DictCursor


class Emp(object):

    def __init__(self, no, name, job, sal):
        self.no = no
        self.name = name
        self.job = job
        self.sal = sal

    def __str__(self):
        return f'\n编号：{self.no}\n姓名：{self.name}\n职位：{self.job}\n月薪：{self.sal}\n'


def main():
    page = int(input('页码: '))
    size = int(input('大小: '))
    con = pymysql.connect(host='localhost', port=3306,
                          database='hrs', charset='utf8',
                          user='yourname', password='yourpass')
    try:
        with con.cursor() as cursor:
            cursor.execute(
                'select eno as no, ename as name, job, sal from tb_emp limit %s,%s',
                ((page - 1) * size, size)
            )
            for emp_tuple in cursor.fetchall():
                emp = Emp(*emp_tuple)
                print(emp)
    finally:
        con.close()


if __name__ == '__main__':
    main()

NoSQL入门

NoSQL概述

如今，大多数的计算机系统（包括服务器、PC、移动设备等）都会产生庞大的数据量。其实，早在2012年的时候，全世界每天产生的数据量就达到了2.5EB（艾字节，$$1EB\approx10^{18}B$$）。这些数据有很大一部分是由关系型数据库来存储和管理的。早在1970年，E.F.Codd发表了论述关系型数据库的著名论文“A relational model of data for large shared data banks”，这篇文章奠定了关系型数据库的基础并在接下来的数十年时间内产生了深远的影响。实践证明，关系型数据库是实现数据持久化最为重要的方式，它也是大多数应用在选择持久化方案时的首选技术。

NoSQL是一项全新的数据库革命性运动，虽然它的历史可以追溯到1998年，但是NoSQL真正深入人心并得到广泛的应用是在进入大数据时候以后，业界普遍认为NoSQL是更适合大数据存储的技术方案，这才使得NoSQL的发展达到了前所未有的高度。2012年《纽约时报》的一篇专栏中写到，大数据时代已经降临，在商业、经济及其他领域中，决策将不再基于经验和直觉而是基于数据和分析而作出。事实上，在天文学、气象学、基因组学、生物学、社会学、互联网搜索引擎、金融、医疗、社交网络、电子商务等诸多领域，由于数据过于密集和庞大，在数据的分析和处理上也遇到了前所未有的限制和阻碍，这一切都使得对大数据处理技术的研究被提升到了新的高度，也使得各种NoSQL的技术方案进入到了公众的视野。

NoSQL数据库按照其存储类型可以大致分为以下几类：

类型	部分代表	特点
列族数据库	HBase Cassandra Hypertable	顾名思义是按列存储数据的。最大的特点是方便存储结构化和半结构化数据，方便做数据压缩，对针对某一列或者某几列的查询有非常大的I/O优势，适合于批量数据处理和即时查询。
文档数据库	MongoDB CouchDB ElasticSearch	文档数据库一般用类JSON格式存储数据，存储的内容是文档型的。这样也就有机会对某些字段建立索引，实现关系数据库的某些功能，但不提供对参照完整性和分布事务的支持。
KV数据库	DynamoDB Redis LevelDB	可以通过key快速查询到其value，有基于内存和基于磁盘两种实现方案。
图数据库	Neo4J FlockDB JanusGraph	使用图结构进行语义查询的数据库，它使用节点、边和属性来表示和存储数据。图数据库从设计上，就可以简单快速的检索难以在关系系统中建模的复杂层次结构。
对象数据库	db4o Versant	通过类似面向对象语言的语法操作数据库，通过对象的方式存取数据。

说明：想了解更多的NoSQL数据库，可以访问http://nosql-database.org/。

Redis概述

Redis是一种基于键值对的NoSQL数据库，它提供了对多种数据类型（字符串、哈希、列表、集合、有序集合、位图等）的支持，能够满足很多应用场景的需求。Redis将数据放在内存中，因此读写性能是非常惊人的。与此同时，Redis也提供了持久化机制，能够将内存中的数据保存到硬盘上，在发生意外状况时数据也不会丢掉。此外，Redis还支持键过期、地理信息运算、发布订阅、事务、管道、Lua脚本扩展等功能，总而言之，Redis的功能和性能都非常强大，如果项目中要实现高速缓存和消息队列这样的服务，直接交给Redis就可以了。目前，国内外很多著名的企业和商业项目都使用了Redis，包括：Twitter、Github、StackOverflow、新浪微博、百度、优酷土豆、美团、小米、唯品会等。

Redis简介

2008年，一个名为Salvatore Sanfilippo的程序员为他开发的LLOOGG项目定制了专属的数据库（因为之前他无论怎样优化MySQL，系统性能已经无法再提升了），这项工作的成果就是Redis的初始版本。后来他将Redis的代码放到了全球最大的代码托管平台Github，从那以后，Redis引发了大量开发者的好评和关注，继而有数百人参与了Redis的开发和维护，这使得Redis的功能越来越强大和性能越来越好。

Redis是REmote DIctionary Server的缩写，它是一个用ANSI C编写的高性能的key-value存储系统，与其他的key-value存储系统相比，Redis有以下一些特点（也是优点）：

Redis的读写性能极高，并且有丰富的特性（发布/订阅、事务、通知等）。
Redis支持数据的持久化（RDB和AOF两种方式），可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
Redis支持多种数据类型，包括：string、hash、list、set，zset、bitmap、hyperloglog等。
Redis支持主从复制（实现读写分析）以及哨兵模式（监控master是否宕机并自动调整配置）。
Redis支持分布式集群，可以很容易的通过水平扩展来提升系统的整体性能。
Redis基于TCP提供的可靠传输服务进行通信，很多编程语言都提供了Redis客户端支持。

Redis的应用场景

高速缓存 - 将不常变化但又经常被访问的热点数据放到Redis数据库中，可以大大降低关系型数据库的压力，从而提升系统的响应性能。
排行榜 - 很多网站都有排行榜功能，利用Redis中的列表和有序集合可以非常方便的构造各种排行榜系统。
商品秒杀/投票点赞 - Redis提供了对计数操作的支持，网站上常见的秒杀、点赞等功能都可以利用Redis的计数器通过+1或-1的操作来实现，从而避免了使用关系型数据的update操作。
分布式锁 - 利用Redis可以跨多台服务器实现分布式锁（类似于线程锁，但是能够被多台机器上的多个线程或进程共享）的功能，用于实现一个阻塞式操作。
消息队列 - 消息队列和高速缓存一样，是一个大型网站不可缺少的基础服务，可以实现业务解耦和非实时业务削峰等特性，这些我们都会在后面的项目中为大家展示。

Redis的安装和配置

可以使用Linux系统的包管理工具（如yum）来安装Redis，也可以通过在Redis的官方网站下载Redis的源代码，解压缩解归档之后通过make工具对源代码进行构建并安装，在更新这篇文档时，Redis官方提供的最新稳定版本是Redis 5.0.4。

wget http://download.redis.io/releases/redis-5.0.4.tar.gz
gunzip redis-5.0.4.tar.gz
tar -xvf redis-5.0.4.tar
cd redis-5.0.4
make && make install

在redis源代码目录下有一个名为redis.conf的配置文件，我们可以先查看一下该文件。

1	vim redis.conf

配置将Redis服务绑定到指定的IP地址和端口。
配置底层有多少个数据库。
配置Redis的持久化机制 - RDB。
配置Redis的持久化机制 - AOF。
配置访问Redis服务器的验证口令。
配置Redis的主从复制，通过主从复制可以实现读写分离。
配置慢查询。

上面这些内容就是Redis的基本配置，如果你对上面的内容感到困惑也没有关系，先把Redis用起来再回头去推敲这些内容就行了。如果想找一些参考书，《Redis开发与运维》是一本不错的入门读物，而《Redis实战》是不错的进阶读物。

Redis的服务器和客户端

接下来启动Redis服务器，下面的方式将以默认的配置启动Redis服务。

1	redis-server

如果希望修改Redis的配置（如端口、认证口令、持久化方式等），可以通过下面两种方式。

方式一：通过参数指定认证口令和AOF持久化方式。

1	redis-server --requirepass yourpass --appendonly yes

方式二：通过指定的配置文件来修改Redis的配置。

1	redis-server /root/redis-5.0.4/redis.conf

下面我们使用第一种方式来启动Redis并将其置于后台运行，将Redis产生的输出重定向到名为redis.log的文件中。

1	redis-server --requirepass yourpass > redis.log &

可以通过ps或者netstat来检查Redis服务器是否启动成功。

1 2	ps -ef \| grep redis-server netstat -nap \| grep redis-server

接下来，我们尝试用Redis客户端去连接服务器。

redis-cli
127.0.0.1:6379> auth yourpass
OK
127.0.0.1:6379> ping
PONG
127.0.0.1:6379>

Redis有着非常丰富的数据类型，也有很多的命令来操作这些数据，具体的内容可以查看Redis命令参考，在这个网站上，除了Redis的命令参考，还有Redis的详细文档，其中包括了通知、事务、主从复制、持久化、哨兵、集群等内容。

说明：上面的插图来自付磊和张益军先生编著的《Redis开发与运维》一书。

127.0.0.1:6379> set username admin
OK
127.0.0.1:6379> get username
"admin"
127.0.0.1:6379> set password "123456" ex 300
OK
127.0.0.1:6379> get password
"123456"
127.0.0.1:6379> ttl username
(integer) -1
127.0.0.1:6379> ttl password
(integer) 286
127.0.0.1:6379> hset stu1 name hao
(integer) 0
127.0.0.1:6379> hset stu1 age 38
(integer) 1
127.0.0.1:6379> hset stu1 gender male
(integer) 1
127.0.0.1:6379> hgetall stu1
1) "name"
2) "hao"
3) "age"
4) "38"
5) "gender"
6) "male"
127.0.0.1:6379> hvals stu1
1) "hao"
2) "38"
3) "male"
127.0.0.1:6379> hmset stu2 name wang age 18 gender female tel 13566778899
OK
127.0.0.1:6379> hgetall stu2
1) "name"
2) "wang"
3) "age"
4) "18"
5) "gender"
6) "female"
7) "tel"
8) "13566778899"
127.0.0.1:6379> lpush nums 1 2 3 4 5
(integer) 5
127.0.0.1:6379> lrange nums 0 -1
1) "5"
2) "4"
3) "3"
4) "2"
5) "1"
127.0.0.1:6379> lpop nums
"5"
127.0.0.1:6379> lpop nums
"4"
127.0.0.1:6379> rpop nums
"1"
127.0.0.1:6379> rpop nums
"2"
127.0.0.1:6379> sadd fruits apple banana orange apple grape grape
(integer) 4
127.0.0.1:6379> scard fruits
(integer) 4
127.0.0.1:6379> smembers fruits
1) "grape"
2) "orange"
3) "banana"
4) "apple"
127.0.0.1:6379> sismember fruits apple
(integer) 1
127.0.0.1:6379> sismember fruits durian
(integer) 0
127.0.0.1:6379> sadd nums1 1 2 3 4 5
(integer) 5
127.0.0.1:6379> sadd nums2 2 4 6 8
(integer) 4
127.0.0.1:6379> sinter nums1 nums2
1) "2"
2) "4"
127.0.0.1:6379> sunion nums1 nums2
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
7) "8"
127.0.0.1:6379> sdiff nums1 nums2
1) "1"
2) "3"
3) "5"
127.0.0.1:6379> zadd topsinger 5234 zhangxy 1978 chenyx 2235 zhoujl 3520 xuezq
(integer) 4
127.0.0.1:6379> zrange topsinger 0 -1 withscores
1) "chenyx"
2) "1978"
3) "zhoujl"
4) "2235"
5) "xuezq"
6) "3520"
7) "zhangxy"
8) "5234"
127.0.0.1:6379> zrevrange topsinger 0 -1
1) "zhangxy"
2) "xuezq"
3) "zhoujl"
4) "chenyx"
127.0.0.1:6379> geoadd pois 116.39738549206541 39.90862689286386 tiananmen 116.27172936413572 39.99
135172904494 yiheyuan 117.27766503308104 40.65332064313784 gubeishuizhen
(integer) 3
127.0.0.1:6379> geodist pois tiananmen gubeishuizhen km
"111.5333"
127.0.0.1:6379> geodist pois tiananmen yiheyuan km
"14.1230"
127.0.0.1:6379> georadius pois 116.86499108288572 40.40149669363615 50 km withdist
1) 1) "gubeishuizhen"
   2) "44.7408"

在Python程序中使用Redis

可以使用pip安装redis模块。redis模块的核心是名为Redis的类，该类的对象代表一个Redis客户端，通过该客户端可以向Redis服务器发送命令并获取执行的结果。上面我们在Redis客户端中使用的命令基本上就是Redis对象可以接收的消息，所以如果了解了Redis的命令就可以在Python中玩转Redis。

1 2	pip3 install redis python3

>>> import redis
>>> client = redis.Redis(host='1.2.3.4', port=6379, password='yourpass')
>>> client.set('username', 'admin')
True
>>> client.hset('student', 'name', 'hao')
1
>>> client.hset('student', 'age', 38)
1
>>> client.keys('*')
[b'username', b'student']
>>> client.get('username')
b'admin'
>>> client.hgetall('student')
{b'name': b'hao', b'age': b'38'}

MongoDB概述

MongoDB简介

MongoDB是2009年问世的一个面向文档的数据库管理系统，由C++语言编写，旨在为Web应用提供可扩展的高性能数据存储解决方案。虽然在划分类别的时候后，MongoDB被认为是NoSQL的产品，但是它更像一个介于关系数据库和非关系数据库之间的产品，在非关系数据库中它功能最丰富，最像关系数据库。

MongoDB将数据存储为一个文档，一个文档由一系列的“键值对”组成，其文档类似于JSON对象，但是MongoDB对JSON进行了二进制处理（能够更快的定位key和value），因此其文档的存储格式称为BSON。关于JSON和BSON的差别大家可以看看MongoDB官方网站的文章《JSON and BSON》。

目前，MongoDB已经提供了对Windows、MacOS、Linux、Solaris等多个平台的支持，而且也提供了多种开发语言的驱动程序，Python当然是其中之一。

MongoDB的安装和配置

可以从MongoDB的官方下载链接下载MongoDB，官方为Windows系统提供了一个Installer程序，而Linux和MacOS则提供了压缩文件。下面简单说一下Linux系统如何安装和配置MongoDB。

wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-amazon-3.6.5.tgz
gunzip mongodb-linux-x86_64-amazon-3.6.5.tgz
mkdir mongodb-3.6.5
tar -xvf mongodb-linux-x86_64-amazon-3.6.5.tar --strip-components 1 -C mongodb-3.6.5/
export PATH=$PATH:~/mongodb-3.6.5/bin
mkdir -p /data/db
mongod --bind_ip 172.18.61.250

2018-06-03T18:03:28.232+0800 I CONTROL  [initandlisten] MongoDB starting : pid=1163 port=27017 dbpath=/data/db 64-bit host=iZwz97tbgo9lkabnat2lo8Z
2018-06-03T18:03:28.232+0800 I CONTROL  [initandlisten] db version v3.6.5
2018-06-03T18:03:28.232+0800 I CONTROL  [initandlisten] git version: a20ecd3e3a174162052ff99913bc2ca9a839d618
2018-06-03T18:03:28.232+0800 I CONTROL  [initandlisten] OpenSSL version: OpenSSL 1.0.0-fips29 Mar 2010
...
2018-06-03T18:03:28.945+0800 I NETWORK  [initandlisten] waiting for connections on port 27017

说明：上面的操作中，export命令是设置PATH环境变量，这样可以在任意路径下执行mongod来启动MongoDB服务器。MongoDB默认保存数据的路径是/data/db目录，为此要提前创建该目录。此外，在使用mongod启动MongoDB服务器时，–bind_ip参数用来将服务绑定到指定的IP地址，也可以用–port参数来指定端口，默认端口为27017。

MongoDB基本概念

我们通过与关系型数据库进行对照的方式来说明MongoDB中的一些概念。

SQL	MongoDB	解释（SQL/MongoDB）
database	database	数据库/数据库
table	collection	二维表/集合
row	document	记录（行）/文档
column	field	字段（列）/域
index	index	索引/索引
table joins	—	表连接/嵌套文档
primary key	primary key	主键/主键（`_id`字段）

通过Shell操作MongoDB

启动服务器后可以使用交互式环境跟服务器通信，如下所示。

mongo --host 172.18.61.250

MongoDB shell version v3.6.5
connecting to: mongodb://172.18.61.250:27017/

查看、创建和删除数据库。

> // 显示所有数据库
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
> // 创建并切换到school数据库
> use school
switched to db school
> // 删除当前数据库
> db.dropDatabase()
{ "ok" : 1 }
>

创建、删除和查看集合。

> // 创建并切换到school数据库
> use school
switched to db school
> // 创建colleges集合
> db.createCollection('colleges')
{ "ok" : 1 }
> // 创建students集合
> db.createCollection('students')
{ "ok" : 1 }
> // 查看所有集合
> show collections
colleges
students
> // 删除colleges集合
> db.colleges.drop()
true
>

说明：在MongoDB中插入文档时如果集合不存在会自动创建集合，所以也可以按照下面的方式通过创建文档来创建集合。

文档的CRUD操作。

> // 向students集合插入文档
> db.students.insert({stuid: 1001, name: '骆昊', age: 38})
WriteResult({ "nInserted" : 1 })
> // 向students集合插入文档
> db.students.save({stuid: 1002, name: '王大锤', tel: '13012345678', gender: '男'})
WriteResult({ "nInserted" : 1 })
> // 查看所有文档
> db.students.find()
{ "_id" : ObjectId("5b13c72e006ad854460ee70b"), "stuid" : 1001, "name" : "骆昊", "age" : 38 }
{ "_id" : ObjectId("5b13c790006ad854460ee70c"), "stuid" : 1002, "name" : "王大锤", "tel" : "13012345678", "gender" : "男" }
> // 更新stuid为1001的文档
> db.students.update({stuid: 1001}, {'$set': {tel: '13566778899', gender: '男'}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> // 插入或更新stuid为1003的文档
> db.students.update({stuid: 1003}, {'$set': {name: '白元芳', tel: '13022223333', gender: '男'}},  upsert=true)
WriteResult({
        "nMatched" : 0,
        "nUpserted" : 1,
        "nModified" : 0,
        "_id" : ObjectId("5b13c92dd185894d7283efab")
})
> // 查询所有文档
> db.students.find().pretty()
{
        "_id" : ObjectId("5b13c72e006ad854460ee70b"),
        "stuid" : 1001,
        "name" : "骆昊",
        "age" : 38,
        "gender" : "男",
        "tel" : "13566778899"
}
{
        "_id" : ObjectId("5b13c790006ad854460ee70c"),
        "stuid" : 1002,
        "name" : "王大锤",
        "tel" : "13012345678",
        "gender" : "男"
}
{
        "_id" : ObjectId("5b13c92dd185894d7283efab"),
        "stuid" : 1003,
        "gender" : "男",
        "name" : "白元芳",
        "tel" : "13022223333"
}
> // 查询stuid大于1001的文档
> db.students.find({stuid: {'$gt': 1001}}).pretty()
{
        "_id" : ObjectId("5b13c790006ad854460ee70c"),
        "stuid" : 1002,
        "name" : "王大锤",
        "tel" : "13012345678",
        "gender" : "男"
}
{
        "_id" : ObjectId("5b13c92dd185894d7283efab"),
        "stuid" : 1003,
        "gender" : "男",
        "name" : "白元芳",
        "tel" : "13022223333"
}
> // 查询stuid大于1001的文档只显示name和tel字段
> db.students.find({stuid: {'$gt': 1001}}, {_id: 0, name: 1, tel: 1}).pretty()
{ "name" : "王大锤", "tel" : "13012345678" }
{ "name" : "白元芳", "tel" : "13022223333" }
> // 查询name为“骆昊”或者tel为“13022223333”的文档
> db.students.find({'$or': [{name: '骆昊'}, {tel: '13022223333'}]}, {_id: 0, name: 1, tel: 1}).pretty()
{ "name" : "骆昊", "tel" : "13566778899" }
{ "name" : "白元芳", "tel" : "13022223333" }
> // 查询学生文档跳过第1条文档只查1条文档
> db.students.find().skip(1).limit(1).pretty()
{
        "_id" : ObjectId("5b13c790006ad854460ee70c"),
        "stuid" : 1002,
        "name" : "王大锤",
        "tel" : "13012345678",
        "gender" : "男"
}
> // 对查询结果进行排序(1表示升序，-1表示降序)
> db.students.find({}, {_id: 0, stuid: 1, name: 1}).sort({stuid: -1})
{ "stuid" : 1003, "name" : "白元芳" }
{ "stuid" : 1002, "name" : "王大锤" }
{ "stuid" : 1001, "name" : "骆昊" }
> // 在指定的一个或多个字段上创建索引
> db.students.ensureIndex({name: 1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
>

使用MongoDB可以非常方便的配置数据复制，通过冗余数据来实现数据的高可用以及灾难恢复，也可以通过数据分片来应对数据量迅速增长的需求。关于MongoDB更多的操作可以查阅官方文档，同时推荐大家阅读Kristina Chodorow写的《MongoDB权威指南》。

在Python程序中操作MongoDB

可以通过pip安装pymongo来实现对MongoDB的操作。

1 2	pip3 install pymongo python3

>>> from pymongo import MongoClient
>>> client = MongoClient('mongodb://127.0.0.1:27017') 
>>> db = client.school
>>> for student in db.students.find():
...     print('学号:', student['stuid'])
...     print('姓名:', student['name'])
...     print('电话:', student['tel'])
... 
学号: 1001.0
姓名: 骆昊
电话: 13566778899
学号: 1002.0
姓名: 王大锤
电话: 13012345678
学号: 1003.0
姓名: 白元芳
电话: 13022223333
>>> db.students.find().count()
3
>>> db.students.remove()
{'n': 3, 'ok': 1.0}
>>> db.students.find().count()
0
>>> coll = db.students
>>> from pymongo import ASCENDING
>>> coll.create_index([('name', ASCENDING)], unique=True)
'name_1'
>>> coll.insert_one({'stuid': int(1001), 'name': '骆昊', 'gender': True})
object at 0x1050cc6c8>
>>> coll.insert_many([{'stuid': int(1002), 'name': '王大锤', 'gender': False}, {'stuid': int(1003), 'name': '白元芳', 'gender': True}])
object at 0x1050cc8c8>
>>> for student in coll.find({'gender': True}):
...     print('学号:', student['stuid'])
...     print('姓名:', student['name'])
...     print('性别:', '男' if student['gender'] else '女')
... 
学号: 1001
姓名: 骆昊
性别: 男
学号: 1003
姓名: 白元芳
性别: 男
>>>

关于PyMongo更多的知识可以通过它的官方文档进行了解，也可以使用MongoEngine这样的库来简化Python程序对MongoDB的操作，除此之外，还有以异步I/O方式访问MongoDB的三方库motor都是不错的选择。

Python-100天(二)-Python语言进阶

2020-03-10T13:51:59.000Z

数据结构和算法

算法：解决问题的方法和步骤
评价算法的好坏：渐近时间复杂度和渐近空间复杂度。
渐近时间复杂度的大O标记：
- - 常量时间复杂度 - 布隆过滤器 / 哈希存储
- - 对数时间复杂度 - 折半查找（二分查找）
- - 线性时间复杂度 - 顺序查找 / 桶排序
- - 对数线性时间复杂度 - 高级排序算法（归并排序、快速排序）
- - 平方时间复杂度 - 简单排序算法（选择排序、插入排序、冒泡排序）
- - 立方时间复杂度 - Floyd算法 / 矩阵乘法运算
- - 几何级数时间复杂度 - 汉诺塔
- - 阶乘时间复杂度 - 旅行经销商问题 - NP

排序算法（选择、冒泡和归并）和查找算法（顺序和折半）

def select_sort(origin_items, comp=lambda x, y: x < y):
    """简单选择排序"""
    items = origin_items[:]
    for i in range(len(items) - 1):
        min_index = i
        for j in range(i + 1, len(items)):
            if comp(items[j], items[min_index]):
                min_index = j
        items[i], items[min_index] = items[min_index], items[i]
    return items

def bubble_sort(origin_items, comp=lambda x, y: x > y):
    """高质量冒泡排序(搅拌排序)"""
    items = origin_items[:]
    for i in range(len(items) - 1):
        swapped = False
        for j in range(i, len(items) - 1 - i):
            if comp(items[j], items[j + 1]):
                items[j], items[j + 1] = items[j + 1], items[j]
                swapped = True
        if swapped:
            swapped = False
            for j in range(len(items) - 2 - i, i, -1):
                if comp(items[j - 1], items[j]):
                    items[j], items[j - 1] = items[j - 1], items[j]
                    swapped = True
        if not swapped:
            break
    return items

def merge_sort(items, comp=lambda x, y: x <= y):
    """归并排序(分治法)"""
    if len(items) < 2:
        return items[:]
    mid = len(items) // 2
    left = merge_sort(items[:mid], comp)
    right = merge_sort(items[mid:], comp)
    return merge(left, right, comp)


def merge(items1, items2, comp):
    """合并(将两个有序的列表合并成一个有序的列表)"""
    items = []
    index1, index2 = 0, 0
    while index1 < len(items1) and index2 < len(items2):
        if comp(items1[index1], items2[index2]):
            items.append(items1[index1])
            index1 += 1
        else:
            items.append(items2[index2])
            index2 += 1
    items += items1[index1:]
    items += items2[index2:]
    return items

def seq_search(items, key):
    """顺序查找"""
    for index, item in enumerate(items):
        if item == key:
            return index
    return -1

def bin_search(items, key):
    """折半查找"""
    start, end = 0, len(items) - 1
    while start <= end:
        mid = (start + end) // 2
        if key > items[mid]:
            start = mid + 1
        elif key < items[mid]:
            end = mid - 1
        else:
            return mid
    return -1

使用生成式（推导式）语法

prices = {
    'AAPL': 191.88,
    'GOOG': 1186.96,
    'IBM': 149.24,
    'ORCL': 48.44,
    'ACN': 166.89,
    'FB': 208.09,
    'SYMC': 21.29
}
# 用股票价格大于100元的股票构造一个新的字典
prices2 = {key: value for key, value in prices.items() if value > 100}
print(prices2)

说明：生成式（推导式）可以用来生成列表、集合和字典。

嵌套的列表

names = ['关羽', '张飞', '赵云', '马超', '黄忠']
courses = ['语文', '数学', '英语']
# 录入五个学生三门课程的成绩
# 错误 - 参考http://pythontutor.com/visualize.html#mode=edit
# scores = [[None] * len(courses)] * len(names)
scores = [[None] * len(courses) for _ in range(len(names))]
for row, name in enumerate(names):
    for col, course in enumerate(courses):
        scores[row][col] = float(input(f'请输入{name}的{course}成绩: '))
        print(scores)

Python Tutor - VISUALIZE CODE AND GET LIVE HELP

heapq、itertools等的用法

"""
从列表中找出最大的或最小的N个元素
堆结构(大根堆/小根堆)
"""
import heapq

list1 = [34, 25, 12, 99, 87, 63, 58, 78, 88, 92]
list2 = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}
]
print(heapq.nlargest(3, list1))
print(heapq.nsmallest(3, list1))
print(heapq.nlargest(2, list2, key=lambda x: x['price']))
print(heapq.nlargest(2, list2, key=lambda x: x['shares']))

"""
迭代工具 - 排列 / 组合 / 笛卡尔积
"""
import itertools

itertools.permutations('ABCD')
itertools.combinations('ABCDE', 3)
itertools.product('ABCD', '123')

collections模块下的工具类

"""
找出序列中出现次数最多的元素
"""
from collections import Counter

words = [
    'look', 'into', 'my', 'eyes', 'look', 'into', 'my', 'eyes',
    'the', 'eyes', 'the', 'eyes', 'the', 'eyes', 'not', 'around',
    'the', 'eyes', "don't", 'look', 'around', 'the', 'eyes',
    'look', 'into', 'my', 'eyes', "you're", 'under'
]
counter = Counter(words)
print(counter.most_common(3))

常用算法：
- 穷举法 - 又称为暴力破解法，对所有的可能性进行验证，直到找到正确答案。
- 贪婪法 - 在对问题求解时，总是做出在当前看来
- 最好的选择，不追求最优解，快速找到满意解。
- 分治法 - 把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题，直到可以直接求解的程度，最后将子问题的解进行合并得到原问题的解。
- 回溯法 - 回溯法又称为试探法，按选优条件向前搜索，当搜索到某一步发现原先选择并不优或达不到目标时，就退回一步重新选择。
- 动态规划 - 基本思想也是将待求解问题分解成若干个子问题，先求解并保存这些子问题的解，避免产生大量的重复运算。

穷举法例子：百钱百鸡和五人分鱼。

# 公鸡5元一只 母鸡3元一只 小鸡1元三只
# 用100元买100只鸡 问公鸡/母鸡/小鸡各多少只
for x in range(20):
    for y in range(33):
        z = 100 - x - y
        if 5 * x + 3 * y + z // 3 == 100 and z % 3 == 0:
            print(x, y, z)

# A、B、C、D、E五人在某天夜里合伙捕鱼 最后疲惫不堪各自睡觉
# 第二天A第一个醒来 他将鱼分为5份 扔掉多余的1条 拿走自己的一份
# B第二个醒来 也将鱼分为5份 扔掉多余的1条 拿走自己的一份
# 然后C、D、E依次醒来也按同样的方式分鱼 问他们至少捕了多少条鱼
fish = 6
while True:
    total = fish
    enough = True
    for _ in range(5):
        if (total - 1) % 5 == 0:
            total = (total - 1) // 5 * 4
        else:
            enough = False
            break
    if enough:
        print(fish)
        break
    fish += 5

贪婪法例子：假设小偷有一个背包，最多能装20公斤赃物，他闯入一户人家，发现如下表所示的物品。很显然，他不能把所有物品都装进背包，所以必须确定拿走哪些物品，留下哪些物品。

|  名称  | 价格（美元） | 重量（kg） || :----: | :----------: | :--------: ||  电脑  |     200      |     20     || 收音机 |      20      |     4      ||   钟   |     175      |     10     ||  花瓶  |      50      |     2      ||   书   |      10      |     1      ||  油画  |      90      |     9      |

"""
贪婪法：在对问题求解时，总是做出在当前看来是最好的选择，不追求最优解，快速找到满意解。
输入：
20 6
电脑 200 20
收音机 20 4
钟 175 10
花瓶 50 2
书 10 1
油画 90 9
"""
class Thing(object):
    """物品"""

    def __init__(self, name, price, weight):
        self.name = name
        self.price = price
        self.weight = weight

    @property
    def value(self):
        """价格重量比"""
        return self.price / self.weight


def input_thing():
    """输入物品信息"""
    name_str, price_str, weight_str = input().split()
    return name_str, int(price_str), int(weight_str)


def main():
    """主函数"""
    max_weight, num_of_things = map(int, input().split())
    all_things = []
    for _ in range(num_of_things):
        all_things.append(Thing(*input_thing()))
    all_things.sort(key=lambda x: x.value, reverse=True)
    total_weight = 0
    total_price = 0
    for thing in all_things:
        if total_weight + thing.weight <= max_weight:
            print(f'小偷拿走了{thing.name}')
            total_weight += thing.weight
            total_price += thing.price
    print(f'总价值: {total_price}美元')


if __name__ == '__main__':
    main()

分治法例子：快速排序。

"""
快速排序 - 选择枢轴对元素进行划分，左边都比枢轴小右边都比枢轴大
"""
def quick_sort(origin_items, comp=lambda x, y: x <= y):
    items = origin_items[:]
    _quick_sort(items, 0, len(items) - 1, comp)
    return items


def _quick_sort(items, start, end, comp):
    if start < end:
        pos = _partition(items, start, end, comp)
        _quick_sort(items, start, pos - 1, comp)
        _quick_sort(items, pos + 1, end, comp)


def _partition(items, start, end, comp):
    pivot = items[end]
    i = start - 1
    for j in range(start, end):
        if comp(items[j], pivot):
            i += 1
            items[i], items[j] = items[j], items[i]
    items[i + 1], items[end] = items[end], items[i + 1]
    return i + 1

回溯法例子：骑士巡逻。

"""
递归回溯法：叫称为试探法，按选优条件向前搜索，当搜索到某一步，发现原先选择并不优或达不到目标时，就退回一步重新选择，比较经典的问题包括骑士巡逻、八皇后和迷宫寻路等。
"""
import sys
import time

SIZE = 5
total = 0


def print_board(board):
    for row in board:
        for col in row:
            print(str(col).center(4), end='')
        print()


def patrol(board, row, col, step=1):
    if row >= 0 and row < SIZE and \
        col >= 0 and col < SIZE and \
        board[row][col] == 0:
        board[row][col] = step
        if step == SIZE * SIZE:
            global total
            total += 1
            print(f'第{total}种走法: ')
            print_board(board)
        patrol(board, row - 2, col - 1, step + 1)
        patrol(board, row - 1, col - 2, step + 1)
        patrol(board, row + 1, col - 2, step + 1)
        patrol(board, row + 2, col - 1, step + 1)
        patrol(board, row + 2, col + 1, step + 1)
        patrol(board, row + 1, col + 2, step + 1)
        patrol(board, row - 1, col + 2, step + 1)
        patrol(board, row - 2, col + 1, step + 1)
        board[row][col] = 0


def main():
    board = [[0] * SIZE for _ in range(SIZE)]
    patrol(board, SIZE - 1, SIZE - 1)


if __name__ == '__main__':
    main()

动态规划例子1：斐波拉切数列。（不使用动态规划将会是几何级数复杂度）

"""
动态规划 - 适用于有重叠子问题和最优子结构性质的问题
使用动态规划方法所耗时间往往远少于朴素解法(用空间换取时间)
"""
def fib(num, temp={}):
    """用递归计算Fibonacci数"""
    if num in (1, 2):
        return 1
    try:
        return temp[num]
    except KeyError:
        temp[num] = fib(num - 1) + fib(num - 2)
        return temp[num]

动态规划例子2：子列表元素之和的最大值。（使用动态规划可以避免二重循环）

说明：子列表指的是列表中索引（下标）连续的元素构成的列表；列表中的元素是int类型，可能包含正整数、0、负整数；程序输入列表中的元素，输出子列表元素求和的最大值，例如：
输入：1 -2 3 5 -3 2
输出：8
输入：0 -2 3 5 -1 2
输出：9
输入：-9 -2 -3 -5 -3
输出：-2

def main():
    items = list(map(int, input().split()))
    size = len(items)
    overall, partial = {}, {}
    overall[size - 1] = partial[size - 1] = items[size - 1]
    for i in range(size - 2, -1, -1):
        partial[i] = max(items[i], partial[i + 1] + items[i])
        overall[i] = max(partial[i], overall[i + 1])
    print(overall[0])


if __name__ == '__main__':
    main()

函数的使用方式

将函数视为“一等公民”
- 函数可以赋值给变量
- 函数可以作为函数的参数
- 函数可以作为函数的返回值
高阶函数的用法（filter、map以及它们的替代品）

1 2	items1 = list(map(lambda x: x 2, filter(lambda x: x % 2, range(1, 10)))) items2 = [x 2 for x in range(1, 10) if x % 2]

位置参数、可变参数、关键字参数、命名关键字参数
参数的元信息（代码可读性问题）
匿名函数和内联函数的用法（lambda函数）
闭包和作用域问题
Python搜索变量的LEGB顺序（Local –> Embedded –> Global –> Built-in）
global和nonlocal关键字的作用
global：声明或定义全局变量（要么直接使用现有的全局作用域的变量，要么定义一个变量放到全局作用域）。
nonlocal：声明使用嵌套作用域的变量（嵌套作用域必须存在该变量，否则报错）。
装饰器函数（使用装饰器和取消装饰器）

例子：输出函数执行时间的装饰器。

def record_time(func):
    """自定义装饰函数的装饰器"""
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time()
        result = func(*args, **kwargs)
        print(f'{func.__name__}: {time() - start}秒')
        return result
        
    return wrapper

如果装饰器不希望跟print函数耦合，可以编写带参数的装饰器。

from functools import wraps
from time import time


def record(output):
    """自定义带参数的装饰器"""

def decorate(func):
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time()
        result = func(*args, **kwargs)
        output(func.__name__, time() - start)
        return result
            
    return wrapper

return decorate

from functools import wraps
from time import time


class Record():
    """自定义装饰器类(通过__call__魔术方法使得对象可以当成函数调用)"""

    def __init__(self, output):
        self.output = output

    def __call__(self, func):

        @wraps(func)
        def wrapper(*args, **kwargs):
            start = time()
            result = func(*args, **kwargs)
            self.output(func.__name__, time() - start)
            return result

        return wrapper

说明：由于对带装饰功能的函数添加了@wraps装饰器，可以通过func.__wrapped__方式获得被装饰之前的函数或类来取消装饰器的作用。

例子：用装饰器来实现单例模式。

from functools import wraps


def singleton(cls):
    """装饰类的装饰器"""
    instances = {}

    @wraps(cls)
    def wrapper(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return wrapper


@singleton
class President():
    """总统(单例类)"""
    pass

说明：上面的代码中用到了闭包（closure），不知道你是否已经意识到了。还没有一个小问题就是，上面的代码并没有实现线程安全的单例，如果要实现线程安全的单例应该怎么做呢？

from functools import wraps
from threading import Lock


def singleton(cls):
    """线程安全的单例装饰器"""
    instances = {}
    locker = Lock()

    @wraps(cls)
    def wrapper(*args, **kwargs):
        if cls not in instances:
            with locker:
                if cls not in instances:
                    instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return wrapper

面向对象相关知识

三大支柱：封装、继承、多态

例子：工资结算系统。

"""
月薪结算系统 - 部门经理每月15000 程序员每小时200 销售员1800底薪加销售额5%提成
"""
from abc import ABCMeta, abstractmethod


class Employee(metaclass=ABCMeta):
    """员工(抽象类)"""

    def __init__(self, name):
        self.name = name

    @abstractmethod
    def get_salary(self):
        """结算月薪(抽象方法)"""
        pass


class Manager(Employee):
    """部门经理"""

    def get_salary(self):
        return 15000.0


class Programmer(Employee):
    """程序员"""

    def __init__(self, name, working_hour=0):
        self.working_hour = working_hour
        super().__init__(name)

    def get_salary(self):
        return 200.0 * self.working_hour


class Salesman(Employee):
    """销售员"""

    def __init__(self, name, sales=0.0):
        self.sales = sales
        super().__init__(name)

    def get_salary(self):
        return 1800.0 + self.sales * 0.05


class EmployeeFactory():
    """创建员工的工厂（工厂模式 - 通过工厂实现对象使用者和对象之间的解耦合）"""

    @staticmethod
    def create(emp_type, *args, **kwargs):
        """创建员工"""
        emp_type = emp_type.upper()
        emp = None
        if emp_type == 'M':
            emp = Manager(*args, **kwargs)
        elif emp_type == 'P':
            emp = Programmer(*args, **kwargs)
        elif emp_type == 'S':
            emp = Salesman(*args, **kwargs)
        return emp


def main():
    """主函数"""
    emps = [
        EmployeeFactory.create('M', '曹操'), 
        EmployeeFactory.create('P', '荀彧', 120),
        EmployeeFactory.create('P', '郭嘉', 85), 
        EmployeeFactory.create('S', '典韦', 123000),
    ]
    for emp in emps:
        print('%s: %.2f元' % (emp.name, emp.get_salary()))


if __name__ == '__main__':
    main()

类与类之间的关系
- is-a关系：继承
- has-a关系：关联 / 聚合 / 合成
- use-a关系：依赖

例子：扑克游戏。

"""
经验：符号常量总是优于字面常量，枚举类型是定义符号常量的最佳选择
"""
from enum import Enum, unique

import random


@unique
class Suite(Enum):
    """花色"""

    SPADE, HEART, CLUB, DIAMOND = range(4)

    def __lt__(self, other):
        return self.value < other.value


class Card():
    """牌"""

    def __init__(self, suite, face):
        """初始化方法"""
        self.suite = suite
        self.face = face

    def show(self):
        """显示牌面"""
        suites = ['♠️', '♥️', '♣️', '♦️']
        faces = ['', 'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
        return f'{suites[self.suite.value]} {faces[self.face]}'

    def __str__(self):
        return self.show()

    def __repr__(self):
        return self.show()


class Poker():
    """扑克"""

    def __init__(self):
        self.index = 0
        self.cards = [Card(suite, face)
                    for suite in Suite
                    for face in range(1, 14)]

    def shuffle(self):
        """洗牌（随机乱序）"""
        random.shuffle(self.cards)
        self.index = 0

    def deal(self):
        """发牌"""
        card = self.cards[self.index]
        self.index += 1
        return card

    @property
    def has_more(self):
        return self.index < len(self.cards)


class Player():
    """玩家"""

    def __init__(self, name):
        self.name = name
        self.cards = []

    def get_one(self, card):
        """摸一张牌"""
        self.cards.append(card)

    def sort(self, comp=lambda card: (card.suite, card.face)):
        """整理手上的牌"""
        self.cards.sort(key=comp)


def main():
    """主函数"""
    poker = Poker()
    poker.shuffle()
    players = [Player('东邪'), Player('西毒'), Player('南帝'), Player('北丐')]
    while poker.has_more:
        for player in players:
                player.get_one(poker.deal())
    for player in players:
        player.sort()
        print(player.name, end=': ')
        print(player.cards)


if __name__ == '__main__':
    main()

说明：上面的代码中使用了Emoji字符来表示扑克牌的四种花色，在某些不支持Emoji字符的系统上可能无法显示。

对象的复制（深复制/深拷贝/深度克隆和浅复制/浅拷贝/影子克隆）
垃圾回收、循环引用和弱引用
Python使用了自动化内存管理，这种管理机制以引用计数为基础，同时也引入了标记-清除和分代收集两种机制为辅的策略。

typedef struct_object {
    /* 引用计数 */
    int ob_refcnt;
    /* 对象指针 */
    struct_typeobject *ob_type;
} PyObject;

/* 增加引用计数的宏定义 */
#define Py_INCREF(op)   ((op)->ob_refcnt++)
/* 减少引用计数的宏定义 */
#define Py_DECREF(op) \ //减少计数
    if (--(op)->ob_refcnt != 0) \
        ; \
    else \
        __Py_Dealloc((PyObject *)(op))

导致引用计数+1的情况：
- 对象被创建，例如a = 23
- 对象被引用，例如b = a
- 对象被作为参数，传入到一个函数中，例如f(a)
- 对象作为一个元素，存储在容器中，例如list1 = [a, a]

导致引用计数-1的情况：- 对象的别名被显式销毁，例如`del a`- 对象的别名被赋予新的对象，例如`a = 24`- 一个对象离开它的作用域，例如f函数执行完毕时，f函数中的局部变量（全局变量不会）- 对象所在的容器被销毁，或从容器中删除对象引用计数可能会导致循环引用问题，而循环引用会导致内存泄露，如下面的代码所示。为了解决这个问题，Python中引入了“标记-清除”和“分代收集”。在创建一个对象的时候，对象被放在第一代中，如果在第一代的垃圾检查中对象存活了下来，该对象就会被放到第二代中，同理在第二代的垃圾检查中对象存活下来，该对象就会被放到第三代中。1
2
3
4
5
6
7
# 循环引用会导致内存泄露 - Python除了引用技术还引入了标记清理和分代回收
# 在Python 3.6以前如果重写__del__魔术方法会导致循环引用处理失效
# 如果不想造成循环引用可以使用弱引用
list1 = []
list2 = [] 
list1.append(list2)
list2.append(list1)
以下情况会导致垃圾回收：- 调用`gc.collect()`- gc模块的计数器达到阀值- 程序退出如果循环引用中两个对象都定义了`__del__`方法，gc模块不会销毁这些不可达对象，因为gc模块不知道应该先调用哪个对象的`__del__`方法，这个问题在Python 3.6中得到了解决。也可以通过`weakref`模块构造弱引用的方式来解决循环引用的问题。

魔法属性和方法（请参考《Python魔法方法指南》）

有几个小问题请大家思考：
- 自定义的对象能不能使用运算符做运算？
- 自定义的对象能不能放到set中？能去重吗？
- 自定义的对象能不能作为dict的键？
- 自定义的对象能不能使用上下文语法？

混入（Mixin）

例子：自定义字典限制只有在指定的key不存在时才能在字典中设置键值对。

class SetOnceMappingMixin:
    """自定义混入类"""
    __slots__ = ()

    def __setitem__(self, key, value):
        if key in self:
            raise KeyError(str(key) + ' already set')
        return super().__setitem__(key, value)


class SetOnceDict(SetOnceMappingMixin, dict):
    """自定义字典"""
    pass


my_dict= SetOnceDict()
try:
    my_dict['username'] = 'jackfrued'
    my_dict['username'] = 'hellokitty'
except KeyError:
    pass
print(my_dict)

元编程和元类

例子：用元类实现单例模式。

import threading


class SingletonMeta(type):
    """自定义元类"""

    def __init__(cls, *args, **kwargs):
        cls.__instance = None
        cls.__lock = threading.Lock()
        super().__init__(*args, **kwargs)

    def __call__(cls, *args, **kwargs):
        if cls.__instance is None:
            with cls.__lock:
                if cls.__instance is None:
                    cls.__instance = super().__call__(*args, **kwargs)
        return cls.__instance


class President(metaclass=SingletonMeta):
    """总统(单例类)"""
    
    pass

面向对象设计原则
- 单一职责原则（SRP）- 一个类只做该做的事情（类的设计要高内聚）
- 开闭原则（OCP）- 软件实体应该对扩展开发对修改关闭
- 依赖倒转原则（DIP）- 面向抽象编程（在弱类型语言中已经被弱化）
- 里氏替换原则（LSP） - 任何时候可以用子类对象替换掉父类对象
- 接口隔离原则（ISP）- 接口要小而专不要大而全（Python中没有接口的概念）
- 合成聚合复用原则（CARP） - 优先使用强关联关系而不是继承关系复用代码
- 最少知识原则（迪米特法则，LoD）- 不要给没有必然联系的对象发消息
说明：上面加粗的字母放在一起称为面向对象的SOLID原则。
GoF设计模式
- 创建型模式：单例、工厂、建造者、原型
- 结构型模式：适配器、门面（外观）、代理
- 行为型模式：迭代器、观察者、状态、策略

例子：可插拔的哈希算法。

class StreamHasher():
    """哈希摘要生成器(策略模式)"""

    def __init__(self, alg='md5', size=4096):
        self.size = size
        alg = alg.lower()
        self.hasher = getattr(__import__('hashlib'), alg.lower())()

    def __call__(self, stream):
        return self.to_digest(stream)

    def to_digest(self, stream):
        """生成十六进制形式的摘要"""
        for buf in iter(lambda: stream.read(self.size), b''):
            self.hasher.update(buf)
        return self.hasher.hexdigest()

def main():
    """主函数"""
    hasher1 = StreamHasher()
    with open('Python-3.7.1.tgz', 'rb') as stream:
        print(hasher1.to_digest(stream))
    hasher2 = StreamHasher('sha1')
    with open('Python-3.7.1.tgz', 'rb') as stream:
        print(hasher2(stream))


if __name__ == '__main__':
    main()

迭代器和生成器

和迭代器相关的魔术方法（__iter__和__next__）
两种创建生成器的方式（生成器表达式和yield关键字）

def fib(num):
    """生成器"""
    a, b = 0, 1
    for _ in range(num):
        a, b = b, a + b
        yield a


class Fib(object):
    """迭代器"""
    
    def __init__(self, num):
        self.num = num
        self.a, self.b = 0, 1
        self.idx = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.idx < self.num:
            self.a, self.b = self.b, self.a + self.b
            self.idx += 1
            return self.a
        raise StopIteration()

并发编程

Python中实现并发编程的三种方案：多线程、多进程和异步I/O。并发编程的好处在于可以提升程序的执行效率以及改善用户体验；坏处在于并发的程序不容易开发和调试，同时对其他程序来说它并不友好。

多线程：Python中提供了Thread类并辅以Lock、Condition、Event、Semaphore和Barrier。Python中有GIL来防止多个线程同时执行本地字节码，这个锁对于CPython是必须的，因为CPython的内存管理并不是线程安全的，因为GIL的存在多线程并不能发挥CPU的多核特性。

"""
面试题：进程和线程的区别和联系？
进程 - 操作系统分配内存的基本单位 - 一个进程可以包含一个或多个线程
线程 - 操作系统分配CPU的基本单位
并发编程（concurrent programming）
1. 提升执行性能 - 让程序中没有因果关系的部分可以并发的执行
2. 改善用户体验 - 让耗时间的操作不会造成程序的假死
"""
import glob
import os
import threading

from PIL import Image

PREFIX = 'thumbnails'


def generate_thumbnail(infile, size, format='PNG'):
    """生成指定图片文件的缩略图"""
file, ext = os.path.splitext(infile)
file = file[file.rfind('/') + 1:]
outfile = f'{PREFIX}/{file}_{size[0]}_{size[1]}.{ext}'
img = Image.open(infile)
img.thumbnail(size, Image.ANTIALIAS)
img.save(outfile, format)


def main():
    """主函数"""
if not os.path.exists(PREFIX):
    os.mkdir(PREFIX)
for infile in glob.glob('images/*.png'):
    for size in (32, 64, 128):
            # 创建并启动线程
        threading.Thread(
            target=generate_thumbnail, 
            args=(infile, (size, size))
        ).start()
        

if __name__ == '__main__':
main()

多个线程竞争资源的情况

"""
多线程程序如果没有竞争资源处理起来通常也比较简单
当多个线程竞争临界资源的时候如果缺乏必要的保护措施就会导致数据错乱
说明：临界资源就是被多个线程竞争的资源
"""
import time
import threading

from concurrent.futures import ThreadPoolExecutor


class Account(object):
    """银行账户"""

    def __init__(self):
        self.balance = 0.0
        self.lock = threading.Lock()

    def deposit(self, money):
        # 通过锁保护临界资源
        with self.lock:
            new_balance = self.balance + money
            time.sleep(0.001)
            self.balance = new_balance


class AddMoneyThread(threading.Thread):
    """自定义线程类"""

    def __init__(self, account, money):
        self.account = account
        self.money = money
        # 自定义线程的初始化方法中必须调用父类的初始化方法
        super().__init__()

    def run(self):
        # 线程启动之后要执行的操作
        self.account.deposit(self.money)

def main():
    """主函数"""
    account = Account()
    # 创建线程池
    pool = ThreadPoolExecutor(max_workers=10)
    futures = []
    for _ in range(100):
        # 创建线程的第1种方式
        # threading.Thread(
        #     target=account.deposit, args=(1, )
        # ).start()
        # 创建线程的第2种方式
        # AddMoneyThread(account, 1).start()
        # 创建线程的第3种方式
        # 调用线程池中的线程来执行特定的任务
        future = pool.submit(account.deposit, 1)
        futures.append(future)
    # 关闭线程池
    pool.shutdown()
    for future in futures:
        future.result()
    print(account.balance)


if __name__ == '__main__':
    main()

修改上面的程序，启动5个线程向账户中存钱，5个线程从账户中取钱，取钱时如果余额不足就暂停线程进行等待。为了达到上述目标，需要对存钱和取钱的线程进行调度，在余额不足时取钱的线程暂停并释放锁，而存钱的线程将钱存入后要通知取钱的线程，使其从暂停状态被唤醒。可以使用threading模块的Condition来实现线程调度，该对象也是基于锁来创建的，代码如下所示：

"""
多个线程竞争一个资源 - 保护临界资源 - 锁（Lock/RLock）
多个线程竞争多个资源（线程数>资源数） - 信号量（Semaphore）
多个线程的调度 - 暂停线程执行/唤醒等待中的线程 - Condition
"""
from concurrent.futures import ThreadPoolExecutor
from random import randint
from time import sleep

import threading


class Account():
    """银行账户"""

    def __init__(self, balance=0):
        self.balance = balance
        lock = threading.Lock()
        self.condition = threading.Condition(lock)

    def withdraw(self, money):
        """取钱"""
        with self.condition:
            while money > self.balance:
                self.condition.wait()
            new_balance = self.balance - money
            sleep(0.001)
            self.balance = new_balance

    def deposit(self, money):
        """存钱"""
        with self.condition:
            new_balance = self.balance + money
            sleep(0.001)
            self.balance = new_balance
            self.condition.notify_all()


def add_money(account):
    while True:
        money = randint(5, 10)
        account.deposit(money)
        print(threading.current_thread().name, 
            ':', money, '====>', account.balance)
        sleep(0.5)


def sub_money(account):
    while True:
        money = randint(10, 30)
        account.withdraw(money)
        print(threading.current_thread().name, 
            ':', money, '<====', account.balance)
        sleep(1)


def main():
    account = Account()
    with ThreadPoolExecutor(max_workers=10) as pool:
        for _ in range(5):
            pool.submit(add_money, account)
            pool.submit(sub_money, account)


if __name__ == '__main__':
    main()

多进程：多进程可以有效的解决GIL的问题，实现多进程主要的类是Process，其他辅助的类跟threading模块中的类似，进程间共享数据可以使用管道、套接字等，在multiprocessing模块中有一个Queue类，它基于管道和锁机制提供了多个进程共享的队列。下面是官方文档上关于多进程和进程池的一个示例。

"""
多进程和进程池的使用
多线程因为GIL的存在不能够发挥CPU的多核特性
对于计算密集型任务应该考虑使用多进程
time python3 example22.py
real    0m11.512s
user    0m39.319s
sys     0m0.169s
使用多进程后实际执行时间为11.512秒，而用户时间39.319秒约为实际执行时间的4倍
这就证明我们的程序通过多进程使用了CPU的多核特性，而且这台计算机配置了4核的CPU
"""
import concurrent.futures
import math

PRIMES = [
    1116281,
    1297337,
    104395303,
    472882027,
    533000389,
    817504243,
    982451653,
    112272535095293,
    112582705942171,
    112272535095293,
    115280095190773,
    115797848077099,
    1099726899285419
] * 5


def is_prime(n):
    """判断素数"""
    if n % 2 == 0:
        return False

    sqrt_n = int(math.floor(math.sqrt(n)))
    for i in range(3, sqrt_n + 1, 2):
        if n % i == 0:
            return False
    return True


def main():
    """主函数"""
    with concurrent.futures.ProcessPoolExecutor() as executor:
        for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
            print('%d is prime: %s' % (number, prime))


if __name__ == '__main__':
    main()

说明：多线程和多进程的比较。
以下情况需要使用多线程：
程序需要维护许多共享的状态（尤其是可变状态），Python中的列表、字典、集合都是线程安全的，所以使用线程而不是进程维护共享状态的代价相对较小。
程序会花费大量时间在I/O操作上，没有太多并行计算的需求且不需占用太多的内存。
以下情况需要使用多进程：
程序执行计算密集型任务（如：字节码操作、数据处理、科学计算）。
程序的输入可以并行的分成块，并且可以将运算结果合并。
程序在内存使用方面没有任何限制且不强依赖于I/O操作（如：读写文件、套接字等）。

异步处理：从调度程序的任务队列中挑选任务，该调度程序以交叉的形式执行这些任务，我们并不能保证任务将以某种顺序去执行，因为执行顺序取决于队列中的一项任务是否愿意将CPU处理时间让位给另一项任务。异步任务通常通过多任务协作处理的方式来实现，由于执行时间和顺序的不确定，因此需要通过回调式编程或者future对象来获取任务执行的结果。Python 3通过asyncio模块和await和async关键字（在Python 3.7中正式被列为关键字）来支持异步处理。

"""
异步I/O - async / await
"""
import asyncio


def num_generator(m, n):
    """指定范围的数字生成器"""
    yield from range(m, n + 1)


async def prime_filter(m, n):
    """素数过滤器"""
    primes = []
    for i in num_generator(m, n):
        flag = True
        for j in range(2, int(i ** 0.5 + 1)):
            if i % j == 0:
                flag = False
                break
        if flag:
            print('Prime =>', i)
            primes.append(i)

        await asyncio.sleep(0.001)
    return tuple(primes)


async def square_mapper(m, n):
    """平方映射器"""
    squares = []
    for i in num_generator(m, n):
        print('Square =>', i * i)
        squares.append(i * i)

        await asyncio.sleep(0.001)
    return squares


def main():
    """主函数"""
    loop = asyncio.get_event_loop()
    future = asyncio.gather(prime_filter(2, 100), square_mapper(1, 100))
    future.add_done_callback(lambda x: print(x.result()))
    loop.run_until_complete(future)
    loop.close()


if __name__ == '__main__':
    main()

说明：上面的代码使用get_event_loop函数获得系统默认的事件循环，通过gather函数可以获得一个future对象，future对象的add_done_callback可以添加执行完成时的回调函数，loop对象的run_until_complete方法可以等待通过future对象获得协程执行结果。

Python中有一个名为aiohttp的三方库，它提供了异步的HTTP客户端和服务器，这个三方库可以跟asyncio模块一起工作，并提供了对Future对象的支持。Python 3.6中引入了async和await来定义异步执行的函数以及创建异步上下文，在Python 3.7中它们正式成为了关键字。下面的代码异步的从5个URL中获取页面并通过正则表达式的命名捕获组提取了网站的标题。

import asyncio
import re

import aiohttp

PATTERN = re.compile(r'\(?P.*)\<\/title\>'</span>)</span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="keyword">async</span> <span class="keyword">def</span> <span class="title function_">fetch_page</span>(<span class="params">session, url</span>):</span><br><span class="line">    <span class="keyword">async</span> <span class="keyword">with</span> session.get(url, ssl=<span class="literal">False</span>) <span class="keyword">as</span> resp:</span><br><span class="line">        <span class="keyword">return</span> <span class="keyword">await</span> resp.text()</span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="keyword">async</span> <span class="keyword">def</span> <span class="title function_">show_title</span>(<span class="params">url</span>):</span><br><span class="line">    <span class="keyword">async</span> <span class="keyword">with</span> aiohttp.ClientSession() <span class="keyword">as</span> session:</span><br><span class="line">        html = <span class="keyword">await</span> fetch_page(session, url)</span><br><span class="line">        <span class="built_in">print</span>(PATTERN.search(html).group(<span class="string">'title'</span>))</span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="keyword">def</span> <span class="title function_">main</span>():</span><br><span class="line">    urls = (<span class="string">'https://www.python.org/'</span>,</span><br><span class="line">            <span class="string">'https://git-scm.com/'</span>,</span><br><span class="line">            <span class="string">'https://www.jd.com/'</span>,</span><br><span class="line">            <span class="string">'https://www.taobao.com/'</span>,</span><br><span class="line">            <span class="string">'https://www.douban.com/'</span>)</span><br><span class="line">    loop = asyncio.get_event_loop()</span><br><span class="line">    tasks = [show_title(url) <span class="keyword">for</span> url <span class="keyword">in</span> urls]</span><br><span class="line">    loop.run_until_complete(asyncio.wait(tasks))</span><br><span class="line">    loop.close()</span><br><span class="line"></span><br><span class="line"></span><br><span class="line"><span class="keyword">if</span> __name__ == <span class="string">'__main__'</span>:</span><br><span class="line">    main()</span><br></pre></td></tr></table></figure><blockquote><p>说明：<strong>异步I/O与多进程的比较</strong>。</p><p>当程序不需要真正的并发性或并行性，而是更多的依赖于异步处理和回调时，asyncio就是一种很好的选择。如果程序中有大量的等待与休眠时，也应该考虑asyncio，它很适合编写没有实时数据处理需求的Web应用服务器。</p></blockquote><p>Python还有很多用于处理并行任务的三方库，例如：joblib、PyMP等。实际开发中，要提升系统的可扩展性和并发性通常有垂直扩展（增加单个节点的处理能力）和水平扩展（将单个节点变成多个节点）两种做法。可以通过消息队列来实现应用程序的解耦合，消息队列相当于是多线程同步队列的扩展版本，不同机器上的应用程序相当于就是线程，而共享的分布式消息队列就是原来程序中的Queue。消息队列（面向消息的中间件）的最流行和最标准化的实现是AMQP（高级消息队列协议），AMQP源于金融行业，提供了排队、路由、可靠传输、安全等功能，最著名的实现包括：Apache的ActiveMQ、RabbitMQ等。</p><p>要实现任务的异步化，可以使用名为Celery的三方库。Celery是Python编写的分布式任务队列，它使用分布式消息进行工作，可以基于RabbitMQ或Redis来作为后端的消息代理。</p>
</article>
</main></body></html>

ash

Git CLI 命令操作手册与详细介绍

目录

1. Git 到底在管理什么

2. Git 配置与帮助系统

2.1 查看版本

2.2 基础配置

2.3 查看某个配置值

2.4 删除配置

2.5 Git 帮助系统

3. 新建仓库与获取仓库

3.1 初始化仓库：git init

3.2 克隆仓库：git clone

3.3 判断当前目录是不是 Git 仓库

4. Git 的四个核心区域

4.1 工作区

4.2 暂存区

4.3 本地仓库

4.4 远程仓库

4.5 最容易混淆的三个对比

5. 日常高频命令

5.1 查看状态：git status

5.2 添加到暂存区：git add

5.3 提交：git commit

5.4 查看差异：git diff

5.5 查看文件内容来自哪个提交：git blame

5.6 查看对象详情：git show

6. 分支与切换

6.1 查看分支：git branch

6.2 创建分支

6.3 切换分支：git switch

6.4 重命名分支

6.5 删除分支

6.6 跟踪远程分支

7. 查看历史与定位问题

7.1 历史查看：git log

7.2 精简历史：git shortlog

7.3 查找历史中的某段文本：git grep

7.4 二分定位引入 bug 的提交：git bisect

8. 远程仓库协作

8.1 查看远程：git remote

8.2 添加远程

8.3 修改远程地址

8.4 删除远程

8.5 获取远程更新：git fetch

8.6 拉取并合并：git pull

8.7 推送：git push

8.8 强制推送

9. 合并、变基与历史整理

9.1 合并分支：git merge

9.2 变基：git rebase

9.3 交互式变基：git rebase -i

9.4 挑选提交：git cherry-pick

9.5 合并中断与继续

10. 撤销、回退与恢复

10.1 恢复工作区文件：git restore

10.2 取消暂存：git restore --staged

10.3 老写法：git checkout -- file

10.4 重置分支：git reset

10.5 反向提交撤销：git revert

10.6 查看引用移动历史：git reflog

10.7 删除未跟踪文件：git clean

11. 标签、暂存、清理与归档

11.1 标签：git tag

11.2 临时保存现场：git stash

11.3 归档导出：git archive

12. 高级协作与维护命令

12.1 多工作树：git worktree

12.2 子模块：git submodule

12.3 仓库完整性检查：git fsck

12.4 垃圾回收与优化：git gc

12.5 打包传输对象：git bundle

12.6 查看引用：git show-ref

12.7 解析对象名：git rev-parse

13. 常见场景速查

13.1 新项目第一次提交

13.2 从远程拉代码开始工作

13.3 提交前检查

13.4 提交到远程新分支

13.5 暂时保存现场去修别的问题

3.1 初始化仓库：`git init`

3.2 克隆仓库：`git clone`

5.1 查看状态：`git status`

5.2 添加到暂存区：`git add`

5.3 提交：`git commit`

5.4 查看差异：`git diff`

5.5 查看文件内容来自哪个提交：`git blame`

5.6 查看对象详情：`git show`

6.1 查看分支：`git branch`

6.3 切换分支：`git switch`

7.1 历史查看：`git log`

7.2 精简历史：`git shortlog`

7.3 查找历史中的某段文本：`git grep`

7.4 二分定位引入 bug 的提交：`git bisect`

8.1 查看远程：`git remote`

8.5 获取远程更新：`git fetch`

8.6 拉取并合并：`git pull`

8.7 推送：`git push`

9.1 合并分支：`git merge`

9.2 变基：`git rebase`

9.3 交互式变基：`git rebase -i`

9.4 挑选提交：`git cherry-pick`

10.1 恢复工作区文件：`git restore`

10.2 取消暂存：`git restore --staged`

10.3 老写法：`git checkout -- file`

10.4 重置分支：`git reset`

10.5 反向提交撤销：`git revert`

10.6 查看引用移动历史：`git reflog`

10.7 删除未跟踪文件：`git clean`

11.1 标签：`git tag`

11.2 临时保存现场：`git stash`

11.3 归档导出：`git archive`

12.1 多工作树：`git worktree`

12.2 子模块：`git submodule`

12.3 仓库完整性检查：`git fsck`

12.4 垃圾回收与优化：`git gc`

12.5 打包传输对象：`git bundle`

12.6 查看引用：`git show-ref`

12.7 解析对象名：`git rev-parse`

Option A：只有 `2 hours`

Option B：有 `2.5-3 hours`

Week 0：`3/25 Wed - 3/27 Fri`

Week 1：`3/30 Mon - 4/3 Fri`

Week 2：`4/6 Mon - 4/10 Fri`

Week 3：`4/13 Mon - 4/17 Fri`

Week 4：`4/20 Mon - 4/24 Fri`

Week 5：`4/27 Mon - 5/1 Fri`

Week 6：`5/4 Mon - 5/8 Fri`