<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="/rss/feed.xsl" type="text/xsl"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>风屋</title><description>博闻强记,多思多问,取法乎上,持之以恒</description><link>https://www.dreameverafter.com</link><language>en</language><item><title>Harness 五子系统模型</title><link>https://www.dreameverafter.com/en/post/harness-wu-zi-xi-tong-mo-xing</link><guid isPermaLink="false">en:harness-wu-zi-xi-tong-mo-xing</guid><description>&quot;harness&quot;这个词在 AI coding agent 的圈子里被用得越来越多了，但大部分人说 harness 的时候，其实指的是一个 prompt 文件。一个 prompt 文件不是 harness。</description><pubDate>Fri, 21 Aug 2026 06:05:37 GMT</pubDate><content:encoded>&lt;p&gt;&lt;strong&gt;指令子系统&lt;/strong&gt;：创建 &lt;code&gt;AGENTS.md&lt;/code&gt;（或 &lt;code&gt;CLAUDE.md&lt;/code&gt;），内容包括项目概览和目的、技术栈和版本、首次运行命令、不可违反的硬约束、指向更详细文档的链接。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;工具子系统&lt;/strong&gt;：确保 agent 有足够的工具访问权限。不要因为”安全考虑”把 shell 给禁了，agent 连 &lt;code&gt;pip install&lt;/code&gt; 都跑不了，还怎么干活？但也别什么都开放，按最小权限原则来。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;环境子系统&lt;/strong&gt;：让环境状态自描述。用 &lt;code&gt;pyproject.toml&lt;/code&gt; 或 &lt;code&gt;package.json&lt;/code&gt; 锁定依赖，用 &lt;code&gt;.nvmrc&lt;/code&gt; 或 &lt;code&gt;.python-version&lt;/code&gt; 指定运行时版本，用 Docker 或 devcontainer 让环境可重现。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;状态子系统&lt;/strong&gt;：长任务必须有进度跟踪。用一个简单的 &lt;code&gt;PROGRESS.md&lt;/code&gt; 文件记录：哪些做完了，哪些在做，哪些被阻塞。每个会话结束前更新，下一个会话开始时读取。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;反馈子系统&lt;/strong&gt;：这是投入产出比最高的子系统。在 &lt;code&gt;AGENTS.md&lt;/code&gt; 里显式列出验证命令：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;验证命令：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;- 测试：pytest tests/ -x&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;- 类型检查：mypy src/ --strict&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;- Lint：ruff check src/&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;- 完整验证：make check（包含以上全部）&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;五个子系统缺一个，harness 就不完整，agent 用起来总会别扭。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;量化 harness 组件价值的方法&lt;/strong&gt;：用”控制变量排除法”。保持模型不变，逐个移除五个子系统，看哪个子系统缺失时性能下降最多。下降最多的组件，说明它在当前任务里边际贡献最大，值得优先保留；是否要加强它，取决于失败归因，而不是只看下降幅度。几乎没有影响的组件，也不能直接判定为无用：它可能是冗余、设计失效，或还没有被这个任务充分触发。这个实验回答的是”当前哪个组件最有价值”，不能单独证明”瓶颈在哪里”。真正定位瓶颈，要先看失败记录和归因：任务没说清楚、上下文不足、环境不可复现、验证反馈缺失，还是状态管理断裂；组件拆除结果只能作为辅助证据。&lt;/p&gt;</content:encoded><category>category:AI</category><category>tag:Harness</category></item><item><title>前端项目通过bridge获取客户端资源，客户端直接返回response对象</title><link>https://www.dreameverafter.com/en/post/fe-bridge-res</link><guid isPermaLink="false">en:fe-bridge-res</guid><description>iOSopen class URLSchemeHandler: NSObject, WKURLSchemeHandler { open func webView(_ webView: WKWebView, start urlSchemeTask: WKURLSchemeTask) { guard let url = urlSchemeTask.request.url, let scheme = u</description><pubDate>Tue, 13 Jan 2026 08:40:42 GMT</pubDate><content:encoded>&lt;h2&gt;iOS&lt;a href=&quot;#ios&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;open class URLSchemeHandler: NSObject, WKURLSchemeHandler {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    open func webView(_ webView: WKWebView, start urlSchemeTask: WKURLSchemeTask) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        guard let url = urlSchemeTask.request.url, let scheme = url.scheme else { return }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        let data = try Data(contentsOf: url)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;       if let response = self.createHTTPResponse(url: url, mimeType: filePathUrl.pathExtension.mimeType){&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;           urlSchemeTask.didReceive(response)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;           urlSchemeTask.didReceive(data)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;           urlSchemeTask.didFinish()&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;       }else{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;           urlSchemeTask.didFailWithError(NSError(domain: &quot;URLShemeHandler&quot;, code: 100, userInfo: nil))&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;       }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    open override func createHTTPResponse(url: URL, mimeType: String, contentLength: Int = 0) -&amp;gt; URLResponse? {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        let headerFields: [String:String] = [&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            &quot;Content-Type&quot;: mimeType,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            &quot;Access-Control-Allow-Origin&quot;:&quot;*&quot;,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            &quot;Access-Control-Allow-Methods&quot;:&quot;GET, POST, PUT, DELETE&quot;,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            &quot;Access-Control-Allow-Headers&quot;:&quot;Content-Type, Authorization&quot;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        ]&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        let response = HTTPURLResponse(url: url, statusCode: 200, httpVersion: &quot;HTTP/1.1&quot;, headerFields: headerFields)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        return response&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h2&gt;安卓 腾讯x5&lt;a href=&quot;#安卓-腾讯x5&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;webView.setWebViewClient(new WebViewClient() {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    @Override&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        String url = request.getUrl().toString();&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        // 拦截特定URL并返回自定义数据&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (url.contains(&quot;your-custom-path&quot;)) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            try {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              // 生成自定义数据（如JSON）&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              String jsonData = &quot;{\&quot;status\&quot;: 200, \&quot;data\&quot;: \&quot;Hello X5\&quot;}&quot;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              InputStream inputStream = new ByteArrayInputStream(jsonData.getBytes(&quot;UTF-8&quot;));&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              // 构造响应头&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              Map&amp;lt;String, String&amp;gt; headers = new HashMap&amp;lt;&amp;gt;();&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              headers.put(&quot;Access-Control-Allow-Origin&quot;, &quot;*&quot;); // 允许所有域&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              headers.put(&quot;Access-Control-Allow-Methods&quot;, &quot;GET, POST&quot;); // 允许的HTTP方法&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              headers.put(&quot;Content-Type&quot;, &quot;application/json&quot;); // 数据类型&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              // 构造WebResourceResponse（MIME类型、编码、输入流、头信息）&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              return new WebResourceResponse(&quot;application/json&quot;, &quot;UTF-8&quot;, 200, &quot;OK&quot;, headers, inputStream);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            } catch (UnsupportedEncodingException e) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                e.printStackTrace();&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        // 默认行为：不拦截，由WebView自行加载&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        return super.shouldInterceptRequest(view, request);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;});&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;</content:encoded><category>category:笔记</category></item><item><title>帝吧神贴《网管》</title><link>https://www.dreameverafter.com/en/post/%E5%B8%9D%E5%90%A7%E7%A5%9E%E8%B4%B4-%E7%BD%91%E7%AE%A1</link><guid isPermaLink="false">en:帝吧神贴-网管</guid><description>《网管》堪称帝吧震吧之作原帖：http://tieba.baidu.com/p/702303937?see_lz=1chapter 1我曾经是个网管，给你们讲讲我见过的一个毅丝吧。书读得不多，水平有限，我不保证我会把一切关于这个毅丝的事都说出来，但是我保证一切都是真的。一楼送给百度。我不说他的ID，就说他。他每天都会来我们网吧上网，一般都是晚上10点左右。买一包7块钱的烟，一瓶可乐或者雪碧。他长得</description><pubDate>Mon, 10 Nov 2025 06:57:23 GMT</pubDate><content:encoded>&lt;p&gt;《网管》堪称帝吧震吧之作&lt;/p&gt;
&lt;p&gt;原帖：&lt;a href=&quot;http://tieba.baidu.com/p/702303937?see_lz=1&quot;&gt;http://tieba.baidu.com/p/702303937?see_lz=1&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 1&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;我曾经是个网管，给你们讲讲我见过的一个毅丝吧。&lt;/p&gt;
&lt;p&gt;书读得不多，水平有限，我不保证我会把一切关于这个毅丝的事都说出来，但是我保证一切都是真的。一楼送给百度。&lt;/p&gt;
&lt;p&gt;我不说他的ID，就说他。他每天都会来我们网吧上网，一般都是晚上10点左右。买一包7块钱的烟，一瓶可乐或者雪碧。他长得不算帅，也不丑，身高大概在1米7左右，脸上总是一副闷闷不乐的样子，但是我能看出来他很善良，你知道的，眼神骗不了人。&lt;/p&gt;
&lt;p&gt;他总喜欢坐在挨着收银台的地方，打开电脑后就登陆QQ，然后上百度，我注意到了，他会一个通宵都泡在李毅吧，神情有时候严肃，有时候又很伤感，但是他也会咯咯的笑。那是少见的时刻，像个天真的孩子，老实说，他笑起来很无邪，眼睛里透露出来的善良更加清晰。&lt;/p&gt;
&lt;p&gt;这些事都是09年初发生的，那时候我刚实习，学的是计算机，但是工作太难找了，就去想着去网吧混混时间。网吧的生意很好，大多时候我都坐在收银台旁边，时不时帮上网的人送水和烟。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 2&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;网吧里大多数人都会通宵玩游戏，除了他。有时候我看到他会写很长一串文字，我无意偷窥别人的隐私。但是我看到他写他的女朋友，他的家人，他的生活。&lt;/p&gt;
&lt;p&gt;这是一个西北部的城市，三四月的雨水不多，但是整天都阴沉沉的，给人一种透不过气来的感觉。那时候我一月工资才七百，因为自小家里经济情况不好，所以我一直很节省，大学四年，女生的手都没碰一下。所以有时候我会盯着那些漂亮的女生看，他也一样。其实我觉得这么一直说他，挺别扭的，我还是称呼他为A吧。&lt;/p&gt;
&lt;p&gt;但是我觉得A应该跟我一样，家里的情况并不是很好，因为大多数时候，他晚上的宵夜就是两个包子。有时候他的头发还油腻腻的，似乎很多天没洗。那些穿着光鲜，眉目如画的姑娘从他身边走过时，他也会用眼睛的余光去看，然后又盯着屏幕，滑动鼠标，似乎什么事都没发生一样。但是就像那些姑娘从来没有看过我一眼一样，也从来没有去注意过他。&lt;/p&gt;
&lt;p&gt;就在那段时间，城市正在严查网吧，所以一到晚上12点，网吧的大门基本都关了。里面的人出不去，外面的人也进不来。有时候网吧满座时，我根本没机器可以上，只能呆呆的做一晚上。看A浏览网页，看视频。或者跟负责收银的姑娘瞎侃。暂且叫她小C吧。&lt;/p&gt;
&lt;p&gt;一开始我并不习惯跟姑娘说太多话，因为在学校我就比较胆小，跟女孩子说话都紧张的要死。但是小C很会找话题，也比较开放，可能是大城市呆久的原因吧。没事儿就喜欢逗我，说交女朋友没，还是处男吗，我一个劲摇头，连回答的勇气都没有。&lt;/p&gt;
&lt;p&gt;我说过了，A总是坐在离收银台很近的地方，有时候我跟C说话，他也会回过头来看看。那时候天气比较冷，但是小C总是只穿很单薄的衣服，丰满之势呼之欲出。也不知道是A在听我们谈话，还是在看小C。&lt;/p&gt;
&lt;p&gt;后来时间长了，接触的多了，胆子也大了起来。因为经常见到A,所以后来他一进网吧，我们都会互相打招呼。他总是嘴角淡淡的笑一下，然后一边拉椅子一边说：“拿包烟，再拿瓶可乐。”&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 3&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;网吧除了我一个网管，还有另外一个负责技术的大网管，平时他就坐在网吧后面的小屋子里。有什么我搞不定的问题，他就出来弄。他长得五大三粗，嘴里总是叼只烟，有很严重的眼袋，眼睛四周都是淡淡的青色，就像很久没睡觉一样。他的脾气很大，喜欢发火，刚去的那段时候，我总是坐着无事可做，他偶尔出来就朝我骂，说我不做事，要告诉老板。我只好站起来假惺惺的走一圈。&lt;/p&gt;
&lt;p&gt;然后他就跟小C笑眯眯的说话，一副讨好的样子，但是小C总是爱理不理。其实小C长得并不漂亮，但表情却显得很张扬，就是那种很有欲望的样子。加上她伟岸的胸脯，难免让人想入非非。&lt;/p&gt;
&lt;p&gt;不过后来就好多了，大网管经常出来转，也不说我了，时不时还递烟给我，其实我那时候还不会抽烟，但是我怕会扫他的面子，还是接过来，点着，说实话，一开始我并不喜欢烟的味道，让我的鼻子和喉咙都不舒服，甚至会让我觉得头晕晕乎乎的。&lt;/p&gt;
&lt;p&gt;但是慢慢习惯后，我也开始买烟了，4块一包的红梅，不太好抽。但是没办法，没什么钱，只能将就着。而我和小A第一次正式的对话也是因烟而起的。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 4&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;网吧通宵的费用从12点到8点是6块，从10点起是8块。那天A像平时一样来到网吧，但是他没去开机器。只是围着网吧转了几圈，最后站在一个人后面看着。大概站了有半个小时，又走出了网吧。直到12点多的时候，他才又进来了。那时候小C正在修指甲，也没抬头看他。他说开个6块的。小C这才放下修指甲的刀，然后扑在收银台上，乳沟也一下子显露出来。看得我心头一阵，而小A也似乎在喝水一样，喉咙迅速的翻动了几下。&lt;/p&gt;
&lt;p&gt;那天A没买烟，也没买可乐。然后找个地方坐下，开机，登QQ，打开百度，进李毅吧。那天我才知道，一直以来我都以为他只有一个ID，原来不是。也许是我平时没注意吧，但是那天夜里我至少看见他用了五个不同的ID发言。&lt;/p&gt;
&lt;p&gt;那天三点多的时候，一直坐在电脑前的小A突然朝我挥了下手，意思是让我过去。我两步踱到他面前，以为他要买东西；“你要买什么”。他抿了抿嘴，露出一个很浅的笑容：“你有烟不，我不记得带钱出来了。”那时我已经在网吧工作一个多月了，也知道他在说谎，肯定是没有钱了。但是给任何人在当时都不会揭穿。一边拿出烟，一边说：“差烟，不知道你抽不抽得习惯。”他呵呵直笑：“有就好，有就好。”&lt;/p&gt;
&lt;p&gt;然后他找我借火机，点燃之后说了声“谢谢”，那时候我已经在刻意锻炼自己的社交能力了，嬉笑的又抽出几支，说：“多拿几支。”他显得很客气，推辞了一下，但是最后还是拿了两支。一支别在耳朵上，一支放在桌子上。&lt;/p&gt;
&lt;p&gt;接着我就坐在他身后不远地方看到，他在输入栏里写了一行字：“今天偷了老爹的一包芙蓉王，会被发现么？”&lt;/p&gt;
&lt;p&gt;我觉得这个世界所有的人都会说谎，我也不例外。母亲打电话来说弟弟读高中了，生活费不是很够，问我工资有没有多的，给弟弟寄点。我一直怕家里担心我，给他们添麻烦，骗他们说实习工资有1500。我知道我没办法拒绝母亲的请求。一口就答应了。那时我全部身家就只有800多，给弟弟寄了200过去，600多足够我一个月花费了，而且那时候还住在学校。网吧还包两顿饭，所以花费不是很大。&lt;/p&gt;
&lt;p&gt;所以A说自己偷了老爹的芙蓉王，也许是个玩笑罢了。网络茫茫，谁没信口开河的时候呢。&lt;/p&gt;
&lt;p&gt;不过后来A又按着键盘，似乎是刷新了一次，然后又点进自己的帖子，后面多了几个回复。A卷了卷衣服的袖子，写下几个字：“不过这烟不太好抽。”我心里暗想，四块的红梅，当然不好抽。然后他点了发表，刷得一下弹出来一个框,原来帖子已经被删除了。&lt;/p&gt;
&lt;p&gt;看得出来A有点不乐意，即使从后背也能想像他的表情，左晃右晃，用手摸了摸嘴，又把头足有晃了几下，深深吸了口气。直接关掉的浏览器。&lt;/p&gt;
&lt;p&gt;这时候有个上网家伙跑到收银台买东西，我一回头才才发现，小C竟然没坐在收银台里。那家伙拍了几下桌子，问：“人呢.”我想大概去厕所了吧，就对那人说：“去厕所了，你等下。”但是等了两三分钟，小C都没出来。那人等得很不耐烦，说快点啊。&lt;/p&gt;
&lt;p&gt;因为老板规定网管是不准碰收银之类的事儿的，我只好站起来进网吧后面找。但是厕所里空无一人。我又转身跑去大网管的屋子里，一手就推开了门，大网管正一手抱着小C啃，一手在小C身上，上下乱摸。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 5&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;当网管那段时间，作息时间很难调整，特别是白班和夜班交替的时候，那一天是最难过的。想睡不能睡，坐在凳子上又困得要命，不是为了那可怜的薪水，我真他娘的不想干了。当网管第一次换班是在中旬，上晚班的时候，早上下班我都不吃早餐，回家啃个小面包，就直接回学校睡觉。一是节省点钱，二是为了能多睡会。&lt;/p&gt;
&lt;p&gt;但是交班那天，我破例去吃了回早餐。因为白天不能睡觉，要留到晚上，好第二天上白班。有时候觉得这个世界还真小，那天在早餐店里就看到了A,自从那次他找我要烟之后，我就再没见过他去网吧了。那时温度还不算高，早上也挺冷的，他穿个大大的风衣，头发又是油腻腻的，还有点乱。一边嚼着包子，一手还往嘴里送稀饭。我看见他之后就给他打了招呼，还递了一支烟，说最近怎么没去网吧了。他咽下嘴里的包子，笑了笑，说最近没空。过几天再去，呵呵。&lt;/p&gt;
&lt;p&gt;我知道他又在撒谎，但是谁又不好面子呢？其实那次他找我要烟，我就知道他肯定是没钱了。这段时间没去，也估计是没钱上网了。那天夜里我推开大网管的门，又急忙关上。但是听到里面有人在骂娘。那时候我已经实习了一个月了，知道什么该看见，什么不该看见，知道什么该记住，什么不该记住。&lt;/p&gt;
&lt;p&gt;“大网管是老板的亲戚。”小C曾经告诉我。我不想得罪任何人，也不想丢掉唯一的一份工作，所以我就当没看到。&lt;/p&gt;
&lt;p&gt;我从网吧后面走出来后，小C很快也出来了，衣服头发都打理得很整齐，就是脖子上有点红印记。我面无表情的看着她：“有人买东西。”&lt;/p&gt;
&lt;p&gt;我琢磨着小C的家境也不是那么富裕，不然一个20多点的小姑娘，家里只要经济稍微好点，也不会来当网吧收银这样的工作，又累工资又少。从小到大，我并不会轻易轻视别人，但是从小C那次之后，就觉得这姑娘挺那啥的。闲时吹吹牛还可以，深交就算了。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 6&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;白班时，我从来没遇到过A。直到我又再次晚班，才看到他。依然是那件风衣，不过头发剪短很多，挺干净的，每次来又开始买烟，买可乐，时不时还给递一根。抽着挺好，7块一包的烟，就是比红梅舒服。&lt;/p&gt;
&lt;p&gt;那时候我和他也算半个熟人了，他经常一边上网，一边回过头来跟我说话。有时候后半夜我和他还津津有味的说这网吧里来过哪些漂亮姑娘。有一次我和他正说得起劲，小C就插了一句嘴，拖着下巴撅着嘴：“两个小处男，整天就知道说姑娘。”&lt;/p&gt;
&lt;p&gt;老天作证，那是我第一次调侃姑娘，也不知道那时候哪有那么大的勇气，笑嘻嘻的看着小C：“你帮我们解决了呗。”说话后我自己都心蹦蹦跳。甚至觉得这不是我自己说的话。说那句话的瞬间，我就突然想起海子一句著名的诗：“我是谁手里磨刀的石块?我为何要把赤子带进海洋。”&lt;/p&gt;
&lt;p&gt;可是你知道，每个人都要改变，如《重庆森林》所说，今天他喜欢凤梨罐头，明天他也许可以喜欢别的。我没办法像海子一样伟大，也不能像他一样生活在沙漠中。我没有事业可以给予兄弟，我没有爱人可以给予爱情。我唯一能做的，就是把孤独留给自己。在大多数人已经安然入眠的夜里，跟一个长相并不是那么漂亮的姑娘，说一句带着挑逗的话，以此打发寂寞的时光。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 7&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;气温渐渐开始回温了，老板吝啬无比，也不让开空调，转这几个换气扇也不起作用，像微风吹起的树叶，无精打彩的慢慢晃动，网吧里又热又闷，小C也越穿越少，乳沟和露出半截的咪咪是看惯了，但是腋下那几挫没剃的腋毛，实在让人倒胃口。本来就不是一流美人，这么一看，更加影响整体形象。&lt;/p&gt;
&lt;p&gt;但是这并没影响大网管的兴趣，小C夜里时不时总会消失一会。脖子上的红印是不怎么见了，倒是头发带着湿漉漉的汗水经常看见。一脸饿汉吃饱了的满足神情，看起来十分操蛋&lt;/p&gt;
&lt;p&gt;那天小C面对我的挑逗，刷得一下站起来，双手叉腰，头颅一昂，挺着波涛不止的上围，带着女权主义者的口气：“来啊，姐姐我帮你们。”&lt;/p&gt;
&lt;p&gt;听得我上下充血，嘴巴顿觉干渴。小A在一边捂着嘴大笑，偷着看了小C几眼，又转过头去上网。&lt;/p&gt;
&lt;p&gt;我跟着哈哈大笑，然后抱着拳头故作不敢：“您凶，我不敢。”小C哼了一句，硬生生的坐下去，惊起波涛一片澎湃。我愣愣的看了几秒，她也没在意。可眼神里，分明是带着暧昧和赤果果的挑逗。一时让我不知如何是好。只能抽出一支烟点上，又转过头看小A上网。&lt;/p&gt;
&lt;p&gt;他似乎是在一个群里聊天，大大的蓝色的字体。我看见他说：“刚从夜总会回来，有个姑娘暗示我上床，我却没兴趣，这是病吗？”&lt;/p&gt;
&lt;p&gt;我不知道“当你很饿，面前又放了个苹果，你却不去吃”是不是有病，也不知道姑娘玉体横陈的时候你无动于衷是不是有病，但是我知道。当你过度去想象那些不切实际的东西，的确有臆想症患者的嫌疑。那是病，真得治。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 8&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;A似乎有很多身份，光我后来陆续看到的ID，就有十多个，有时候他是职业游戏玩家，有时候他是公务员，有时候是老师，还有时候是吃香喝辣的富二代，或者是大学学生，公司的经理。可是我从来没看到一个真实的他。 一个夜里通宵，头发油腻，抽7快香烟，喝两块可乐的他。我想是这个时候太缺乏安全感了，所有人都将自己的真实面目隐藏起来，而你看到的，长久看到的，只是一张虚假的脸孔。说着无关痛痒的谎言，或为了发泄，或为了排解孤独，但是至始至终，这些谎言都没有伤害到任何人。也许那是理想，但是却永远无法触及。&lt;/p&gt;
&lt;p&gt;不光如此，他说自己的上网地点也是层出不穷，在家，在公司，在朋友家，在广场用无线笔记本，在车上，但是却从来没在网吧。有一次我看到他打了一大段的字，大体内容是，痛骂电信服务不好，经常断网，维护人员动作又慢，又说一次交了三年的费用，就换来这种服务，中国真不是呆下去的地方。等忙完这段时间，就着手搞移民。那一刻他是一家公司的老板，说着自己都信以为真的谎言。&lt;/p&gt;
&lt;p&gt;在文章的结尾他还说，他发誓，不能为稻粮谋，要去做自己想做的事。赚钱？太没意思了。&lt;/p&gt;
&lt;p&gt;还有一次，他说自己是大学的学生，有两个女生同时喜欢他了，一个漂亮，一个家里有钱。又不知道从哪里弄来几张照片，说大家给我看看。哪个可以上手。其实那时候他正坐在网吧，一边抽着7块的烟，衣服后面粘了一小块的污渍，与他无关的姑娘坐在他的左右身旁，他时不时偷瞄一眼。然后他又说，你们信么。我已经很难喜欢上一个姑娘了，初恋的女友太优秀了。我总是忍不住拿出来跟其他女生比，一比就喜欢不起来了。我很痛苦，怎么办？大家帮帮我吧。&lt;/p&gt;
&lt;p&gt;那是去年5月，城市已经开始热起来，他坐在摇着几个换气扇的网吧，脖子后面划出几颗汗水。点击发表，又刷新，又点进自己的帖子。然后一手托着腮帮子，一脸虔诚的表情，就像一个在等待老师答案的小朋友，静静等着回复&lt;/p&gt;
&lt;p&gt;也许除了我，没有人会知道那是谎言，以及他无法到达的梦想，甚至连他自己在那时候，也许都把自己的话当成真的了吧。那样的表情和眼神，不是能装出来的。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 9&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;从小到大，我都没做过让自己胆战心惊，觉得紧张不已的事，先是怕给家里惹麻烦，而且自己胆子也不大。家里在农村，但是连偷红薯的勇气都没有。同村的孩子都笑我胆小，以后肯定怕老婆。&lt;/p&gt;
&lt;p&gt;从家里出来读大学时，母亲和父亲都很高兴，说要我努力。学费会给我凑齐。父亲还难得的开了次玩笑，咧着黄牙说：“娶个城里媳妇回来嘛。”他一生面朝黄土背朝天，没出过门，没读过几年书，以为城里遍地是黄金，走路都能捡到钱的地方。但是这并不影响我爱他们，他们也从来不曾对我食言。给我吃饭的钱，给我凑学费，大三实习前回去，我发现他们已经苍老了很多，但是看到我，他们眼神里都仿佛看到希望一样光芒，我知道，我是他们的全部，弟弟还在读书，还要上大学，而他们已经老了。&lt;/p&gt;
&lt;p&gt;而我在大学里也省吃俭用，遇到过喜欢的女生，但是一来我不是那种帅的男生，手上也没钱，想恋爱实在是很难，那样的生活，太花钱了，而我远远无法完成。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 10&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;终于放假一天了，还发了工资。小C说一起工作一个多月了，一切去吃顿饭吧。大学几年，我是从来不去外面吃饭的，哪怕只要十几块，也够我两天的生活费了，我不想一顿就吃完。我显得很犹豫，想着找借口拒绝。小C似乎看出了我的心思，轻轻拉了一下我的衣袖，说去吧。我们选便宜点的。&lt;/p&gt;
&lt;p&gt;饭店的确不贵，荤菜只要五块，素菜只要三块，小C和我点了一荤两素，要了两瓶啤酒。我本来就不是话多的人，吃饭时一直都是小C在说话，说她以前工作的地方，说笑话给我听。我默默的听着，时不时搭两句话。小C却越吃越起劲，我俩陆续喝了好几瓶。我是那种一喝酒上脸的人，觉得不行的时候坚决不喝了。小C也没劝我，就自己一个人继续喝着。我坐在一边看着她，突然见到她脸上有种莫名的悲哀浮现，接着两行清泪就哗啦啦的流了出来。&lt;/p&gt;
&lt;p&gt;小时候弟弟经常哭，父母又忙农活，一般都是我带着玩，他哭的时候我就连哄带吓。或者去厨房给他弄点开水，放点糖在里面让他喝。他喝完总会眨眨还带着泪水的眼睛，说：“哥真甜。”他那时候还小，我蹲下身摸摸他的头，重复着说了好多次的话；“你以后不哭，哥就经常给你弄糖水喝。”弟弟也是用小手抱着我的头，高兴异常：“哥真好，哥真好。”&lt;/p&gt;
&lt;p&gt;不过让我哄女孩子，那我就不会了，因为从来没遇到过。小C低头擦了擦眼泪，水汪汪的眼睛看着我，说：“你知道吗，我早就不想干这工作了，要不是家里。。。”说到这，莹莹粉泪又刷得流了出来。我手足无措，不知道如何是好，最后只好从饭桌上抽了两张纸巾递给她。她接过去朝我笑了笑，红着眼圈看着我：“家里不好，没办法，现在工作不好找，我又没文凭，什么都不会。。。”&lt;/p&gt;
&lt;p&gt;自从那次看到小C和大网管的事儿，我对这姑娘就没什么特别好感。人生多变，最忌讳的就是吐露心声，被人抓住弱点。那天就是小C一个人说，说她家里的情况，说父母亲，还有弟弟妹妹，她说就想多赚点钱，给家里买个电视，让他们晚上也多点乐趣。末了她又擦了擦眼泪，笑着对我说:“不像你们大学生，做几个月就换工作，工资肯定会很高吧。”&lt;/p&gt;
&lt;p&gt;我正琢磨着怎么回应他这样话，A一下就出现在我的眼前：“老板，要个米粉，素的。”&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 11&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;他似乎从来没换过的那件风衣，看起来有点脏的牛仔裤，一双蓝色的人字拖鞋。神情疲惫，我主动跟他打招呼：“准备去上网了？”他笑着从衣服口袋拿出一包烟，抽出一根递给我，又拿出一支递给小C,小C一愣，然后伸手接过烟。据我所知，小C平时是不抽烟的。&lt;/p&gt;
&lt;p&gt;等A的米线上来时，三个人坐在两张桌子上已经寒暄了很久了。C一下子就像变了个人，说着调笑的话。A问她怎么眼睛红了，C拿起桌子上的酒瓶摇了摇：“喝得有点多。”&lt;/p&gt;
&lt;p&gt;我清楚记得那是2009年5月1日，那天我们放假了。在那座城市的一个小饭馆里，我和小C对坐着，她眼睛通红，A在一旁吃着米线。三个人嘻嘻哈哈，有说有笑。从那天开始，我开始对这个世界充满疑惑，那些光鲜耀人的微笑背后，是否都有着不为人知的苦楚？在一张张不同神情的面孔中，是不是都隐藏着不为人知的秘密？&lt;/p&gt;
&lt;p&gt;那天一顿不算丰盛的晚餐吃了三个小时，九点多钟从饭店出来，头上有着城市里难得一见的月亮，像一颗晶莹剔透的眼泪。传说这黑幕之上住着无所不能的神仙，不知道他们能不能了解人家那些难以启齿的悲哀和一滴滴无法流淌的眼泪。&lt;/p&gt;
&lt;p&gt;所有人都有秘密不是吗？我也有，那天不知道是酒精作用还是别的原因，回到宿舍躺下后就亢奋不已，我知道，那是荷尔蒙在起作用。它让我向往着一样东西，以及一瞬间的快感。我是一个懂得控制的人，手淫次数并不多。那天我没忍住，从床上爬起来，借洗澡的机会做手部运动。而我想的人，竟然是小C，一张不漂亮却充满欲望的脸，和她无限接近我的涂得绯红的嘴唇。自那次手淫几个月之后，我才终于有生以来第一次尝试到女人的滋味，却又让我在到达最后一刻时，觉得无比空虚和失落。&lt;/p&gt;
&lt;p&gt;在我还没遇到那种空虚和失落前，生活还是一如既往，吃廉价面包，吃网吧供应的两顿饭。C和A也变得越来越熟悉，我的话也越来越多。但是在夜里，大多数时候，我都只是默默的坐着，看着A那些既不害人也不害己的言语，就像看到自己的无奈，看到无法挣脱的日复一日的，看到小C那种时常挂着笑容的脸庞后面，一颗无助和哀伤的心，以及那些要痛苦煎熬才能达到的心愿。哪怕是一个小小的电视机，也如梦一般无法接近。&lt;/p&gt;
&lt;p&gt;小A曾经给我看过很多的帖子，有漂亮姑娘，好笑的视频，动人的帖子，但是大多数时候，屏幕上都是那些肌肤似雪，身姿婀娜的姑娘，他总会啧啧自言自语的称赞，真漂亮。然后回过头看着我：“漂亮吧。”我笑着点头，表示认同。心理却很不是滋味，再漂亮又怎么样？我只能看看罢了。&lt;/p&gt;
&lt;p&gt;“现实就是这么残忍。。。”大网管语重心长的说。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 12&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;那天是有人在网吧卡座睡觉，桌子上是一盒吃过的康师傅方便面盒子和半瓶矿泉水。但是那家伙却没上网。老板交代过，不上网的不准在网吧睡觉。大网管出来正好看到，一脚提醒那人，那家伙猛得被惊醒，一下就坐起身来，起来时候手一乱打，直接扫翻了方便面盒子，残羹倾洒而出，污浊而肮脏，流到地上，流在桌子上，撒到那人的身上，顿时侵出一块湿漉漉的水痕，上面覆盖着方便面被泡软的面渣。&lt;/p&gt;
&lt;p&gt;大网管更生气了，一把拉起那人，“滚出去，滚出去！”那人惊魂未定，傻愣愣的被推搡的出门了。出大门的时候，还差点摔了一跤。大网管回过头看了我一眼，我盯着他。始终觉得这样太粗鲁了。&lt;/p&gt;
&lt;p&gt;他晃晃悠悠像个二流子一样走到我面前：“现实就这这么残忍，看什么看？”那时候我有点哭笑不得，想不到此二流子还会说这么诗意的话。&lt;/p&gt;
&lt;p&gt;我没作声，转头朝别的地方走去，C依然摸着指甲，似乎什么都没发生一样。A回头看了我一眼，眸子里似乎在害怕着什么。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 13&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;6月的天气渐渐热起来，小C的衣服单薄到能看见胸罩了，弄得我上班都满脑子瞎想。最该死的是，A有时候还看床上动作片，他总是把视频窗口拉到很小，又开着浏览器，戴着耳麦，左顾右盼。一旦有人从他身边经过，他就迅速的把视频最小化，然后装模作样的在看网页，或者点出QQ头像，假装在打字。看过一会后，他总会起身朝网吧后面的厕所走去，不说我也知道他去干嘛。这无可厚非，叔本华说过，性冲动是人类的潜意识，是为种族繁衍而起，是天赋人权，没有人可以指责和剥夺。而很多时候，我们总是把它当做一件耻辱，不可见光的秘密。&lt;/p&gt;
&lt;p&gt;作为一个毅丝不挂，我坚信大帝所说的恶有恶报。大网管终于恶报了，老板说他高烧送医院了。让我看着点电脑，有什么问题好好解决，还说干得好给我加工资。我当然高兴，毕业还有一个多月，多拿点工资就是一点。&lt;/p&gt;
&lt;p&gt;俗话说老虎下山，猴子称霸。大网管走了，也没人管了。除了人满的时候我呆呆坐着，大多数时候我都会找机器上网。夜里就坐在小A旁边，有时候小C也会坐着听歌，玩游戏。我从小就没玩过什么游戏，大学才学会上网，也不知道那时候为什么选计算机专业，或许是觉得热门好赚钱好找工作吧。小C后半夜一般都会睡一会，让我多看着点网吧的事儿，有时候她就趴在电脑桌上，穿着裸露的衣服，咪咪微露，起伏不定，看得我欲火中烧，邪念四起，胯下鸡动无比。不过激动归激动，激动完了还是继续上网打发时间。&lt;/p&gt;
&lt;p&gt;小A很沉迷于百度贴吧，不光是李毅吧，还有什么帅哥吧，QQ吧，美女吧，他有时候也会去。大多时候都默默看着，少数时候写些东西。他是完全沉浸其中，连我明目张胆的看着他写东西，他也毫不在意。那些赤裸裸的编造出来的文字，带着兴奋和不屑一顾的语气，总是会让我觉得有那么一点点难过。&lt;/p&gt;
&lt;p&gt;6月几乎是去年最忙的一个月，利用晚上上班还在写毕业论文，准备答辩，还要给在网上投简历，快拿到毕业证了，也是该找个对口的工资高点的工作了。小A依然是一如既往的上网，小C整天也是那副神情。倒是大网管，古语说出来混，迟早要还。那天他把那个在网吧睡觉的推搡出去，结果刚出院没多久又进去了。被人打得鼻青脸肿，说是用生铜管打的，医生说要留院观察，看看内伤有没有问题。老板是他亲戚，愣是要查是谁、警察来调录像，最后也没查出什么结果来。估计是那人临走干了大网管一顿，然后跑了。&lt;/p&gt;
&lt;p&gt;老板吝啬是吝啬，不过说话倒是很讲信用，给我发了850块的工资。想着反正也多拿了点，而且上个月工资还剩下200多，就给弟弟寄了300过去，还寻思着请小C和小A吃一顿简单点的。礼尚往来嘛，上次去吃饭，还是小C给的钱，弄得我都有点不好意思。小A也是认识了这么久，烟没少给我发，看他也跟我差不多，家境不会好去哪里，可能是同病相怜吧，就索性一起约出来吃点。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 14&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;那天的那段饭，是我这么大以来吃过最贵的一顿饭，用了80多。说实话，那时候心里还是有点儿心疼，不过后来想想，既然高兴过了，也就算了。嘿嘿，我倒是很会安慰自己。那天一共点了5个菜，还要了一个汤。&lt;/p&gt;
&lt;p&gt;小A似乎是很久没见过荤腥了，吃得很猛，喝酒也是不在话下。席间还跟小C划拳，对饮。我笑眯眯的在一旁看着，心里琢磨着这顿得花多少钱，想想那时候，还真是个小气鬼。不过那也是我第一次真正认识到小A，酒后吐真言嘛，他说自己是学生，去年毕业。没拿到毕业证，一直在混日子。我面带笑容，安慰他说，你看我还不是快毕业了，不一样在混。其实心里怕得要死，想要是有天我找不到工作怎么办。弟弟还在读书，父母又没什么钱给我。想想都觉得可怕。&lt;/p&gt;
&lt;p&gt;只有小C听完后在一旁默不作声，只是偶尔笑一笑。我很少见到她这样严肃不笑的表情，红扑扑的脸蛋，看着我和A说话。她只是高中毕业的女孩子，我当时浑然不觉这样的对话会对她有所刺激。那是那时的我，不管不顾，不会洞察人的内心，以为世界都如我所见，如我所想。现在回想，我会耻笑那时的轻浮和无耻，愚蠢的青春自以为是。但是我也许会终身为那时的无知而觉得幸福，因为那时我是个”赤子“，未曾涉及“海洋”一步。可是现在，除了我，没有人会愿意回忆那段浅薄的岁月。并以此为傲。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 15&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这个世界不单是女人有虚荣心，男人也有。有时候起来的早，跟舍友在侃大山，他们说起姑娘，我也会提起C。说她前面如何大，如何骚。舍友就一个劲鼓动我去搞。我只能打着哈哈说算了。要找工作了呢。其实心里早已垂涎三尺，苦于无胆无机会。想想我也不小了，竟然女生都没碰过，也挺丢人的。&lt;/p&gt;
&lt;p&gt;有天晚上8点多，我上完白班从网吧出来，正好碰到A说今天晚上我们出去玩玩。在宿舍我也听舍友说过关于酒吧和KTV的事，我总觉得那些东西好贵。芝华士十二年要500，十八年要900，皇家礼炮要1800多啊，1800多啊，父母辛苦一年种几亩地，卖出去的粮食也不过2000多点。我实在不敢去消费，也没那个闲钱。所以我当时就拒绝了A，很明确的说没银子。A说既然我叫你，就我买单嘛。我不知道他的钱哪里来的，我也不想问。&lt;/p&gt;
&lt;p&gt;那天他还带我去吃了顿烧鸭，吃完已经10点多了。然后A拦了辆出租车，对司机说：“XX路。”&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 16&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;父母虽然一辈子都在耕种，没读过书。但是从小到大，他们都告诉我要善良，要脚踏实地。不要做出轨的事情。老天保佑，大学里那么多的声色犬马，我都没有跟随。也算是听话的好儿童了。那时我已经21岁了，上班，看书，睡觉，和我那些风流成性，一掷千金的同学来说，我实在是默默无闻，甚至走在路上都没有人会看我一眼，而那些我向往的姑娘，也只会轻轻从我身边走过，像一阵风，或者天上的一朵云彩，再美丽我也无能为力。那是那时的我，一无所有，两手空空，城市的华灯耀眼，却没有一盏灯为我而亮。&lt;/p&gt;
&lt;p&gt;XX路是本市出了名的红灯区，当时我就瞪着看A。A笑了笑，说：“有什么的，去去嘛”。江湖传言中那条街是肉弹横飞，大腿林立，柳下惠经过都要双脚发软，欲罢不能，很多大学男生就是在哪儿结束了可耻的处男生涯。而且物美价廉，泰式到全套，吹拉弹唱十八般武艺无所不能。那时候我的小心肝可是跳得厉害，从来没见过女人的胴体，难道要开先例了？&lt;/p&gt;
&lt;p&gt;到XX路时，哪里早已是一派粉红世界。小姑娘到大妈，长相清纯的到小C类型的，果然是名不虚传，看看都得发硬。小A下车后拉着我直奔一家按摩店，说又不那啥，按摩一下嘛。虽然我没去按过，但是我也知道，那不是什么好地方。&lt;/p&gt;
&lt;p&gt;按摩店分两层，下面是个门面，姑娘全在上面，我跟着A跑上了二楼。老板说让我们自己挑姑娘，我不太好意思，主要是觉得那么多人站那儿让我挑，看着我，让我觉得不自在。于是我说随便吧，老板嘻嘻笑，说那行，我给你找个。&lt;/p&gt;
&lt;p&gt;说是按摩，其实就是那点事儿。按摩那姑娘长得一般，大概只有18岁的样子，穿着个旗袍。一进来就关门，以极其娴熟的速度脱掉旗袍。留着蕾丝的小内和胸罩。几乎在一瞬间，我就充血了。心里像被猫爪一样不知所措。那姑娘爬上床，让我躺下。一边按一边跟我说话。问我乱七八糟的事情，就差叫我把户口本拿出来了。我很不耐烦，她倒是越按越敏感，终于小弟弟不自觉地抬头挺胸了。她是不是故意碰着哪里？我尽量让自己平静，不喘大气。其实全身早就鸡皮疙瘩起遍，头皮发麻。那姑娘见我没说话，终于更进一步了。直接按向我脐下三寸：“帅哥，这里要按不嘛。”&lt;/p&gt;
&lt;p&gt;难怪人人都说美女值钱，帅哥不值钱。原来30块钱一小时就能买个帅哥称号，真他娘的廉价。其实照照镜子我也知道我顶多算不丑，帅哥就拉倒了。我吞了一口口水，鬼使神差的没有作声，只是笑了笑。玉手之下，岂有完卵啊？&lt;/p&gt;
&lt;p&gt;那天夜里下起了零星的小雨，整个城市都散发出一股淡淡的泥土味道。和A从按摩店走出来，那姑娘的模样像滴入街道的雨水一样渐渐消融，还在刚刚，和她有着最亲密的肌肤接触。而现在，我却再也不记得他了，更不知道她姓谁名甚。&lt;/p&gt;
&lt;p&gt;临走时她穿好旗袍，背对着我说：”亲爱的，帮我拉下后面的拉链。“我心里作呕不已，谁他娘的是你亲爱的。旗袍上绣着很多大红花，那条长长的拉链看起来鲜红无比，像一条永远无法愈合的伤口。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 17&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;A拦着我的肩头，说哥们儿怎么样。不错吧。我笑了下，微微点头。正想往前走，就听到C在叫我。我抬头一看，她正用一种尔不过如此的眼神看着我，顿时让我羞愧不已，恨不得钻进裤裆。&lt;/p&gt;
&lt;p&gt;C走上前朝我身后看了看？指着问，进去过啦？A连忙帮腔，说就是带他来看看。嘿嘿。C戳了戳A的额头，你小子，别把人带坏了。很久之后我才知道，A不过是丢了块砖头给我，而我才是出玉的人。黑白不分，善恶不明，再也不提年少的纯洁与美梦。&lt;/p&gt;
&lt;p&gt;跟C打过招呼，A又拉着我去吃东西。我说刚吃了饭，又去宵夜啊。他哈哈大笑，声音淫荡无比：“就当是补补嘛，”我心想有人买单，既然如此恭敬不如从命了。&lt;/p&gt;
&lt;p&gt;其实那天吃东西我完全没心思，当了十几年好学生，竟然被熟人看到我那啥，实在让我觉得不舒服，好像全身都有毛毛虫爬，坐立不安。&lt;/p&gt;
&lt;p&gt;倒是A一个劲的说得天花乱坠。郭德纲之辈都望尘莫及，估计听了都恨不得拜他当师傅。我几口绿豆汤下去。他已经跟多个美女有过巫山云雨了。从牡丹江边到南中国。从格尔木到上海外滩。早上还在和北京小妞调情。晚上就到了九龙涂炭香港同胞。冬天在三亚和美女水中嬉戏。春天跟藏北的女信徒共度灵河。也不怕佛祖一巴掌拍掉他的小弟弟。牛逼到张伯伦都自愧不如，西门庆要挥刀自宫，登徒子都不能算根葱。我赶紧又给自己喂了一勺子绿豆。那口甘甜的绿豆还没进入我胃里。A又开始意淫国外形势。东亚尽在手中，西欧不在话下，大洋彼岸也不过一个媚眼，估计除了死去的玛丽莲梦露没被他意淫过。他对泰国人妖都实行过精神强奸。若不是丫跟我畅谈过去，展望未来。恐怕连孩子都生了一打了。让我顿时觉得羞愧无比，疚于耽误了他的时间，心中不由长出八尺卑微内伤，暗涌淤血几升。也终于明白猪肉为什么这么贵了。都他娘给母猪口交去了，哪会进屠宰场啊。&lt;/p&gt;
&lt;p&gt;手淫强身,意淫强国。真理啊。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 18&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这座城市的夜色总是让我不安，越觉世界在不停的下沉。从我身边走过的每一个人都似乎心怀不轨，非娼即盗。那些擦肩而过的浓妆淡抹，不管是否有我心仪的面孔，都会让我顿觉失落。他们如此美丽迷人，而我却了无一物。&lt;/p&gt;
&lt;p&gt;梦想是好的。瞎想也是好的。一切结束后现实依然红果果的站在我的面前，奶奶曾经跟我说过这么一句话；“晚上路千条，白天旧模样。”有时候就算用尽一生的力量，你也永远无法去改变什么。&lt;/p&gt;
&lt;p&gt;就像小A，小C，就像我。&lt;/p&gt;
&lt;p&gt;那天夜里吃完宵夜后，雨已经停了，我们悠哉游哉的走在午夜的街道上，A依然说着那些姑娘，那些或真实，或虚拟的姑娘，我分不清（HX啊，XX）真假。但是我唯一知道的是，她们已经不在他身边了。&lt;/p&gt;
&lt;p&gt;路过XX广场时，周围是高楼林立，彻夜不眠的灯火。A突然停了下来，深深吸了口气：“这么多盏灯，怎么没有一个是属于我们的家呢？”他看着我，像是不可反驳的质问。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 19&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;“你小子到底进去没。”小C问我。&lt;/p&gt;
&lt;p&gt;其实那天夜里看到她，我就应该明白，一个小姑娘去那种地方干嘛？我直直的看着她：“那你去哪儿干嘛。”&lt;/p&gt;
&lt;p&gt;小C从收银台绕出来，杏母横瞪：“几天不见你冲了不少啊。”&lt;/p&gt;
&lt;p&gt;那时我已经学会如何见杆子就爬了，管你是烈女还是荡妇与我何干？我歪嘴笑了笑：“你不会在哪儿做兼职吧。哈哈”&lt;/p&gt;
&lt;p&gt;C立马就发作了，小嘴一嘟，粉拳如雨，以排山倒海之势朝我压了过来。我赶紧避让。&lt;/p&gt;
&lt;p&gt;她站在原地跺了跺脚：“我住那边儿的！”&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 20&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;2010年1月，我已经在一家公司正式上班了，普通的工作，薪水2500，啥保险都不买。有天我去给客户送文件，说来也巧，当天正好一份说明文没带，我就去网吧上Q，找同事发过来，准备在附近复印。而那个网吧的网管，竟然是原来那个大网管。看见我进来，他立马认出我;“很久不见哦，哪里发财嘛。”我抖了抖手上的文件：“给人打工呢，发什么财。”那厮笑了下，给我递了根烟，说有大学文凭就是好啊，随便都找个工作。不像我，当了这么多年网管，还是网管。我抿嘴笑了笑，不知道该说什么。他又似乎不太服气自己现在的生活：“以前，我也挺不错的，对吧。网吧技术都是我管呢。”我知道我已经不需要说些什么了，找了个地方坐下。想起大半年前的那个下午，他走出网吧，被几根熟铜管放倒在地下，打得叫天喊地，像一头被人拉上屠场的猪。而他钟情的那个姑娘，C，也只当他是个玩物而已。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 21&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;A伏在我的耳边说；“你知不知道，C跟大网管有一腿。我去厕所时候看见的。”我转过头，一脸惊讶的表情看着他：“是吗。不可能吧。”&lt;/p&gt;
&lt;p&gt;A又端坐在电脑前面，敲打着键盘：“真的，不骗你，估计是个人都能干她。”&lt;/p&gt;
&lt;p&gt;临近7月了，毕业证到手了。简历投了无数份，可总遇到不是跟网吧差不多薪水，就是骗人的勾当。我整天坐在网吧发呆，小C问我你工作怎么样了。我摇摇头，一脸阳痿的样子看着她；“没着落。”&lt;/p&gt;
&lt;p&gt;她依旧是拖着下巴，露出个乳沟，白花花的咪咪诱人无比,一副替我着急的样子:“先做着这个吧，找到了再走也不迟。”&lt;/p&gt;
&lt;p&gt;你知道，任何一个姑娘，哪怕她貌似无盐女，哪怕她是个人尽可夫的荡妇，她依然有温柔可人的一面，足以在一瞬间融化任何一颗坚硬的心。让你瞬间荡起柔情无数，甚至让你以为在那一瞬间爱上了她。我必须承认，那时我的心在扑扑乱跳。&lt;/p&gt;
&lt;p&gt;转过头去，就看见A正在噼里啪啦的打着一句诗：“城市的尽头我两手空空，悲痛时握不住一颗泪滴。&lt;/p&gt;
&lt;p&gt;韩寒说狗是一个很奇怪的动物，能把莫不想干的两个人联系起来。比如他和四姐。有时候诗歌也是一个很奇怪的东西，能把两颗距离很远的心联系到一起。看到A写下那句时，顿然明白他身后那些未曾提及的人或者事。一切的谎言都会有所指向，不是空穴来风。&lt;/p&gt;
&lt;p&gt;他继续写着字，大概是说理想很难实现，就算富足，也觉得空虚。除了满肚子愤世嫉俗理由，再也不能为生活找到任何意义。那时他是富家子弟，衣食无忧，成天开着车在偌大的城市里闲逛，而姑娘又太浅薄，挥挥手就能跟着他走。写完后他又习惯性的吸了口气，而就在不久前，他还在一个夜里，喘着来历不明的现金，走进按摩店，接受30RMB/小时的服务。我理解他的谎言，理解曾经被现实逼得无所遁形，吃一碗稀饭两个小包子的早餐，把3块一碗的米线当晚餐，穿着整个冬天都没换的风衣，脏脏的牛仔裤，头发油腻腻的。他用这样异样的方式书写着他的理想，铜细万千，美女投怀。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 22&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;我一向觉得庆幸，虽然不能来自富豪之家，甚至算不上小康。但是我却在生命最黯淡的时光中，看到了理想的光芒，那是我的，是A的，是C的。有什么比窥见灵魂的闪动更让人觉得惊心呢？&lt;/p&gt;
&lt;p&gt;“我要努力存钱,给家里买电视。”“我要努力存钱，让爸妈过得好点。”…我觉得我从来不了解一个真实的C，虽然她曾在酒后向我吐露真言。但是无论如何，这个姑娘在心底的最深处，依旧是善良的。可是如今，我眼前这个衣着暴露，行为放荡，眼神随时都带着挑逗的姑娘到底是谁？&lt;/p&gt;
&lt;p&gt;“我是你娘。”C说&lt;/p&gt;
&lt;p&gt;那天她正站在网吧的大门口，指着我破口大骂。&lt;/p&gt;
&lt;p&gt;你可以侮辱我，侮辱我的人格，甚至尊严，但是你不能侮辱我的父母。我始终相信任何深厚的情感，都会造就一个勇敢的决定。我走到她面前，一巴掌煽了过去。打得四座无声。A那时正在上网，向犊子一样从座位上串起来：“你们干嘛啊。”&lt;/p&gt;
&lt;p&gt;父亲一生朴素，没做过一件出轨的事，和母亲更是相敬如宾。在丈夫打妻子习以为常的地方，简直是个异数。在我离开家去上大学的前一夜，母亲叮嘱了我很多。我记得她说过这么一句话：“你也不小了，如果找到女朋友，可要对她好啊，城里不同乡下，千万别动手打人，人家姑娘会伤心的。”那是2005年8月27号的夜里，她两鬓已现斑白，大半辈子都过着辛苦的生活，眼泪像滑落的珍珠般在我眼前流淌。&lt;/p&gt;
&lt;p&gt;四年后，我终于第一次背离了母亲的嘱咐。带着恼怒和焦躁的心。那天下午整个城市都万里无云，晚霞把整个城市都映得通红，太阳像一个巨大的血窟窿历历在目。&lt;/p&gt;
&lt;p&gt;我不想拿六百八百一月的工资，不想毕业后如A一般厮混，我想要一份稳定的工作，一份合适的工资。让弟弟有生活费，让母亲不用再如此劳作。想必那时，她正在从地里回家的路上吧，在沿途会用溪水洗手，顺便喝点清泉解渴，然后回家劈柴做饭。&lt;/p&gt;
&lt;p&gt;远在千里外的家炊烟袅袅，而我却站在整个孤独的城市怒气不止。&lt;/p&gt;
&lt;p&gt;C摸着自己通红的脸，哇的一声就哭了出来。泪水横流，目光如炬。让我内心无法平静，站在那个夕阳曾经是谁的眼泪也让我如此动容？站在那个夕阳西下的黄昏，所有的往事和无奈的现实如浪花般席卷而来，夹杂着C的泪水和嘤嘤的哭泣，让我一时不知道何去何从。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 23&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;那天我回到宿舍后，心情久久不能平复。舍友的音响里放着朴树的歌：&lt;/p&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;p&gt;请快些寄给我一把镰刀 让我回来收割你的眼泪&lt;/p&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;p&gt;A打电话约我出来喝酒。我想他跟我一样，在这个城市没太多朋友，除了上网也没有其他的东西可以打发时间了，某些时候也如我一般需要有人陪伴。你知道的，孤独不可怕，可怕的是无法消散的寂寥。&lt;/p&gt;
&lt;p&gt;那天我喝了很多，在街头的大排档，但是心头清醒无比。A也是喝得醉醺醺的，说：“姑娘算个毛。C那婊子，打了就打了，那是她自找的。对吧。”他把酒杯高高举起：“来，一口闷。”&lt;/p&gt;
&lt;p&gt;已经是盛夏了，晚风带着阵阵凉气习习而来。啤酒冰冷，顺吼而下，让我的心涧寒意四起。&lt;/p&gt;
&lt;p&gt;“你怎么能动手打人呢？”A站在C的旁边说。&lt;/p&gt;
&lt;p&gt;投了N份简历，面试几次碰壁，心情烦躁无比。而且还是透着白班去的。回到网吧小C问我怎么样，我低着头不做声，只是不停的摇头。我从来不曾觉得网吧的空气如此沉闷，又慢悠悠的走出网吧，站在门口的台阶上抽烟。小C蹦跶着走出来；“抽闷烟啊，慢慢来嘛。”我心想，你又不是我，当然不知道着急。埋着头叹了口气。小C嘴巴一撅：“还是个爷们呢，这点事儿都唉声叹气。”&lt;/p&gt;
&lt;p&gt;弟弟早上打电话来，说：“哥，你能寄点生活费吗，上个月本来还有的，前天全买学校的学习资料了。”他的声音很小，唯唯诺诺一般。我问他那你这两天吃的什么。他沉默了好久。“你说啊”我一下就吼了出来。“馒头”弟弟在那头慢腾腾的说着两个字，像是要哭出来一样。&lt;/p&gt;
&lt;p&gt;我知道我没控制住自己，也许那天下午我根本就不想控制。回头看了看C：“你谁啊，关你鸟事。”&lt;/p&gt;
&lt;p&gt;“我是你娘。”&lt;/p&gt;
&lt;p&gt;以后日子，当我想起这件事，我都恨不得给自己一耳光。我知道C的那句话并无恶意，因为她还带着微微的笑意。可是我依然挥出了那一巴掌。&lt;/p&gt;
&lt;p&gt;你怎么能动手打人呢？”“怎么能动手打人呢？”A从椅子上站起来说。&lt;/p&gt;
&lt;p&gt;我坐在大排档的橡胶椅上，手指轻轻弹着空荡荡的啤酒瓶，双眼死死盯着A：“你确定他是婊子？”&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 24&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;暑假到了。网吧的人流一下少了很多。大网管也没来过了。老板说白班夜班一个网管，一个收银就够了。&lt;/p&gt;
&lt;p&gt;但是A却几乎每天晚上都来，有一次我去厕所，隐隐听见他声音，已近是夜12点了。我听见他说：“准备睡觉呢，工资还没发，你叫爸爸给寄点来吧。”“有，有，五金保险全都有。”“是啊，一年了，老板说涨工资呢。”&lt;/p&gt;
&lt;p&gt;我不想打扰他，便又折了回去。C好久都没有理我了，只是有时说着不痛不痒的话，她依然静静修着她的指甲。A从厕所出来时带着兴奋的表情。看到我就说：“女朋友的电话，他不让我夜里在外面。”我什么也没说，只是含着嘴唇笑了笑。&lt;/p&gt;
&lt;p&gt;A总是在日志里含蓄的写着QQ日志。有一次他在日志里写了一段类似叶芝式的句子：”无人眷顾我的年华，无人看到我的理想，只有你，在黑夜淌进我的心田。”&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 25&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;以色列国王所罗门曾在《雅歌》中如此赞美新娘：你的颈项如象牙塔，你的眼目像希实本巴特那拉并门旁的水池。&lt;/p&gt;
&lt;p&gt;多美的诗歌，多美的象牙塔。而当我跨进大学这坐标为象牙塔的地方时，却从来没有看到新娘般动人的容颜。饭堂里永远有人上下其手，互相乱摸，夜里的小树林永远有人在鬼鬼祟祟的做着什么。宿舍有一个虔诚的基督教徒，自称三代信徒，非信上帝者不娶。此教徒每天早晚必念圣经，阵阵有词，还不停给宿舍的人布道。有时候他念着圣经，有人却放着日本床上武打片。。。恩恩啊啊啊。。。听起来是十分带劲。&lt;/p&gt;
&lt;p&gt;有时看着那本页面被刷成粉红的《圣经》，我心里竟然会升起一股恶毒的念头，越看越像红灯区灯光的颜色。如果上帝被诱惑，大概也免不了犯错吧。&lt;/p&gt;
&lt;p&gt;不是我不愿乱摸，不是我不愿做鬼鬼祟祟的事，我骂着好13被狗X了，骂着大白菜被猪啃了。想来好笑，如果有机会，我何曾不想当回猪？我渐渐发现，不是我善良，而是我受的诱惑不够，或者说从来不曾受过诱惑。&lt;/p&gt;
&lt;p&gt;我觉得应该向C道歉，那天是我不对。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 26&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;我跟A说:“你帮我把C约出来。”&lt;/p&gt;
&lt;p&gt;那时他正在看着各种豪华跑车的照片，歪着头斜了我一眼：“约那婊子嘛.”然后指着显示器，两眼冒光：“你看，这些车，等我有钱了。。”&lt;/p&gt;
&lt;p&gt;每一个人都曾有过关于金钱的憧憬，一夜暴富，财神临门，瞬间中了几千万，香车美女，灯红酒绿，在那些遥不可及的姑娘身上喘着大气，让她们变成世间最淫荡的女人，或者在从未涉足的场所挥金如土，引来侧目无数。你会忘了一切，忘了你身在何处，甚至从未觉得时间如此短暂。&lt;/p&gt;
&lt;p&gt;A又狠狠吸了几下鼻子：“。。。对吧，姑娘们还不都往我这里跑啊。”&lt;/p&gt;
&lt;p&gt;我始终是一个农村出来的人，A始终是城市最底层的人。我们没有任何资本可以自豪，只能梦想着有一天能够自豪。&lt;/p&gt;
&lt;p&gt;A从未提及他的父母，除非他是富二代的时候，他才会在白得扎眼的输入框里说，Daddy出国了，不知道何时才会回家。mammy也总是喜欢去澳门玩大富豪。弄得我只能天天跟家里的保姆们面对面。然后他又迅速地在保姆后面加了个“们”，保姆们面对面。。房子太大了，空荡荡的感觉，让人闻不到一点外面的气息，这样的日子，真没FEEL。似乎他家是住在香港浅水湾或者三藩市一样。满嘴的羊骚英文味。&lt;/p&gt;
&lt;p&gt;那时他正坐在网吧里，已经是7月了，老板终于肯开空调了，带着一股臭臭的味道，夹杂着烟草的缭绕，各种像腐烂的豆瓣酱一样的脚臭，还有泡得太久的方便面发出的余味，以及那些劣等胭脂香水味。几个穿着引人犯罪的姑娘从他身后悠然而过，甩着手里低劣的提包，高跟鞋发出滴答滴答的声响，消失在网吧门口，融进了无边的夜色。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 27&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;城市日复一日的繁华着，华灯初上之时，每一个人都有一条回家的路，但却没有一条路属于我。我不能去高档的酒楼，不能开着拉风的汽车，哈根达斯，星巴克之类的地方，我都只能远远看着，就像看着夜空中那些不可抚摸的群星。&lt;/p&gt;
&lt;p&gt;所以我也不能带着C去什么地方吃饭，也不能给她买东西赔礼道歉。白班结束后，我在附近的菜市场买了半斤排骨，半斤瘦肉，一根萝卜，还有1块2一斤的青菜。经过楼下的卤菜摊位时，又买了两块八毛钱的卤豆腐。&lt;/p&gt;
&lt;p&gt;那时我已经毕业了，学校再也住不了了。280一月的合租屋，厕所合用，厨房合用，一切可以合用的都得合用。整个楼房是上世纪90年代的，楼角长满了青苔，楼道里永远没有路灯，墙壁上贴满了各种广告，开锁，治性病,通下水道，办证，还飘散着一股尿骚的恶臭。住户们对此很不满意，有人在那些密密麻麻的广告标签上写着大大的毛笔字，贴广告死全家，乱撒尿烂JJ，砸烂灯泡遭雷劈，连着祖宗十八代都问候完了，我想那些话如果能够应验，那么中国肯定不会是第一人口大国。&lt;/p&gt;
&lt;p&gt;这是农村的习惯，我知道有时候一些与生俱来，被日以继月熏陶的本质，永远都没办法从我身上剥夺。我做了几个菜，煲了一小锅汤，以此宴请客人。&lt;/p&gt;
&lt;p&gt;“小C说，“有人做饭干嘛不去。”她又指了指我；“记得买点啤酒。’一脸我欠了她几百万的样子。&lt;/p&gt;
&lt;p&gt;A始终不肯去帮我叫C，甚至不愿来我破旧的出租屋。我只能亲自出马了。也许他在笑我，竟然给一个婊子做饭。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 28&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;我一直相信，任何卑微的生命里，都有一颗骄傲的心。年少时一无所有，但是你可以是翩翩美少年，迷倒少女万千，无关金钱，权利和任何的物质利益。成年后也许你依然两手空空，但是那时你胸中万卷，腹下千言，才华横溢。终于你老了，容颜不再，江郎才尽，油光满面，大腹便便，不过也许你已成家立业，儿女在膝，娇妻在房，能看着N张房产证和银行卡上好几个零暗暗自喜。&lt;/p&gt;
&lt;p&gt;A也一样。他在那些黑白堆砌而成的字里行间说，我三岁就识字，七岁背唐诗，作文基本都是满分，看过的书比某些人见过的书还多。他不会扫地，不会洗衣，不会下厨，当然，更不会给婊子下厨。那时他是出身书香门第，名门望族，闲时读书练字，观花逗鸟。忙时周游四方，行便四方。笔墨之间尽显风流。书房也贴满了祖辈们的字画。只不过后来遭遇文革，家道中落，但是却独善其身，不为物欲所动。钱？哼，粪土罢了。&lt;/p&gt;
&lt;p&gt;那时网吧来了很多宣传游戏的，带来很多海报，老板说你们给贴上去，贴上去。泡沫横飞，口水乱吐。XXX公测，跟XXX一起看美女，跟美女一起玩XXX。那些不是水墨泼就得山水图，不是狼毫写出的黑字，只是一张张泛着光的复制品。A就坐在他们下面，就像坐在他家的书房一样。而我知道，那不过是一个网吧。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 29&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;李叔同说人嘛，就是要干一行像一行。所以他是公子哥时风流不羁，成了文人就才高八斗，当画匠嘛，那就技惊四座。最后他终于去做和尚了，死时说：‘问余何适，廓尔亡言。花枝春满，天心月圆。”人生似乎就是这样，茫茫红尘，前路不知所向。唯一能做的就是活着等待，等待春满花开，皓月当空。&lt;/p&gt;
&lt;p&gt;我没办法住进偌大的别墅，买下一桌的满汉全席。所以C来时，我告诉她：“出租屋有点小。菜也不多”那时我站在食物链的最底层，向往狼虎之心，却手无缚鸡之力。&lt;/p&gt;
&lt;p&gt;小C突然变得很娴静，说话的声音像一汪秋水散开的涟漪，悄无声息的漾进我心底最柔软的地方：“刚毕业嘛，都是这样。”她昂着头看着我，脸上的笑容像一颗含苞待放的蓓蕾，在我眼前瞬间绽放。&lt;/p&gt;
&lt;p&gt;那是我命中的第一朵桃花，岂能不记得绽放时的美丽？&lt;/p&gt;
&lt;p&gt;我一直不愿跟A吐露心声，但是却需要一个人来给我指点迷津。不过我又无法向任何人启齿，别人口中的婊子，有着不是那么美丽的脸蛋，不是那么完美的人生过往，也不是天才横溢的女人。我看见面前有一堵巨大的墙壁，所有的流言与非议的目光朝我逼迫而来，离我年少时的心越来越远。&lt;/p&gt;
&lt;p&gt;对，她不过是个婊子 ，曾经在我面前和别的男人缠绵。&lt;/p&gt;
&lt;p&gt;A说上吧，上吧。反正是个婊子。&lt;/p&gt;
&lt;p&gt;那是我生命中的第一个女人，披头散发，喘息不止，在暗淡的灯光下显得面目狰狞。也许是第一次碰女人的缘故吧，没有像别人所说的几十分钟一个小时的持久，恐怕连五分钟都不够，我就已经像融化的沥青一样瘫软在身上。&lt;/p&gt;
&lt;p&gt;她紧紧的抱了我很久，然后又捏着粉拳打在我的背上，带着娇柔的声调：“坏蛋，你要把我压死啊。”&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 30&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;公司的生意很好，每个星期都得陪着客户，那已经是2010年的1月了，吃饭，唱K，找小姐，其实前面两个都是个过场，最后一个才是正题。无数次将来路不明的女人搂在怀里，无数次在陌生的脸庞边醒来。我不敢亲吻她们，不敢用嘴唇接触她们的肌肤。&lt;/p&gt;
&lt;p&gt;我看着她们在走进房间的数分钟里变得一丝不挂，然后告诉我：“快点来吧。”可是当荷尔蒙挥发之后，欲望在一瞬间戛然而止时。我一遍遍问着自己，你是想念那第一张并不完美的脸庞，想念她在我怀中如襁褓里的婴儿安睡，任由她嘴鼻间的气息在我赤裸的身体上游走，还是眷恋这一个个描眉画眼，胭脂玉体的女郎？谁才是曾经占据内心所有的那个人？&lt;/p&gt;
&lt;p&gt;我有着一颗不可抑制的窥探之心，企图将内心所有的恶念与虚荣驱赶，将所有的丑陋和挣扎放在眼前拷问我的心灵。可是我做不到，那些血肉模糊的尴尬，任何人都难以直面，当然，也包括A。&lt;/p&gt;
&lt;p&gt;他总是独来独往，除了我，再也无人与他对坐，听他口中的过往与未来的理想。7月的夜里热的让人抓心挠肺。A告诉那些素未谋面，也永远不会见到的陌生人：他曾经的女友们都走了，她们漂亮，善解人意，她们有的出国了，有的怕太爱他而决绝的分手了。在他爱过，和爱过他的那些女人中，每一张面孔都足以惊动世人。每一次牵手都让人心如鹿撞，每一次的微笑都让人如痴如醉，还有她们的拥抱，带着无法抗拒的柔情和炙热。可是她们都走了，他只能在厮混中度日，他不喜欢那些漂亮的陌生的姑娘，她们算什么？有钱就能上，婊子，全他娘的是婊子。&lt;/p&gt;
&lt;p&gt;A的神情痛苦不已，然后把手高举过头顶：“网管，拿包5块的XX烟。”那是7月盛夏的夜晚，终于下雨了，夹着夏风呼啸而来，水滴倾盆而下，湿润了每一个渴望温暖的怀抱。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 31&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;弟弟从学校打电话来，说学校要放假了，这月就不用寄钱了。我听了悠悠说了句好，正准备叮嘱他假期多帮家里做点农活。弟弟就带着笑嘻嘻的口气问我：“妈让我问你啥时候娶媳妇儿。”农村结婚都早，奶奶生爸爸时才17，我出生时母亲才19。我呵呵笑了下：“早着呢，哪儿有这么快。”“妈让我问的，妈让我问的…”&lt;/p&gt;
&lt;p&gt;那是我人生中最灰暗的日子，没钱没车没房子，甚至前途都没有，跟一个不算漂亮的女人开始我的爱情。但也是我人生中最觉得幸福的时光，每天上班，拿出多的薪水，下班一起买菜，一起做饭，闲聊，ML,相拥而眠。放假时陪C逛街，那真是名副其实的逛街，几乎不买任何东西，经过那些光鲜的服装店，那些巨大的广告牌，C总会用余光看一看，然后把手挽得更紧，头贴在我的臂膀上。跟我说着她想说的话。有时候我真希望时间就这么过完，朝着那些人潮涌动的街道一直走下去，永不停止。&lt;/p&gt;
&lt;p&gt;她不会气势汹汹骂人了，也不会咄咄逼人的说着放荡的话，有一次我们无意说起了那一巴掌，她就不说话了，用画着劣质眼影的眼睛看着我，一行泪水从眼睛里滑了出来，接着另一行泪水也幕然而出，皱着眉头，嘟着樱桃小嘴：“你还打我，你还打我。”听得我心头发酸，两眼湿润，只能紧紧的把她抱在怀里。&lt;/p&gt;
&lt;p&gt;“你跟C在一起了吧。”A跟我说。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 32&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;我歪着头看着他：“没有啊.”A咯咯直笑，拍了拍我的肩膀：“别不承认。”&lt;/p&gt;
&lt;p&gt;A终于恋爱了，跟一个网络上的姑娘，那个女人几乎占据了他的全部夜晚，似乎是从贴吧找来的。从那时起，A一到网吧就会戴上耳麦跟那个女人聊天，可是他从来不开视频。从别的地方照片发过去。我不知道那个女生的模样，不知道她身在何方。我唯一知道的是，她成了A的一个寄托。A帮她冲游戏卡，冲Q币，甚至冲电话费。后来我才知道，那个女人跟我们在一个城市。&lt;/p&gt;
&lt;p&gt;A在浏览器上继续他的生活，他是有着如花美眷，似水流年的少年，喜欢穿帆布鞋，牛仔裤，白色的衬衫，头发清爽和干净。不抽烟，不酗酒，依然是一个羞涩的处男。聊天窗口的肉麻漫天直飞，足以麻倒远古恐龙。但是在他笑容满面，露出两排被烟熏黄的牙齿，眸子里尽是幸福的表情。&lt;/p&gt;
&lt;p&gt;他偶尔跟换ID，说终于把喜欢了好久的姑娘追到了。大家说我该护她吗？人家是很清纯的小姑娘呢，家境富裕，弹得一手好钢琴，画得一手好画，说起话来让人全身发酥。然后又不知去何人的博客里弄来一张照片，大家看看，怎么样？&lt;/p&gt;
&lt;p&gt;不是所有的事情都会那么敬如人意，A也会有烦恼。他告诉网线另一端的那些人，说我不是单身了，有个女生还说喜欢我，准备做我的备胎，我应该答应么。他依旧是那个少年，不过多了几分烦恼。是啊，多好的姑娘啊，虽然不够女朋友漂亮，但也不赖，只是希望在她有空时陪着我。我要答应吗？要答应吗？A抬起头，看着网吧前面上的海报，伸了个大大的懒腰。&lt;/p&gt;
&lt;p&gt;政府下政策了，来网吧上网的要身份证了，未满十八岁的不准进来。A每次都会拿出那张洗的皱巴巴的第一代身份证，上面的他是16岁时的样子，短发圆脸，畏畏缩缩的感觉，似乎在恐惧着眼前的镜头。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 33&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;7月末收到好几个公司的面试，花38块买了件衬衫，65块买了双皮鞋。我说过，C的骨子里还是渗透着善良和朴实，她会在出门前把鞋擦得干干净净，像新的一样，皮油是没必要了，就用报纸和厨房的油布也行。&lt;/p&gt;
&lt;p&gt;趁着白天上班，我又好几次偷跑出去，面试时倒是很顺利，可是接下来，却没收到一点消息。C还是修着她永远修不完的指甲，时不时朝我吐着舌头。A依然每天坐在网吧，穿着洗的发白的牛仔裤，带着黄色污渍的白T恤，还是那双蓝色的人字拖鞋，双腿不停的抖着。&lt;/p&gt;
&lt;p&gt;他说工作很麻烦啊，手下的员工不做事儿，老是给我找麻烦。出差公款乱用，出去跑业务只会偷懒。有些大学毕业生一个季度下来都没什么业绩。唉，谁让我心不够狠呢，是新人，就让他们慢慢跑吧，大家出来混都不容易。不过真不知道他们月薪2000多怎么活下去的。&lt;/p&gt;
&lt;p&gt;“该怎么活怎么活呗。”C用双手揽着我的脖子：“我要求又不高，工作慢慢来嘛，好不？”然后在我脸上重重的亲了一下。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 34&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;给老妈取个名字叫mummy，给老爸取个名字叫Daddy，没过多久，似乎住在香港或者三藩市的A也给自己取了个英文名：Charles。&lt;/p&gt;
&lt;p&gt;Charles的空间越来越漂亮了，开着10块一月的黄钻，到处搜集着煽情或者美妙的帖子。相册的姑娘越来越多了。个个都是月画烟描，粉妆玉啄，长发飘逸，短发宜人，要不然就是烈焰红唇，热情无比，或者含唇窃笑，小家碧玉。看得人眼花缭乱，只感叹美女都以相机为家了，是不会落入凡尘一步的。&lt;/p&gt;
&lt;p&gt;在那里，我也见到了多年前的A,面颊白皙，也不是圆嘟嘟的感觉了，站在不知道何处，背靠一辆跑车与一枚美女合影，笑得春光灿烂，河水倒流。有人在下面留言问：你女朋友？ Charles回复说：嘿嘿。。。&lt;/p&gt;
&lt;p&gt;“嘿嘿，这是D。”A指着那姑娘说。&lt;/p&gt;
&lt;p&gt;小平同志教育我们说实践是检验真理的唯一标准。同理，姑娘也是。&lt;/p&gt;
&lt;p&gt;那天A穿着新买的T恤，干净的牛仔裤，鞋子也弄得一尘不染。D站在她旁边，裤脚略带喇叭形状，奇短无比的吊带，胸几乎就是没有，更让人崩溃的是，还穿着一双红皮鞋。&lt;/p&gt;
&lt;p&gt;那次A很大方，买了饮料，小吃。然后从口袋里拿出软玉溪，抽出一根转身递给我，抿了抿嘴，露出一个很浅的笑容：“来，抽一根。”&lt;/p&gt;
&lt;p&gt;那一刻时间仿若倒流，我看到一个头发油腻腻的家伙，穿着单薄风衣，脏牛仔裤，人字拖，在我耳边问：“你有烟不，我不记得带钱出来了。”&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 35&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;终于等到换班了。工作也有着落了，面试几次，终于有公司通知我9月上班了。就是我现在这家公司，做软件，跑客户。前三个月没业务要求。薪水整整打了一个滚。弟弟下学期的生活费不用愁了，有多余的还能给家里寄点。接到通知那天下午，C买了做了很多菜。在纸箱做成的小饭桌前，她坐在小板凳上，弓着腰，握着一次性的塑料杯子，傻笑的看着我。就像以前一般，露出半个咪咪，红唇无限接近，饭是没心思吃了，我站起来把她一把拉到床边按了下去。&lt;/p&gt;
&lt;p&gt;第二早上被电话吵醒，A问我晚上去不去酒吧。我知道那地方消费贵，不是我能负担的。A也许根本没打算让我买单：“我叫你去的嘛，肯定我买单。”&lt;/p&gt;
&lt;p&gt;那是我从未涉足的地方，巨大的音响发出震耳的声响，红男绿女喝得天昏地暗，在暗淡的灯光下，所有的脸庞看起来都暧昧不已，似乎随时都能欢迎一具陌生躯体的进入。A抱着D，指着桌子上的瓶子：“这个芝华士…”我端起那些红茶兑过的酒精，用小得可怜的玻璃杯一口饮下，苦涩不已，在我看来不过尔尔。无奈人视之如醇醪,而我以为是砒霜，虽然毒不死我，也不见得是什么好东西。但是它们却被人群一次次高举，DJ高喊着：“今天有寂寞的人吗？”人群振臂高呼：‘有。”“有晚上不回家的吗。？”他们声嘶力竭：“有。”&lt;/p&gt;
&lt;p&gt;在那个夜里，我一次次举起杯盏，喝下并不喜欢的暗红液体。舞池喷出层层白色的烟雾，灯光缭绕之下，环肥燕瘦的姑娘，身姿婀娜的舞者，所有人都喜笑颜开，如同置身人间天堂一般。&lt;/p&gt;
&lt;p&gt;不久之后，我开始习惯他们。就像他们是我自己一样。忘掉那些白皙如雪的面孔，忘掉那些水晶般剔透的眼眸，忘记那些干净清澈的笑脸。以及那些儿时的嬉戏，发小的挚情和未曾到达的理想。理想？回忆？甜蜜？能当饭吃吗？&lt;/p&gt;
&lt;p&gt;客户说那陪酒的白衣服姑娘不错啊。我晃晃悠悠的端起酒杯，走向白衣女郎，翘着二郎腿坐在她旁边，用食指撩了撩她的头发，又回头指了指客户。那头满脸坑坑哇哇，手毛奇长，还带着淡淡腋臭长得像猪一样的客户。姑娘雪肤花冒，作蹙眉之态，缓缓向我伸出五根手指：“五百。”&lt;/p&gt;
&lt;p&gt;那是谁伸出的芊芊玉手，如置身于寒风中微微颤抖？&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 36&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;准备开毕业聚会了。我觉得应该去。同窗四年，不过一起吃过两次饭。&lt;/p&gt;
&lt;p&gt;2009年8月1号，我那傻13舍友，一身酒臭，满目血丝，饭后在酒吧抱着姑娘上下其手，猛扑狠啃，像头发情的野猪。在他所有的同学面前出尽了洋相。&lt;/p&gt;
&lt;p&gt;我还记得三年前，那是宿舍为数不多的几次吃饭，11块一位的自助餐，酒水另算，米饭免费。他也曾在那个黄昏喝得狂吐不止，然后嚎啕大哭，涕泪俱下。彼时晚风微微，冷月高悬。在昏黄的路灯下。他抱着我的腿大声嚎叫，“我要她。我就要她。呜呜呜呜。我就只要她。”那年他十九岁，哭得像个丧母的幼雏。&lt;/p&gt;
&lt;p&gt;如今姑娘已不是那个姑娘了，眼里的血丝取代了泪水。白天上班，晚上瞎混。我亲爱的傻13舍友。你还会记得那个为之泪下的姑娘么？三年的光阴流转，是谁让你的满腹柔肠化为乌有？&lt;/p&gt;
&lt;p&gt;那时我未经人道，不知爱情有如此魔力，能让泪水挥洒而下。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 37&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;A说：“你觉得她怎么样？”那个她是D，一个穿着红皮鞋，不太会打扮的姑娘，一个并不是那么美丽的姑娘。他望着我，带着小心翼翼的眼神，像是怕打碎脆弱的瓷器一般。&lt;/p&gt;
&lt;p&gt;当时A正走进网吧，站在我面前问了这句话。&lt;/p&gt;
&lt;p&gt;我咧开嘴巴，露出一个大大的笑容：“你喜欢就好。。。。”其实这不是我想说的全部，我还想告诉她，“别管别人怎么说。”可是我始终没开口。看着他掏出那张依旧皱巴巴的身份证，交钱，上机，登陆QQ…重复着那些似乎不会改变的动作。&lt;/p&gt;
&lt;p&gt;你知道男人的一生总会经历很多女人，不管他们是貌若天仙，还是长相平凡，甚至带着几分丑陋和粗俗，但总有那么一个时刻，会让你砰然心跳。&lt;/p&gt;
&lt;p&gt;八月了，到月底我就可以辞职了。A还彻夜的坐在网吧，而我再也不曾见过D了。黑幕茫茫的夜空，像是一条悠长隧道的入口。A就坐在着黑夜之下，那是那一刻的他，毕业了，工作找到了，工资也不少，但是跟女朋友闹矛盾了，整整一个月没见面。昨天逛街时突然碰到了，女友盯着她，然后眼泪哗啦啦的往下流。他说女友那一刻的眼神，让他想起四年前那个暮春的初遇，云鬓花颜，长裙飘飘，让他一生都沉浸其中。&lt;/p&gt;
&lt;p&gt;外面起风了，吹得树叶哗啦啦的乱响，城市的霓虹像巨大的火焰将夜空照亮。网吧里的音响放着北京一夜，A的嘴唇一合一闭，跟着轻轻哼起：&lt;/p&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;p&gt;不敢在午夜问路&lt;/p&gt;
&lt;p&gt;怕走到了百花深处&lt;/p&gt;
&lt;p&gt;人说百花的深处住着老情人&lt;/p&gt;
&lt;p&gt;缝着绣花鞋&lt;/p&gt;
&lt;p&gt;面容安详的老人依旧等着&lt;/p&gt;
&lt;p&gt;那出征的归人&lt;/p&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 38&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;母亲走了几里山路到镇上给我打电话，问我什么时候回家，没说几句，我就听见她在那头哽咽。我告诉她过年才回家，她才稍微笑了笑，说那就好，那就好。母亲一生都在农村，未曾去过别的地方，最多就是在镇上赶集，卖点鸡蛋，或者地里的青菜。上一次回家看到她时，她已经是满脸皱纹了，一双手粗糙发黄，手掌起满了老茧。我知道她的艰辛，但是她却从未对我提起。她是我的母亲，我完全被她感染了，22年来从未向家里说过内心的苦闷和忧愁，我始终在对他们笑，我想他们知道，我很好。哪怕我只能住280一月的出租屋，一个星期吃一次肉，在城市里过着最卑微和最单调的生活。&lt;/p&gt;
&lt;p&gt;母亲说：要好好做人。&lt;/p&gt;
&lt;p&gt;最后半个月的晚班了。工资到手，我就准备换个离公司比较近的地方，一来省点车费，二来中午可以自己回家做饭。我把这些告诉了C。她高中毕业，没有手艺，只能做些简单的工作。我不能养她，也不能带她走。从我推开门那一瞬间开始，她已经不能融入我的生命了。&lt;/p&gt;
&lt;p&gt;她被另一个男人拥吻着，被另一个男人周身抚摸着，她闭着眼睛，长发散乱，呼吸急促，而她脖子上那暗红的印记，就像一个封印，让原本流淌的着的柔情，被牢牢冻住。&lt;/p&gt;
&lt;p&gt;我坐在大排档的橡胶椅上，手指轻轻弹着空荡荡的啤酒瓶，双眼死死盯着A：“你确定他是婊子？”&lt;/p&gt;
&lt;p&gt;他看着我：“你不觉得。”&lt;/p&gt;
&lt;p&gt;我靠在椅子上，仰面看着满载着群星夜空：“关我P事”&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 39&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;提前三天给老板打电话，说要辞职。老板在那头说：“好。”然后啪得一声挂掉电话。&lt;/p&gt;
&lt;p&gt;09年的8月29号早上，到新公司签合同。我来到这个城市四年了，这是第一份正式的工作。实习三个月，然后转正。给C打了个电话，说：“下午不去网吧了。老板来了的话，工资你先帮我拿下。”C在那头似乎很兴奋,连声说了几句好，又问：“合同签了？”我说：“恩”.然后支吾了几句，悄无声息的挂掉电话。&lt;/p&gt;
&lt;p&gt;新租的房子到公司只要走5分钟。一个小厨房，一个小厕所，一个卧室，没客厅。450一月、房东美其名曰简单公寓。的确挺简单，什么都是小的，小电视机，小冰箱，小柜子，就是床还勉强凑合。&lt;/p&gt;
&lt;p&gt;我没带C来这里。那天我告诉她说要搬走时。她先是朝我笑了笑，接着又低下了头。她一直是个聪明姑娘，知道有些事情无法改变：“我还要在这边上班呢。你先搬过去吧。”这话说得两面玲珑，大家都有台阶下。 有什么办法呢？我有钱我可以养你，我有人脉可以给一份工作，可是我什么都没有。庄子有句话说得真好：“相濡以沫，相呴以湿，不若相忘于江湖。”&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;chapter 40（完结篇）&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;上班的前一天开始收拾东西，C在一边帮着整理。8月份的工资是800整，交过房租后身上还有接近1000，那天收拾好东西，我和C坐在床上，相对无言很久。后来我站起身来，递给她500块钱：“你不是说要给家里买电视么。”&lt;/p&gt;
&lt;p&gt;这个城市从来都不属于我，C也一样，未来我将遇到的所有姑娘都一样。C低着头，始终没有接过钱。我只好把钱放在床上，拖着箱子提着包推门而出。那是500块，我曾经大半个月的工资，给了我生命中的第一女人。我说过了，不是我善良，因为已经明白人生难免有孤独和寂寞的时候，所以我不想一开始就无人陪伴，22年的孤寂已经把我折磨够了。买卖不成仁义在嘛，何必弄得反目成仇？留点小恩惠，给点小感动，说不定哪天就能吃回头草，吞回锅肉。对不？&lt;/p&gt;
&lt;p&gt;我昂着头走出那栋破烂不堪的楼房，我知道，一切都会重新开始。&lt;/p&gt;
&lt;p&gt;天黑前我把所有的东西都搬进新住处，地上扫得一尘不染。这时A给我打电话，我说什么事。他说你搬家了？我恩了一声。他沉默了好久，说我今天去那你住一晚上行不行。我没理由拒绝的。那天夜里我睡得很好，住处解决了，工作找到了，一切的问题都解决了。甚至连A什么时候起床离开都不知道，他只留了个纸条：我走了。&lt;/p&gt;
&lt;p&gt;翻身看看时间已经7点40了，我匆忙起身穿好衣服。挤了点牙膏冲进厕所，哪里有一面镜子，特别特别的大。我呆呆的站在门口，看见镜子里的A面孔发黄，头发凌乱，拿着牙刷的手正颤颤发抖，用一脸惊恐的表情望着我。（完）&lt;/p&gt;</content:encoded><category>category:生活</category></item><item><title>自然视力恢复法（转）</title><link>https://www.dreameverafter.com/en/post/%E8%87%AA%E7%84%B6%E8%A7%86%E5%8A%9B%E6%81%A2%E5%A4%8D%E6%B3%95-%E8%BD%AC</link><guid isPermaLink="false">en:自然视力恢复法-转</guid><description>文章转自王垠博客：自然视力恢复法。防止和逆转近视是一个相当简单的事情，理解其中的原理只需要高中光学知识，具体操作方法只需要另外配一副眼镜，然而我也是最近才发现。简短版这篇文章因为增加了很多原理说明，变得有点长。如果你不耐烦看那些原理，这里有一个两句话的版本。想要逆转近视，你只需要做这件事：配一副比你本来的度数少 100 度的眼镜。戴上这个眼镜的视觉效果，就像是近视 100 度的人，基本不影响生活。</description><pubDate>Mon, 10 Nov 2025 02:21:39 GMT</pubDate><content:encoded>&lt;p&gt;文章转自王垠博客：&lt;a href=&quot;http://www.yinwang.org/posts/myopia&quot;&gt;自然视力恢复法&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;防止和逆转近视是一个相当简单的事情，理解其中的原理只需要高中光学知识，具体操作方法只需要另外配一副眼镜，然而我也是最近才发现。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;简短版&lt;/strong&gt;&lt;a href=&quot;#简短版&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;这篇文章因为增加了很多原理说明，变得有点长。如果你不耐烦看那些原理，这里有一个两句话的版本。想要逆转近视，你只需要做这件事：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;配一副比你本来的度数少 100 度的眼镜。戴上这个眼镜的视觉效果，就像是近视 100 度的人，基本不影响生活。以后就戴这副眼镜照常生活，该怎么用眼怎么用，不需要做什么特别的事情。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;几个月之后，会发现视力变好，度数降低了。当度数降低了 50 度左右，就去换一副新的镜片，保持比实际度数低 100 度。如此循环，直到视力恢复到 1.0。&lt;/p&gt;
&lt;p&gt;不耐烦的人已经可以去操作了，但如果你不相信这事有这么简单，希望了解这个方法的原理，那就继续往下看吧。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;眼球外部肌肉的秘密&lt;/strong&gt;&lt;a href=&quot;#眼球外部肌肉的秘密&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;figure&gt;&lt;img /&gt;&lt;/figure&gt;
&lt;p&gt;近视的成因，得从眼球外部肌肉说起。眼球的外面有 6 块精密的肌肉（4 块直肌，2 块斜肌）。很多人以为这些外部肌肉只是用于转动眼球，而 100 年前有个叫 W. H. Bates 的眼科专家通过对动物眼睛做实验发现，这些肌肉也能改变眼球的形状，进行精密的对焦操作。&lt;/p&gt;
&lt;figure&gt;&lt;img /&gt;&lt;/figure&gt;
&lt;p&gt;从图中可以看到，那两块斜肌环绕着眼球侧面，可以一起产生侧向的压力，通过挤压使眼球变长，而那四块直肌一起向后用力，就可以让眼球变短。Bates 的实验（通过给这些肌肉通电），也显示了以上的现象。在这 6 块肌肉的相互作用下，眼球随时都在改变形状。&lt;/p&gt;
&lt;p&gt;通常认为人眼只是用睫状肌改变晶状体的形状进行对焦，而其实眼球外部的肌肉也同时参与了这个操作，它们通过改变眼球的形状（改变眼轴长度）来进行对焦。你可以认为眼球是一个底片可以活动的相机，它可以通过改变镜头（晶状体）的焦距进行对焦，也可以通过同时改变底片（视网膜）的位置来进行对焦。&lt;/p&gt;
&lt;figure&gt;&lt;img /&gt;&lt;/figure&gt;
&lt;p&gt;相对于晶状体的对焦范围，改变眼球形状能获得的改变很小。也许可以认为晶状体是进行“粗略对焦”，而外部肌肉改变眼球形状是在进行“精密对焦”。因为外部肌肉能改变眼球的形状，所以它们对于近视的形成和逆转起着关键性作用。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;近视产生的原理&lt;/strong&gt;&lt;a href=&quot;#近视产生的原理&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;&lt;/strong&gt;&lt;/p&gt;&lt;figure&gt;&lt;strong&gt;&lt;img /&gt;&lt;/strong&gt;&lt;/figure&gt;&lt;p&gt;&lt;/p&gt;
&lt;p&gt;看近的时候，如果眼球完全放松，成像就会落到视网膜后面。为了看清物体，晶状体需要被压缩，增大屈光。同时眼球的形状也可能被外部肌肉稍微拉长，这样成像就能正好落在视网膜上。看近的时间太长，眼球就可能持续处于被拉长的状态。长期保持这种形状，眼轴就变长了，看远的时候也回不去，以至于看不清远处物体，就近视了。&lt;/p&gt;
&lt;p&gt;所以近视产生的根本原因，是长时间紧张地看近距离的物体（比如书，手机，电脑），而跟光线，遗传什么的都没有直接的关系。长时间看近，眼轴就变长，这样睫状肌不费力就能看清近处的物体，所以近视是动物眼睛的一个 feature，而不是 bug。眼轴变长是为了让人看近时更轻松，是一种对生活环境的适应，谁叫你看近的时候那么多呢？&lt;/p&gt;
&lt;p&gt;很多人以为小孩的近视是“假性近视”，以为是睫状肌紧张所致，眼球并没有变形，所以求助于各种治疗假性近视的方法。其实小孩的近视也都是因为眼轴变长，是真性近视，所以各种号称治疗假性近视的方法都是不灵的。我认为“假性近视”这个说法，就是为各种不起作用的智商税产品准备的，可以说是一个伪科学词汇。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;不近视的“基因”&lt;/strong&gt;&lt;a href=&quot;#不近视的基因&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;有些人说自己“基因好”，似乎无论如何滥用眼睛也不会近视，但我发现这种人似乎都有一种特殊的用眼方式。虽然貌似一直在看近，但眼睛其实处于一种“似看非看”的放松状态，似乎并没有聚焦在近处，而是在看屏幕后面某个地方，或者聚焦在屏幕上很小的一点上。这种情况下晶状体其实是放松的，眼球也没有被拉长，虽然长时间“看近”，却也不会近视，因为他们并不是真正聚焦在近处的。这种用眼方式在 Bates 的书上有介绍，叫做「Central Fixation」。&lt;/p&gt;
&lt;p&gt;所以我感觉这种所谓的“不近视基因”，也许并不是生理的遗传，而是心理和习惯上的“遗传”。父母的教育和生活方式传给了孩子，以至于他们看东西养成那种好的习惯，结果就不会近视。反之那种“学术家庭”，父母看很多书，孩子也跟着很爱看书，结果就近视了，然后人们就以为是遗传的。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;近视度数与“清晰范围”的关系&lt;/strong&gt;&lt;a href=&quot;#近视度数与清晰范围的关系&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;如果你近视了也不戴眼镜，度数是很难超过 300 度的，一般在 200 度左右就不会再发展了。因为 200 度近视的眼睛，完全放松的时候，正好能看清 0.5m 远的物体。这个 0.5m 距离叫做 200 度近视的“清晰范围”，在这个距离以内的物体，200 度近视的人都能看清。为什么我知道是 0.5m 呢？公式是这样：
**
&lt;em&gt;100 / 近视度数 = 能看清的最大距离（以 m 计算）&lt;/em&gt;**&lt;/p&gt;
&lt;p&gt;练习：根据这个公式， 300 度近视的人能看清多远的物体？&lt;/p&gt;
&lt;p&gt;根据这个公式，你也可以估算出要产生某个度数的近视，你需要看多近的物体。比如，眼睛需要产生 200 度的近视，就可以在晶状体完全放松的状态下看清 0.5m 的物体。所以持续看 0.5m（及以外）的物体，能造成的近视就不会超过 200 度。&lt;/p&gt;
&lt;p&gt;看 0.5m 以内的物体，基本是需要弯腰曲背的，自己也会发现不舒服，会调整回去。所以如果一个人不戴眼镜，是比较难超过 300 度近视的。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;如何防止近视发展&lt;/strong&gt;&lt;a href=&quot;#如何防止近视发展&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;高度近视产生的原因，一般都是戴着全度数（或过度矫正）的眼镜看近。近视的眼睛看近处，本来比正常眼睛更轻松，睫状肌不怎么用力，所以如果看近时不戴眼镜，近视就不会发展得很厉害。但戴上全度数眼镜之后，这个让看近变得轻松的 feature 被抵消了，睫状肌仍然需要用力才能获得需要的屈光，外部肌肉继续拉长眼轴，结果眼轴继续加长，近视就不断加深。然后又去验光，配足新的度数，然后就恶性循环了……&lt;/p&gt;
&lt;p&gt;所以对于已经近视的人，眼镜最好不要配足 1.0 的度数，平时的眼镜应该至少在 1.0 的度数基础上减掉 25 度。&lt;/p&gt;
&lt;p&gt;如果已经近视，度数不超过 200 度。那么注意看近的时候不要戴眼镜，因为戴全度数眼镜看近是近视加深的根源。需要看远的时候可以戴眼镜。另外注意阅读距离不要太近，这样近视就不会发展。&lt;/p&gt;
&lt;p&gt;为什么眼科医生和眼镜店都告诉你要配足度数，否则就会加深近视呢？因为你近视度数越高，他们的生意就越好 ;)&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;近视逆转的原理&lt;/strong&gt;&lt;a href=&quot;#近视逆转的原理&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;figure&gt;&lt;img /&gt;&lt;/figure&gt;
&lt;p&gt;近视的自然逆转，关键在于“看远”。注意这里的“看远”是加了引号的。&lt;/p&gt;
&lt;p&gt;首先我来解释一下什么叫做“看远”。这里所谓的“远”，并不是指固定的距离，而是指物体在眼球中成像的位置。如果晶状体完全放松之后，成像仍然落在视网膜前面（如上图），对于人的视觉来说，这就叫“远”了。所以对于 1.0 视力的人，6 米以外才能叫“看远”，对于近视 100 度的人，100/100 = 1 米以外就叫“看远”，而对于近视 500 度的人来说，100/500 = 0.2 米以外就可以算“看远”了。&lt;/p&gt;
&lt;p&gt;看远的时候，晶状体需要放松，减少屈光。如果晶状体完全放松之后，成像仍然落在视网膜前面，就看不清物体。这时候如果继续注视物体，眼球外部的肌肉就会开始轻轻地压缩眼球，使眼轴变短一点点（可能只有 0.x 毫米），这样模糊的物体就会逐渐清晰一些。如果经常处于这种模糊状态，眼轴反复地小幅度压缩，就会永久性地缩短，近视就会逆转。&lt;/p&gt;
&lt;p&gt;所以近视逆转的关键，在于经常处于看远有点模糊的状态。物体不一定需要很远，只要超出了清晰范围就行。比如，你如果已经 200 度近视，那么你不戴眼镜看 0.5m 以外的物体，都能达到逆转近视的效果。&lt;/p&gt;
&lt;p&gt;注意这需要是一个长期习惯性的操作，最好是不知不觉，自然而然地进行，成为一种习惯。刻意地每天专门腾出时间来做“练习”，往往难以达到很好的效果。另外注意应该很自然地看物体，不要为了看清物体而忘了眨眼睛，或者盯着看太久，那样对眼睛不好。轻轻地看“远”处的物体，自然用眼就好了。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;逆转近视的具体方法&lt;/strong&gt;&lt;a href=&quot;#逆转近视的具体方法&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;知道了原理，我们来看看具体怎么操作。&lt;/p&gt;
&lt;p&gt;最简单粗暴的逆转近视的方法，就是完全不戴眼镜。最近有一个 18 岁的年轻人，本来双眼近视 600 多度，听了我讲的原理之后，开始平时完全不戴眼镜（除了必须看清远处的时候），结果 3 个月之后度数降低了 100 度左右。&lt;/p&gt;
&lt;figure&gt;&lt;img /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img /&gt;&lt;/figure&gt;
&lt;p&gt;高度近视的人完全不戴眼镜生活，当然可能是相当痛苦的，所以我建议稍缓和的方式，也就是戴“低度数眼镜”。方法是这样，如果你近视 600 度，就把眼镜度数降低 100 度，配一副 500 度的眼镜，散光不要减。你戴上它之后看到的景象，就相当于一个只近视 100 度的人，生活几乎不受影响。&lt;/p&gt;
&lt;p&gt;100 度近视眼的清晰范围是 1m，所以你只要看 1m 以外的物体，都会达到逆转近视的效果。这副眼镜起到的效果，就是降低了算作“看远”的距离，把戴全度数眼镜算“看近”的地方，很多都变成了“看远”，这样看远的机会就大大增加了。&lt;/p&gt;
&lt;p&gt;所以方法就是配一副降 100 度的眼镜，平时都戴它就行了。几个月之后，近视度数应该会下降一些。如果你明显感觉看东西比以前清晰了，估计降了 50 度的时候，就去验光，配一副更低度数的眼镜，保持与实际度数 100 度的差距。如此良性循环……&lt;/p&gt;
&lt;p&gt;但降 100 度的眼镜看电脑可能就有点太清晰了，所以如果想见效快一些，可以再配一副降 150 度的眼镜。平时在外面戴降 100 度的眼镜，看电脑的时候换成降 150 度的眼镜，把屏幕放在 100/150 = 0.66m 以外稍有点模糊的地方。这样越是看电脑，视力越是变好。但我不建议把字全都用力看清楚，模糊就让它模糊着，也不要看得太累了，注意休息。&lt;/p&gt;
&lt;p&gt;另外需要注意的是，屏幕的字体不要设置得太大。很多人误以为大的字体可以保护视力，其实正好相反。大字体的视角太大，相当于是在看更加近的物体。把屏幕字体设置为正常大小，或者稍小一些，这样视角变小，就相当于在看更远的物体。久而久之，视力就改善了。&lt;/p&gt;
&lt;p&gt;因为大脑总是选择视力好的那只眼睛提供的图像，所以这个方法总是让视力较好的那一只眼睛变得更好，所以如果两只眼睛视力相差太多，就会更加不平衡。如果两只眼睛视力相差大于 50 度，需要配眼镜让两眼视力比较平均。&lt;/p&gt;
&lt;p&gt;这个方法会很缓慢，不要急于求成。想想你的近视是多少年形成的，所以逆转也不会很快。3 个月能逆转 25 度就已经很好了，这样一年就少了 100 度。因为肌肉在悄悄用力压眼球，所以要注意不要太用力看，不要过量。这跟健身不要过量的原理差不多。年龄超过 40 岁的人要特别小心，因为眼球的玻璃体开始老化，如果太过用力地看，可能会导致飞蚊症。如果你太拼，很短的时间之内视力提高了很多，那就应该提高警惕了，小心弄坏眼睛！&lt;/p&gt;
&lt;p&gt;我不确信这个方法适合所有人。虽然我认为眼睛应该不像普通认为的那样，成年就定型，但眼球可能确实有一个接近“定型”的年龄。超过年龄可能就不大容易逆转，或者非常缓慢。如果你尝试了一年还没有一点变化，那可能眼睛已经定型了。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;近视度数很高的情况&lt;/strong&gt;&lt;a href=&quot;#近视度数很高的情况&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;因为高度近视容易导致视网膜脱落之类的严重问题，所以如果超过了 800 度，最好是先去医院做个眼底检查，没有问题再小心，小剂量地尝试，切不可太用力看东西。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;近视度数很低的情况&lt;/strong&gt;&lt;a href=&quot;#近视度数很低的情况&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;如果你通过以上的方法，把近视度数减少到了 100 度，或者你的近视度数本来较低，比如低于 100 度，那么光是不戴眼镜，是比较难恢复到 1.0 视力的。这是因为度数太低的时候，外部肌肉产生的眼球形变很小，难以形成持续的改变。&lt;/p&gt;
&lt;p&gt;对于近视度数很低的情况，可以采用戴老花镜的办法。比如你近视 100 度，那么可以去买一个 50 度的老花镜。戴上之后就成了近视 150 度的视觉效果，所以你看 0.66m 以外的物体就会开始模糊。你每天戴着这个老花镜看屏幕，近视就会减少。等减少到一定程度，就再去买一个 100 度或者 150 度的老花镜来戴，直到恢复到 1.0 或者更好的视力。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;方便的视力评估方法&lt;/strong&gt;&lt;a href=&quot;#方便的视力评估方法&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;如果你试验了一段时间，怎么才能方便地知道有没有改善呢？总不能三天两头地去验光，视力表挂家里又太难看。我有个简单的办法，那就是在你经常坐的地方选择一个参照物，最好是上面有字的物体。比如我喜欢坐在沙发上看电视柜上的 Marshall 音箱的 logo，根据它的清晰程度，我就知道我的视力有没有改善。&lt;/p&gt;
&lt;p&gt;如果你想精确一些，可以拿一张有字的纸和一个钢卷尺，用卷尺测量每只眼睛能看清的距离。然后根据上面那个公式「近视度数 = 100/清晰距离」，就能得到大概的度数了。或者你光是记住你能看清的距离，用这个作为比较的基础也行。&lt;/p&gt;
&lt;p&gt;我不建议频繁地进行这种测量，因为改善的过程非常缓慢，可能起起伏伏，所以频繁测量会带来挫败感。最好是顺其自然，隔长一点时间测，这样也许会有惊喜的感觉。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;自然很重要&lt;/strong&gt;&lt;a href=&quot;#自然很重要&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;相比我这种完全“无为”的自然视力恢复法，网络上流传着好些其它方法，比如 EndMyopia 一类的。这些方法一般要求你做一些特定的事情，比如花很多时间做「Active Focus」一类的练习。有些方法让人瞪着眼睛使劲看远，甚至让人不眨眼，看得流泪还忍痛继续看。有些让人用“3D 立体图”来进行“交叉眼”练习，而且严重夸大改善的速度。&lt;/p&gt;
&lt;p&gt;这些方法让人以为必须做点什么，必须严格按照他们的说法来，才会有效果，却没搞清楚近视逆转的原理。我也曾经短时间尝试过某些这类练习，但后来我发现，它们都不是自然地在用眼，有可能造成严重的紧张，甚至导致眼睛受伤。后来我发现，其实什么特别的练习都不需要做，只把眼镜度数配低就行了。&lt;/p&gt;
&lt;p&gt;这类练习看似“自然”，其实可能是相当危险的。眼睛是有血肉的活物，而且是有弹性的，并不是像面团一样可以随意蹂躏成形的。它不可能在短时间之内就永久改变自己的形状，它可能受伤。疼痛是非常重要的信号，它让你停止伤害自己的行为。要是忽视疼痛的信号，就有可能受伤。所以我不推荐任何会导致眼睛不适的方法，我不相信任何宣扬“忍痛继续，坚持就是胜利”的人。要知道这个世界充满了骗子，他们可能是想害人。&lt;/p&gt;
&lt;p&gt;虽然我的做法除了配眼镜之外没有其他特别的练习，最大限度的接近了“自然用眼”，但仍然有可能因为眼镜度数太低，或者看太久，或者因为有一定“野心”而出现异常的疲劳或者疼痛。所以我建议，一旦出现疼痛或者异常的紧张，请立即停止当下的做法，充分休息。如果多次尝试之后仍然不舒服，可以稍提高眼镜的度数，比如只降低 75 度或者 50 度，等眼睛不适感消失，恢复自然之后再继续尝试。&lt;/p&gt;
&lt;p&gt;虽然你知道应该“自然”，但这个事情毕竟是有一些目的性在里面，所以有些人可能不自觉的会用眼过度，或者做一些强迫自己的事情。我总结了一下，有一些信号可以提醒自己，出现了不该做的事情：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;眼眶，太阳穴或眼球出现酸痛&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;视力出现模糊，之前看得清的东西现在看不清了&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;看东西有双影&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;眼睛对焦速度减慢&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;出现飞蚊&lt;/p&gt;
&lt;p&gt;遇到以上情况的话，你应该停下来休息。如果经常出现以上现象，就应该检查一下自己的做法了。比如，你是不是经常强迫眼睛去看清太远太模糊的物体？是不是盯着一个地方看太久？是不是忘了眨眼睛？是不是一直在努力看远，而没有看近的时候？等等。&lt;/p&gt;
&lt;h3&gt;&lt;strong&gt;参考资料&lt;/strong&gt;&lt;a href=&quot;#参考资料&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;W. H. Bates - Prefect Sight Without Glasses (&lt;a href=&quot;https://books.google.com.hk/books?id=MilnrDgQiwgC&quot;&gt;&lt;strong&gt;PDF 下载&lt;/strong&gt;&lt;/a&gt;)。中文版译名《不戴眼镜的完美视力》已出版。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Todd Becker - Myopia: A Modern Yet Reversible Disease（&lt;a href=&quot;https://www.youtube.com/watch?v=x5Efg42-Qn0&quot;&gt;&lt;strong&gt;讲座视频&lt;/strong&gt;&lt;/a&gt;）&lt;/p&gt;</content:encoded><category>category:随笔</category></item><item><title>Win11 光标变白消失解决方案（浏览器开启硬件加速后，在鼠标滑到文本处出现）</title><link>https://www.dreameverafter.com/en/post/win11-%E5%85%89%E6%A0%87%E5%8F%98%E7%99%BD%E6%B6%88%E5%A4%B1%E8%A7%A3%E5%86%B3%E6%96%B9%E6%A1%88-%E6%B5%8F%E8%A7%88%E5%99%A8%E5%BC%80%E5%90%AF%E7%A1%AC%E4%BB%B6%E5%8A%A0%E9%80%9F%E5%90%8E-%E5%9C%A8%E9%BC%A0%E6%A0%87%E6%BB%91%E5%88%B0%E6%96%87%E6%9C%AC%E5%A4%84%E5%87%BA%E7%8E%B0</link><guid isPermaLink="false">en:win11-光标变白消失解决方案-浏览器开启硬件加速后-在鼠标滑到文本处出现</guid><description>直接上除了等官方修复（我等了三年）以外的终极方案。（1）打开记事本，复制粘贴下面的代码，保存为win11Fix.reg, 注意文件扩展名必须式reg，文件名可以任意Windows Registry Editor Version 5.00 [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Dwm] &quot;OverlayTestMode&quot;=dword:00000</description><pubDate>Mon, 30 Jun 2025 14:14:03 GMT</pubDate><content:encoded>&lt;p&gt;直接上除了等官方修复（我等了三年）以外的终极方案。&lt;/p&gt;
&lt;p&gt;（1）打开记事本，复制粘贴下面的代码，保存为win11Fix.reg, 注意文件扩展名必须式reg，文件名可以任意&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;Windows Registry Editor Version 5.00&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Dwm]&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&quot;OverlayTestMode&quot;=dword:00000005&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;（2）双击运行刚才保存的Fix.reg文件，一直点确认，直至注册表修改完成。&lt;/p&gt;
&lt;p&gt;（3）重启电脑&lt;/p&gt;
&lt;p&gt;如果使用上边的代码，出现了其他问题，可以使用下面的代码，将注册表重置到系统一开始的默认值。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;Windows Registry Editor Version 5.00&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Dwm]&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&quot;OverlayTestMode&quot;=-&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;blockquote&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;a href=&quot;https://www.bilibili.com/opus/732416349359308857?spm_id_from=333.1007.0.0&quot;&gt;引用：Win11 光标变白消失解决方案&lt;/a&gt;&lt;/p&gt;</content:encoded><category>category:随笔</category></item><item><title>Terminal里用option/alt + 鼠标点击，就可以让光标到指定位置</title><link>https://www.dreameverafter.com/en/post/terminal-li-yong-option-alt-shu-biao-dian-ji-jiu-ke-yi-rang-guang-biao-dao-zhi-ding-wei-zhi</link><guid isPermaLink="false">en:terminal-li-yong-option-alt-shu-biao-dian-ji-jiu-ke-yi-rang-guang-biao-dao-zhi-ding-wei-zhi</guid><description>如题，我居然才知道这个技巧。。</description><pubDate>Mon, 23 Jun 2025 03:15:23 GMT</pubDate><content:encoded>&lt;p&gt;如题，我居然才知道这个技巧。。&lt;/p&gt;</content:encoded><category>category:随笔</category></item><item><title>60个经典心理学效应</title><link>https://www.dreameverafter.com/en/post/jing-dian-xin-li-xue-xiao-ying</link><guid isPermaLink="false">en:jing-dian-xin-li-xue-xiao-ying</guid><description>为什么会情人眼里出西施？为什么Dating场景通常布置成灯光昏暗状？为什么人会屡战屡败？为什么自我暗示会有效果？“男女搭配，干活不累”有没有科学解释？.....人类社会的很多奇妙现象与行为均可归结为人的心理活动，以及由此产生的行为，都可以通过心理学进行解释。 有关成长认知的效应 1. 习得性无助（屡</description><pubDate>Wed, 16 Apr 2025 03:30:52 GMT</pubDate><content:encoded>&lt;p&gt;为什么会情人眼里出西施？为什么Dating场景通常布置成灯光昏暗状？为什么人会屡战屡败？为什么自我暗示会有效果？“男女搭配，干活不累”有没有科学解释？…人类社会的很多奇妙现象与行为均可归结为人的心理活动，以及由此产生的行为，都可以通过心理学进行解释。&lt;/p&gt;
&lt;h2&gt;有关成长认知的效应&lt;a href=&quot;#有关成长认知的效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;1. 习得性无助（屡次碰壁后放弃）&lt;a href=&quot;#1-习得性无助屡次碰壁后放弃&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指个人经历了失败与挫折后,面临问题时产生的无能为力、丧失信心的心理状态与行为。[由宾夕法尼亚大学的Martin E.P.Seligma（1942-）先后与J.Bruce Overmier、科罗拉多大学博尔德分校的Steven F.Maier在1967年的动物实验中首次提出。]&lt;/p&gt;
&lt;p&gt;案例：嘟嘟小时候总是有很多理想，可每当他将理想告诉爸爸时，爸爸总是说“你看你…不是那块料；你…这不现实；…”，有时，甚至还要挨揍，后来嘟嘟就再也没提自己的梦想了…&lt;/p&gt;
&lt;h3&gt;2. 皮格马利翁效应（所愿即所得）&lt;a href=&quot;#2-皮格马利翁效应所愿即所得&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;亦称期望效应、罗森塔尔效应，指人们基于对某种情境的知觉而形成的期望或预言，会使该情境产生适应这一期望或预言的效应。你期望什么，你就会得到什么，很多当下所得其实是过去的“未来期待”产生的结果。简而言之，就是对期望的心理暗示，可以促使人们的认知和行为发生同向改变，进而使该期望得以实现。[由美国心理学家、哈佛大学教授RobertRosenthal（1933-）和他的学生A. L. Jacobson，于1968年进行的7项小学教育实验后提出。]&lt;/p&gt;
&lt;p&gt;案例：小时候，由于班里同学平均颜值都很高，爸妈敏锐地发现妮妮对自己的外貌不是很自信，后来爸妈和老师都常对她说：“妮妮，你长得可真漂亮，而且成绩也在进步，真为你开心！”，于是妮妮自信心越来越足，每天照镜子的时候，也觉得自己变美了。渐渐地，妮妮真的越来越自信、漂亮了，而且对自己要求越来越高，连成绩也越来越好了。&lt;/p&gt;
&lt;h3&gt;3. 阿伦森效应（得到赞扬就开心，失去赞扬就灰心）&lt;a href=&quot;#3-阿伦森效应得到赞扬就开心失去赞扬就灰心&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指随着奖励减少而导致态度逐渐消极，随着奖励增加而导致态度逐渐积极的心理现象。表现为人们喜欢那些对自己的喜欢、奖励、赞扬不断增加的人或物，而不喜欢那对自己的喜欢、奖励、赞扬不断减少的人或物。[由美国社会心理学家Elliot Aronson（1932-）提出。]&lt;/p&gt;
&lt;p&gt;案例：工业区大院里有个大旧油罐，中午放学后孩子们都喜欢到罐子里蹦蹦跳跳，声音扰人，很多人劝阻都无济于事，小孩反而愈加闹腾。一天，一位老爷爷说，我们来打个赌，谁跳的最大声，谁就可以拿到一把玩具枪，结果果然获胜者成功拿奖。第二天，老爷爷把礼物改成了两颗奶糖，孩子们没多大兴趣，敷衍的跳了跳，胜者拿走了奶糖。第三天，老爷爷把礼物改成了两颗花生，结果孩子们不愿意了，纷纷表示“不玩了，不玩了，没意思，要回家看电视去”。老爷爷通过巧妙的心理弱化效应，竟然把困扰大家的“熊孩子闹腾”解决了。&lt;/p&gt;
&lt;h3&gt;4. 南风效应（温暖待人）&lt;a href=&quot;#4-南风效应温暖待人&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;也称温暖法则，指人际交往中，温和的沟通方式可以让人觉得心理舒适，而“冰冷”的沟通方式则会让人反感。源于法国作家拉•封丹(Jean de la Fontaine（1621-1695）)写过的一则寓言：北风和南风比威力，看谁能把行人身上的大衣脱掉。详细而言，人际沟通中要注重尊重和关心，讲究方法，温和相处。该故事中，北风和南风比威力，看谁能把行人身上的大衣脱掉。北风首先来一个冷风凛凛寒冷刺骨，结果行人为了抵御北风的侵袭，便把大衣裹得紧紧的。南风则徐徐吹动，顿时风和日丽，行人因为觉得很暖和，所以开始解开钮扣，继而脱掉了大衣。&lt;/p&gt;
&lt;p&gt;北风首先来一个冷风凛凛、寒冷刺骨，结果行人为了抵御北风的侵袭，便把大衣裹得紧紧的。南风则徐徐吹动，顿时风和日丽，行人觉得春暖上身，始而解开纽扣，继而脱掉大衣，南风获得了胜利。&lt;/p&gt;
&lt;p&gt;南风之所以能达到目的，是因为它顺应了人的内在需要。&lt;/p&gt;
&lt;p&gt;在恋爱中，与其指责抱怨对方，不如温暖他。找到对方的内心需求点，真诚的去满足对方的需求，让对方感受到被接纳，同时对方也会反过来更加的去包容你。&lt;/p&gt;
&lt;p&gt;案例：你希望朋友帮你做某件事情，如果你使用要求、使唤的口气可能对方不一定愿意，但如果你好好地和对方说话，夸奖一下对方，对方通常会答应帮助你，与伴侣、陌生人相处也适用。&lt;/p&gt;
&lt;h3&gt;5. 酸萄萄效应（阿Q精神）&lt;a href=&quot;#5-酸萄萄效应阿q精神&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指当一个人自身真正的需求无法得到满足而产生挫折感时，为解除内心不安，编造一些“理由”自我安慰，以消除紧张，减轻压力，使自己从不满、不安等消极心理状态中解脱出来，保护自己免受伤害的现象。[源自古希腊哲学家、文学家Aesop（前620-前560）所著的《伊索寓言》中的&amp;lt;狐狸与葡萄&amp;gt;寓言故事。据古希腊历史学家ΗΡΟΔΟΤΟΣ（前480年─前425）记载，Aesop曾是Samos Island岛上雅德蒙家的奴隶，被多次转卖后因知识渊博而获得自由，并环游世界为人们讲述寓言故事，后来被德尔菲人杀害。]&lt;/p&gt;
&lt;p&gt;案例：阿Q被人打得不轻，又不敢还手，于是在心里说“总算被X子打了！”开心地抹去嘴角的血丝，头发飘逸着走了。&lt;/p&gt;
&lt;h3&gt;6. 自我参照效应（这是干货，我得记下来）&lt;a href=&quot;#6-自我参照效应这是干货我得记下来&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指记忆材料与自我相联系时的记忆效果优于其它编码条件的现象。如在接触新东西的时候，如果它与我们自身有密切关系的话，学习的时候就有动力，而且不容易忘记。 [由美国心理学家Carl Ransom Rogers（1902-1987）和Kuiper等人于1977年提出。]&lt;/p&gt;
&lt;p&gt;案例：嘟嘟最近在学习设计，在图书馆偶然看到一本不错的设计教程时，爱不释手，花两天时间就学完了，对其中的要点记忆犹新。&lt;/p&gt;
&lt;h3&gt;7. 角色效应（我爸是X刚）&lt;a href=&quot;#7-角色效应我爸是x刚&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指当一个人处于某种角色或角色发生改变时，通常会因这种角色（或角色的改变）而引起的心理或行为变化的现象。[最早出处不详，由日本心理学家长岛真夫等人在研究班级指导对”角色“加工的意义时得到验证。]&lt;/p&gt;
&lt;p&gt;案例：曾经贪玩捣蛋的哆哆，自从当上班长后，因为自己的角色的转变，不仅表现得学习认真，还积极主持班里的各项事务，主动组织班级公益活动，责任感和自信心都增强了，跟之前判若两人。&lt;/p&gt;
&lt;h3&gt;8. 锐化效应（观念影响认知过程）&lt;a href=&quot;#8-锐化效应观念影响认知过程&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指人的既有价值观能对其知觉具有促进作用的现象。具体而言，当在社会知觉过程中，人们的价值在知觉对象前如被激活，这种价值观对其知觉作用是十分明显的。[由新西兰情绪心理学家Strongman,K.T.在其“知觉存在”实验中提出。]&lt;/p&gt;
&lt;p&gt;案例：如从小老师就教学生要讲诚信，这就会使学生在以后的知觉过程中，按照这个诚实的价值观去判断、去知觉，该时出现那怕是十分微不足道的带有诚实信息的表现，我们就会被内隐的个性观唤醒，认为这是一个诚实的人，而且还可能具有善良、热爱、随和、温柔等品质。&lt;/p&gt;
&lt;h3&gt;9. 奖惩效应（胡萝卜加大棒）&lt;a href=&quot;#9-奖惩效应胡萝卜加大棒&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指通过对目标人行为实施外部强化或弱化手段，可影响其自身评价等心理活动，进而带来其行为的强化或弱化的现象。详细而言，表扬、鼓励和信任，往往能激发一个人的自尊心和上进心；得体、适度、就事论事的惩罚措施可促使一个人对错误行为的改过等。[出处不详，一般认为是基于历史经验和心理学实验而得。]&lt;/p&gt;
&lt;p&gt;案例：童年哆哆的父母对他的学习采取奖励与兴趣引导措施，同时对生活中较严重的过错采取惩罚措施，长大后，哆哆成了一个人格完整、好学上进的人。&lt;/p&gt;
&lt;h2&gt;有关现象的效应&lt;a href=&quot;#有关现象的效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;10. 霍桑效应（被关注时自我暗示）&lt;a href=&quot;#10-霍桑效应被关注时自我暗示&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指当人们在意识到自己正在被关注或者观察的时候，会刻意去改变一些行为或者是言语表达的心理。[由哈佛大学教授George Elton Mayo（1880-1949）为首的研究小组在1924-1933年间开展的实验研究提出，命名自当时研究所在的美国西部电气公司座落在芝加哥的一间工厂名“Hawthorne”。]&lt;/p&gt;
&lt;p&gt;案例：Club上，与胡侃正High的哆哆，转眼看到心中女神学姐在看自己时，立马整理了自己的衣装，变得安静、绅士起来，还礼貌的打了个招呼。&lt;/p&gt;
&lt;h3&gt;11. 搭便车效应（坐享其成）&lt;a href=&quot;#11-搭便车效应坐享其成&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;是指在利益群体内，某个成员为了本利益集团的利益所作的努力，集团内所有的人都有可能得益，但其成本则由这个人个人承担，这就是搭便车效应。[由美国经济学家、马里兰大学教授Mancur Olson (1932-1998) 于1965年发表的《The Logic of Collective Action Public Goods and the Theory of Groups》一书中首次提出。]&lt;/p&gt;
&lt;p&gt;案例：懒人村里住着很多人家，门口的马路常年失修，一到下雨泥泞不堪，但是大家都不愿自己掏钱去修，刚买新车回村的嘟嘟实在不堪忍受，自己一人把路给修了，于是，整个村子都有了整洁的路走，村里啥也没贡献的那些懒人们顺利“搭便车了”。&lt;/p&gt;
&lt;h3&gt;12. 棘轮效应（由奢入俭难）&lt;a href=&quot;#12-棘轮效应由奢入俭难&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指人的消费习惯形成之后有不可逆性，呈现出“向上调整容易”，而“向下调整难”的现象。[可追溯中国宋代政治家和文学家司马光（1019-1086）《训俭示康》中“由俭入奢易，由奢入俭难”的内容。现代则由美国经济学家J.S.Duesenberry在其《收入、储蓄的消费行为理论》中提出。]&lt;/p&gt;
&lt;p&gt;案例：哆哆从小穿惯了一线品牌的服装，突然有一天妈妈说，咱们现在家里经济困难，咱们要改穿快时尚品牌了，结果哆哆想到没法跟同学攀比了，觉得痛不欲生，每次出门都是巨大的煎熬。&lt;/p&gt;
&lt;h3&gt;13. 墨菲定律（概率大于零的事，均可能发生）&lt;a href=&quot;#13-墨菲定律概率大于零的事均可能发生&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指凡是可能出错的事有很大几率会出错，即任何一件事情，只要其发生的概率大于零，该事情总会（迟早）在某一时刻发生。启示人们做事情一方面要对错误保持平常心，一方面也要防微杜渐，不存侥幸。[最早源自1949年，美国空军上尉工程师Edward A. Murphy的对他的某位运气不太好的同事随口开的玩笑：“如果一件事有可能被做坏，让他去做就一定会更坏。”1992年，由Edward A. Murphy正式提出。]&lt;/p&gt;
&lt;p&gt;案例1：嘟嘟觉得从下地铁到上高铁只需要5分钟，结果地铁安检排队花了20分钟，上楼候车大厅的上行电梯竟然也坏了（颇有屋漏偏逢连夜雨的感觉）。&lt;/p&gt;
&lt;p&gt;案例2：小姐姐喜欢一位小哥哥，于是约他到家里做客，让他过来修自己刚故意弄坏的电脑键盘，并新切了果盘，准备一起打游戏。结果…这小哥哥一修好键盘，就飞奔着跟他的伙伴们打球去了。&lt;/p&gt;
&lt;h3&gt;14. 野马结局（小事扩大化）&lt;a href=&quot;#14-野马结局小事扩大化&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指因一些细微小事情而造成情绪的巨大波动，以致因他人的外在因素导致自己受伤害的现象。理论证明人的情绪是有成本的，情绪是人选择的结果。吸血蝙蝠吸取野马的血为食，但所吸的血量极少，远不足以使野马死去，野马的死因是暴怒和狂奔。美国密歇根大学心理学家Nandi Nelson研究表明，人一生有十分之三的时间处于情绪不佳状态，学会与消极情绪作斗争非常重要；加州大学心理学教授Robert Saye和匹兹堡大学医学中心教授Rolade Dahl都认为尊重‘生物节奏’ ，保证充足的作息规律和睡眠质量，可降低负面情绪的发生。&lt;/p&gt;
&lt;p&gt;因芝麻小事而大动肝火，以致因别人的过失而伤害自己。很多时候，我们要想明白到底为了什么而生气和焦虑，不要因别人的过失而伤害自己。&lt;/p&gt;
&lt;p&gt;案例：哆哆爸爸忘了把喝完的水杯洗了，哆哆更年期的妈妈见到立马“原地爆炸”，说哆哆爸爸不注重家庭秩序、不懂得体谅人，还要把历史上有关家庭卫生的事情拿出来数落爸爸一番…爸爸安静地在看电视，可哆哆妈妈却气的不行，打电话跟哆哆姐姐继续数落他爸爸一小时。&lt;/p&gt;
&lt;h3&gt;15. 巴纳姆效应（为何不少人迷信星座？）&lt;a href=&quot;#15-巴纳姆效应为何不少人迷信星座&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;也称福勒效应、星相效应。指一部分人常常认为一种笼统的、一般性的人格描述十分准确地揭示了自己的特点的现象。详细而言，当用一些普通、含糊不清、广泛的形容词来描述一个人时，一些认知有限，或缺乏独立思考和理性思维的人往往很容易接受这些描述，并认为描述中所说的就是自己。巴纳姆效应从反面揭示了一部分人因认知缺陷而迷信星座命理学的奥秘。遗憾的是，很多人歪曲利用该理论大肆宣传“星座命理学”的有效性，这类宣传也常被称为“伪心理学”。[可追溯到古代的星相学、占星术；现代由心理学家Bertram Forer于1948年对学生进行一项人格测验证明。此后被心理学家Paul Meehl以19世纪美国著名杂技演员“ Barnum ”的名字命名，源自P.T. Barnum（1810-1891）曾对自己表演总结为：“我之所以很受欢迎，是因为节目中包含了每个人都喜欢的成分，使得每一分钟都有人上当受骗。”]&lt;/p&gt;
&lt;p&gt;案例：某汽车品牌赞助某知识类自媒体节目、科学论坛等，观众容易产生该汽车与知识青年身份、群体的关联，进而产生开该汽车品牌都是知识青年的联想，一些知识分子更是坚定的选择购买该品牌的车，实际二者无任何本质联系。&lt;/p&gt;
&lt;h3&gt;16. 从众效应（跟风现象）&lt;a href=&quot;#16-从众效应跟风现象&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;也称羊群效应。指人在社会群体中容易不加分析地接受大多数人认同的观点或行为的心理倾向。[由美国心理学家Solomon E.Asch（1907-1996）于1952年进行的实验证明。其结果显示，有76%的人至少做了一次从众的判断，还有24%的人一直没有从众，平均有33%的人判断是从众的。]&lt;/p&gt;
&lt;p&gt;案例1：妮妮看到公司很多人都剪了短发，自己不顾自己脸型适合长发的事实，也跟着剪了短发，随后又后悔不已。&lt;/p&gt;
&lt;p&gt;案例2：传说有一种面包游戏，由于面粉是垄断经营且限70袋批发，加上拍卖模式，面粉价格屡创新高。与此同时，票号印票、投机炒作成瘾，导致面包价格连年攀高。直到，一些面包尚实在卖不动了，就临时雇退休广场舞大爷大妈到面包店里表演抢购，好些消费者开心成交，其中不乏首付是“四个养老金荷包”赞助的、首付的一半是借来的…，为了维持面包价格，又推出面包限买、贵族面包、秀才面包等概念…特别有意思。&lt;/p&gt;
&lt;h3&gt;17. 旁观者效应（人成群会降低责任感）&lt;a href=&quot;#17-旁观者效应人成群会降低责任感&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;也称责任分散效应，指对某一件事来说，如果是单个个体被要求单独完成任务，责任感就会很强，会作出积极的反应。但如果是要求一个群体共同完成任务，群体中的每个个体的责任感就会很弱，面对困难或遇到责任往往会退缩的现象。[由心理学家Bibb Latane于1970年，随后在Bibb Latane和John Darley 进行的多项实验研究中证明。]&lt;/p&gt;
&lt;p&gt;案例：一位乘客坐过了站而迁怒于司机，严重干扰了司机的驾驶状态，酿成了交通悲剧，而引人深思的是，在这位乘客与司机争吵的几分钟内，车内竟无人上前进行制止。&lt;/p&gt;
&lt;h3&gt;18. 破窗效应(恶习总易被模仿)&lt;a href=&quot;#18-破窗效应恶习总易被模仿&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指不良现象如果被放任存在，会诱使人们仿效，甚至变本加厉的现象。[源自美国斯坦福大学心理学家Philip Zimbardo于1969年进行了一项汽车实验的结果证明。根据此实验，政治学家James Q. Wilson和犯罪学家George L. Kelling正式提出该理论，并通过《Broken Windows》一文发表于1982年3版《The Atlantic Monthly》杂志。]&lt;/p&gt;
&lt;p&gt;案例：如果一些面户外墙上的一些涂鸦没有及时清理，很快墙上就布满了乱七八糟、不堪入目的新涂鸦。&lt;/p&gt;
&lt;h3&gt;19. 鸟笼效应（为多余物品添搭档）&lt;a href=&quot;#19-鸟笼效应为多余物品添搭档&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指人们会在偶然获得一件原本不需要的物品的基础上，继续添加更多与之相关而自己不需要的东西的行为。[源自1907年，同时从哈佛大学退休的詹姆斯教授和好友物理学家卡尔森的打赌。一天，詹姆斯告诉卡尔森：“我一定会让你不久就养上一只鸟的。”卡尔森不以为然：“我不信！”，过几日，卡尔森生日，詹姆斯送来了一只精致的鸟笼作为礼物。心领神会的卡尔森笑了：“我只当它是一件漂亮的工艺品，你就别费劲了！”然而，此后每逢客人来访，看到桌上的鸟笼，都会问卡尔森：“教授，你养的鸟什么时候死了？”卡尔森只好一次次地向客人解释：“我从来就没有养过鸟。”但回答总让客人投以不信任的目光，最后，卡尔森教授只好买了一只鸟。詹姆斯的打赌奏效了。]&lt;/p&gt;
&lt;p&gt;案例：表姐给妮妮送了一只小白兔，有洁癖的妮妮习惯养花草，但不愿意养宠物，可送来的活物又没法送人，于是自己只得去楼下宠物超市给它买吃的，打算第二天送人，结果第二天没送出去，第三天放学回家，看到小兔冷的有点发抖，于是自己又给小兔买了小窝，以及一些玩具，慢慢的，妮妮竟然离不开兔子了。&lt;/p&gt;
&lt;h3&gt;20. 贝勃规律（预先刺激可形成感知迟钝）&lt;a href=&quot;#20-贝勃规律预先刺激可形成感知迟钝&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;“贝勃规律”指就是人们一开始受到的刺激越强，对以后的刺激也就越迟钝。即第一次刺激能缓解第二次的小刺激。简单而言，就是一件事物存在着边际效用递减的规律。[出自A.科林·卡梅伦等著的《用Stata学微观计量经济学》。]&lt;/p&gt;
&lt;p&gt;案例1：晚上妈妈包了羊肉饺子，哆哆吃第一个时，觉得美味极了，满足感爆棚，吃到第10个时，觉得味道依然不错，当吃到到第20 个时，哆哆觉得饺子不怎么好吃了，当吃到第25个时，哆哆都不知道自己吃的是啥了。&lt;/p&gt;
&lt;p&gt;案例2：人们对火车票价由200元涨到250元会十分敏感，但经历这次涨价之后，如果房价涨了100万甚至200万元，人们竟然觉得涨幅不是很大。又如，公司欲裁掉公认的某影响极坏的重要职员时，应该先大范围地做一些人员调整或辞职，最后再将目标指向裁员目标，通过心理刺激降低其落差感，实现温和减员。&lt;/p&gt;
&lt;h3&gt;21. 冷热水效应（巧用心理反差出惊喜）&lt;a href=&quot;#21-冷热水效应巧用心理反差出惊喜&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指人们对事物的评判标准会随着心理的变化而变化，这种标准的变化又通常会影响人们对事物的感知。[原指“先将手放在冷水中，再放到温水中，会感到温水热；当先将手放在热水中，再放到温水中，会感到温水凉，同一杯温水，出现了两种不同的感觉的现象”，由中国作家高兴宇提出，并发表于《演讲与口才》2001年第6期。]&lt;/p&gt;
&lt;p&gt;案例：哆哆对市场很有信心，想给老板来个惊喜，于是在业绩目标中设定了一个较低的10万元目标，经过努力，到月底业绩总结时，哆哆完成了30万的业绩，深得老板肯定，顺利升主管。&lt;/p&gt;
&lt;h3&gt;22. 瀑布心理效应（无意之词，主动“躺枪”）&lt;a href=&quot;#22-瀑布心理效应无意之词主动躺枪&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;某人一句随便说出的话，却弄得别人十分“不平静”，导致态度行为的变化等，有点“一石激起千层浪”的意味。这种现象在心理学上，被称之为“瀑布心理效应”，正象大自然中的瀑布一样，上面平平静静，下面却溅花腾雾。[理论具体出处不详。]&lt;/p&gt;
&lt;p&gt;案例1：996艰难创业的你听到王首付慷慨陈词“年轻人，要先定一个小目标，比如一个亿”，然后你就开始想：“是啊，我们公司一帮人辛辛苦苦每年才赚300万，真的是太差劲了…”然后整个人都不好了。&lt;/p&gt;
&lt;p&gt;案例2：一天，你正娴熟的打开冰箱打算顺老板的茶喝，听到不远处一声惊呼：“抓…快抓住他！”，你赶紧迅雷不及掩耳之势关掉冰箱，装作欣赏窗外的美景。回头看，老板和前台MM正在追打一只乱入公司的老鼠呢，额~虚惊一场！&lt;/p&gt;
&lt;h3&gt;23. 心理摆效应（犹豫矛盾）&lt;a href=&quot;#23-心理摆效应犹豫矛盾&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指在特定背景的心理活动过程中，感情的等级越高，呈现的心理坡度越大，因此就很容易向相反的情绪状态进行转化，表现为多度性和两极性。[可追溯至《儒林外史》中范进的乐极生悲等文学描述，理论具体出处不详。]&lt;/p&gt;
&lt;p&gt;举例：几乎每个人都会遇到这种情况，同朋友聚会时热闹得快快乐乐，自己单独一人时又孤寂得冷冷清清；出去玩一场觉得很开心，可回来后又为日常生活的单调枯燥而心烦。&lt;/p&gt;
&lt;h3&gt;24. 视网膜效应（眼随心境）&lt;a href=&quot;#24-视网膜效应眼随心境&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指当人们产生某种特别的需要或心向时，就会对需要的对象产生浓厚的兴趣，自然或不自然的去留意相关信息，而无意识地过滤掉无关信息，产生选择性注意的现象。[基于卡内基训练创始人Dale Carnegie（1888-1955）提出的一个论点发展而来，Dale Carnegie认为，每个人的特质中大约有80%是长处或优点，而20%左右是我们的缺点。当一个人只知道自己的缺点，而不知发掘优点时，“视网膜效应” 就会促使这个人发现他身边许多人也有类似的缺点，进而无法改善他的人际关系，生活也不快乐。]&lt;/p&gt;
&lt;p&gt;案例：为了彰显个性，嘟嘟定了一辆稀有的原厂紫色汽车，赢得了好多回头率。但与此同时，他每次在外面都会无意识地关注身边的紫色汽车，渐渐地，由于这种过度的聚焦关注，他竟然觉得身边紫色汽车一下子多了好多，而实际上并没有。&lt;/p&gt;
&lt;h3&gt;25. 安慰剂效应（喝水能治病你信不？）&lt;a href=&quot;#25-安慰剂效应喝水能治病你信不&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;又名伪药效应、非特定效应，指病人虽然获得无效的治疗，但却基于“对治疗的预期”或“对医务人员的信任”而产生了一定的积极反应，而让病患症状得到舒缓的现象。[由美国著名医学家、麻醉师Henry K. Beecher（1904—1976）于1955年提出。该理论虽源于医学，但实际上安慰剂效应在医学界尚存争议。]&lt;/p&gt;
&lt;p&gt;案例：春夏之交，原生都市孩纸哆哆、妮妮和同学们到野外郊游，为眼前清澈的泉水、碧绿的草地和迷人的风景所深深吸引，休息时，哆哆很高兴地接过妮妮递过来的水壶喝了一大口，情不自禁地感叹道“山里的水真甜”，其实他喝的还是妮妮从城里带来的水呢。&lt;/p&gt;
&lt;h3&gt;26. 多米诺骨牌效应（系统内部连锁反映）&lt;a href=&quot;#26-多米诺骨牌效应系统内部连锁反映&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;在一个存在内部联系的体系中，一个很小的初始能量就可能导致一连串的连锁反应。强调的是事物间的传递性、连续性。”[“多米诺”骨牌可追溯至中国宋宣宗二年（1120年）民间出现了一种名叫“骨牌”的游戏，1849年，一位名叫“多米诺”的意大利传教士把这种骨牌带回了米兰，并于19世纪发展成一项世界性的运动。“多米诺骨牌效应”名称正源于此。1950年4月24日，时任美国总统Harry S. Truman（1884-1972）批准了一份名为《美国关于印度支那的立场的文件》，首次以政策文件的方式表述了多米诺理论的基本内涵。文件指出：“如果印度支那被GCD政府控制，其邻国泰国和缅甸也将落入GCD统治之下。”又于1954年，由美国时任总统Dwight David Eisenhower（1890-1969）进行了详细阐述。随后逐渐用于分析心理学现象。]&lt;/p&gt;
&lt;p&gt;案例1：有一次和男友的朋友们聚会的时候，所有人的女朋友都化妆了，只有妮妮是素颜的。男友当下有些不高兴，但是也没有多说什么。从那次开始，两人就时不时有些小的争吵，后来变成了大吵，最终两人竟以骂战结束了恋情。&lt;/p&gt;
&lt;p&gt;案例2：2008年美国的次贷危机逐渐扩散，形成了全球性的金融危机。&lt;/p&gt;
&lt;h3&gt;27. 蔡格尼克记忆效应（半途而废或求成心切）&lt;a href=&quot;#27-蔡格尼克记忆效应半途而废或求成心切&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;1927年，心理学家蔡格尼克做了一个实验&lt;/p&gt;&lt;div&gt;&lt;/div&gt;，同时演算相同的数学题。其间让A组顺利演算完毕，而B组演算中途，突然下令停止。然后让两组分别回忆演算的题目，B组明显优于A组。这种未完成的不爽深刻的留存于B组人的记忆中，久搁不下。而那些已完成的人，“完成欲”得到了满足，便轻松地忘记了任务。&lt;p&gt;&lt;/p&gt;
&lt;p&gt;这种解答未遂的问题，深刻地留存在记忆中的心态叫蔡戈尼效应。&lt;/p&gt;
&lt;p&gt;蔡格尼克记忆效应同样适用于恋爱心理当中，很多人即便是恋爱或者结婚后也很难忘怀曾经追求过、但是却没追上的人，这是因为我们总是对那些已完成了的、已有结果的事情极易忘怀，而对中断了的、未完成的、未达目标的事情却总是记忆犹新。&lt;/p&gt;
&lt;p&gt;所以，如果发现你的男朋友或者女朋友，仍然在试图跟那些他们曾经没追上的人联系的时候，不用过分在意，因为这并不代表他们还深爱着对方，他们只不过是被蔡格尼克效应所困扰而已。&lt;/p&gt;
&lt;p&gt;案例1：哆哆为了赢得游戏年度总冠军，没日没夜的打游戏，最终导致病倒在床而失去比赛机会。&lt;/p&gt;
&lt;p&gt;案例2：妮妮觉得体型训练好痛苦，每次到点去健身房上课时，又默默地刷起了微博、抖音、知乎，最终一年下来，妮妮还是保持原样。&lt;/p&gt;
&lt;h3&gt;28. 超限效应（你说够了没有?）&lt;a href=&quot;#28-超限效应你说够了没有&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指刺激过多、过强或作用时间过久，从而引起心理极不耐烦或逆反的心理现象，超限效应带给人们很多启示，如演讲时抓住听众的关键在开始的三分钟，有效的交流时间是30分钟内。此外，批评人适宜采取幽默式批评，且批评与鼓励应该同步。[具体理论研究出处不详]&lt;/p&gt;
&lt;p&gt;案例：哆哆因为一次成绩没考好，被妈妈重复数落了半小时，也不听哆哆解释，最后哆哆气得摔门而出，半夜妈妈又不情愿地把他从同学家哄了回来。&lt;/p&gt;
&lt;h2&gt;有关行为处事的效应&lt;a href=&quot;#有关行为处事的效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;29. 空白效应（空白产生美）&lt;a href=&quot;#29-空白效应空白产生美&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指人在感知事物时，如果感知对象不完整，便会自然地运用联想，在头脑中对不完整的感知对象进行自我补充。并且在进行这种联想和补充的过程中，会产生更加强烈的心理效应，印象变得更加深刻的现象。[空白效应最早在艺术领域应用，可追溯至中西方古代绘画作品中的留白手法，从教育视角看，可追溯至法国作家Alphonse Daudet（1840-1897）在《最后一课》中对主人翁韩麦尔先生的描写，随后用于心理学等领域。]&lt;/p&gt;
&lt;p&gt;案例：在演讲的过程中，适当地留一些空白，会取得良好的演讲效果。&lt;/p&gt;
&lt;h3&gt;30. 拆屋效应（人们惯于接受折中）&lt;a href=&quot;#30-拆屋效应人们惯于接受折中&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指先提出很大、较多的要求，接着提出较小、较少的要求，最后使双方达成协议的现象。[可追溯至鲁迅先生于1927年在《无声的中国》一文中的内容：“中国人的性情总是喜欢调和、折中的、譬如你说，这屋子太暗，说在这里开一个天窗，大家一定是不允许的，但你主张拆掉屋顶，他们就会来调和，愿意开天窗了“。理论首次由J.L.Freedman和S.C.Fraser于1966年做的“无压力的屈从——登门槛技术”的现场实验中提出。]&lt;/p&gt;
&lt;p&gt;案例：供应商一开始报价了一个很高的报价，并表示价格是底价了，当你表示已经有合作单位时，对方往往会给出一个很有诚意的惊喜低价。&lt;/p&gt;
&lt;h3&gt;31. 登门槛效应（任务由易到难好推进）&lt;a href=&quot;#31-登门槛效应任务由易到难好推进&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;又称得寸进尺效应，指一个人一旦接受了他人的一个微不足道的要求，为了避免认知上的不协调，或想给他人以前后一致的印象，就有可能接受更大的要求。 [与“拆屋效应”类似，也是首次由J.L.Freedman和S.C.Fraser于1966年做的“无压力的屈从——登门槛技术”的现场实验中提出。具体区别：拆屋效应中的目标者，对满足行动者的要求有较大预期，而登门槛效应中的目标者，对满足行动者的要求较小预期，因此导致看似矛盾的差异。]&lt;/p&gt;
&lt;p&gt;案例：嘟嘟不愿接受较高较难的要求，因为它费时费力又难以成功，相反，他却乐于接受较小的、较易完成的要求，在实现了较小的要求后，再慢慢地接受较大的要求。&lt;/p&gt;
&lt;h3&gt;32. 关系场效应(三个臭皮匠还是三个和尚？)&lt;a href=&quot;#32-关系场效应三个臭皮匠还是三个和尚&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;在角色群体的活动效率中，既可能产生增力作用，也可能导致减力作用。这种由不同的角色扮演者组成的群体产生的内聚力或摩擦力，在社会心理学中，统称为“关系场效应”。增力如“三个臭皮匠，赛过诸葛亮”，减力如“三个和尚没水喝”。[可追溯至很多中西方的古代历史故事，现代理论具体出处不详。]&lt;/p&gt;
&lt;p&gt;案例：熊和狮子联合捕到了一头鹿，在两者陷入长久的功劳之争时，昏迷的鹿醒来溜走了。&lt;/p&gt;
&lt;h3&gt;33. 飞轮效应（万事开头难）&lt;a href=&quot;#33-飞轮效应万事开头难&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指做一件事一开始很难，可一旦我们挺过去这个难关后，只需付出很小的努力，甚至不废吹灰之力就能得到很大的收获。[源自物理实验：为了使静止的飞轮转动起来，一开始须花很大的力气反复地推轮子，当达到一定的速度时，就不需要太大的力气，即使力量没有增加，轮子也会转得更快，后逐渐应用于商业和心理学分析中。]&lt;/p&gt;
&lt;p&gt;案例：嘟嘟创业前期，因为资金、人才等问题，发展艰难。后来慢慢步入正轨，资本厚了、招募到了优秀的人才，事业也越来越好，一天天壮大。&lt;/p&gt;
&lt;h3&gt;34. 缄默效应（限于强迫过度谨言）&lt;a href=&quot;#34-缄默效应限于强迫过度谨言&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指在人际沟通中，由于担心对方权威或强迫等压力，人们大都选择缄默或者挑对方喜欢的、迎合对方的话来说，尽量避免说让对方不快或有可能降低自身价值的话。即沟通中表面言语与真实内心态度不一致的现象。缄默效应容易导致沟通信息失真，因此，在组织管理与人际沟通中应尽量减少强制、压迫的沟通方式。[可间接追溯至鲁迅的一句名言：“不在沉默中爆发，就在沉默中灭亡。”具体理论出处不详。]&lt;/p&gt;
&lt;p&gt;希望别人对你说实话，在他说话时看着他的眼睛并保持沉默，此时相对安静的空间，会让有所隐瞒的他，感觉到压力，不自觉地对你说出实话。&lt;/p&gt;
&lt;p&gt;案例：教育督察员到某问题学校调研，召集教职员就学校教育中遇到的问题提出看法和建议，由于现场有“厉害”校长出席，部分年轻老师本来准备好的一些重要问题和建议，却迫于于校长在场的压力而被迫选择保持缄默，或只挑选了一些轻微的问题进行讨论。&lt;/p&gt;
&lt;h3&gt;35. 海格力斯效应（放下仇恨路路通）&lt;a href=&quot;#35-海格力斯效应放下仇恨路路通&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;是指一种人际间或群体间存在的怨怨相报、致使仇恨越来越深的社会心理效应。其启发人们，人际之间不应该在仇恨上“火上浇油”，而是要学会放下。[源自古希腊神话：一天，英雄大力士海格力斯走在坎坷不平的路上，见脚边有个很难看的袋子样的东西，海格力斯便踩了一脚。谁知那东西不但没破，并成倍地胀大，愤怒的海格力斯顺手操起一根大木棒砸那个怪东西，结果，那东西竟膨胀到把路也堵死了。正当海格力斯纳闷时，一位圣者走到跟前对他说：“朋友，快别动它了，忘了它，离它远去吧，它叫仇恨袋，你不惹它，它便会小如当初；你若侵犯它，它就会膨胀起来与你敌对到底。”]&lt;/p&gt;
&lt;p&gt;案例：嘟嘟和哆哆由于误解或嫉妒，两人之间有了矛盾，这时，如果其中一方的报复心理加剧，会使对方相应扩大报复力度而陷入恶性循环。相反，如果双方能真诚沟通、消除误解，自然可以和乐相处。&lt;/p&gt;
&lt;h3&gt;36. 蘑菇效应（职场新人被冷落）&lt;a href=&quot;#36-蘑菇效应职场新人被冷落&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指一个新进入者在一个组织里面临的怀疑、不公等遭遇，以及随后因表现差异而发展成被认可或被忽视的现象。其启示是在公司新人进入后，应该规避蘑菇效应的负面影响，避免该效应长期存在导致人才浪费、流失。[源于一个形象的比喻：“蘑菇长在阴暗的角落，得不到阳光，也没有肥料，自生自灭，只有长到足够高的时候才会开始被人关注，可此时它自己已经能够接受阳光了”。20世纪70年，美国很多新程序员工置于不受重视的部门，干一些打杂的活，常常会受到无端的批评、指责，甚至代人受过，得不到必要的指导和提携，被人称为“蘑菇管理”。理论具体出处不详。]&lt;/p&gt;
&lt;p&gt;举例：一个刚参加工作的人总是先做一些不起眼的事情，而且得不到重视。当他默默无闻地工作一段时间后，如果工作出色就逐渐被人关注并得到重用；如果工作不出色就逐渐被边缘化，甚至被人遗忘。&lt;/p&gt;
&lt;h3&gt;37. 酝酿效应（难题不决，放松找灵感）&lt;a href=&quot;#37-酝酿效应难题不决放松找灵感&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指反复探索一个问题的解决而毫无结果时，把问题暂时搁置一段时间，往往会由于某种机遇一下子便找到解决办法的现象。[可追溯至古希腊时期，古希腊国王让阿基米德想办法确认皇冠是否被工匠参假，他冥思苦想而不得解，随后他竟然因在洗澡时发现了浮力原理而把问题解决了。意大利美学家Benedetto Croce（1866—1952）指出，人的知识有两种，一种是直觉的，一种是逻辑的，前者是“从想像得来的”，后者是“从理智得来的”。直觉是人脑对于对象中隐含的整体性、次序性、和谐性的某种迅速而直接的洞察和领悟，它可以引导我们绕过不可逾越的高山，曲径通幽，以达柳暗花明的境界。美国心理学家Silveira于1971年通过实验证明了这一效应。]&lt;/p&gt;
&lt;p&gt;案例：你正为一个广告创意无法突破而焦急不已，这时女神对你说，“要不要去楼下喝茶去呀”，你欣然同往，没想到你们聊着聊着，灵感乍现，想出了一个令甲方爸爸都拍案叫绝的好点子。&lt;/p&gt;
&lt;h3&gt;38. 投射效应（以己度人）&lt;a href=&quot;#38-投射效应以己度人&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指将自己的特点归因到其他人身上的倾向，即在认知和对他人形成印象时，以为他人也具备与自己相似的特性的现象，把自己的感情、意志、特性投射到他人身上并强加于人的认知障碍。[由美国心理学家E.A.Ross通过实验证明，时间不详。 ]&lt;/p&gt;
&lt;p&gt;案例：衣食无忧、心地善良的妮妮总以为人们都是“正义和良善的”；靠权斗谋私发家的啖总则认为每个人都是”绝对自私自利且天经地义”。&lt;/p&gt;
&lt;h3&gt;39. 食盐效应（要智慧行善）&lt;a href=&quot;#39-食盐效应要智慧行善&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指好东西应当适度、适时，需要的才是最好的。如人常说的，锦上添花， 不及一次及时的雪中送炭。[原指做菜时，盐不可或缺，但是放得太多却让人难以下口，后被引入教育学领域，理论正式出处不详。]&lt;/p&gt;
&lt;p&gt;案例：嘟嘟的一个同事因为家中父亲生病，急需要借一笔钱回家，识趣的同事纷纷解囊救济，而唯独嘟嘟却希望凭借自己的关系帮助同事联系医院、医生，甚至还几次三番地要拉着同事去和医生聊聊…，&lt;/p&gt;
&lt;h3&gt;40. 迟延满足效应（延迟满足更划算）&lt;a href=&quot;#40-迟延满足效应延迟满足更划算&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;也称糖果效应。指为人们了长远的、更大的利益，而自愿延缓或放弃目前的、较小的满足的现象。心理学家还通过观察发现，从小时候的自控、判断、自信的小实验中能推测出一个人长大后的个性。[由美国斯坦福大学心理学教授Walter Mischel于1960年的“延迟满足”实验提出并证明。]&lt;/p&gt;
&lt;p&gt;案例：在一个游戏中，桌上各放着两颗糖，如果小朋友能坚持20分钟，就能得到这两颗糖，如果不能坚持，就只能得到一颗，并且现在就能拿到，自律较好的小朋友（2/3）都会选择稍微等20分钟再拿，以获得更大的收益。生活中延迟满足也可以提升幸福感。&lt;/p&gt;
&lt;h3&gt;41. 三明治效应&lt;a href=&quot;#41-三明治效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;批评心理学中，把批评的内容夹在两个表扬之中，会使受批评者偷快地接受批评。&lt;/p&gt;
&lt;p&gt;在建议和批评的同时，不忘认同、赏识、肯定、关爱对方，可以使接受批评者积极地接受批评，并改正自己的不足方面。&lt;/p&gt;
&lt;h3&gt;42. 鸟笼效应&lt;a href=&quot;#42-鸟笼效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;如果一个人的客厅有了一个空鸟笼，过一段时间，他很可能会买只鸟回来养。&lt;/p&gt;
&lt;p&gt;人们会在偶然获得一件原本不需要的物品的基础上，自觉不自觉地添加更多自己不需要的东西。&lt;/p&gt;
&lt;h3&gt;43. 蝴蝶效应&lt;a href=&quot;#43-蝴蝶效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;亚马逊雨林一只蝴蝶翅膀偶尔振动，也许两周后就会引起美国德克萨斯州的一场龙卷风。&lt;/p&gt;
&lt;p&gt;蝴蝶效应是说，初始条件十分微小的变化经过不断放大，对其未来状态会造成极其巨大的差别。&lt;/p&gt;
&lt;p&gt;有些小事可以糊涂，有些小事如经系统放大，则对一个组织、一个国家来说是很重要的，就不能糊涂。&lt;/p&gt;
&lt;h3&gt;44. 手表效应&lt;a href=&quot;#44-手表效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;手表定律是指一个人有一只表时，可以知道现在是几点钟，而当他同时拥有两只时却无法确定。两只表并不能告诉一个人更准确的时间，反而会使看表的人失去对准确时间的信心。&lt;/p&gt;
&lt;p&gt;手表定律在企业管理方面给我们一种非常直观的启发，就是对同一个人或同一个组织不能同时采用两种不同的方法，不能同时设置两个不同的目标，甚至每一个人不能由两个人来同时指挥，否则将使这个企业或者个人无所适从。&lt;/p&gt;
&lt;h2&gt;有关人际印象的效应&lt;a href=&quot;#有关人际印象的效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;45. 刺猬效应&lt;a href=&quot;#45-刺猬效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;几只困倦的刺猬，由于寒冷而拥在一起，可因为各自身上都长着刺，于是它们离开了一段距离，但又冷得受不了，于是凑到一起。&lt;/p&gt;
&lt;p&gt;几经折腾，两只刺猬终于找到一个合适的距离：既能互相获得对方的温暖而又不至于被扎。&lt;/p&gt;
&lt;p&gt;刺猬效应主要是指人际交往中的“心理距离效应”。&lt;/p&gt;
&lt;p&gt;与另一半保持一定的距离，既不会使你们的关系疏离，也不会让你们对对方失去新鲜感、神秘感，这是亲密关系的一种最佳状态。&lt;/p&gt;
&lt;p&gt;距离的保持靠一定的原则来维持，这种原则对所有人都一视同仁：既可以约束领导者自己，也可以约束员工。掌握了这个原则，也就掌握了成功管理的秘诀。&lt;/p&gt;
&lt;h3&gt;46. 聚光灯效应（过于在乎别人怎么看自己）&lt;a href=&quot;#46-聚光灯效应过于在乎别人怎么看自己&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;又称焦点效应，指不经意的把自己的问题放到无限大。常表现为普遍高估别人对自己的关注程度，在意自己给别人留下的印象。[由康奈尔大学心理学教授Thomas Gilovich和美国心理学家Kenneth Savitsky在1999年进行的“聚光灯效应”实验提出并证明。]&lt;/p&gt;
&lt;p&gt;举例：假设给人一件颜色特别奇怪的T恤穿在身上，然后让他到一群人里面去走一圈，他一般会自认为有50%的人在关注他，而事实上只有20%的人而已。&lt;/p&gt;
&lt;h3&gt;47. 黑暗效应（朦胧场景好约会）&lt;a href=&quot;#47-黑暗效应朦胧场景好约会&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;浪漫的西餐厅是很多人情侣约会的首选，因为在光线比较暗的场所，约会双方彼此看不清对方表情，就很容易减少戒备感而产生安全感。在这种情况下，彼此产生亲近的可能性就会远远高于光线比较亮的场所。心理学家将这种现象称之为”黑暗效应”。由加拿大多伦多大学和美国西北大学科学家通过实验证明。&lt;/p&gt;
&lt;p&gt;所以，尽可能多的找机会与对方在昏暗的光线下相处，比如昏暗的车里，是一个吸引人的好办法&lt;/p&gt;
&lt;p&gt;案例：叫你大白天街上表白，知道为什么现在还单身了吧。&lt;/p&gt;
&lt;h3&gt;48. 名片效应（一面遇知己）&lt;a href=&quot;#48-名片效应一面遇知己&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指在交际中，如果表明自己与对方的态度和价值观相同，就会使对方感觉到你与他有更多的相似性。 [由前苏联社会心理学家Ш.АН.адирашвили提出，具体时间不详。]&lt;/p&gt;
&lt;p&gt;案例：经历几次面试失败的哆哆，在最近一次应聘之前，仔细打听了该公司老板的情况，发现这家公司的老板以前有着与自己相似的求职经历，于是在应聘时，他就与老总畅谈自己的求职经历，以及怀才不遇的感慨，果然，得到了老板的赏识，最终被顺利录用。&lt;/p&gt;
&lt;h3&gt;49. 人际吸引律（各种原因的相互吸引）&lt;a href=&quot;#49-人际吸引律各种原因的相互吸引&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;指因各种因素导致个体与他人之间形成情感上相互亲密的状态，是人际关系中的一种肯定形式。按吸引的程度，人际吸引可分为亲合、喜欢和爱情。亲合是较低层次的人际吸引，喜欢是中等程度的吸引，爱情是最强烈的人际吸引形式。[由“卡内基训练”创始人Dale Carnegie（1888-1955）提出。]&lt;/p&gt;
&lt;p&gt;人际吸引律分为以下六种：接近吸引律（双方存在着诸多接近点，相互吸引）、互惠吸引律（双方因能给对方带来收益、酬偿而相互吸引）、对等吸引律（因对方喜欢自己，而导致自己也喜欢对方）、诱发吸引律（由自然或人为环境等引发的吸引）互补吸引律（双方因个性或需要及满足需要的途径互补时，而引发的相互吸引）光环吸引律（因能力、特长、品质或社会知名度高等特征就像光环一样使人产生晕轮效应）&lt;/p&gt;
&lt;p&gt;案例：一次活动中默默与你相聊甚欢，对你赞赏有加，于是你也表现除了对他的好感，结果你们都加了微信，成了好朋友。&lt;/p&gt;
&lt;h3&gt;50. 首因效应 （第一印象很重要）&lt;a href=&quot;#50-首因效应-第一印象很重要&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;也称优先效应、第一印象效应、先入为主效应。指人们通常对一个人最初接触时的信息形成“先入为主”的鲜明印象，从而影响人们以后对此人的评价。是系列位置效应的一种类型。[由美国心理学家A.S.Lochins（1907~1996）于1957年通过实验证明。]&lt;/p&gt;
&lt;p&gt;案例：如小销售新手哆哆，谈业务时总是衣冠整洁、谈吐细致礼貌，虽然有些技术细节不熟，但给客户留下了良好的印象，深得客户好感，也让他顺利签了单。&lt;/p&gt;
&lt;h3&gt;51. 近因效应（新印象是可以塑造的）&lt;a href=&quot;#51-近因效应新印象是可以塑造的&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;也称为“新颖效应”，是指最新出现的刺激物促使新印象形成的心理效果。与首因效应相反，是指在多种刺激一次出现的时候，印象的形成主要取决于后来出现的刺激，即对他人最新的认识掩盖了以往形成的评价。是系列位置效应的一种类型。由心理学家A·卢琴斯于1957年根据实验首次提出；1964年，心理学家C·梅约和W·克劳克特通过实验进一步证明。&lt;/p&gt;
&lt;p&gt;近因效应是指当人们在回想一系列事物时对末尾部分的记忆效果优于中间部分的现象。这种现象是由于近因效应的作用。信息前后间隔时间越长，近因效应越明显。原因在于前面的信息在记忆中逐渐模糊，从而使近期信息在短时记忆中更清晰。&lt;/p&gt;
&lt;p&gt;案例：毕业后10年未见面的老同学，聚会上你一眼就认出了她/他；而且最熟悉的记忆除了最要好的时刻，多半是临别时的情景。&lt;/p&gt;
&lt;h3&gt;52. 刻板效应（湖南人爱吃辣）&lt;a href=&quot;#52-刻板效应湖南人爱吃辣&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;刻板效应，又称刻板印象，它是指对某个群体产生一种固定的看法和评价，并对属于该群体的个人也给予这一看法和评价。[由苏联社会心理学家包达列夫（1923-）于1965年提出并通过实验证明。]&lt;/p&gt;
&lt;p&gt;案例：基于对博士“学识渊博”的印象，人们一般认为博士肯定无所不知，或者一定写字很漂亮，其实多数博士更多的是在一个领域的专注精通，而不是常人以为的知识广度的积累；而且也不一定就写得一手漂亮字呢。&lt;/p&gt;
&lt;h3&gt;53. 晕轮效应（情人眼里出西施）&lt;a href=&quot;#53-晕轮效应情人眼里出西施&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;也称光环效应，指人们对他人的认知判断是基于根据自身的个人喜好出发，再从这个判断推论出认知对象的其他品质，使得最终出现“以点概面、以偏概全”的现象。[最早是由美国著名心理学家Edward Lee Thorndike（1894-1949）于20世纪20年代提出，随后美国心理学家K.Dion、Harold Harding Kelley （1921-2003）、Richard E.Nisbett（1941-）相继通过实验证明。 ]&lt;/p&gt;
&lt;p&gt;案例：俄国作家普希金狂热地爱上了“莫斯科第一美人”娜坦丽，并和她闪婚。婚后才发现两人差别巨大，当普希金每次与她分享自己的诗作时，她总是毫无兴趣、心生排斥，相反却要普希金陪她游乐，出席豪华晚会、舞会，普希金为此丢下创作，弄得债台高筑，最后还为她决斗而死，一颗文学巨星就此陨落。&lt;/p&gt;
&lt;p&gt;遗憾的是，光环效应往往持续的时间不会太长，等这种效应散去，对方的缺点也就逐渐的显露出来。然后，我们可能就会在某一时间段突然觉得，“ta没有以前那么好了”，然后我们对于爱情的热度也随之递减。&lt;/p&gt;
&lt;h3&gt;54. 曝光效应（日久生情）&lt;a href=&quot;#54-曝光效应日久生情&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;也称多看效应，指对越熟悉的东西越喜欢的现象。&lt;/p&gt;
&lt;p&gt;20世纪60年代，心理学家查荣茨做过这样一个实验：他向参加实验的人出示一些人的照片，让他们观看。有些照片出现了二十几次，有的出现十几次，而有的则只出现了一两次。之后，请看照片的人评价他们对照片的喜爱程度。结果发现，参加实验的人看到某张照片的次数越多，就越喜欢这张照片。他们更喜欢那些看过二十几次的熟悉照片，而不是只看过几次的新鲜照片。也就是说，曝光的次数增加了喜欢的程度。&lt;/p&gt;
&lt;p&gt;案例：微信头像建议大家使用自己的真实照片，总之要想办法多让对方看到自己，或是自己的照片。&lt;/p&gt;
&lt;h3&gt;55. 异性效应（男女搭配，干活不累）&lt;a href=&quot;#55-异性效应男女搭配干活不累&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;也叫“磁铁效应”，指异性接触会产生一种特殊的相互吸引力和激发力，并能从中体验到难以言传的感情追求，对人的活动和学习通常起积极的影响。[最早可追溯至古希腊时期弗洛伊德用精神分析方法解释生物繁衍过程中的心理伴生现象，现代理论研究不详。]&lt;/p&gt;
&lt;p&gt;案例：公司一开始程序员基本都是男孩纸，时常加班让大家十分痛苦、颇有怨言，后来公司招聘了很多女纸程序员一起加班，男程序员竟然没再抱怨，有时还主动延长加班时间呢。&lt;/p&gt;
&lt;h3&gt;56. 吊桥效应&lt;a href=&quot;#56-吊桥效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;当一个人提心吊胆的走过吊桥的一瞬间，抬头发现了一个异性，这是最容易产生感情的情形。因为吊桥上提心吊胆引起的心跳加速，会被人误以为是看见了命中注定的另一半而产生的反应。这就是为什么电影里英雄救美后，美女都会爱上那个救她的英雄的原因。&lt;/p&gt;
&lt;p&gt;所以，要想吸引一个人，约会的时候可以尽量选择那些刺激的游戏，或者看恐怖的电影。&lt;/p&gt;
&lt;h3&gt;57. 富兰克林效应&lt;a href=&quot;#57-富兰克林效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;这是根据18世纪美国的国父之一的本杰明·富兰克林所说的一句话发展而来的。富兰克林说：相比那些被你帮助过的人，那些曾经帮助过你的人会更愿意再帮你一次。换句话说：让别人喜欢你，最好的办法不是去帮助他们，而是让他们帮助你。&lt;/p&gt;
&lt;p&gt;当然，这事是有技巧的，你别上来就弄件大事找对方帮忙哈，你可以先从一些很小的，对方轻而易举就能做到的事情下手。比如，让对方顺便帮你带杯咖啡，或者是帮你整理一下领带之类的。&lt;/p&gt;
&lt;h3&gt;58. 阿伦森效应&lt;a href=&quot;#58-阿伦森效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;有个实验：分4组人对某一人给予不同的评价，借以观察某人对哪一组最具好感。第一组始终对之褒扬有加，第二组始终对之贬损否定，第三组先贬后褒，第四组先褒后贬。&lt;/p&gt;
&lt;p&gt;此实验对数十人进行过后，发现绝大部分人对第三组最具好感，而对第四组最为反感。&lt;/p&gt;
&lt;p&gt;所以我们在恋爱中也要注意阿伦森效应，在跟另一半的相处中不要一味的夸奖赞美，而是要夸奖适度，并且褒贬结合，这样才会使得你的夸奖更加有意义。&lt;/p&gt;
&lt;h3&gt;59. 同质效应&lt;a href=&quot;#59-同质效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;人天生就是自恋的，我们总是喜欢那些跟自己相似度很高的人，相似的人也更容易相互吸引。&lt;/p&gt;
&lt;p&gt;我们喜欢自己，相当重要的原因是我们了解自己，对自己很熟悉。所以我们会喜欢和自己相似的人，或者是那些我们想象着可能和我们有某些共同特性的人，这样的人会让我们感觉到熟悉和安全。&lt;/p&gt;
&lt;p&gt;所以，想要吸引一个人，请尽量多的展示你与对方的相似点，比如吃她爱吃的东西，听她喜欢的音乐，做她曾做过的事情，让对方感受到你懂他，你跟他是那么合拍，这样会更加吸引对方靠近你。&lt;/p&gt;
&lt;h3&gt;60. 毛毛虫效应&lt;a href=&quot;#60-毛毛虫效应&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;将毛毛虫们首尾相接，围一圈放在花盆边缘，花盆不远的地方撒一些松叶，毛毛虫夜以继日地绕着花盆转圈，最终因饥饿和精疲力尽相继死去。&lt;/p&gt;
&lt;p&gt;当我们的工作遭遇挫折或陷入停顿时，应努力寻求突破。不能只关注做了多少工作，还要关注做出多少成果，也就是“效益 ”。&lt;/p&gt;</content:encoded><category>category:随笔</category></item><item><title>Duff&apos;s Device</title><link>https://www.dreameverafter.com/en/post/duff-s-device</link><guid isPermaLink="false">en:duff-s-device</guid><description>Duff&apos;s Device 是 C 语言中一种经典的循环展开优化技术，由 Tom Duff 于 1983 年在卢卡斯影业开发，旨在解决串口通信等场景下的性能瓶颈。它通过结合 switch 语句的 case fall-through（无 break 的穿透执行）特性与循环展开，减少循环条件判断次数，从</description><pubDate>Sun, 13 Apr 2025 10:02:58 GMT</pubDate><content:encoded>&lt;p&gt;Duff’s Device 是 C 语言中一种经典的循环展开优化技术，由 Tom Duff 于 1983 年在卢卡斯影业开发，旨在解决串口通信等场景下的性能瓶颈。它通过结合 switch 语句的 case fall-through（无 break 的穿透执行）特性与循环展开，减少循环条件判断次数，从而提升数据复制效率。&lt;/p&gt;
&lt;h2&gt;一、核心原理与代码结构&lt;a href=&quot;#一核心原理与代码结构&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;Duff’s Device 的核心思想是 循环展开（Loop Unrolling） 与 余数处理 的结合：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;循环展开&lt;/p&gt;
&lt;p&gt;将原本逐次处理单个数据的循环改为每次处理多个数据（如 8 次），减少循环条件判断的开销。例如，传统循环每次迭代需执行一次条件判断，而展开后每 8 次操作仅需一次判断。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;余数处理&lt;/p&gt;
&lt;p&gt;当数据总量 count 不是展开倍数（如 8）时，通过 switch 语句的跳转机制，从对应余数位置开始执行剩余操作，确保所有数据均被处理。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;经典代码示例：&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; duff_copy&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; *&lt;/span&gt;&lt;span&gt;to&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; *&lt;/span&gt;&lt;span&gt;from&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; count&lt;/span&gt;&lt;span&gt;) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int&lt;/span&gt;&lt;span&gt; n &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; (count &lt;/span&gt;&lt;span&gt;+&lt;/span&gt;&lt;span&gt; 7&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;/&lt;/span&gt;&lt;span&gt; 8&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;span&gt;  // 计算完整循环次数（向上取整）&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    switch&lt;/span&gt;&lt;span&gt; (count &lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt; 8&lt;/span&gt;&lt;span&gt;) {&lt;/span&gt;&lt;span&gt;       // 确定余数起始点&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case&lt;/span&gt;&lt;span&gt; 0&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;do&lt;/span&gt;&lt;span&gt; { &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;to&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; *&lt;/span&gt;&lt;span&gt;from&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;7&lt;/span&gt;&lt;span&gt;:      &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;to&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; *&lt;/span&gt;&lt;span&gt;from&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;6&lt;/span&gt;&lt;span&gt;:      &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;to&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; *&lt;/span&gt;&lt;span&gt;from&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;5&lt;/span&gt;&lt;span&gt;:      &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;to&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; *&lt;/span&gt;&lt;span&gt;from&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;4&lt;/span&gt;&lt;span&gt;:      &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;to&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; *&lt;/span&gt;&lt;span&gt;from&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;span&gt;:      &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;to&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; *&lt;/span&gt;&lt;span&gt;from&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;span&gt;:      &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;to&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; *&lt;/span&gt;&lt;span&gt;from&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;span&gt;:      &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;to&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; *&lt;/span&gt;&lt;span&gt;from&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                } &lt;/span&gt;&lt;span&gt;while&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;--&lt;/span&gt;&lt;span&gt;n &lt;/span&gt;&lt;span&gt;&amp;gt;&lt;/span&gt;&lt;span&gt; 0&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;执行逻辑：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;当 count 是 8 的倍数时，从 case 0 进入循环，每次处理 8 个数据，循环次数为 count/8。&lt;/li&gt;
&lt;li&gt;当 count 非 8 的倍数时，switch 根据余数跳转到对应 case 标签，先处理余数个数据，再进入完整循环。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;二、历史背景与性能优化&lt;a href=&quot;#二历史背景与性能优化&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;诞生场景
Tom Duff 在编写内存映射 I/O 操作时发现传统循环性能低下：每次循环中的条件判断（如 while (—count &amp;gt; 0)）占用了大量时间，成为性能瓶颈。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;性能提升机制&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;减少无用指令：传统循环中每次迭代需执行递减计数与条件判断，这些指令对实际数据操作无贡献，Duff’s Device 通过展开循环减少此类指令占比。&lt;/li&gt;
&lt;li&gt;利用 CPU 并行性：现代 CPU 的指令级并行（ILP）技术（如流水线、分支预测）在循环展开后更高效，减少因频繁分支判断导致的流水线停顿。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;性能测试示例：
在早期测试中，Duff’s Device 将循环执行时间从 25.4 秒降至 14.7 秒，提升约 42%。&lt;/p&gt;
&lt;h2&gt;三、优缺点与争议&lt;a href=&quot;#三优缺点与争议&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;优点&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;性能提升：在早期硬件和编译器优化不足时显著减少指令开销。&lt;/li&gt;
&lt;li&gt;代码紧凑性：通过 switch 和循环的嵌套实现逻辑紧凑。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;缺点&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;可读性差：非常规的代码结构增加了理解难度，可能引发维护问题。现代编译器优化：现代编译器（如 GCC、Clang）能自动进行循环展开，手动优化可能反被编译器优化策略干扰。&lt;/li&gt;
&lt;li&gt;平台依赖性：某些处理器对紧凑循环的优化效果优于展开后的长代码。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;争议&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;语法合法性：Duff’s Device 利用 C 语言的 switch 穿透特性，虽合法但违背常规编码习惯，被视为对语言特性的“创造性滥用”。&lt;/li&gt;
&lt;li&gt;实用性争议：在当今硬件与编译技术下，其性能优势已不明显，更多作为编程技巧案例存在。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;四、现代应用与启示&lt;a href=&quot;#四现代应用与启示&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;应用场景&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;嵌入式系统：在资源受限且编译器优化有限的场景中仍有价值。&lt;/li&gt;
&lt;li&gt;教学案例：用于讲解循环展开、编译器优化原理及 C 语言语法特性。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;启示&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;性能优化思维：鼓励开发者深入理解硬件与编译原理，探索底层优化可能性。&lt;/li&gt;
&lt;li&gt;代码可维护性权衡：在追求性能时需评估代码可读性代价，避免过度优化。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;更直观的代码&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; copy&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; src&lt;/span&gt;&lt;span&gt;[]&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; dest&lt;/span&gt;&lt;span&gt;[]&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; size&lt;/span&gt;&lt;span&gt;) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int&lt;/span&gt;&lt;span&gt; rounds &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; size &lt;/span&gt;&lt;span&gt;/&lt;/span&gt;&lt;span&gt; 8&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int&lt;/span&gt;&lt;span&gt; i &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; 0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    switch&lt;/span&gt;&lt;span&gt; (size &lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt; 8&lt;/span&gt;&lt;span&gt;) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case&lt;/span&gt;&lt;span&gt; 0&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;while&lt;/span&gt;&lt;span&gt; (rounds &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; 0&lt;/span&gt;&lt;span&gt;) { rounds&lt;/span&gt;&lt;span&gt;--&lt;/span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;dest&lt;/span&gt;&lt;span&gt;[i] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; src&lt;/span&gt;&lt;span&gt;[i]; i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;7&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;dest&lt;/span&gt;&lt;span&gt;[i] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; src&lt;/span&gt;&lt;span&gt;[i]; i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;6&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;dest&lt;/span&gt;&lt;span&gt;[i] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; src&lt;/span&gt;&lt;span&gt;[i]; i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;5&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;dest&lt;/span&gt;&lt;span&gt;[i] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; src&lt;/span&gt;&lt;span&gt;[i]; i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;4&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;dest&lt;/span&gt;&lt;span&gt;[i] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; src&lt;/span&gt;&lt;span&gt;[i]; i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;dest&lt;/span&gt;&lt;span&gt;[i] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; src&lt;/span&gt;&lt;span&gt;[i]; i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;dest&lt;/span&gt;&lt;span&gt;[i] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; src&lt;/span&gt;&lt;span&gt;[i]; i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        case &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;dest&lt;/span&gt;&lt;span&gt;[i] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; src&lt;/span&gt;&lt;span&gt;[i]; i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;逻辑：通过 switch 处理余数后，进入 while 循环展开 8 次复制操作，每次循环减少条件判断次数。&lt;/p&gt;
&lt;h2&gt;总结&lt;a href=&quot;#总结&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;Duff’s Device 是 C 语言中一项标志性的优化技术，展示了底层编程的创造力与性能优化思维。尽管其现代实用性受限，但作为理解循环展开、编译器优化及语言特性的经典案例，仍具有重要学习价值。&lt;/p&gt;</content:encoded><category>category:随笔</category><category>tag:C/C++</category></item><item><title>八位堂SN30Pro说明书</title><link>https://www.dreameverafter.com/en/post/%E5%85%AB%E4%BD%8D%E5%A0%82sn30pro%E8%AF%B4%E6%98%8E%E4%B9%A6</link><guid isPermaLink="false">en:八位堂sn30pro说明书</guid><pubDate>Sun, 13 Apr 2025 09:47:02 GMT</pubDate><content:encoded>&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/attachment%3A5db470b9-ac0f-4f90-9072-7d2565a209f1%3ASN30proSF30pro_Manual_00.png?table=block&amp;amp;id=1d40ce9e-f2fd-803e-ad73-ce6663d1a8ff&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;</content:encoded><category>category:生活</category></item><item><title>为 UIControl 实现线程安全的 Block 事件扩展：原理与实践</title><link>https://www.dreameverafter.com/en/post/wei-uicontrol-shi-xian-xian-cheng-an-quan-de-block-shi-jian-kuo-zhan-yuan-li-yu-shi-jian</link><guid isPermaLink="false">en:wei-uicontrol-shi-xian-xian-cheng-an-quan-de-block-shi-jian-kuo-zhan-yuan-li-yu-shi-jian</guid><description>一、背景与痛点 在 iOS 开发中，UIControl 的 Target-Action 机制是处理用户交互事件的标准方式。然而当面临以下场景时，传统方案会暴露明显缺陷： 线程安全问题：在后台线程修改事件监听可能导致 UI 操作不同步 代码冗余：需为每个事件单独创建 selector 方法 维护成本：</description><pubDate>Tue, 25 Mar 2025 12:22:06 GMT</pubDate><content:encoded>&lt;h2&gt;一、背景与痛点&lt;a href=&quot;#一背景与痛点&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;在 iOS 开发中，&lt;code&gt;UIControl&lt;/code&gt; 的 Target-Action 机制是处理用户交互事件的标准方式。然而当面临以下场景时，传统方案会暴露明显缺陷：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;线程安全问题&lt;/strong&gt;：在后台线程修改事件监听可能导致 UI 操作不同步&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;代码冗余&lt;/strong&gt;：需为每个事件单独创建 selector 方法&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;维护成本&lt;/strong&gt;：难以批量移除特定类型的事件监听&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;内存风险&lt;/strong&gt;：容易因循环引用导致内存泄漏&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;代码如下：&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;import&lt;/span&gt;&lt;span&gt; UIKit&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// MARK: - 线程安全关联对象键&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;private&lt;/span&gt;&lt;span&gt; struct&lt;/span&gt;&lt;span&gt; AssociatedKeys&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    @MainActor&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    static&lt;/span&gt;&lt;span&gt; var&lt;/span&gt;&lt;span&gt; blockKey: &lt;/span&gt;&lt;span&gt;UInt8&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; 0&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// MARK: - Block 事件包装类&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;final&lt;/span&gt;&lt;span&gt; class&lt;/span&gt;&lt;span&gt; ControlBlockTarget&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;NSObject &lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    var&lt;/span&gt;&lt;span&gt; block: ((UIControl) &lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt; Void&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;?&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    var&lt;/span&gt;&lt;span&gt; events: UIControl.Event&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    init&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;block&lt;/span&gt;&lt;span&gt;: ((UIControl) &lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt; Void&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;?&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;events&lt;/span&gt;&lt;span&gt;: UIControl.Event) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        self&lt;/span&gt;&lt;span&gt;.block &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; block&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        self&lt;/span&gt;&lt;span&gt;.events &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; events&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        super&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt;init&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    @objc&lt;/span&gt;&lt;span&gt; func&lt;/span&gt;&lt;span&gt; invoke&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;sender&lt;/span&gt;&lt;span&gt;: UIControl) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        block&lt;/span&gt;&lt;span&gt;?&lt;/span&gt;&lt;span&gt;(sender)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// MARK: - 线程安全扩展&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;extension&lt;/span&gt;&lt;span&gt; UIControl&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // MARK: - Public Methods&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    /// 添加 Block 事件（线程安全）&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    public&lt;/span&gt;&lt;span&gt; func&lt;/span&gt;&lt;span&gt; sb_addBlock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt; events: UIControl.Event, &lt;/span&gt;&lt;span&gt;block&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;@escaping&lt;/span&gt;&lt;span&gt; (UIControl) &lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt; Void&lt;/span&gt;&lt;span&gt;) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        DispatchQueue.main.&lt;/span&gt;&lt;span&gt;async&lt;/span&gt;&lt;span&gt; { [&lt;/span&gt;&lt;span&gt;weak&lt;/span&gt;&lt;span&gt; self&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;in&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            guard&lt;/span&gt;&lt;span&gt; let&lt;/span&gt;&lt;span&gt; self&lt;/span&gt;&lt;span&gt; else&lt;/span&gt;&lt;span&gt; { &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            let&lt;/span&gt;&lt;span&gt; target &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; ControlBlockTarget&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;block&lt;/span&gt;&lt;span&gt;: block, &lt;/span&gt;&lt;span&gt;events&lt;/span&gt;&lt;span&gt;: events)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            self&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt;addTarget&lt;/span&gt;&lt;span&gt;(target, &lt;/span&gt;&lt;span&gt;action&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#selector&lt;/span&gt;&lt;span&gt;(ControlBlockTarget.&lt;/span&gt;&lt;span&gt;invoke&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;sender:&lt;/span&gt;&lt;span&gt;)), &lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;: events)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            self&lt;/span&gt;&lt;span&gt;.blockTargets.&lt;/span&gt;&lt;span&gt;append&lt;/span&gt;&lt;span&gt;(target)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    /// 设置唯一 Block（覆盖原有同类型事件）&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    public&lt;/span&gt;&lt;span&gt; func&lt;/span&gt;&lt;span&gt; sb_setBlock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt; events: UIControl.Event, &lt;/span&gt;&lt;span&gt;block&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;@escaping&lt;/span&gt;&lt;span&gt; (UIControl) &lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt; Void&lt;/span&gt;&lt;span&gt;) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        DispatchQueue.main.&lt;/span&gt;&lt;span&gt;async&lt;/span&gt;&lt;span&gt; { [&lt;/span&gt;&lt;span&gt;weak&lt;/span&gt;&lt;span&gt; self&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;in&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            guard&lt;/span&gt;&lt;span&gt; let&lt;/span&gt;&lt;span&gt; self&lt;/span&gt;&lt;span&gt; else&lt;/span&gt;&lt;span&gt; { &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            // 原子化移除指定事件的所有处理&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            self&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt;sb_removeAllBlocks&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;: events)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            // 添加新处理&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            let&lt;/span&gt;&lt;span&gt; target &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; ControlBlockTarget&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;block&lt;/span&gt;&lt;span&gt;: block, &lt;/span&gt;&lt;span&gt;events&lt;/span&gt;&lt;span&gt;: events)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            self&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt;addTarget&lt;/span&gt;&lt;span&gt;(target, &lt;/span&gt;&lt;span&gt;action&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#selector&lt;/span&gt;&lt;span&gt;(ControlBlockTarget.&lt;/span&gt;&lt;span&gt;invoke&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;sender:&lt;/span&gt;&lt;span&gt;)), &lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;: events)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            self&lt;/span&gt;&lt;span&gt;.blockTargets.&lt;/span&gt;&lt;span&gt;append&lt;/span&gt;&lt;span&gt;(target)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    /// 移除指定事件的所有 Block&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    public&lt;/span&gt;&lt;span&gt; func&lt;/span&gt;&lt;span&gt; sb_removeAllBlocks&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt; events: UIControl.Event) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        DispatchQueue.main.&lt;/span&gt;&lt;span&gt;async&lt;/span&gt;&lt;span&gt; { [&lt;/span&gt;&lt;span&gt;weak&lt;/span&gt;&lt;span&gt; self&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;in&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            guard&lt;/span&gt;&lt;span&gt; let&lt;/span&gt;&lt;span&gt; self&lt;/span&gt;&lt;span&gt; else&lt;/span&gt;&lt;span&gt; { &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            var&lt;/span&gt;&lt;span&gt; remainingTargets: [ControlBlockTarget] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; []&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            for&lt;/span&gt;&lt;span&gt; target &lt;/span&gt;&lt;span&gt;in&lt;/span&gt;&lt;span&gt; self&lt;/span&gt;&lt;span&gt;.blockTargets {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                if&lt;/span&gt;&lt;span&gt; target.events &lt;/span&gt;&lt;span&gt;==&lt;/span&gt;&lt;span&gt; events {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                    // 完全匹配时移除&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                    self&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt;removeTarget&lt;/span&gt;&lt;span&gt;(target, &lt;/span&gt;&lt;span&gt;action&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;nil&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;: target.events)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                } &lt;/span&gt;&lt;span&gt;else&lt;/span&gt;&lt;span&gt; if&lt;/span&gt;&lt;span&gt; target.events.&lt;/span&gt;&lt;span&gt;contains&lt;/span&gt;&lt;span&gt;(events) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                    // 处理事件交集的情况&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                    let&lt;/span&gt;&lt;span&gt; newEvents &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; target.events.&lt;/span&gt;&lt;span&gt;subtracting&lt;/span&gt;&lt;span&gt;(events)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                    if&lt;/span&gt;&lt;span&gt; !&lt;/span&gt;&lt;span&gt;newEvents.&lt;/span&gt;&lt;span&gt;isEmpty&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                        self&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt;removeTarget&lt;/span&gt;&lt;span&gt;(target, &lt;/span&gt;&lt;span&gt;action&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;nil&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;: target.events)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                        target.events &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; newEvents&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                        self&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt;addTarget&lt;/span&gt;&lt;span&gt;(target, &lt;/span&gt;&lt;span&gt;action&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#selector&lt;/span&gt;&lt;span&gt;(ControlBlockTarget.&lt;/span&gt;&lt;span&gt;invoke&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;sender:&lt;/span&gt;&lt;span&gt;)), &lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;: newEvents)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                        remainingTargets.&lt;/span&gt;&lt;span&gt;append&lt;/span&gt;&lt;span&gt;(target)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                    } &lt;/span&gt;&lt;span&gt;else&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                        self&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt;removeTarget&lt;/span&gt;&lt;span&gt;(target, &lt;/span&gt;&lt;span&gt;action&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;nil&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;: target.events)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                } &lt;/span&gt;&lt;span&gt;else&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                    remainingTargets.&lt;/span&gt;&lt;span&gt;append&lt;/span&gt;&lt;span&gt;(target)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            self&lt;/span&gt;&lt;span&gt;.blockTargets &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; remainingTargets&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    /// 原子化移除所有 Block&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    public&lt;/span&gt;&lt;span&gt; func&lt;/span&gt;&lt;span&gt; sb_removeAllBlocks&lt;/span&gt;&lt;span&gt;() {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        sb_removeAllBlocks&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;: .allEvents)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // MARK: - Private Properties&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    private&lt;/span&gt;&lt;span&gt; var&lt;/span&gt;&lt;span&gt; blockTargets: [ControlBlockTarget] {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        get&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            objc_getAssociatedObject&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;self&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;AssociatedKeys.blockKey) &lt;/span&gt;&lt;span&gt;as?&lt;/span&gt;&lt;span&gt; [ControlBlockTarget] &lt;/span&gt;&lt;span&gt;??&lt;/span&gt;&lt;span&gt; []&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        set&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            objc_setAssociatedObject&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                self&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                &amp;amp;&lt;/span&gt;&lt;span&gt;AssociatedKeys.blockKey,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                newValue,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                .OBJC_ASSOCIATION_RETAIN_NONATOMIC&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;使用示例&lt;a href=&quot;#使用示例&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;let&lt;/span&gt;&lt;span&gt; button &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; UIButton&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;button.&lt;/span&gt;&lt;span&gt;sb_addBlock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;: .touchUpInside) { [&lt;/span&gt;&lt;span&gt;weak&lt;/span&gt;&lt;span&gt; self&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;_&lt;/span&gt;&lt;span&gt; in&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    self&lt;/span&gt;&lt;span&gt;?&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt;handleLogin&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 替换现有事件&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;button.&lt;/span&gt;&lt;span&gt;sb_setBlock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;: .touchDragExit) { &lt;/span&gt;&lt;span&gt;_&lt;/span&gt;&lt;span&gt; in&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    print&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;拖动取消操作&quot;&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 批量移除事件&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;view.&lt;/span&gt;&lt;span&gt;sb_removeAllBlocks&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;: .allTouchEvents)&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;注意事项&lt;a href=&quot;#注意事项&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;不可嵌套调用&lt;/strong&gt;：避免在 Block 内执行 &lt;code&gt;sb_removeAllBlocks&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;优先级控制&lt;/strong&gt;：与系统 &lt;code&gt;addTarget&lt;/code&gt; 方法混用时注意执行顺序&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;性能监控&lt;/strong&gt;：在列表滚动等高频场景建议使用节流包装器&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;调试技巧&lt;/strong&gt;：通过 &lt;code&gt;po blockTargets&lt;/code&gt; 在 LLDB 查看当前事件绑定状态&lt;/li&gt;
&lt;/ol&gt;</content:encoded><category>category:笔记</category><category>tag:Swift</category></item><item><title>前端代码规范</title><link>https://www.dreameverafter.com/en/post/%E5%89%8D%E7%AB%AF%E4%BB%A3%E7%A0%81%E8%A7%84%E8%8C%83</link><guid isPermaLink="false">en:前端代码规范</guid><description>代码规范</description><pubDate>Mon, 23 Dec 2024 12:17:35 GMT</pubDate><content:encoded>&lt;h1&gt;前端开发规范&lt;a href=&quot;#前端开发规范&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;h2&gt;命名规范&lt;a href=&quot;#命名规范&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;避免使用缩写，除非缩写广泛接受并理解。&lt;/li&gt;
&lt;li&gt;使用有意义的变量、函数和类名。&lt;/li&gt;
&lt;li&gt;变量和函数名使用驼峰命名法（e.g., &lt;code&gt;myVariableName&lt;/code&gt;）。&lt;/li&gt;
&lt;li&gt;常量全部大写。&lt;/li&gt;
&lt;li&gt;类名使用帕斯卡命名法（e.g., &lt;code&gt;MyClassName&lt;/code&gt;）。&lt;/li&gt;
&lt;li&gt;对于代码文件，文件名使用驼峰命名法（e.g., myFile.js or myFile.ts）。&lt;/li&gt;
&lt;li&gt;对于静态文件，如图片文件，文件名使用蛇形命名法（e.g., my_file.png）。&lt;/li&gt;
&lt;li&gt;目录使用使用驼峰命名法（e.g., &lt;code&gt;myFolderName&lt;/code&gt;）。&lt;/li&gt;
&lt;li&gt;目录和非静态文件也可以用烤串命名法Kebab Case，但是烤串，就都烤串，保持一致性（my-folder-name）。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;缩进和空格&lt;a href=&quot;#缩进和空格&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;使用两个空格进行缩进。&lt;/li&gt;
&lt;li&gt;使用一致的缩进风格，不混用空格和制表符。&lt;/li&gt;
&lt;li&gt;在代码块之间使用空行进行分隔，以提高可读性。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;注释&lt;a href=&quot;#注释&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;使用注释来解释代码的关键部分和复杂逻辑。&lt;/li&gt;
&lt;li&gt;使用注释文档化函数、方法和类的目的和参数。&lt;/li&gt;
&lt;li&gt;删除不再需要的注释，以保持代码干净。&lt;/li&gt;
&lt;/ul&gt;
&lt;h1&gt;前端HTML规范&lt;a href=&quot;#前端html规范&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;h2&gt;目的&lt;a href=&quot;#目的&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;本规范旨在确保前端开发项目中的HTML代码具有一致性，易于维护和理解。&lt;/p&gt;
&lt;h2&gt;基本规则&lt;a href=&quot;#基本规则&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;缩进和空格&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用两个空格作为缩进。&lt;/li&gt;
&lt;li&gt;不要使用制表符。&lt;/li&gt;
&lt;li&gt;在标签之间使用一个空格。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;小写字母&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;所有HTML标签、属性和属性值应该使用小写字母。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;文件编码&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用UTF-8编码作为HTML文档的字符编码。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;注释&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用HTML注释来解释代码的功能，如&lt;code&gt;&amp;lt;!-- 这是一个注释 --&amp;gt;&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;自闭合标签&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;对于自闭合标签（如&lt;code&gt;&amp;lt;img&amp;gt;&lt;/code&gt;、&lt;code&gt;&amp;lt;input&amp;gt;&lt;/code&gt;），不要在结束标签中添加斜杠，即使用&lt;code&gt;&amp;lt;img&amp;gt;&lt;/code&gt;而不是&lt;code&gt;&amp;lt;img /&amp;gt;&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;结构&lt;a href=&quot;#结构&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;文档类型声明&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用HTML5文档类型声明：&lt;code&gt;&amp;lt;!DOCTYPE html&amp;gt;&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;文档结构&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用语义化标签如&lt;code&gt;&amp;lt;header&amp;gt;&lt;/code&gt;、&lt;code&gt;&amp;lt;nav&amp;gt;&lt;/code&gt;、&lt;code&gt;&amp;lt;main&amp;gt;&lt;/code&gt;、&lt;code&gt;&amp;lt;section&amp;gt;&lt;/code&gt;等来组织文档内容。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;标题&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;每个页面应该有一个明确的&lt;code&gt;&amp;lt;title&amp;gt;&lt;/code&gt;标签。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;语言属性&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;指定页面的语言属性：&lt;code&gt;&amp;lt;html lang=&quot;en&quot;&amp;gt;&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;标签&lt;a href=&quot;#标签&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;嵌套规则&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;标签应该按照正确的嵌套规则嵌套，不要出现不正确的嵌套。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;自定义属性&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;避免使用自定义属性，应该使用&lt;code&gt;data-*&lt;/code&gt;属性来存储自定义数据。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;属性&lt;a href=&quot;#属性&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;引号&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用双引号来包裹属性值，如&lt;code&gt;&amp;lt;input type=&quot;text&quot; class=&quot;input-text&quot;&amp;gt;&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;布尔属性&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;对于布尔属性如&lt;code&gt;disabled&lt;/code&gt;、&lt;code&gt;checked&lt;/code&gt;，不要添加属性值，直接使用属性名即可：&lt;code&gt;&amp;lt;input type=&quot;checkbox&quot; checked&amp;gt;&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;CSS和JavaScript&lt;a href=&quot;#css和javascript&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;外部资源&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;将CSS和JavaScript文件包含在HTML文档的底部，以避免阻塞页面加载。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;内联样式和脚本&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;尽量避免使用内联样式和脚本，将样式和脚本从HTML中分离出来。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;性能&lt;a href=&quot;#性能&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;图像优化&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用适当的图像格式（如WebP）和压缩工具以提高性能。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;资源缓存&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;配置HTTP缓存头来提高资源的缓存性能。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;验证和测试&lt;a href=&quot;#验证和测试&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;HTML验证&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用HTML验证工具，如W3C验证器，来确保HTML代码的合法性。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;跨浏览器测试&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;在不同浏览器和设备上测试页面，确保页面在各种环境下都能正确显示和工作。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;参考链接&lt;a href=&quot;#参考链接&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://html.spec.whatwg.org/multipage/&quot;&gt;HTML Living Standard&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://validator.w3.org/&quot;&gt;W3C HTML Validation Service&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h1&gt;CSS规范 - Less 代码规范&lt;a href=&quot;#css规范---less-代码规范&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;p&gt;本文档旨在定义Less样式表的编码规范，以确保代码的一致性和可维护性。遵循这些规则将有助于团队协作和项目的可持续性。&lt;/p&gt;
&lt;h2&gt;文件结构&lt;a href=&quot;#文件结构&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;1. 文件命名&lt;a href=&quot;#1-文件命名&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;使用有意义的文件名，描述文件中包含的样式内容。&lt;/li&gt;
&lt;li&gt;使用小写字母和连字符（&lt;code&gt;-&lt;/code&gt;）作为文件名的分隔符。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;header&lt;/span&gt;&lt;span&gt;.less&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;product-list&lt;/span&gt;&lt;span&gt;.less&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2. 文件组织&lt;a href=&quot;#2-文件组织&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;根据模块或功能将样式文件组织成目录。&lt;/li&gt;
&lt;li&gt;避免创建过大的样式文件，应该根据需要拆分为多个文件。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例：&lt;/strong&gt;&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;styles/&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  ├── common/&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  │     ├── typography.less&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  │     ├── layout.less&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  ├── components/&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  │     ├── buttons.less&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  │     ├── forms.less&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  ├── pages/&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  │     ├── home.less&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  │     ├── product.less&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h2&gt;样式规范&lt;a href=&quot;#样式规范&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;3. 命名约定&lt;a href=&quot;#3-命名约定&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;使用有意义的类名和变量名，描述其用途而不是样式的外观。&lt;/li&gt;
&lt;li&gt;使用小写字母和连字符作为类名和变量名的分隔符。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;.header&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  background-color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#333&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#fff&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;$&lt;/span&gt;&lt;span&gt;primary-color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#3498db&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4. 嵌套规则&lt;a href=&quot;#4-嵌套规则&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;使用嵌套规则以提高可读性，但不要滥用。&lt;/li&gt;
&lt;li&gt;避免嵌套深度过深，通常不超过3层。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例：&lt;/strong&gt;&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;.nav&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  ul&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    li&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;      a&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#333&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        &amp;amp;&lt;/span&gt;&lt;span&gt;:&lt;/span&gt;&lt;span&gt;hover&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;          color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#3498db&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;      }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;5. 变量和Mixin&lt;a href=&quot;#5-变量和mixin&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;使用变量存储重复的值，如颜色、字体、尺寸等。&lt;/li&gt;
&lt;li&gt;使用Mixin来组织可重复使用的样式规则。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例：&lt;/strong&gt;&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;@&lt;/span&gt;&lt;span&gt;primary-color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#3498db&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;.button&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#fff&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  background-color&lt;/span&gt;&lt;span&gt;: @&lt;/span&gt;&lt;span&gt;primary-color&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  border&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;span&gt;px&lt;/span&gt;&lt;span&gt; solid&lt;/span&gt;&lt;span&gt; darken&lt;/span&gt;&lt;span&gt;(@&lt;/span&gt;&lt;span&gt;primary-color&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;10&lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  border-radius&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;4&lt;/span&gt;&lt;span&gt;px&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;.rounded-corners&lt;/span&gt;&lt;span&gt;() {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  border-radius&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;4&lt;/span&gt;&lt;span&gt;px&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;.element&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  .rounded-corners&lt;/span&gt;&lt;span&gt;();&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  background-color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#f5f5f5&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;6. 注释&lt;a href=&quot;#6-注释&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;使用注释来解释样式的用途、兼容性注意事项、以及其他必要信息。&lt;/li&gt;
&lt;li&gt;使用单行注释（&lt;code&gt;//&lt;/code&gt;）来注释一行样式，使用块注释（&lt;code&gt;/* */&lt;/code&gt;）来注释多行或较大的代码块。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例：&lt;/strong&gt;&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// 主标题样式&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  font-size&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;24&lt;/span&gt;&lt;span&gt;px&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  font-weight&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;bold&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;/*&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  .sidebar 样式&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  注意：IE 11 不支持 flex 布局&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;*/&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;.sidebar&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  display&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;flex&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  // 其他样式规则&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h2&gt;编码规范&lt;a href=&quot;#编码规范&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;7. 缩进和空格&lt;a href=&quot;#7-缩进和空格&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;使用两个空格作为缩进。&lt;/li&gt;
&lt;li&gt;在属性和值之间使用一个空格。&lt;/li&gt;
&lt;li&gt;在冒号后面加一个空格，如&lt;code&gt;property: value;&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;.header&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  background-color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#333&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#fff&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  margin&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;10&lt;/span&gt;&lt;span&gt;px&lt;/span&gt;&lt;span&gt; 0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;8. 排版&lt;a href=&quot;#8-排版&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;使用一致的排版规则，如在大括号前换行，并在大括号后加空格。&lt;/li&gt;
&lt;li&gt;使用单引号（&lt;code&gt;&apos;&lt;/code&gt;）而不是双引号（&lt;code&gt;&quot;&lt;/code&gt;）来定义字符串值。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;.button&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#fff&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  background-color&lt;/span&gt;&lt;span&gt;: @&lt;/span&gt;&lt;span&gt;primary-color&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;9. 换行&lt;a href=&quot;#9-换行&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;样式规则之间使用空行分隔，提高可读性。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例：&lt;/strong&gt;&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;.header&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  background-color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#333&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  color&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;#fff&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;.content&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  font-size&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;16&lt;/span&gt;&lt;span&gt;px&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  line-height&lt;/span&gt;&lt;span&gt;: &lt;/span&gt;&lt;span&gt;1.5&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;10. 良好的实践&lt;a href=&quot;#10-良好的实践&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;避免使用&lt;code&gt;!important&lt;/code&gt;，除非绝对必要。&lt;/li&gt;
&lt;li&gt;避免使用通配符选择器（&lt;code&gt;*&lt;/code&gt;）和ID选择器。&lt;/li&gt;
&lt;li&gt;遵循DRY（不要重复自己）原则，避免重复的样式规则。&lt;/li&gt;
&lt;/ul&gt;
&lt;h1&gt;JavaScript规范&lt;a href=&quot;#javascript规范&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;h2&gt;命名规范&lt;a href=&quot;#命名规范-1&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;变量和函数名&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用有意义的名称，避免单个字符的变量名。&lt;/li&gt;
&lt;li&gt;使用驼峰命名法（camelCase）来命名变量和函数，例如：&lt;code&gt;myVariableName&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;类名使用帕斯卡命名法（PascalCase），例如：&lt;code&gt;MyClassName&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;常量&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用全大写字母和下划线（UPPER_CASE）来命名常量。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;构造函数&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;构造函数的名称应以大写字母开头，例如：&lt;code&gt;function MyConstructor() {}&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;缩进和空格&lt;a href=&quot;#缩进和空格-1&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;缩进和空格&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用两个空格进行缩进。&lt;/li&gt;
&lt;li&gt;不混用空格和制表符。&lt;/li&gt;
&lt;li&gt;使用一致的缩进风格。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;行尾空格&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;避免在行尾添加空格。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;注释&lt;a href=&quot;#注释-1&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;代码注释&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用注释来解释代码的关键部分、复杂逻辑、以及不明显的业务规则。&lt;/li&gt;
&lt;li&gt;使用多行注释（&lt;code&gt;/* ... */&lt;/code&gt;）或单行注释（&lt;code&gt;// ...&lt;/code&gt;）根据情况选择。&lt;/li&gt;
&lt;li&gt;注释应该清晰、简洁、和正确地反映代码的意图。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;文档化注释&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;在函数、方法和类的定义上使用文档化注释，描述它们的目的、参数、返回值等信息。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;变量和作用域&lt;a href=&quot;#变量和作用域&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;变量声明&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;始终使用&lt;code&gt;let&lt;/code&gt;或&lt;code&gt;const&lt;/code&gt;来声明变量，避免使用&lt;code&gt;var&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;全局变量&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;最小化全局变量的使用，将变量限制在函数作用域或块作用域内。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;变量的初始化&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;在声明变量时，始终进行初始化。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;变量作用域&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;尽量将变量的作用域限制在最小范围内，避免全局作用域污染。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;函数&lt;a href=&quot;#函数&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;函数声明&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用函数表达式或箭头函数而不是函数声明。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;函数参数&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用有意义的参数名称。&lt;/li&gt;
&lt;li&gt;避免过多的参数，最好控制在3-4个以内。&lt;/li&gt;
&lt;li&gt;使用默认参数值，以避免未定义的参数值。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;返回语句&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;每个函数应该有一个明确定义的返回语句。&lt;/li&gt;
&lt;li&gt;避免在函数中早期返回。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;函数长度&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;函数应保持短小，一般不超过20行。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;条件语句和循环&lt;a href=&quot;#条件语句和循环&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;条件语句&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用&lt;code&gt;if&lt;/code&gt;，&lt;code&gt;else if&lt;/code&gt;，&lt;code&gt;else&lt;/code&gt;，&lt;code&gt;switch&lt;/code&gt;等条件语句来处理条件逻辑。&lt;/li&gt;
&lt;li&gt;避免嵌套过深的条件语句。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;循环&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用&lt;code&gt;for&lt;/code&gt;、&lt;code&gt;while&lt;/code&gt;和&lt;code&gt;do...while&lt;/code&gt;等循环结构来处理迭代。&lt;/li&gt;
&lt;li&gt;避免无限循环。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;异步编程&lt;a href=&quot;#异步编程&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;异步编程&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;使用Promise、async/await等来处理异步操作，避免回调地狱。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;模块化&lt;a href=&quot;#模块化&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;模块化&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;使用ES6模块系统（&lt;code&gt;import&lt;/code&gt;和&lt;code&gt;export&lt;/code&gt;）来组织代码。&lt;/li&gt;
&lt;li&gt;避免全局变量和函数。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;错误处理&lt;a href=&quot;#错误处理&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;错误处理&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;使用&lt;code&gt;try...catch&lt;/code&gt;块来处理可能的异常。&lt;/li&gt;
&lt;li&gt;自定义错误类型，以便更好地识别错误的来源。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;示例&lt;a href=&quot;#示例&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;在块中始终使用括号以增加可读性：&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// 好的...&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;while&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;true&lt;/span&gt;&lt;span&gt;) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  shuffle&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 不好的...&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;while&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;true&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  shuffle&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 也不好...&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;while&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;true&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;shuffle&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;使用 &lt;code&gt;===&lt;/code&gt; 比较运算符，以避免处理类型强制转换的复杂性。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;一致使用引号，例如，只在代码中使用单引号或双引号，不要混合使用。除非有正当理由，否则更喜欢使用单引号，以便其中的 HTML 无需转义。例如：&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  // 好的...&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  const&lt;/span&gt;&lt;span&gt; foo&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; &apos;只是一个普通的字符串&apos;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  // 好的...&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  const&lt;/span&gt;&lt;span&gt; foo&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; &apos;&amp;lt;a href=&quot;/bar&quot;&amp;gt;漂亮干净的 HTML 字符串&amp;lt;/a&amp;gt;&apos;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  // 不好的...&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  const&lt;/span&gt;&lt;span&gt; foo&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; &quot;&amp;lt;a href=&lt;/span&gt;&lt;span&gt;\&quot;&lt;/span&gt;&lt;span&gt;/bar&lt;/span&gt;&lt;span&gt;\&quot;&lt;/span&gt;&lt;span&gt;&amp;gt;带有转义双引号的 HTML 字符串&amp;lt;/a&amp;gt;&quot;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;使用 &lt;code&gt;event.preventDefault()&lt;/code&gt; 代替 &lt;code&gt;return false&lt;/code&gt; 以阻止默认事件操作。在考虑上下文为事件时，返回布尔值在语义上是不正确的。&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// 在这个上下文中，返回 false 没有意义&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;htmlElement.&lt;/span&gt;&lt;span&gt;addEventListener&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&apos;click&apos;&lt;/span&gt;&lt;span&gt;, (&lt;/span&gt;&lt;span&gt;e&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;=&amp;gt;&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  // 做一些事情&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  return&lt;/span&gt;&lt;span&gt; false&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;})&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 使用 preventDefault&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;htmlElement.&lt;/span&gt;&lt;span&gt;addEventListener&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&apos;click&apos;&lt;/span&gt;&lt;span&gt;, (&lt;/span&gt;&lt;span&gt;e&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;=&amp;gt;&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  e.&lt;/span&gt;&lt;span&gt;preventDefault&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  // 做一些事情&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;})&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;不再使用 &lt;code&gt;var&lt;/code&gt; - 我们有 &lt;code&gt;const&lt;/code&gt; 和 &lt;code&gt;let&lt;/code&gt;，Babel 将根据需要进行编译。在 JavaScript 中，&lt;code&gt;const&lt;/code&gt; 表示标识符不能被重新分配。&lt;code&gt;let&lt;/code&gt; 表示变量可能会被重新分配，它还表示该变量只在其定义的块中使用。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;单个 let 模式：&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// 单个 let 模式：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;let&lt;/span&gt;&lt;span&gt; mylet1 &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; 1&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    anotherlet2 &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &apos;test&apos;&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    andAnotherlet &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; true&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 这样可以吗？&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;let&lt;/span&gt;&lt;span&gt; mylet1 &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; 1&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    anotherlet2 &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &apos;test&apos;&lt;/span&gt;&lt;span&gt; // 糟糕，自动分号插入在这里弹出了一个分号...&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    andAnotherlet &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; true&lt;/span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;// 现在是全局的&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 更好？&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;let&lt;/span&gt;&lt;span&gt; a &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; 1&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  , b &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; 2&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  , sum &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; a &lt;/span&gt;&lt;span&gt;+&lt;/span&gt;&lt;span&gt; b&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  , myobject &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; {}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  , i&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  , j&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 传统的多个 let 模式：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;let&lt;/span&gt;&lt;span&gt; myLet &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; 1&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;let&lt;/span&gt;&lt;span&gt; anotherLet2 &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &apos;test&apos;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;let&lt;/span&gt;&lt;span&gt; andAnotherLet &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; true&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;不要使用分号 - JavaScript 不需要它们&lt;a href=&quot;#不要使用分号---javascript-不需要它们&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;h3&gt;避免过多的函数参数&lt;a href=&quot;#避免过多的函数参数&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;如果一个函数需要超过三个参数，考虑重构以使用配置对象：&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// 不好&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;let&lt;/span&gt;&lt;span&gt; myFunction1&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; function&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;arg1&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;arg2&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;arg3&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;arg4&lt;/span&gt;&lt;span&gt;) {}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;myFunction1&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&apos;firstArgument&apos;&lt;/span&gt;&lt;span&gt;, argument2, &lt;/span&gt;&lt;span&gt;true&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&apos;My Third Argument&apos;&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 好的&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;let&lt;/span&gt;&lt;span&gt; myFunction2&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; function&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;config&lt;/span&gt;&lt;span&gt;) {}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;myFunction2&lt;/span&gt;&lt;span&gt;({&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  arg1: &lt;/span&gt;&lt;span&gt;&apos;firstArgument&apos;&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  arg2: argument2&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  arg3: &lt;/span&gt;&lt;span&gt;true&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  arg4: &lt;/span&gt;&lt;span&gt;&apos;My Third Argument&apos;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;})&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;配置对象：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;允许可选参数，&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;更易于阅读，&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;更易于维护。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;命名约定&lt;a href=&quot;#命名约定&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;尽管我们可以推断 &lt;code&gt;_oA&lt;/code&gt; 是一个私有对象，但我们对它将包含的值一无所知。&lt;/p&gt;
&lt;p&gt;对于长寿命变量，请使用既有描述性又简洁的变量名称。避免在上下文之外使用可能被视为保留变量名称的名称。例如&lt;/p&gt;
&lt;p&gt;，在 JavaScript 中，&lt;code&gt;e&lt;/code&gt; 被视为事件对象。不要将其用于其他用途。&lt;/p&gt;
&lt;p&gt;对于临时变量，即用于存储短寿命值的变量，例如用于迭代的变量，可以使用不具描述性的名称，例如 &lt;code&gt;i, j, k&lt;/code&gt;。&lt;/p&gt;
&lt;h3&gt;注释&lt;a href=&quot;#注释-2&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;注释您的代码。有两个原因您应该进行注释：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;内联注释解释不能仅通过代码传达的设计或架构决策。这些主要是为了其他开发人员修改、扩展或调试代码的好处，但也适用于您 - 一周后您可能会回到代码并想知道它是如何工作的。&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;/**&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; * 我是一个格式良好的注释&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; */&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 我是一个格式良好的简短单行注释&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;let&lt;/span&gt;&lt;span&gt; i &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; 0&lt;/span&gt;&lt;span&gt;; i &lt;/span&gt;&lt;span&gt;&amp;lt;&lt;/span&gt;&lt;span&gt; 10&lt;/span&gt;&lt;span&gt;; i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;); &lt;/span&gt;&lt;span&gt;// 哎呀，不要在行尾添加注释&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;/* ===================================================&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; * 哎呀，不要制定自己的注释格式&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; * ==================================================*/&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 这是一个长注释&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 它真的不应该&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 使用单行&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 注释语法。&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;为那些想要使用您的库/插件等而不阅读代码的用户提供 API 文档。使用 JSDoc 标准对文件和函数进行注释：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;/**&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; * &lt;/span&gt;&lt;span&gt;@file&lt;/span&gt;&lt;span&gt; 用于构建产品色板的 jQuery UI Widget&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; * &lt;/span&gt;&lt;span&gt;@author&lt;/span&gt;&lt;span&gt; Joel Mitchell&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; * &lt;/span&gt;&lt;span&gt;@name&lt;/span&gt;&lt;span&gt; $.cx.productSwatch&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; * @dependencies: jQuery, jQuery UI widget 工厂（用于测试的 mockjax）&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; */&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;/**&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; * 用于关闭菜单的事件处理程序&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; * &lt;/span&gt;&lt;span&gt;@param&lt;/span&gt;&lt;span&gt; {Event}&lt;/span&gt;&lt;span&gt; e&lt;/span&gt;&lt;span&gt; jQuery 事件对象&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt; */&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;var&lt;/span&gt;&lt;span&gt; myFunction&lt;/span&gt;&lt;span&gt; =&lt;/span&gt;&lt;span&gt; function&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;e&lt;/span&gt;&lt;span&gt;) {}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;将代码分隔为单独的行&lt;a href=&quot;#将代码分隔为单独的行&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;在适用的情况下，请确保代码写在单独的行上，以帮助 Git 差异和错误报告：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// 好的&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;page.&lt;/span&gt;&lt;span&gt;setViewport&lt;/span&gt;&lt;span&gt;({&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  width: &lt;/span&gt;&lt;span&gt;1280&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  height: &lt;/span&gt;&lt;span&gt;1024&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;})&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 不太好&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;page.&lt;/span&gt;&lt;span&gt;setViewport&lt;/span&gt;&lt;span&gt;({width: &lt;/span&gt;&lt;span&gt;1280&lt;/span&gt;&lt;span&gt;, height: &lt;/span&gt;&lt;span&gt;1024&lt;/span&gt;&lt;span&gt;})&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h1&gt;Vue规范&lt;a href=&quot;#vue规范&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;p&gt;参考：&lt;a href=&quot;https://v2.cn.vuejs.org/v2/style-guide/index.html&quot;&gt;https://v2.cn.vuejs.org/v2/style-guide/index.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;单文件组件的文件名应该要么始终是单词大写开头 (PascalCase)，要么始终是横线连接 (kebab-case)。&lt;/p&gt;
&lt;p&gt;对于绝大多数项目来说，在单文件组件和字符串模板中组件名应该总是 PascalCase 的——但是在 DOM 模板中总是 kebab-case 的。&lt;/p&gt;
&lt;p&gt;PascalCase 相比 kebab-case 有一些优势：&lt;/p&gt;
&lt;p&gt;编辑器可以在模板里自动补全组件名，因为 PascalCase 同样适用于 JavaScript。
 视觉上比  更能够和单个单词的 HTML 元素区别开来，因为前者的不同之处有两个大写字母，后者只有一个横线。
如果你在模板中使用任何非 Vue 的自定义元素，比如一个 Web Component，PascalCase 确保了你的 Vue 组件在视觉上仍然是易识别的。
不幸的是，由于 HTML 是大小写不敏感的，在 DOM 模板中必须仍使用 kebab-case。&lt;/p&gt;
&lt;p&gt;还请注意，如果你已经是 kebab-case 的重度用户，那么与 HTML 保持一致的命名约定且在多个项目中保持相同的大小写规则就可能比上述优势更为重要了。在这些情况下，在所有的地方都使用 kebab-case 同样是可以接受的&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;&amp;lt;!-- 在单文件组件和字符串模板中 --&amp;gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&amp;lt;MyComponent/&amp;gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&amp;lt;!-- 在 DOM 模板中 --&amp;gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&amp;lt;my-component&amp;gt;&amp;lt;/my-component&amp;gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&amp;lt;!-- 或者在所有地方 --&amp;gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&amp;lt;my-component&amp;gt;&amp;lt;/my-component&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;</content:encoded><category>category:开发</category><category>tag:前端</category></item><item><title>设计模式</title><link>https://www.dreameverafter.com/en/post/she-ji-mo-shi</link><guid isPermaLink="false">en:she-ji-mo-shi</guid><description>行为模式 Chain Of Responsibilit（责任链） 意图：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连城一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。 适用性 有多个对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。 你想在不</description><pubDate>Mon, 28 Oct 2024 02:08:28 GMT</pubDate><content:encoded>&lt;h2&gt;行为模式&lt;a href=&quot;#行为模式&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;Chain Of Responsibilit（责任链）&lt;a href=&quot;#chain-of-responsibilit责任链&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连城一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;有多个对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。&lt;/li&gt;
&lt;li&gt;你想在不明确指定接受者的情况下，向多个对象中的一个提交一个请求。&lt;/li&gt;
&lt;li&gt;可处理一个请求的对象集合应被动态指定。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;降低耦合度。&lt;/li&gt;
&lt;li&gt;增强了给对象指派职责的灵活性。&lt;/li&gt;
&lt;li&gt;不保证被接受。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;职责链常与Composite一起使用。这种情况下，一个构件的父构件可作为它的后继。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Command（命令）&lt;a href=&quot;#command命令&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。&lt;/li&gt;
&lt;li&gt;别名：动作（Action），事物（Transaction）。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;抽象出待执行的动作以参数化某对象。&lt;/li&gt;
&lt;li&gt;在不同的时刻指定、排列和执行请求。&lt;/li&gt;
&lt;li&gt;支持取消操作。&lt;/li&gt;
&lt;li&gt;支持修改日志，这样当系统崩溃时，这些修改可以被充作一遍。&lt;/li&gt;
&lt;li&gt;用构建在原语操作上的高层操作构造一个系统。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;命令模式将调用操作的对象与知道如何实现该操作的对象解偶。&lt;/li&gt;
&lt;li&gt;命令时头等的对象。它们可像其他的对象一样被操作和扩展。&lt;/li&gt;
&lt;li&gt;你可将多个命令装配成一个复合命令。&lt;/li&gt;
&lt;li&gt;增加新的命令很容易，因为这无需改变已有的类。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Composite 模式可被用来实现宏命令。&lt;/li&gt;
&lt;li&gt;Memento 模式可用来保持某个状态，命令用这一状态来取消它的效果。&lt;/li&gt;
&lt;li&gt;在被放入历史表列前必须被拷贝的命令起到一种原型的作用。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Interpreter（解释器）&lt;a href=&quot;#interpreter解释器&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;当有一个语言需要解释执行，并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。而当存在以下情况时该模式效果最好：
&lt;ul&gt;
&lt;li&gt;该文法简单对于复杂的文法，文法的类层次变得庞大而无法管理。&lt;/li&gt;
&lt;li&gt;效率不是一个关键问题，最高效的解释器通常不是通过直接解释语法分析树实现的，而是首先将它们转换成另一种形式。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;易于改变和扩展文法。&lt;/li&gt;
&lt;li&gt;也易于实现文法。&lt;/li&gt;
&lt;li&gt;复杂的文法难以维护。&lt;/li&gt;
&lt;li&gt;增加了新的解释表达式的方式。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Composite 模式：抽象语法树是一个复合模式的实例。&lt;/li&gt;
&lt;li&gt;Flyweight 模式：说明了如何在抽象语法树中共享终结符。&lt;/li&gt;
&lt;li&gt;Iterator：解释器可用一个迭代器遍历该结构。&lt;/li&gt;
&lt;li&gt;Visitor：可用来在一个类中维护抽象语法树中的各节点的行为。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Iterator（迭代器）&lt;a href=&quot;#iterator迭代器&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。&lt;/li&gt;
&lt;li&gt;别名：游标（Cursor）。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;访问一个聚合对象的内容而无需暴露它的内部表示。&lt;/li&gt;
&lt;li&gt;支持对聚合对象的多种遍历。&lt;/li&gt;
&lt;li&gt;为遍历不同的聚合结构提供一个统一的接口（即，支持多态迭代）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;他支持以不同的方式遍历一个聚合。&lt;/li&gt;
&lt;li&gt;迭代器简化了聚合的接口。&lt;/li&gt;
&lt;li&gt;在同一个聚合上可以有多个遍历。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Composite：迭代器常被应用到象符合这样的递归结构上。&lt;/li&gt;
&lt;li&gt;Factory Method：多态迭代器靠 Factory Method 来例化适当的迭代器子类。&lt;/li&gt;
&lt;li&gt;Memento：长于迭代器一起使用。迭代器可使用一个 memento 来捕获一个迭代的状态。迭代器在其内部存储 memento。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Mediator（中介者）&lt;a href=&quot;#mediator中介者&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：用一个中介对象来封装一系列的对象交互。中介者使用各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立的改变它们之间的交互。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;一组对象以定义良好但是复杂的方式进行通信。&lt;/li&gt;
&lt;li&gt;一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象。&lt;/li&gt;
&lt;li&gt;想定制一个分布在多个类中的行为，而又不想生成太多的子类。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;减少了子类生成。&lt;/li&gt;
&lt;li&gt;它将各个对象解耦。&lt;/li&gt;
&lt;li&gt;它简化了对象协议。&lt;/li&gt;
&lt;li&gt;它对对象如何协作进行了抽象。&lt;/li&gt;
&lt;li&gt;它使控件集中化。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Facade 与中介者的不同之处在于它是对一个对象子系统进行抽象，从而提供了一个更为方便的接口。他的协议时单向的，即 Facade 对象对这个子系统类提出请求，但反之则不行。相反，Mediator 提供了各 Colleague 对象不支持或不能支持的协作行为，而且协议时多向的。&lt;/li&gt;
&lt;li&gt;Colleague 可使用 Observer 模式与 Mediator 通信。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Memento（备忘录）&lt;a href=&quot;#memento备忘录&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。&lt;/li&gt;
&lt;li&gt;别名：Token。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;必须保存一个对象在某一个时刻的（部分）状态，这样以后需要时它才能恢复到先前的状态。&lt;/li&gt;
&lt;li&gt;如果一个用接口来让其它对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;保持封装边界。&lt;/li&gt;
&lt;li&gt;它简化了原发器。&lt;/li&gt;
&lt;li&gt;使用备忘录可能代价很高。&lt;/li&gt;
&lt;li&gt;定义宅接口和宽接口。&lt;/li&gt;
&lt;li&gt;维护备忘录的潜在代价。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Command：命令可使用备忘录来为可撤销的操作维护状态。&lt;/li&gt;
&lt;li&gt;Iterator：如前所述备忘录可用于迭代。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Observer（观察者）&lt;a href=&quot;#observer观察者&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：定义对象的一种一对多的依赖关系，当一个对象的状态放生改变时，所有依赖于它的对象都得到通知并被自动更新。&lt;/li&gt;
&lt;li&gt;别名：依赖（Dependents），发布-订阅（publish-Subscrib）&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;当一个抽象模型有两个方面，其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以独自地改变和复用。&lt;/li&gt;
&lt;li&gt;当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变。&lt;/li&gt;
&lt;li&gt;当一个对象必须通知其他对象，而他又不能假定其它对象是谁。换言之，你不希望这些对象是紧密耦合的。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;目标和观察者间的抽象耦合。&lt;/li&gt;
&lt;li&gt;支持广播通信。&lt;/li&gt;
&lt;li&gt;意外的更新。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;mediator：通过封装复杂的更新语义，ChangeManager 充当目标和观察者之间的中介者。&lt;/li&gt;
&lt;li&gt;Singleton：ChangeManager 可使用 Singleton 模式来保证它是唯一的并且是可全局访问的。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;State（状态)&lt;a href=&quot;#state状态&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。&lt;/li&gt;
&lt;li&gt;别名：状态对象（Objects for States）&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为。&lt;/li&gt;
&lt;li&gt;一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;它将与特定状态相关的行为局部化，并且将不同的状态行为分割开来。&lt;/li&gt;
&lt;li&gt;它使得状态转换显示化。&lt;/li&gt;
&lt;li&gt;State对象可被共享。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Flyweig 模式解释了何时以及怎样共享状态对象。&lt;/li&gt;
&lt;li&gt;状态对象通常都是 Singleton。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Strategy（策略）&lt;a href=&quot;#strategy策略&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：定义一系列算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。&lt;/li&gt;
&lt;li&gt;别名：政策（Policy）。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;许多相关的类仅仅是行为有异。&lt;/li&gt;
&lt;li&gt;需要使用一个算法的不同变体。&lt;/li&gt;
&lt;li&gt;算法使用客户不应该知道的数据。&lt;/li&gt;
&lt;li&gt;一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;相关算法系列。&lt;/li&gt;
&lt;li&gt;一个替代继承的方法。&lt;/li&gt;
&lt;li&gt;消除了一些条件语句。&lt;/li&gt;
&lt;li&gt;实现的选择。&lt;/li&gt;
&lt;li&gt;客户必须了解不同的 Strategy。&lt;/li&gt;
&lt;li&gt;Strategy 和 Context 之间的通信开销。&lt;/li&gt;
&lt;li&gt;增加了对象的数目。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Flyweight：Stratrgy 对象经常是很好的轻量级对象。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Template  Method（模板方法）&lt;a href=&quot;#template--method模板方法&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：定义一个操作中的算法骨架，而将一些步骤延迟到子类中。TemplateMethod 使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;一次性实现一个算法的不变部分，并将可变的行为留给子类来实现。&lt;/li&gt;
&lt;li&gt;各子类中公共的行为应被提出来并集中到一个公共父类中以避免代码重复。&lt;/li&gt;
&lt;li&gt;控制子类扩展。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;模板方法是一种代码复用的基本技术。它们在类库中尤为重要，它们提取了类库中的公共行为。&lt;/li&gt;
&lt;li&gt;模板方法导致一种反向的控制结构，这种结构有时被称为“好莱坞法则”，即“别找我们，我们找你”。这指的是一个父类调用一个子类的操作，而不是相反。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Factory Method 模式常被模板方法调用。&lt;/li&gt;
&lt;li&gt;Strategy：模板方法使用继承来改变算法的一部分。Strategy 使用委托来改变整个算法。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Visitor（访问者）&lt;a href=&quot;#visitor访问者&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：表示一个作用于某对象结构中各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。&lt;/li&gt;
&lt;li&gt;需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你像避免让这些操作“污染”这些对象的类。&lt;/li&gt;
&lt;li&gt;定义对象结构的类很少改变，但是经常需要在此结构上定义新的操作。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;访问者模式使得易于增加新的操作。&lt;/li&gt;
&lt;li&gt;访问者集中相关的操作而分离无关的操作。&lt;/li&gt;
&lt;li&gt;增加新的 ConcreteElement 类很困难。&lt;/li&gt;
&lt;li&gt;通过类层次进行访问。&lt;/li&gt;
&lt;li&gt;积累状态。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Composite：访问者可以用于对一个由 Composite 模式定义的对象结构进行操作。&lt;/li&gt;
&lt;li&gt;Interpreter：访问者可以用于解释。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;结构型模式&lt;a href=&quot;#结构型模式&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;Adapter 适配器&lt;a href=&quot;#adapter-适配器&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：将一个类的接口转换成客户希望的另外一个接口。Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。&lt;/li&gt;
&lt;li&gt;别名：包装器（Wrapper）&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;你想使用一个已经存在的类，而它的接口不符合你的需求。&lt;/li&gt;
&lt;li&gt;你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。&lt;/li&gt;
&lt;li&gt;（仅适用于对象 Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们都接口。对象适配器可以适配它的父类接口。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;类适配器
&lt;ul&gt;
&lt;li&gt;用一个具体的 Adapter 类对 Adaptee 和 Target 进行匹配。结果是当我们想要匹配一个类以及所有它的子类时，类 Adapter 将不能胜任工作。&lt;/li&gt;
&lt;li&gt;使得 Adapter 可以重定义 Adaptee 的部分行为，因为 Adapter 是 Adaptee 的一个子类。&lt;/li&gt;
&lt;li&gt;仅仅引入了一个对象，并不需要额外的指针以间接得到 adaptee。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;对象适配器
&lt;ul&gt;
&lt;li&gt;允许一个 Adapter 与多个 Adaptee——即 Adaptee 本身以及它的所有子类（如果有子类的话）同时工作。Adapter 也可以一次给所有的 Adaptee 添加功能。&lt;/li&gt;
&lt;li&gt;使得重定义 Adaptee 的行为比较困难。这就需要生成 Adaptee 的子类并且使得 Adapter 引用这个子类而不是引用 Adaptee 本身。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;模式 Bridge 的结构与对象适配器相似，但是 Bridge 模式的出发点不同：Bridge 目的是将接口部分和实现部分分离，从而对它们可以较为容易也相对独立的加以改变。而 Adapter 则意味着改变一个已有对象的接口。&lt;/li&gt;
&lt;li&gt;Decorator 模式增强了其他对象的功能而同时又不改变它的接口。因此 decorator 对应用程序的透明性比适配器要好。结果是 decorator 支持递归组合，而纯粹使用适配器是不可能实现这一点的。&lt;/li&gt;
&lt;li&gt;模式 Proxy 在不改变它的接口的条件下，将另一个对象定义了一个代理。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Bridge（桥接）&lt;a href=&quot;#bridge桥接&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：将抽象部分与它的实现部分分离，使它们都可以独立第变化。&lt;/li&gt;
&lt;li&gt;别名：Handle/Body&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;你不希望在抽象和它的实现部分之间有一个固定的绑定关系。例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换。&lt;/li&gt;
&lt;li&gt;类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。这时 Bridge 模式是你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。&lt;/li&gt;
&lt;li&gt;对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。&lt;/li&gt;
&lt;li&gt;（C）你想对客户完全隐藏抽象的实现部分。在 C 中，类的表示在类接口是可见的。&lt;/li&gt;
&lt;li&gt;当需要许多类要生成的时候（为各种子类互相支持功能，只能继续扩展子类以支持），这样一个类层次结构说明你必须将一个对象分解成两个部分。这种类层次结构为“嵌套的普化”。&lt;/li&gt;
&lt;li&gt;你想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点。一个简单的例子便是 Coplien 的 String 类，在这个类中多个对象可以共享同一个字符串表示（StringRep）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;分离接口及其实现部分。&lt;/li&gt;
&lt;li&gt;提高可扩充性。&lt;/li&gt;
&lt;li&gt;实现细节对客户通明。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Abstract Factory 模式可以用来创建和配置一个特定的 Bridge 模式。&lt;/li&gt;
&lt;li&gt;Adapter 模式用来帮助无关的类协同工作，它通常在系统设计完成后才会被使用。然而，Bridge 模式则是在系统开始时就被使用，它使得抽象接口和实现部分可以独立进行改变。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Composite（组成）&lt;a href=&quot;#composite组成&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：将对象组合成树形结构以表示“部分-整体”的层次结构。Composite 使得用户对单个对象和组合对象的使用具有一致性。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;你想表示对象的部分-整体层次结构。&lt;/li&gt;
&lt;li&gt;你希望用户忽略组合对象和单个对象的不同，用户将统一地使用组合结构中的所有对象 。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;定义了包含基本对象和组合对象的类层次结构。&lt;/li&gt;
&lt;li&gt;简化客户端代码。&lt;/li&gt;
&lt;li&gt;使得更容易增加新类型的组件。&lt;/li&gt;
&lt;li&gt;使你的设计变得更一般化。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;通常部件-父部件连接用于 Responsibilit of Chain 模式。&lt;/li&gt;
&lt;li&gt;Decorator 模式经常与 Composite 模式一起使用。&lt;/li&gt;
&lt;li&gt;Flyweight 让你共享组件，但不再能引用他们的父控件。&lt;/li&gt;
&lt;li&gt;Itertor 可用来便利 Composite。&lt;/li&gt;
&lt;li&gt;Visitor 将本来应该分布在 Composite 和 Leaf 类中的操作和行为局部化。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Decorator（装饰）&lt;a href=&quot;#decorator装饰&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：动态地给一个对象添加一些额外的职责。就增加新功能来说，Decorator 模式相比生成子类更为灵活。&lt;/li&gt;
&lt;li&gt;别名：包装器（wrapper）&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。&lt;/li&gt;
&lt;li&gt;处理那些可以撤销的职责。&lt;/li&gt;
&lt;li&gt;当不能采用生成子类的方法进行扩充时。
&lt;ul&gt;
&lt;li&gt;可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。&lt;/li&gt;
&lt;li&gt;因为类定义被隐藏，或类定义不能用于生成子类。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;比静态继承更灵活。&lt;/li&gt;
&lt;li&gt;避免在层次结构高层的类有太多的特征。&lt;/li&gt;
&lt;li&gt;Decorator 与它的 Component 不一样。&lt;/li&gt;
&lt;li&gt;有许多小对象。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Adapter 模式：Decorator 模式不同于 Adapter 模式，因为装饰仅改变对象的职责而不改变它的接口；而适配器将给对象一个全新的接口。&lt;/li&gt;
&lt;li&gt;Composite 模式：可以将装饰视为一个退化的，仅有一个组件的组合。然而，装饰仅给对象添加一些额外的职责——它的目的不在于对象聚集。&lt;/li&gt;
&lt;li&gt;Strategy 模式：用一个装饰你可以改变对象的外表；而 Strategy 模式使得你可以改变对象的内核。这是改变对象的两种途径。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Facade（外观）&lt;a href=&quot;#facade外观&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：为子系统中的一组接口提供一个一致的界面，Facade 模式定义了一个高层接口，这个接口使得一个子系统更加容易使用。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;当你要为一个复杂子系统提供一个简单接口时。&lt;/li&gt;
&lt;li&gt;客户程序与抽象类的实现部分之间存在着很大的依赖性。&lt;/li&gt;
&lt;li&gt;当你需要构建一个层次结构的子系统时，使用 Facade 模式定义子系统中每层的入口点。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;它对客户屏蔽子系统组件，因而减少了客户处理的对象的数目并使得子系统使用起来更加方便。&lt;/li&gt;
&lt;li&gt;它实现了子系统与客户之间的松耦合关系，而子系统内部的功能组件往往是紧耦合的。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Abstra Factory 模式可以与 Facade 模式一起使用以提供一个接口，这一接口可用来以一种子系统独立的方式创建子系统对象。&lt;/li&gt;
&lt;li&gt;Mediator 模式与 Facade 模式的相似之处是，它抽象了一些已有的类的功能。&lt;/li&gt;
&lt;li&gt;通常来讲，仅需要一个 Facade 对象，因此 Facade 对象通常属于 Singleton 模式。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Flyweight（享元）&lt;a href=&quot;#flyweight享元&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：运用共享技术有效地支持大量细粒度的对象。&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;一个应用程序使用了大量的对象。&lt;/li&gt;
&lt;li&gt;完全由于使用大量的对象，造成很大的储存开销。&lt;/li&gt;
&lt;li&gt;对象的大多数状态都可变为外部状态。&lt;/li&gt;
&lt;li&gt;如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象。&lt;/li&gt;
&lt;li&gt;应用程序不依赖于对象标识。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;使用 Flyweight 模式时，传输、查找和/或计算外部状态都会产生运行时的开销，尤其当 flyweight 原先被储存为内部状态时。&lt;/li&gt;
&lt;li&gt;然而，空间上的节能抵消了这些开销。共享的 flyweight 越多，空间节省也就越大。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Flyweight 模式通常和 Composite 模式结合起来，用共享叶结点的有向无环图实现一个逻辑上的层次结构。&lt;/li&gt;
&lt;li&gt;通常，最好用 Flyweight 实现 State 和 Strategy 对象。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Proxy（代理）&lt;a href=&quot;#proxy代理&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：为其他对象提供一种代理以控制对这个对象的访问。&lt;/li&gt;
&lt;li&gt;别名：Surrogate&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;远程代理为一个对象在不同的地址空间提供局部代表。&lt;/li&gt;
&lt;li&gt;虚代理根据需要创建开销很大的对象。&lt;/li&gt;
&lt;li&gt;保护代理控制对原始对象的访问。&lt;/li&gt;
&lt;li&gt;智能指引取代了简单的指针，他在访问对象时执行一些附加操作。
&lt;ul&gt;
&lt;li&gt;对指向实际对象的引用计数，这样当该对象没有引用时，可以自动释放它。&lt;/li&gt;
&lt;li&gt;当第一次引用一个持久对象时，将它装入内存。&lt;/li&gt;
&lt;li&gt;在访问一个实际对象前，检查是否已经锁定了它，以确保其他对象不能改变它。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;远程代理可以隐藏一个对象存在于不同地址空间的事实。&lt;/li&gt;
&lt;li&gt;虚代理可以进行最优化，例如根据要求创建对象。&lt;/li&gt;
&lt;li&gt;保护代理和智能指引都允许在访问一个对象时有一些附加的内务处理。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Adapter为它所适配的对象提供了一个不同的接口。相反，代理提供了与它的实体相同的接口。&lt;/li&gt;
&lt;li&gt;尽管 Decorator 的实现部分与代理相似，但 decorator 的目的不一样。Decorator 为对象添加一个或多个功能，而代理则控制对象的访问。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;创建型模式&lt;a href=&quot;#创建型模式&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;Abstract Factory 抽象工厂&lt;a href=&quot;#abstract-factory-抽象工厂&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：提供一个创建一系列相关或相互依赖对象的借口，而无需指定它们具体的类&lt;/li&gt;
&lt;li&gt;别名：Kit&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;一个系统要独立于他的产品的创建、组合和表示时&lt;/li&gt;
&lt;li&gt;一个系统要由多个产品系列中的一个来配置时&lt;/li&gt;
&lt;li&gt;当你要强调一系列相关的产品对象的设计以便进行联合使用时&lt;/li&gt;
&lt;li&gt;当你提供一个产品类库，而只想显示它们的接口而不是实现时&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;它分离了具体的类&lt;/li&gt;
&lt;li&gt;它使得易于交换产品系列&lt;/li&gt;
&lt;li&gt;它有利于产品的一致性&lt;/li&gt;
&lt;li&gt;难以支持新类种的产品&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Abstract Factory 类通常用工厂方法（Factory Method）实现，但它们也可以用 Prototype（原型） 实现&lt;/li&gt;
&lt;li&gt;一个具体的工厂通常是单件（单例 Singleton）&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Builder 生成器&lt;a href=&quot;#builder-生成器&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时&lt;/li&gt;
&lt;li&gt;当构造过程必须允许被构造的对象有不同的表示时&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;它使你可以改变一个产品的内部表示&lt;/li&gt;
&lt;li&gt;它将构造代码和表示代码分开&lt;/li&gt;
&lt;li&gt;它使你对构造过程进行更精细的控制&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Abstract Factory 与 Builder 相似，因为它也可以创建复杂对象。主要的区别就是 Builder 模式着重于一步步构造一个复杂对象。而 Abstract Factory 着重于多个系列的产品对象（简单的或复杂的）。Builder 在最后的一步返回产品，而对于 Abstract Factory 来说，产品时立即返回的&lt;/li&gt;
&lt;li&gt;Composite 通常时 Builder 产生的&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Factory Method 工厂方法&lt;a href=&quot;#factory-method-工厂方法&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：定义一个用于创建对象的接口，让子类决定具体实例化哪个类。Factory Method 使一个类的实例化延迟到其子类&lt;/li&gt;
&lt;li&gt;别名：需构造器（Virtual Constructor）&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;当一个类不知道它所必须创建的对象的类的时候&lt;/li&gt;
&lt;li&gt;当一个类希望由它的子类来指定它所创建的对象的时候&lt;/li&gt;
&lt;li&gt;当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;工厂方法不再将与特定应用有关的类绑定到你的代码中。&lt;/li&gt;
&lt;li&gt;工厂方法一个潜在的缺点在于客户可能仅仅为了创建一个特定的类对象，就不得不创建 Creato让的子类&lt;/li&gt;
&lt;li&gt;用工厂方法在一个类的内部创建对象通常比直接创建对象更灵活。工厂方法给子类一个挂钩以提供对象的扩展版本&lt;/li&gt;
&lt;li&gt;工厂方法并不往往只是被 Creator 调用，客户可以找到一些更有用的工厂方法，尤其在平行类层次的情况下&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;Abstract Factory 经常用工厂方法来实现。Abstract Factory 模式中动机一节的例子也对工厂方法进行了说明&lt;/li&gt;
&lt;li&gt;工厂方法通常在 Template Methods 中被调用。&lt;/li&gt;
&lt;li&gt;Prototypes 不需要创建 Creator 的子类。但是，它们通常要求余个针对 Product 类的 Initialize 操作。Creator 使用 Initialize 来初始化对象。而工厂方法不需要这样的操作&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Prototype 原型&lt;a href=&quot;#prototype-原型&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;当一个系统应该独立于它的产品创建、构成和表示时，要使用原型模式&lt;/li&gt;
&lt;li&gt;当要实例化的类实在运行时刻指定时，例如，通过动态装载&lt;/li&gt;
&lt;li&gt;为了避免创建一个与产品类层次平行的工厂层次时&lt;/li&gt;
&lt;li&gt;当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;运行时增加和删除产品&lt;/li&gt;
&lt;li&gt;改变值以指定新对象&lt;/li&gt;
&lt;li&gt;改变结构以指定新对象&lt;/li&gt;
&lt;li&gt;减少子类的构造&lt;/li&gt;
&lt;li&gt;用类动态配置应用&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;原型模式和抽象工厂在某些方面时相互竞争的，但是它们也可以一起使用。抽象工厂款以储存一个被克隆的原型的集合，并且返回产品对象&lt;/li&gt;
&lt;li&gt;大量使用 Composite 和 Decorator 模式的设计通常也可从 Prototype 模式处获益&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Singleton （单件/单例）&lt;a href=&quot;#singleton-单件单例&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;意图：保证类仅有一个实例，并提供一个访问它的全局访问点&lt;/li&gt;
&lt;li&gt;适用性
&lt;ul&gt;
&lt;li&gt;当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时&lt;/li&gt;
&lt;li&gt;当这个唯一实例应该时通过子类化可扩展的，并且客户应该无需更改代码就能使用余个扩展的实例时&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;效果
&lt;ul&gt;
&lt;li&gt;对唯一实例的受控访问&lt;/li&gt;
&lt;li&gt;缩小名空间&lt;/li&gt;
&lt;li&gt;允许操作和表示的精化&lt;/li&gt;
&lt;li&gt;允许可变数目的实例&lt;/li&gt;
&lt;li&gt;比类操作更灵活&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;相关模式
&lt;ul&gt;
&lt;li&gt;很多模式都可以使用 Singleton 模式实现。如抽象工厂、Builder，和原型&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;</content:encoded><category>category:随笔</category></item><item><title>Sony相机拍照PP设置</title><link>https://www.dreameverafter.com/en/post/sony-pp-setting</link><guid isPermaLink="false">en:sony-pp-setting</guid><description>![](https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F13c5f9a9-8be2-466f-9e80-4680cf20690b%2FIMG_4763.jpg?table=block</description><pubDate>Sun, 20 Oct 2024 05:25:22 GMT</pubDate><content:encoded>&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F13c5f9a9-8be2-466f-9e80-4680cf20690b%2FIMG_4763.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8045-b420-eab6a8d9dd89&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fe2a87991-ba62-49b2-a4d4-4b0c9f14027b%2FIMG_4764.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80e4-867b-df60fbce8243&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Ffc880ae4-c648-4960-b7b7-2e49d3b93c5d%2FIMG_4765.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8036-85b2-cba9cc72831a&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fbf3b55ba-6daf-44b3-a8d7-ca13ee07e17b%2FIMG_4766.jpg?table=block&amp;amp;id=1250ce9e-f2fd-804a-a2ee-fb74da107093&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F2bcdbf98-7454-46e3-8b8b-019d5e4ce39a%2FIMG_4767.jpg?table=block&amp;amp;id=1250ce9e-f2fd-808a-92a2-eb065a320fd2&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Ffc3cca1a-00ae-4d18-b38a-22d454a0a254%2FIMG_4768.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80f9-b014-d66a26ebeb60&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fecb82109-1b39-40fc-820c-7906ae59179d%2FIMG_4769.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80b1-981e-d4c9a78985fc&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Ffe417b4a-4f39-49a2-ba84-7aabcd077baa%2FIMG_4770.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80cf-8768-fbd2db1b604f&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fc3de8fcf-89df-4fac-861c-ac2d1fbbf85c%2FIMG_4771.jpg?table=block&amp;amp;id=1250ce9e-f2fd-808d-8587-eaf4a527dbe2&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fcd57f43d-a616-4f8c-b821-b9647dc91837%2FIMG_4772.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8061-95be-f45ee4dcb159&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fbbbc7697-0eef-49d6-8959-bea39a82f64f%2FIMG_2296.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8084-9a24-f2eb6500fe59&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F179fa1ff-d45b-4e01-927e-aee7a5516a12%2FIMG_2297.jpg?table=block&amp;amp;id=1250ce9e-f2fd-806d-82e1-f4f560352271&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F1dab3748-d6b1-4ba4-addd-0c227f36c0d2%2FIMG_2298.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8057-8c6f-f484e153a794&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F6a7c7f51-d2dc-4892-86dd-9ee478f7b5ad%2FIMG_2299.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8071-bf01-e32bba412679&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fc20f9ee3-45e1-407d-986e-bd6ac4894865%2FIMG_2300.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80e7-b56e-e0c6ed4f47c6&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fe0fbe9b2-3556-44c1-9f7f-058c30e2896b%2FIMG_2301.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8080-a31f-ef39f8bf126a&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F37374a3d-8461-4b51-ba3e-7a7236eabfb1%2FIMG_2302.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8087-bcf2-f35327fbefe4&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F472b2c00-4ae0-4329-8cff-1438dbf99d70%2FIMG_2303.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80d0-aa50-ee350c989dee&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F262c1056-5ec2-4ade-89bb-8939651274e3%2FIMG_2304.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80e7-8491-d00836cd2cd3&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F899ae883-3ef6-4bda-8a1c-9c1f22c22789%2FIMG_2305.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80f5-9f3c-f45b5921f226&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fb8bd0ab5-37ad-4bdd-a747-c90edc3c0f4d%2FIMG_2306.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80ed-a3e2-d6b7ff69239d&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fee803efe-8bf8-4fcc-9344-3876e462de1a%2FIMG_2307.jpg?table=block&amp;amp;id=1250ce9e-f2fd-804e-9dad-e2ee802fce0f&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F634b4f96-e48f-462c-a232-f749131ec873%2FIMG_2308.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80a0-afe0-d1a014e57823&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F2dcc7970-2a48-41b9-a50b-5017f3b50fb5%2FIMG_2309.jpg?table=block&amp;amp;id=1250ce9e-f2fd-802d-ba62-cc0280bd6765&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F993163a0-fcf5-461d-941a-36d025ce764b%2FIMG_2310.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8012-a434-dcf614d00880&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F90f518c2-15c7-4fc3-b739-b595b2d7febd%2FIMG_2311.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80f4-9334-d13cfe22fd7e&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F4ef21cf9-ef3f-4828-9b71-d16b4e0f6660%2FIMG_2312.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8010-a168-c229937f2602&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F45ced1e3-5055-4554-a3c1-ddf87640bf24%2FIMG_2313.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8018-b499-de0678c7e5e8&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F72f4d142-953b-470f-8c0c-33575e6cf9ba%2FIMG_2314.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80d5-bc44-dfe7d633caf0&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F4da7a898-75c4-47b1-b2fe-1a2ddf0cb552%2FIMG_2315.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80f4-ba90-deacfce17bb3&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fad68d686-3adf-442b-a3dc-7c9558a6a08a%2FIMG_2316.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8077-b682-cc2b36ed02d0&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F31007e23-cb7e-403e-a155-288a85eb12e3%2FIMG_2317.jpg?table=block&amp;amp;id=1250ce9e-f2fd-809c-8087-c44260fd1476&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fb93f554f-fc5a-49d0-9a64-8c2248aff96c%2FIMG_2318.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80c7-9f88-f70d5cca6323&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Ff0d3fc62-86d6-4535-9028-cc1c4e7aea79%2FIMG_2319.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8009-9a80-e4498714cdc7&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fca3e25a9-7420-490c-bdf7-6201fdea857c%2FIMG_2320.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8024-aee1-ebb564a4a2f0&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fb9a48ae2-64bc-42b9-9ba8-d0fae3cab647%2FIMG_2321.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80a3-8fe8-f7139dfa85a9&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F9c387e44-4158-4c04-8e93-f70d4d3584e1%2FIMG_2322.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8036-b5a6-d0fba2a3284a&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F7bd879cd-cd07-48b2-8e4d-7894222a172a%2FIMG_2323.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80cb-90ca-fc3964a268a5&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F76a25410-4d28-4a42-ad23-1e0996fa8893%2FIMG_2324.jpg?table=block&amp;amp;id=1250ce9e-f2fd-801e-8f46-d924a3e47d16&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F189a8f91-4d87-4fa0-a848-ffdc21dc150f%2FIMG_2325.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8049-b83b-ffc40bc35f11&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F54d3340e-521e-4723-bf7d-fd45928a8696%2FIMG_2326.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8044-8a36-e66b40664118&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F7c614de8-1285-4bf3-bf5e-178d78d57f1a%2FIMG_2327.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8091-bf9b-cf41e5265ee8&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F99d2684d-7f2c-4a9d-95d8-1ae889eef1ee%2FIMG_2328.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8000-b957-f4fea46895f2&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fd0eda53c-a8e6-4dbb-9a11-131cc8bdaaab%2FIMG_2329.jpg?table=block&amp;amp;id=1250ce9e-f2fd-809e-9e14-fc12da6df8df&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fb666c8f0-2cd9-466f-87f9-91bff2d69d7d%2FIMG_2330.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8013-a75f-c857f6340199&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fbc3a7c37-33f9-4e37-a7e9-16471eb0348a%2FIMG_2332.jpg?table=block&amp;amp;id=1250ce9e-f2fd-804b-818e-fff3824394b7&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fbc3a7c37-33f9-4e37-a7e9-16471eb0348a%2FIMG_2332.jpg?table=block&amp;amp;id=1250ce9e-f2fd-804b-818e-fff3824394b7&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F91e59338-140a-4715-8b78-aeb18dd6b034%2FIMG_2333.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8027-82db-e380595f7e53&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Ffc5e8a79-10b1-4941-ae79-cbd40f82d350%2FIMG_2334.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80f4-a28d-c5ead6190118&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F7755a4de-25b2-42cc-91cf-267eb3e4e0f7%2FIMG_2335.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80c1-bde1-cbdbe7b0f5e1&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F7d951082-dbca-4ce9-a58f-1958ff329d22%2FIMG_2336.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8088-a6bb-e0ba293823e1&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fe849ef0b-e95f-4f04-936e-ae2a251e1e52%2FIMG_2337.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80f1-849a-c01c01250886&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Ff71a0bc0-fdd2-43b4-b187-b74f257bc645%2FIMG_2338.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80c0-8f1d-e6db33f48522&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F580aae30-cdd1-49a4-b930-1ba0cc5020d9%2FIMG_2339.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8022-aefb-c6aa1400a4f6&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fa6edaf48-38ab-432d-9b53-c8b92de2140b%2FIMG_2340.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8041-a862-fd078c13baee&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F453df91a-d7a6-4c41-8129-4831dd97612c%2FIMG_2341.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80a7-a18e-f984b7735618&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F0511c1bb-6d6d-4821-872f-6aa87d57e94e%2FIMG_2342.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8019-ac00-e842ad715545&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fe8a31568-45d8-421d-838f-670d37611444%2FIMG_2343.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8001-b471-c2d25baccba2&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fb4c3cbc0-b320-4a29-b012-5457722c963b%2FIMG_2344.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80ad-a916-cb9339fcb25f&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fbf1d8a1b-9a34-4a67-8347-8673522d5135%2FIMG_2345.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80d5-96bd-ed3b8da96044&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fd5d42bc2-3d6d-4be5-96d5-12e6fead8931%2FIMG_2346.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80b6-bdac-c288024f8f2a&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F2b53d4a7-7fb7-4318-80aa-40e291ba3cba%2FIMG_2347.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80c1-8447-ef0916fd71dc&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fee8b9ddc-2dda-486f-828c-da92667412bf%2FIMG_2348.jpg?table=block&amp;amp;id=1250ce9e-f2fd-808d-9800-d8925f833360&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F7543c668-bbf6-4add-be70-e8fc3fd5ffb5%2FIMG_2350.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8087-9e01-c92cbe62efda&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fbcfe9eea-b3f0-45c2-8c5c-7e480b4fc1b7%2FIMG_2351.jpg?table=block&amp;amp;id=1250ce9e-f2fd-804c-95d9-eec3efbfba8d&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Fcbb6a4c3-0b9b-4c30-b5cd-9276f903ab7a%2FIMG_2352.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80b6-867d-ce01248b02d4&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F2fba52d6-d96b-4c43-9cf8-8a28d55f3527%2FIMG_2353.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8072-911a-d4b4aafdf831&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F2211ca90-ee16-4a73-9798-0aea550fd708%2FIMG_2355.jpg?table=block&amp;amp;id=1250ce9e-f2fd-803b-bd5b-f9160d51bf4c&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F0920cebb-3de5-4ec7-a17a-a9f807332913%2FIMG_2356.jpg?table=block&amp;amp;id=1250ce9e-f2fd-8079-9f33-ede2789084f2&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2F888c73d7-3a18-4d76-b207-e150eafd812e%2FIMG_2357.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80e3-89e7-eb92c34c3000&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;
&lt;figure&gt;&lt;img src=&quot;https://ankang.notion.site/image/https%3A%2F%2Fprod-files-secure.s3.us-west-2.amazonaws.com%2F6f735299-3f58-48b3-a280-623eb164ead8%2Ff12ffa1d-e8b1-406f-9edc-882b1f15c3a3%2FIMG_2358.jpg?table=block&amp;amp;id=1250ce9e-f2fd-80b5-9d40-e8a2e126583b&amp;amp;spaceId=6f735299-3f58-48b3-a280-623eb164ead8&amp;amp;width=1420&amp;amp;userId=&amp;amp;cache=v2&quot; alt=&quot;&quot; loading=&quot;lazy&quot; /&gt;&lt;/figure&gt;</content:encoded><category>category:随笔</category><category>tag:折腾</category></item><item><title>k8s前端项目利用nginx部署项目不停机</title><link>https://www.dreameverafter.com/en/post/k8s%E5%89%8D%E7%AB%AF%E9%A1%B9%E7%9B%AE%E5%88%A9%E7%94%A8nginx%E9%83%A8%E7%BD%B2%E9%A1%B9%E7%9B%AE%E4%B8%8D%E5%81%9C%E6%9C%BA</link><guid isPermaLink="false">en:k8s前端项目利用nginx部署项目不停机</guid><description>思路是利用docker部署的时候，在新的docker没有启动完成之前，一直保留老的docker，不切换流量到新docker。以下配置都在docker到yaml文件中配置的。首先配置Deployment：spec: replicas: 1 minReadySeconds: 60 #容器接受流量延缓时间：单位为秒，默认为0。如果没有设置的话，k8s会认为容器启动成功后就可以用了。设置该值可以延缓容器流</description><pubDate>Fri, 18 Oct 2024 08:50:22 GMT</pubDate><content:encoded>&lt;p&gt;思路是利用docker部署的时候，在新的docker没有启动完成之前，一直保留老的docker，不切换流量到新docker。&lt;/p&gt;
&lt;p&gt;以下配置都在docker到yaml文件中配置的。&lt;/p&gt;
&lt;p&gt;首先配置Deployment：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;spec:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  replicas: 1&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  minReadySeconds: 60 #容器接受流量延缓时间：单位为秒，默认为0。如果没有设置的话，k8s会认为容器启动成功后就可以用了。设置该值可以延缓容器流量切分&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  strategy:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    type: RollingUpdate&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    rollingUpdate:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;      maxSurge: 2 #最多Pod数量：为数字类型/百分比。如果 maxSurge 设置为1，replicas 设置为10，则在发布过程中pod数量最多为10 + 1个（多出来的为旧版本pod，平滑期不可用状态）。maxUnavailable 为 0 时，该值也不能设置为0&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;      maxUnavailable: 0 #升级中最多不可用pod的数量：为数字类型/百分比。当 maxSurge 为 0 时，该值也不能设置为0&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;发现还是会有十几秒无法访问网站，抱502。&lt;/p&gt;
&lt;p&gt;然后又补充了检测nginx状态：&lt;/p&gt;
&lt;p&gt;还是在Deployment配置：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;readinessProbe:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  httpGet:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    path: /nginx_status # Kubernetes 会向容器的 80 端口发送 HTTP GET 请求，访问 /nginx_status 路径。&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    port: 80 # 指定要访问的端口号为 80。&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  initialDelaySeconds: 15 # 容器启动后，Kubernetes 会等待 15 秒再开始执行&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  periodSeconds: 30 # Kubernetes 每隔 30 秒执行一次 readinessProbe。&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  failureThreshold: 3 # 如果 readinessProbe 连续失败 3 次，Kubernetes 会认为容器不健康，并停止将流量路由到该容器。&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后配置nginx：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;# 健康检查&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;location /nginx_status {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    stub_status on;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    access_log off;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    allow 127.0.0.1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;达到了预期，具体效果都在注释里了。&lt;/p&gt;
&lt;p&gt;由于docker的yaml配置通过空格确定层级的，所以有可能曾经错误，所以下面放出来所有的Deployment用来对比：&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;apiVersion: apps/v1&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;kind: Deployment&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;metadata:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  namespace: $DOCKERHUB_NAMESPACE&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  name: $APP_NAME&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;spec:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  replicas: 1&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  minReadySeconds: 60 #容器接受流量延缓时间：单位为秒，默认为0。如果没有设置的话，k8s会认为容器启动成功后就可以用了。设置该值可以延缓容器流量切分&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  strategy:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    type: RollingUpdate&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    rollingUpdate:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;      maxSurge: 2 #最多Pod数量：为数字类型/百分比。如果 maxSurge 设置为1，replicas 设置为10，则在发布过程中pod数量最多为10 + 1个（多出来的为旧版本pod，平滑期不可用状态）。maxUnavailable 为 0 时，该值也不能设置为0&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;      maxUnavailable: 0 #升级中最多不可用pod的数量：为数字类型/百分比。当 maxSurge 为 0 时，该值也不能设置为0&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  selector:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    matchLabels:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;      #app: $APP_NAME&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;      app.kubernetes.io/name: $APP_NAME&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  template:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    metadata:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;      labels:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        app: $APP_NAME&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        app.kubernetes.io/name: $APP_NAME&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    spec:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;      containers:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        - env:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            - name: ENV_PROFILE&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              value: $ENV_PROFILE&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;          image: $DOCKER_IMAGE&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;          imagePullPolicy: Always&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;          name: $APP_NAME&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;          readinessProbe:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            httpGet:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              path: /nginx_status # Kubernetes 会向容器的 80 端口发送 HTTP GET 请求，访问 /nginx_status 路径。&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              port: 80 # 指定要访问的端口号为 80。&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            initialDelaySeconds: 15 # 容器启动后，Kubernetes 会等待 15 秒再开始执行&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            periodSeconds: 30 # Kubernetes 每隔 30 秒执行一次 readinessProbe。&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            failureThreshold: 3 # 如果 readinessProbe 连续失败 3 次，Kubernetes 会认为容器不健康，并停止将流量路由到该容器。&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;          ports:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            - containerPort: 80&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;          resources:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            limits:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              cpu: 300m&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              memory: 512Mi&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            requests:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              cpu: 100m&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              memory: 512Mi&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;      restartPolicy: Always&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;如果不需要检查具体的 HTTP 响应，可以使用 &lt;code&gt;tcpSocket&lt;/code&gt; 探针来检查 Nginx 的端口是否打开。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;          readinessProbe:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            tcpSocket:&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;              port: 80&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            initialDelaySeconds: 15&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            periodSeconds: 30&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            failureThreshold: 3&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;经多次测试，还是会出现页面502，随机有几个资源文件502导致，所以以上探针方案并不能完全解决平滑发版，还需继续研究。&lt;/p&gt;</content:encoded><category>category:工具</category></item><item><title>Vue3+Vite+history模式+Nginx 部署二级路径</title><link>https://www.dreameverafter.com/en/post/vue3-vite-history%E6%A8%A1%E5%BC%8F-nginx-%E9%83%A8%E7%BD%B2%E4%BA%8C%E7%BA%A7%E8%B7%AF%E5%BE%84</link><guid isPermaLink="false">en:vue3-vite-history模式-nginx-部署二级路径</guid><description>需求是vite打包的项目部署到指定的二级路径。例如把前端项目部署在https:foo.com/bar/上，可以通过https:foo.com/bar/打开前端项目网页。关键点在于三点：1. vite.config.ts 中的 base# vite.config.ts 中的 defineConfig 方法 base: &apos;/bar/&apos;2. router 中的 createRouterconst rou</description><pubDate>Fri, 18 Oct 2024 08:40:52 GMT</pubDate><content:encoded>&lt;p&gt;需求是vite打包的项目部署到指定的二级路径。&lt;/p&gt;
&lt;p&gt;例如把前端项目部署在https&lt;/p&gt;&lt;div&gt;&lt;/div&gt;.com/bar/上，可以通过https&lt;div&gt;&lt;/div&gt;.com/bar/打开前端项目网页。&lt;p&gt;&lt;/p&gt;
&lt;p&gt;关键点在于三点：&lt;/p&gt;
&lt;h3&gt;1.  vite.config.ts 中的 base&lt;a href=&quot;#1--viteconfigts-中的-base&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;# vite.config.ts 中的 defineConfig 方法&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;base: &apos;/bar/&apos;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2.  router 中的 createRouter&lt;a href=&quot;#2--router-中的-createrouter&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;const router = createRouter({&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;  history: createWebHistory(&apos;/bar/&apos;), // 直接写死/bar/，这里可以用环境变量import.meta.env.BASE_URL或者自己设置别的环境变量&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;})&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3. 配置 nginx&lt;a href=&quot;#3-配置-nginx&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;location /bar {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    index index.html;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    alias /usr/share/nginx/dist/bar; # 二级路由用alias，放在服务器上的项目路径&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    try_files $uri $uri/ /bar/index.html; # 核心就是try_files，会在这几个地方都试一下，如果不配置会404&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;至于配置环境变量什么的花活就看自己项目需求了。&lt;/p&gt;</content:encoded><category>category:工具</category></item><item><title>差生文具多</title><link>https://www.dreameverafter.com/en/post/%E5%B7%AE%E7%94%9F%E6%96%87%E5%85%B7%E5%A4%9A</link><guid isPermaLink="false">en:差生文具多</guid><description>各种文具记录</description><pubDate>Sun, 04 Aug 2024 07:21:23 GMT</pubDate><content:encoded>&lt;h2&gt;中性笔&lt;a href=&quot;#中性笔&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;樱花 craftlab 003： 国产平替笔芯 晨光 2080 G-5&lt;/p&gt;
&lt;p&gt;辛科凝： 笔芯 三菱85N&lt;/p&gt;</content:encoded><category>category:工具</category></item><item><title>iOS开发工具</title><link>https://www.dreameverafter.com/en/post/iOS%E5%BC%80%E5%8F%91%E5%B7%A5%E5%85%B7</link><guid isPermaLink="false">en:iOS开发工具</guid><description>iOS开发工具</description><pubDate>Sun, 04 Aug 2024 05:14:16 GMT</pubDate><content:encoded>&lt;h2&gt;iOS设备的机型型号&lt;a href=&quot;#ios设备的机型型号&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;https://www.theiphonewiki.com/wiki/Models&quot;&gt;the iPhone Wiki&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href=&quot;https://gist.github.com/adamawolf/3048717&quot;&gt;List of Apple’s mobile device codes types a.k.a. machine ids (e.g. iPhone1,1, Watch1,1, etc.) and their matching product names&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;iOS设备尺寸&lt;a href=&quot;#ios设备尺寸&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;先简要列出来几个常用的。&lt;/p&gt;





























&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;设备&lt;/th&gt;&lt;th&gt;icon size&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;iPhone XS Max&lt;/td&gt;&lt;td&gt;1242px × 2688px&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;iPhone XR&lt;/td&gt;&lt;td&gt;828px × 1792px&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;iPhone X&lt;/td&gt;&lt;td&gt;1125px × 2436px&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;iPhone 8 Plus&lt;/td&gt;&lt;td&gt;1242px × 2208px&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;iPhone 8&lt;/td&gt;&lt;td&gt;750px × 1334px&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;&lt;a href=&quot;https://developer.apple.com/design/human-interface-guidelines/ios/icons-and-images/app-icon/&quot;&gt;App Icon Sizes&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href=&quot;https://developer.apple.com/design/human-interface-guidelines/ios/icons-and-images/launch-screen/&quot;&gt;屏幕尺寸&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;iOS开发常用开源库&lt;a href=&quot;#ios开发常用开源库&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;https://github.com/pujiaxin33/JXCategoryView&quot;&gt;分类切换滚动视图控件&lt;/a&gt;
&lt;a href=&quot;https://github.com/lixiang1994/LEEAlert&quot;&gt;Alert提醒控件：LEEAlert&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;变量名简写&lt;a href=&quot;#变量名简写&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;http://www.abbreviations.com/&quot;&gt;变量名简写&lt;/a&gt;这个网站非常好用，满足起名纠结症。&lt;/p&gt;
&lt;h2&gt;KaTeX 文档&lt;a href=&quot;#katex-文档&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;http://www.abbreviations.com/&quot;&gt;KaTeX方法表&lt;/a&gt;
&lt;a href=&quot;https://katex.org/docs/supported.html&quot;&gt;官方KaTeX方法表&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;写KaTex的时候查语法用。&lt;/p&gt;</content:encoded><category>category:iOS</category></item><item><title>高数概念、公式、定理</title><link>https://www.dreameverafter.com/en/post/%E9%AB%98%E6%95%B0%E6%A6%82%E5%BF%B5-%E5%85%AC%E5%BC%8F-%E5%AE%9A%E7%90%86</link><guid isPermaLink="false">en:高数概念-公式-定理</guid><description>一、函数1. 函数的定义设有两个变量x 和y，D 是一个非空数集。如果对\forall x \in D，变量y 按照某一确定的法则f 总有相应的值与之对应，则称y 是x 的函数，记为y=f(x)。数集D 称之为函数的定义域。2. 函数的性质（1）奇偶性设函数y=f(x) 的定义区间I 关于原点对称，如果对于I 内任意一点x ，恒有f(-x)=f(x)，则称f(x) 为区间I 内的偶函数；如果恒有f</description><pubDate>Tue, 09 Jul 2024 12:57:11 GMT</pubDate><content:encoded>&lt;h1&gt;一、函数&lt;a href=&quot;#一函数&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;h2&gt;1. 函数的定义&lt;a href=&quot;#1-函数的定义&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;p&gt;设有两个变量x 和y，D 是一个非空数集。如果对\forall x \in D，变量y 按照某一确定的法则f 总有相应的值与之对应，则称y 是x 的&lt;strong&gt;函数&lt;/strong&gt;，记为y=f(x)。数集D 称之为函数的定义域。&lt;/p&gt;
&lt;h2&gt;2. 函数的性质&lt;a href=&quot;#2-函数的性质&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;（1）奇偶性&lt;a href=&quot;#1奇偶性&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;设函数y=f(x) 的定义区间I 关于原点对称，如果对于I 内任意一点x ，恒有f(-x)=f(x)，则称f(x) 为区间I 内的&lt;strong&gt;偶函数&lt;/strong&gt;；如果恒有f(-x)=-f(x)，则称f(x) 为区间I 内的&lt;strong&gt;奇函数&lt;/strong&gt;。&lt;/p&gt;
&lt;h3&gt;（2）有界性&lt;a href=&quot;#2有界性&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;设函数f(x) 在X 上有定义，如果存在常数M，当x \in X 时，恒有f(x)\leqslant M，则称f(x) 在X 上有&lt;strong&gt;上界；设函数&lt;/strong&gt;f(x)** 在&lt;strong&gt;X&lt;/strong&gt; 上有定义，如果存在常数&lt;strong&gt;m&lt;/strong&gt;，当&lt;strong&gt;x \in X&lt;/strong&gt; 时，恒有&lt;strong&gt;f(x)\geqslant m&lt;/strong&gt;，则称&lt;strong&gt;f(x)&lt;/strong&gt; 在&lt;strong&gt;X&lt;/strong&gt; 上有下界**；设函数f(x) 在X 上有定义，如果存在常数0” math-inline=&quot;&quot;&amp;gt;M&amp;gt;0，当x \in X 时，恒有|f(x)|\leqslant M，则称f(x) 在X 上&lt;strong&gt;有界&lt;/strong&gt;。&lt;/p&gt;
&lt;h3&gt;（3）周期性&lt;a href=&quot;#3周期性&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;设函数f(x) 在区间I 上有定义，若存在0” math-inline=&quot;&quot;&amp;gt;T&amp;gt;0，对任意的x \in I，有x±T\in I ，并且f(x+T)=f(x)，则称f(x) 为&lt;strong&gt;周期函数&lt;/strong&gt;。使得上述关系式成立的最小正数T 称为f(x) 的&lt;strong&gt;最小正周期&lt;/strong&gt;，简称为函数f(x) 的&lt;strong&gt;周期&lt;/strong&gt;。&lt;/p&gt;
&lt;h3&gt;（4）单调性&lt;a href=&quot;#4单调性&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;设函数f(x) 在区间I 上有定义，如果对于该区间内的任意两点x_1&amp;lt;x_2，恒有f(x_1)&amp;lt;f(x_2)（或f(x_2)” math-inline=&quot;&quot;&amp;gt;f(x_1)&amp;gt;f(x_2)），则称f(x) 在区间I 内&lt;strong&gt;单调增加&lt;/strong&gt;（或&lt;strong&gt;单调减少&lt;/strong&gt;）。&lt;/p&gt;
&lt;h2&gt;3. 反函数、复合函数、初等函数、分段函数、隐函数&lt;a href=&quot;#3-反函数复合函数初等函数分段函数隐函数&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;
&lt;h3&gt;（1）反函数&lt;a href=&quot;#1反函数&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;设函数y=f(x) 的定义域为D ，值域为R。若对任意y \in R，有唯一确定的x \in D，使得y = f(x)，则记为x=f^{-1}(y)，称其为y=f(x) 的&lt;strong&gt;反函数&lt;/strong&gt;。&lt;/p&gt;
&lt;h3&gt;（2）复合函数&lt;a href=&quot;#2复合函数&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;若函数u=\varphi (x) 在x_0 处有定义，函数y=f(u) 在u_0=\varphi(x_0) 处有定义，则函数y=f[\varphi(x)] 在x_0 处有定义，称y=f[\varphi(x)] 是由函数y=f(u) 和u=\varphi (x) 复合而成的&lt;strong&gt;复合函数&lt;/strong&gt;，&lt;span&gt;&lt;span&gt;uu&lt;/span&gt;&lt;span&gt;&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;u&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt; 为中间变量。&lt;/p&gt;
&lt;h3&gt;（3）初等函数&lt;a href=&quot;#3初等函数&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;由六类基本初等函数经过有限次四则运算及有限次复合运算得到的，并能用一个数学表达式表示的函数，称为&lt;strong&gt;初等函数&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;注&lt;/strong&gt; 六类基本初等函数为：&lt;/p&gt;
&lt;p&gt;y=C （常数）；&lt;/p&gt;
&lt;p&gt;y=x^a （a\in R是常数）；&lt;/p&gt;
&lt;p&gt;0 且 a\neq1）；” math-inline=&quot;&quot;&amp;gt;y=a^x （a&amp;gt;0 且 a\neq1）；&lt;/p&gt;
&lt;p&gt;0 且 a\neq1），当a=e时，记y=\ln x；” math-inline=&quot;&quot;&amp;gt;y=\log_ax （a&amp;gt;0 且 a\neq1），当a=e时，记y=\ln x；&lt;/p&gt;
&lt;p&gt;y=\sin x,\cos x,\tan x,\cot x,\sec x,\csc x；&lt;/p&gt;
&lt;p&gt;y=\arcsin x,\arccos x,\arctan x,arccot x.&lt;/p&gt;
&lt;h3&gt;（4）分段函数&lt;a href=&quot;#4分段函数&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;在定义域内的不同范围用不同表达式表示的函数称为&lt;strong&gt;分段函数&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;注&lt;/strong&gt; 常见的分段函数有：&lt;/p&gt;
&lt;p&gt;1 绝对值函数x = \begin{cases} x,&amp;amp;x\geqslant 0, \ -x,&amp;amp;x&amp;lt;0, \end{cases}&lt;/p&gt;
&lt;p&gt;2 符号函数 0, \ 0 &amp;amp;x=0, \ -1,&amp;amp; x\newcommand{\sign}&lt;span&gt;1&lt;/span&gt;(#1)}&lt;/p&gt;
&lt;p&gt;\sign {x} = \begin{cases} 1 &amp;amp;x&amp;gt;0, \ 0 &amp;amp;x=0, \ -1,&amp;amp; x&amp;lt;0, \end{cases}&lt;/p&gt;
&lt;p&gt;3 取整函数[x] 表示不超过x 的最大整数，显然有[x]\leqslant x &amp;lt;[x]+1。&lt;/p&gt;
&lt;h3&gt;（5）隐函数&lt;a href=&quot;#5隐函数&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;p&gt;如果在方程F(x,y)=0中，当x 取某区间内的任一值时，相应地总有满足这一方程的唯一的y 值存在，则称方程F(x,y)=0 在该区间内确定了一个&lt;strong&gt;隐函数&lt;/strong&gt;y=y(x)。&lt;/p&gt;</content:encoded><category>category:笔记</category></item><item><title>常用代码模板2——数据结构</title><link>https://www.dreameverafter.com/en/post/%E5%B8%B8%E7%94%A8%E4%BB%A3%E7%A0%81%E6%A8%A1%E6%9D%BF2-%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84</link><guid isPermaLink="false">en:常用代码模板2-数据结构</guid><description>单链表// head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点 int head, e[N], ne[N], idx; // 初始化 void init() { head = -1; idx = 0; } // 在链表头插入一个数a void insert(int a) { e[idx] = a, ne[idx] = head, head = id</description><pubDate>Sun, 07 Jul 2024 10:16:22 GMT</pubDate><content:encoded>&lt;h3&gt;单链表&lt;a href=&quot;#单链表&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int head, e[N], ne[N], idx;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 初始化&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void init()&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    head = -1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    idx = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 在链表头插入一个数a&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void insert(int a)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    e[idx] = a, ne[idx] = head, head = idx ++ ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 将头结点删除，需要保证头结点存在&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void remove()&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    head = ne[head];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;双链表&lt;a href=&quot;#双链表&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// e[]表示节点的值，l[]表示节点的左指针，r[]表示节点的右指针，idx表示当前用到了哪个节点&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int e[N], l[N], r[N], idx;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 初始化&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void init()&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    //0是左端点，1是右端点&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    r[0] = 1, l[1] = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    idx = 2;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 在节点a的右边插入一个数x&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void insert(int a, int x)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    e[idx] = x;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    l[idx] = a, r[idx] = r[a];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    l[r[a]] = idx, r[a] = idx ++ ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 删除节点a&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void remove(int a)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    l[r[a]] = l[a];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    r[l[a]] = r[a];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;栈&lt;a href=&quot;#栈&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// tt表示栈顶&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int stk[N], tt = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 向栈顶插入一个数&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;stk[ ++ tt] = x;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 从栈顶弹出一个数&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;tt -- ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 栈顶的值&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;stk[tt];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 判断栈是否为空&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;if (tt &amp;gt; 0)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;队列&lt;a href=&quot;#队列&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;普通队列：&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// hh 表示队头，tt表示队尾&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int q[N], hh = 0, tt = -1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 向队尾插入一个数&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;q[ ++ tt] = x;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 从队头弹出一个数&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;hh ++ ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 队头的值&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;q[hh];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 判断队列是否为空&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;if (hh &amp;lt;= tt)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;ol&gt;
&lt;li&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;循环队列&lt;/p&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// hh 表示队头，tt表示队尾的后一个位置&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int q[N], hh = 0, tt = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 向队尾插入一个数&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;q[tt ++ ] = x;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;if (tt == N) tt = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 从队头弹出一个数&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;hh ++ ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;if (hh == N) hh = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 队头的值&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;q[hh];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 判断队列是否为空&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;if (hh != tt)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;单调栈&lt;a href=&quot;#单调栈&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;常见模型：找出每个数左边离它最近的比它大/小的数&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int tt = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;for (int i = 1; i &amp;lt;= n; i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (tt &amp;amp;&amp;amp; check(stk[tt], i)) tt -- ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    stk[ ++ tt] = i;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;单调队列&lt;a href=&quot;#单调队列&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;常见模型：找出滑动窗口中的最大值/最小值&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int hh = 0, tt = -1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;for (int i = 0; i &amp;lt; n; i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (hh &amp;lt;= tt &amp;amp;&amp;amp; check_out(q[hh])) hh ++ ;  // 判断队头是否滑出窗口&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (hh &amp;lt;= tt &amp;amp;&amp;amp; check(q[tt], i)) tt -- ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    q[ ++ tt] = i;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;KMP&lt;a href=&quot;#kmp&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// s[]是长文本，p[]是模式串，n是s的长度，m是p的长度&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;求模式串的Next数组：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;for (int i = 2, j = 0; i &amp;lt;= m; i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (j &amp;amp;&amp;amp; p[i] != p[j + 1]) j = ne[j];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (p[i] == p[j + 1]) j ++ ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    ne[i] = j;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 匹配&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;for (int i = 1, j = 0; i &amp;lt;= n; i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (j &amp;amp;&amp;amp; s[i] != p[j + 1]) j = ne[j];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (s[i] == p[j + 1]) j ++ ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (j == m)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        j = ne[j];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        // 匹配成功后的逻辑&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;Trie树&lt;a href=&quot;#trie树&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;int son[N][26], cnt[N], idx;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 0号点既是根节点，又是空节点&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// son[][]存储树中每个节点的子节点&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// cnt[]存储以每个节点结尾的单词数量&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 插入一个字符串&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void insert(char *str)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int p = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (int i = 0; str[i]; i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        int u = str[i] - &apos;a&apos;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (!son[p][u]) son[p][u] = ++ idx;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        p = son[p][u];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    cnt[p] ++ ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 查询字符串出现的次数&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int query(char *str)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int p = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (int i = 0; str[i]; i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        int u = str[i] - &apos;a&apos;;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (!son[p][u]) return 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        p = son[p][u];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    return cnt[p];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;并查集&lt;a href=&quot;#并查集&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;(1)朴素并查集：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int p[N]; //存储每个点的祖宗节点&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 返回x的祖宗节点&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int find(int x)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (p[x] != x) p[x] = find(p[x]);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        return p[x];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 初始化，假定节点编号是1~n&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (int i = 1; i &amp;lt;= n; i ++ ) p[i] = i;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 合并a和b所在的两个集合：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    p[find(a)] = find(b);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;(2)维护size的并查集：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int p[N], size[N];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    //p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 返回x的祖宗节点&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int find(int x)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (p[x] != x) p[x] = find(p[x]);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        return p[x];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 初始化，假定节点编号是1~n&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (int i = 1; i &amp;lt;= n; i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        p[i] = i;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        size[i] = 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 合并a和b所在的两个集合：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    size[find(b)] += size[find(a)];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    p[find(a)] = find(b);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;(3)维护到祖宗节点距离的并查集：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int p[N], d[N];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    //p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 返回x的祖宗节点&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int find(int x)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (p[x] != x)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            int u = find(p[x]);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            d[x] += d[p[x]];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            p[x] = u;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        return p[x];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 初始化，假定节点编号是1~n&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (int i = 1; i &amp;lt;= n; i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        p[i] = i;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        d[i] = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 合并a和b所在的两个集合：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    p[find(a)] = find(b);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;堆&lt;a href=&quot;#堆&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// ph[k]存储第k个插入的点在堆中的位置&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// hp[k]存储堆中下标是k的点是第几个插入的&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int h[N], ph[N], hp[N], size;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 交换两个点，及其映射关系&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void heap_swap(int a, int b)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    swap(ph[hp[a]],ph[hp[b]]);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    swap(hp[a], hp[b]);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    swap(h[a], h[b]);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void down(int u)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int t = u;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (u * 2 &amp;lt;= size &amp;amp;&amp;amp; h[u * 2] &amp;lt; h[t]) t = u * 2;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (u * 2 + 1 &amp;lt;= size &amp;amp;&amp;amp; h[u * 2 + 1] &amp;lt; h[t]) t = u * 2 + 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (u != t)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        heap_swap(u, t);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        down(t);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void up(int u)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (u / 2 &amp;amp;&amp;amp; h[u] &amp;lt; h[u / 2])&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        heap_swap(u, u / 2);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        u &amp;gt;&amp;gt;= 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// O(n)建堆&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;for (int i = n / 2; i; i -- ) down(i);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;一般哈希&lt;a href=&quot;#一般哈希&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;(1) 拉链法&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int h[N], e[N], ne[N], idx;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 向哈希表中插入一个数&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    void insert(int x)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        int k = (x % N + N) % N;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        e[idx] = x;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        ne[idx] = h[k];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        h[k] = idx ++ ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 在哈希表中查询某个数是否存在&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    bool find(int x)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        int k = (x % N + N) % N;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        for (int i = h[k]; i != -1; i = ne[i])&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            if (e[i] == x)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;                return true;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        return false;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;(2) 开放寻址法&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int h[N];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int find(int x)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        int t = (x % N + N) % N;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        while (h[t] != null &amp;amp;&amp;amp; h[t] != x)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            t ++ ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            if (t == N) t = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        return t;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;字符串哈希&lt;a href=&quot;#字符串哈希&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;typedef unsigned long long ULL;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;ULL h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 初始化&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;p[0] = 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;for (int i = 1; i &amp;lt;= n; i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    h[i] = h[i - 1] * P + str[i];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    p[i] = p[i - 1] * P;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 计算子串 str[l ~ r] 的哈希值&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;ULL get(int l, int r)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    return h[r] - h[l - 1] * p[r - l + 1];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;</content:encoded><category>category:笔记</category></item><item><title>常用代码模板1——基础算法</title><link>https://www.dreameverafter.com/en/post/%E5%B8%B8%E7%94%A8%E4%BB%A3%E7%A0%81%E6%A8%A1%E6%9D%BF1-%E5%9F%BA%E7%A1%80%E7%AE%97%E6%B3%95</link><guid isPermaLink="false">en:常用代码模板1-基础算法</guid><description>快速排序算法模板void quick_sort(int q[], int l, int r) { if (l &amp;gt;= r) return; int i = l - 1, j = r + 1, x = q[(l + r) &amp;gt;&amp;gt; 1]; while (i &amp;lt; j) { do i ++ ; while (q[i] &amp;lt; x); do j -- ; while (q[j] &amp;gt</description><pubDate>Sun, 07 Jul 2024 10:15:54 GMT</pubDate><content:encoded>&lt;h3&gt;快速排序算法模板&lt;a href=&quot;#快速排序算法模板&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;void quick_sort(int q[], int l, int r)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (l &amp;gt;= r) return;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;		int i = l - 1, j = r + 1, x = q[(l + r) &amp;gt;&amp;gt; 1];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (i &amp;lt; j)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        do i ++ ; while (q[i] &amp;lt; x);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        do j -- ; while (q[j] &amp;gt; x);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (i &amp;lt; j) swap(q[i], q[j]);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    quick_sort(q, l, j), quick_sort(q, j + 1, r);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;快速选择算法模板&lt;a href=&quot;#快速选择算法模板&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;int quick_select(int q[], int l, int r, int k) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (l &amp;gt;= r) return q[l];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int i = l - 1, j = r + 1, x = q[(l + r) &amp;gt;&amp;gt; 1];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (i &amp;lt; j) {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        while (q[++i] &amp;lt; x);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        while (q[--j] &amp;gt; x);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (i &amp;lt; j) swap(q[i],  q[j]);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (j - l + 1 &amp;gt;= k) return quick_select(q, l, j, k);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    else return quick_select(q, j + 1, r, k - (j - l + 1));&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;归并排序算法模板&lt;a href=&quot;#归并排序算法模板&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;const int N = 1e5 + 10; // 数组元素个数&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int a[N], tmp[N];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void merge_sort(int q[], int l, int r)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (l &amp;gt;= r) return;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int mid = l + r &amp;gt;&amp;gt; 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    merge_sort(q, l, mid);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    merge_sort(q, mid + 1, r);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int k = 0, i = l, j = mid + 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (i &amp;lt;= mid &amp;amp;&amp;amp; j &amp;lt;= r)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (q[i] &amp;lt;= q[j]) tmp[k ++ ] = q[i ++ ];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        else tmp[k ++ ] = q[j ++ ];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (i &amp;lt;= mid) tmp[k ++ ] = q[i ++ ];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (j &amp;lt;= r) tmp[k ++ ] = q[j ++ ];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (i = l, j = 0; i &amp;lt;= r; i ++, j ++ ) q[i] = tmp[j];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;整数二分算法模板&lt;a href=&quot;#整数二分算法模板&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;bool check(int x) {/* ... */} // 检查x是否满足某种性质&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int bsearch_1(int l, int r)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (l &amp;lt; r)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        int mid = l + r &amp;gt;&amp;gt; 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (check(mid)) r = mid;    // check()判断mid是否满足性质&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        else l = mid + 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    return l;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int bsearch_2(int l, int r)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (l &amp;lt; r)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        int mid = l + r + 1 &amp;gt;&amp;gt; 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (check(mid)) l = mid;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        else r = mid - 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    return l;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;浮点数二分算法模板&lt;a href=&quot;#浮点数二分算法模板&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;bool check(double x) {/* ... */} // 检查x是否满足某种性质&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;double bsearch_3(double l, double r)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    const double eps = 1e-6;   // eps 表示精度，取决于题目对精度的要求&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (r - l &amp;gt; eps)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        double mid = (l + r) / 2;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (check(mid)) r = mid;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        else l = mid;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    return l;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;高精度加法&lt;a href=&quot;#高精度加法&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// C = A + B, A &amp;gt;= 0, B &amp;gt;= 0&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;vector&amp;lt;int&amp;gt; add(vector&amp;lt;int&amp;gt; &amp;amp;A, vector&amp;lt;int&amp;gt; &amp;amp;B)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (A.size() &amp;lt; B.size()) return add(B, A);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    vector&amp;lt;int&amp;gt; C;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int t = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (int i = 0; i &amp;lt; A.size(); i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        t += A[i];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (i &amp;lt; B.size()) t += B[i];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        C.push_back(t % 10);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        t /= 10;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (t) C.push_back(t);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    return C;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;高精度减法&lt;a href=&quot;#高精度减法&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;bool cmp(vector&amp;lt;int&amp;gt; &amp;amp;A, vector&amp;lt;int&amp;gt; &amp;amp;B)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (A.size() != B.size()) return A.size() &amp;gt; B.size();&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (int i = A.size() - 1; i &amp;gt;= 0; i -- )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (A[i] != B[i])&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            return A[i] &amp;gt; B[i];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    return true;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// C = A - B, 满足A &amp;gt;= B, A &amp;gt;= 0, B &amp;gt;= 0&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;vector&amp;lt;int&amp;gt; sub(vector&amp;lt;int&amp;gt; &amp;amp;A, vector&amp;lt;int&amp;gt; &amp;amp;B)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    vector&amp;lt;int&amp;gt; C;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (int i = 0, t = 0; i &amp;lt; A.size(); i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        t = A[i] - t;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (i &amp;lt; B.size()) t -= B[i];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        C.push_back((t + 10) % 10);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (t &amp;lt; 0) t = 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        else t = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (C.size() &amp;gt; 1 &amp;amp;&amp;amp; C.back() == 0) C.pop_back();&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    return C;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;高精度乘低精度&lt;a href=&quot;#高精度乘低精度&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// C = A * b, A &amp;gt;= 0, b &amp;gt; 0&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;vector&amp;lt;int&amp;gt; mul(vector&amp;lt;int&amp;gt; &amp;amp;A, int b)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    vector&amp;lt;int&amp;gt; C;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int t = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (int i = 0; i &amp;lt; A.size() || t; i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (i &amp;lt; A.size()) t += A[i] * b;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        C.push_back(t % 10);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        t /= 10;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (C.size() &amp;gt; 1 &amp;amp;&amp;amp; C.back() == 0) C.pop_back();&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    return C;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;高精度除以低精度&lt;a href=&quot;#高精度除以低精度&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// A / b = C ... r, A &amp;gt;= 0, b &amp;gt; 0&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;vector&amp;lt;int&amp;gt; div(vector&amp;lt;int&amp;gt; &amp;amp;A, int b, int &amp;amp;r)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    vector&amp;lt;int&amp;gt; C;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    r = 0;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (int i = A.size() - 1; i &amp;gt;= 0; i -- )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        r = r * 10 + A[i];&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        C.push_back(r / b);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        r %= b;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    reverse(C.begin(), C.end());&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (C.size() &amp;gt; 1 &amp;amp;&amp;amp; C.back() == 0) C.pop_back();&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    return C;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;一维前缀和&lt;a href=&quot;#一维前缀和&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;S[i] = a[1] + a[2] + ... a[i]&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;a[l] + ... + a[r] = S[r] - S[l - 1]&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;二维前缀和&lt;a href=&quot;#二维前缀和&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;S[i, j] = 第i行j列格子左上部分所有元素的和&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵的和为：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;S[x2, y2] - S[x1 - 1, y2] - S[x2, y1 - 1] + S[x1 - 1, y1 - 1]&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;一维差分&lt;a href=&quot;#一维差分&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;给区间[l, r]中的每个数加上c：B[l] += c, B[r + 1] -= c&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;二维差分&lt;a href=&quot;#二维差分&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;给以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵中的所有元素加上c：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;S[x1, y1] += c, S[x2 + 1, y1] -= c, S[x1, y2 + 1] -= c, S[x2 + 1, y2 + 1] += c&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;双指针算法&lt;a href=&quot;#双指针算法&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;for (int i = 0, j = 0; i &amp;lt; n; i ++ )&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (j &amp;lt; i &amp;amp;&amp;amp; check(i, j)) j ++ ;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    // 具体问题的逻辑&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;常见问题分类：&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    (1) 对于一个序列，用两个指针维护一段区间&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    (2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;离散化&lt;a href=&quot;#离散化&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;vector&amp;lt;int&amp;gt; alls; // 存储所有待离散化的值&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;sort(alls.begin(), alls.end()); // 将所有值排序&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;alls.erase(unique(alls.begin(), alls.end()), alls.end());   // 去掉重复元素&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;// 二分求出x对应的离散化的值&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;int find(int x) // 找到第一个大于等于x的位置&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int l = 0, r = alls.size() - 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    while (l &amp;lt; r)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        int mid = l + r &amp;gt;&amp;gt; 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (alls[mid] &amp;gt;= x) r = mid;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        else l = mid + 1;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    return r + 1; // 映射到1, 2, ...n&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;区间合并&lt;a href=&quot;#区间合并&quot;&gt;&lt;span&gt;&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;
&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;pre&gt;&lt;code&gt;&lt;span&gt;&lt;span&gt;// 将所有存在交集的区间合并&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;void merge(vector&amp;lt;PII&amp;gt; &amp;amp;segs)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    vector&amp;lt;PII&amp;gt; res;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    sort(segs.begin(), segs.end());&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    int st = -2e9, ed = -2e9;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    for (auto seg : segs)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        if (ed &amp;lt; seg.first)&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        {&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            if (st != -2e9) res.push_back({st, ed});&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;            st = seg.first, ed = seg.second;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        }&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;        else ed = max(ed, seg.second);&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    if (st != -2e9) res.push_back({st, ed});&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;    segs = res;&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/span&gt;
&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;</content:encoded><category>category:笔记</category></item></channel></rss>